import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import io.trtc.tuikit.atomicxcore.api.CompletionHandler
import io.trtc.tuikit.atomicxcore.api.live.LiveAudienceStore
import io.trtc.tuikit.atomicxcore.api.live.LiveUserInfo

class AudienceManager(
    private val liveId: String
) {
    private val audienceStore: LiveAudienceStore = LiveAudienceStore.create(liveId)
    private val scope = CoroutineScope(Dispatchers.Main)

    // Expose the [full] audience list state flow for UI layer subscription
    private val _audienceList = MutableStateFlow<List<LiveUserInfo>>(emptyList())
    val audienceList: StateFlow<List<LiveUserInfo>> = _audienceList.asStateFlow()
    
    // Expose the audience count state flow
    private val _audienceCount = MutableStateFlow(0)
    val audienceCount: StateFlow<Int> = _audienceCount.asStateFlow()
    
    init {
        // 1. Subscribe to state and events, see next section for implementation
        subscribeToAudienceState()
        subscribeToAudienceEvents()

        // 2. Actively fetch initial data for the first screen
        fetchInitialAudienceList()
    }

    /// Actively fetch a snapshot of the audience list once
    private fun fetchInitialAudienceList() {
        audienceStore.fetchAudienceList(object : CompletionHandler {
            override fun onSuccess() {
                println("Successfully fetched the initial audience list")
                // After success, the data will be automatically updated via the state subscription channel below
            }

            override fun onFailure(code: Int, desc: String) {
                println("Failed to fetch the initial audience list: $desc")
            }
        })
    }
    
    // ... subsequent code
}

class AudienceManager {
    /// Subscribe to state for audience count and list snapshots
    private fun subscribeToAudienceState() {
        scope.launch {
            // audienceList is a full snapshot
            audienceStore.liveAudienceState.audienceList.collect { audienceList ->
                _audienceList.value = audienceList
            }
        }

        scope.launch {   
            // audienceCount is the real-time total
            audienceStore.liveAudienceState.audienceCount.collect { count ->
                _audienceCount.value = count
            }
        }
    }
    
    private val liveAudienceListener = object : LiveAudienceListener() {
        override fun onAudienceJoined(newAudience: LiveUserInfo) {
            println("Audience ${newAudience.userName} joined the live room")
            // Incremental update: add the new audience member to the end of the current list
            val currentList = _audienceList.value.toMutableList()
            if (!currentList.any { it.userID == newAudience.userID }) {
                currentList.add(newAudience)
                _audienceList.value = currentList
            }
        }


        override fun onAudienceLeft(departedAudience: LiveUserInfo) {
            println("Audience ${departedAudience.userName} left the live room")
            // Incremental update: remove the departed audience member from the current list
            val currentList = _audienceList.value.toMutableList()
            currentList.removeAll { it.userID == departedAudience.userID }
            _audienceList.value = currentList
        }
    }


    /// Subscribe to events to handle real-time audience join/leave
    private fun subscribeToAudienceEvents() {
        audienceStore.addLiveAudienceListener(liveAudienceListener)
    }
}

class AudienceManager {
    fun kick(userId: String) {
        audienceStore.kickUserOutOfRoom(userId, object : CompletionHandler {
            override fun onSuccess() {
                println("Successfully kicked user $userId out of the room")
                // After a successful kick, you will receive an onAudienceLeft event
            }

            override fun onFailure(code: Int, desc: String) {
                println("Failed to kick user $userId: $desc")
            }
        })
    }
}

class AudienceManager {
    /// Promote user to administrator
    fun promoteToAdmin(userId: String) {
        audienceStore.setAdministrator(userId, object : CompletionHandler {
            override fun onSuccess() {
                println("Successfully promoted user $userId to administrator")
            }
            
            override fun onFailure(code: Int, desc: String) {
                println("Failed to set administrator: $desc")
            }
        })
    }

    /// Revoke user's administrator status
    fun revokeAdmin(userId: String) {
        audienceStore.revokeAdministrator(userId, object : CompletionHandler {
            override fun onSuccess() {
                println("Successfully revoked administrator status for user $userId")
            }

            override fun onFailure(code: Int, desc: String) {
                println("Failed to revoke administrator: $desc")
            }
        })
    }
}

import io.trtc.tuikit.atomicxcore.api.live.LiveAudienceListener
import io.trtc.tuikit.atomicxcore.api.live.LiveAudienceStore
import io.trtc.tuikit.atomicxcore.api.live.LiveUserInfo
import io.trtc.tuikit.atomicxcore.api.barrage.Barrage
import io.trtc.tuikit.atomicxcore.api.barrage.BarrageStore
import io.trtc.tuikit.atomicxcore.api.barrage.BarrageType

class LiveRoomManager(
    private val liveId: String
) {

    init {
        // Initialize two core managers
        setupWelcomeMessageFlow()
    }
    
    
    private val liveAudienceListener = object : LiveAudienceListener() {
        override fun onAudienceJoined(audience: LiveUserInfo) {
            // 3. Create a local tip message
            val welcomeTip = Barrage().apply {
                liveID = liveId
                messageType = BarrageType.TEXT
                textContent = "Welcome ${audience.userName} to the live room."
            }


            // 4. Get an instance of BarrageStore (this will be the same instance due to internal mechanisms)
            val barrageStore = BarrageStore.create(liveId)


            // 5. Use BarrageStore's method to insert it into the barrage list
            barrageStore.appendLocalTip(welcomeTip)
        }
    }


    private fun setupWelcomeMessageFlow() {
        // 1. Get an instance of LiveAudienceStore
        val audienceStore = LiveAudienceStore.create(liveId)

        // 2. Subscribe to audience events
        audienceStore.addLiveAudienceListener(liveAudienceListener)
    }
}