import Foundation
import AtomicXCore 
import Combine     

class AudienceManager {
    private let liveId: String
    private let audienceStore: LiveAudienceStore
    private var cancellables = Set<AnyCancellable>()
    
    // 对外暴露【全量】观众列表的发布者，方便UI层订阅
    let audienceListPublisher = CurrentValueSubject<[LiveUserInfo], Never>([])
    // 对外暴露观众总数的发布者
    let audienceCountPublisher = PassthroughSubject<UInt, Never>()

    init(liveId: String) {
        self.liveId = liveId
        // 1. 通过 liveId 获取 LiveAudienceStore 的实例
        self.audienceStore = LiveAudienceStore.create(liveID: liveId)
        
        // 2. 订阅状态和事件
        subscribeToAudienceState()
        subscribeToAudienceEvents()
        
        // 3. 主动拉取首屏数据
        fetchInitialAudienceList()
    }

    /// 主动获取一次观众列表快照
    func fetchInitialAudienceList() {
        audienceStore.fetchAudienceList { [weak self] result in
            switch result {
            case .success:
                print("首次拉取观众列表成功")
                // 成功后，数据会通过下面的 state 订阅通道自动更新
            case .failure(let error):
                print("首次拉取观众列表失败: \\(error.localizedDescription)")
            }
        }
    }
    
    // ... 后续代码
}

extension AudienceManager {
    /// 订阅 state，用于获取观众总数和列表快照
    private func subscribeToAudienceState() {
        audienceStore.state
            .subscribe()
            .receive(on: DispatchQueue.main)
            .sink { [weak self] state in
                // state.audienceList 是一个全量快照
                self?.audienceListPublisher.send(state.audienceList)
                // state.audienceCount 是实时总数
                self?.audienceCountPublisher.send(state.audienceCount)
            }
            .store(in: &cancellables)
    }

    /// 订阅 event，用于处理观众的实时进出
    private func subscribeToAudienceEvents() {
        audienceStore.liveAudienceEventPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self] event in
                guard let self = self else { return }
                
                var currentList = self.audienceListPublisher.value
                
                switch event {
                case .onAudienceJoined(let newAudience):
                    print("观众 \\(newAudience.userName) 加入了直播间")
                    // 增量更新：在当前列表末尾添加新观众
                    if !currentList.contains(where: { $0.userID == newAudience.userID }) {
                        currentList.append(newAudience)
                        self.audienceListPublisher.send(currentList)
                    }
                    
                case .onAudienceLeft(let departedAudience):
                    print("观众 \\(departedAudience.userName) 离开了直播间")
                    // 增量更新：从当前列表中移除离开的观众
                    currentList.removeAll { $0.userID == departedAudience.userID }
                    self.audienceListPublisher.send(currentList)
                }
            }
            .store(in: &cancellables)
    }
}

extension AudienceManager {
    func kick(userId: String) {
        audienceStore.kickUserOutOfRoom(userID: userId) { result in
            switch result {
            case .success:
                print("成功将用户 \\(userId) 踢出房间")
                // 踢出成功后，您会收到 onAudienceLeft 事件
            case .failure(let error):
                print("踢出用户 \\(userId) 失败: \\(error.localizedDescription)")
            }
        }
    }
}

extension AudienceManager {
    /// 将用户设为管理员
    func promoteToAdmin(userId: String) {
        audienceStore.setAdministrator(userID: userId) { result in
            if case .success = result {
                print("成功将用户 \\(userId) 设为管理员")
            }
        }
    }

    /// 撤销用户的管理员身份
    func revokeAdmin(userId: String) {
        audienceStore.revokeAdministrator(userID: userId) { result in
            if case .success = result {
                print("成功撤销用户 \\(userId) 的管理员身份")
            }
        }
    }
}

import Foundation
import AtomicXCore 
import Combine

class LiveRoomManager {
    private let liveId: String
    private let audienceManager: AudienceManager
    private let barrageManager: BarrageManager // 假设您已实现了弹幕文档中的BarrageManager
    private var cancellables = Set<AnyCancellable>()

    init(liveId: String) {
        self.liveId = liveId
        // 初始化两个核心管理器
        self.audienceManager = AudienceManager(liveId: liveId)
        self.barrageManager = BarrageManager(liveId: liveId)

        // 设置联动
        setupWelcomeMessageFlow()
    }

    private func setupWelcomeMessageFlow() {
        // 1. 获取 LiveAudienceStore 的实例
        let audienceStore = LiveAudienceStore.create(liveID: self.liveId)

        // 2. 获取 BarrageStore 的实例 (得益于内部机制，这会是同一个实例)
        let barrageStore = BarrageStore.create(liveID: self.liveId)

        // 3. 订阅观众事件
        audienceStore.liveAudienceEventPublisher
            .receive(on: DispatchQueue.main)
            .sink { event in
                // 4. 只处理观众加入事件
                guard case .onAudienceJoined(let newAudience) = event else {
                    return
                }

                // 5. 创建一条本地提示消息
                var welcomeTip = Barrage()
                welcomeTip.messageType = .text 
                welcomeTip.textContent = "欢迎 \\(newAudience.userName) 进入直播间！"

                // 6. 调用 BarrageStore 的接口将其插入弹幕列表
                barrageStore.appendLocalTip(message: welcomeTip)
            }
            .store(in: &cancellables)
    }
}