Audience Management

import Foundation
import AtomicXCore 
import Combine     

class AudienceManager {
    private let liveId: String
    private let audienceStore: LiveAudienceStore
    private var cancellables = Set<AnyCancellable>()
    
    // Expose the [full] audience list publisher for UI layer subscription
    let audienceListPublisher = CurrentValueSubject<[LiveUserInfo], Never>([])
    // Expose the audience count publisher
    let audienceCountPublisher = PassthroughSubject<UInt, Never>()

    init(liveId: String) {
        self.liveId = liveId
        // 1. Get the LiveAudienceStore instance by liveId
        self.audienceStore = LiveAudienceStore.create(liveID: liveId)
        
        // 2. Subscribe to state and events
        subscribeToAudienceState()
        subscribeToAudienceEvents()
        
        // 3. Proactively fetch initial data for the first screen
        fetchInitialAudienceList()
    }

    /// Proactively fetch a snapshot of the audience list
    func fetchInitialAudienceList() {
        audienceStore.fetchAudienceList { [weak self] result in
            switch result {
            case .success:
                print("Successfully fetched the audience list for the first time")
                // On success, data will be automatically updated via the state subscription channel below
            case .failure(let error):
                print("Failed to fetch the audience list for the first time: \(error.localizedDescription)")
            }
        }
    }
    
    // ... subsequent code
}

extension AudienceManager {
    /// Subscribe to state to get audience count and list snapshot
    private func subscribeToAudienceState() {
        audienceStore.state
            .subscribe()
            .receive(on: DispatchQueue.main)
            .sink { [weak self] state in
                // state.audienceList is a full snapshot
                self?.audienceListPublisher.send(state.audienceList)
                // state.audienceCount is the real-time total
                self?.audienceCountPublisher.send(state.audienceCount)
            }
            .store(in: &cancellables)
    }

    /// Subscribe to events to handle real-time audience join/leave
    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("Audience \(newAudience.userName) joined the live room")
                    // Incremental update: add the new audience member to the end of the current list
                    if !currentList.contains(where: { $0.userID == newAudience.userID }) {
                        currentList.append(newAudience)
                        self.audienceListPublisher.send(currentList)
                    }
                    
                case .onAudienceLeft(let departedAudience):
                    print("Audience \(departedAudience.userName) left the live room")
                    // Incremental update: remove the departed audience member from the current list
                    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("Successfully kicked user \(userId) out of the room")
                // After a successful kick, you will receive an onAudienceLeft event
            case .failure(let error):
                print("Failed to kick user \(userId) out: \(error.localizedDescription)")
            }
        }
    }
}

extension AudienceManager {
    /// Promote user to administrator
    func promoteToAdmin(userId: String) {
        audienceStore.setAdministrator(userID: userId) { result in
            if case .success = result {
                print("Successfully promoted user \(userId) to administrator")
            }
        }
    }

    /// Revoke user's administrator status
    func revokeAdmin(userId: String) {
        audienceStore.revokeAdministrator(userID: userId) { result in
            if case .success = result {
                print("Successfully revoked administrator status for user \(userId)")
            }
        }
    }
}

import Foundation
import AtomicXCore 
import Combine

class LiveRoomManager {
    private let liveId: String
    private let audienceManager: AudienceManager
    private let barrageManager: BarrageManager // Assume you have implemented BarrageManager as described in the barrage documentation
    private var cancellables = Set<AnyCancellable>()

    init(liveId: String) {
        self.liveId = liveId
        // Initialize two core managers
        self.audienceManager = AudienceManager(liveId: liveId)
        self.barrageManager = BarrageManager(liveId: liveId)

        // Set up linkage
        setupWelcomeMessageFlow()
    }

    private func setupWelcomeMessageFlow() {
        // 1. Get the LiveAudienceStore instance
        let audienceStore = LiveAudienceStore.create(liveID: self.liveId)

        // 2. Get the BarrageStore instance (thanks to internal mechanisms, this will be the same instance)
        let barrageStore = BarrageStore.create(liveID: self.liveId)

        // 3. Subscribe to audience events
        audienceStore.liveAudienceEventPublisher
            .receive(on: DispatchQueue.main)
            .sink { event in
                // 4. Only handle audience join events
                guard case .onAudienceJoined(let newAudience) = event else {
                    return
                }

                // 5. Create a local tip message
                var welcomeTip = Barrage()
                welcomeTip.messageType = .text 
                welcomeTip.textContent = "Welcome \(newAudience.userName) to the live room!"

                // 6. Call BarrageStore's API to insert it into the barrage list
                barrageStore.appendLocalTip(message: welcomeTip)
            }
            .store(in: &cancellables)
    }
}