import io.trtc.tuikit.atomicxcore.api.CompletionHandler
import io.trtc.tuikit.atomicxcore.api.live.CoGuestStore

val liveId = "Room ID"
val guestStore = CoGuestStore.create(liveId)

// User taps "Request to Co-host"
fun requestToConnect() {
    // timeout: request timeout, e.g., 30 seconds
    guestStore.applyForSeat(-1, 30, null, object : CompletionHandler {
        override fun onSuccess() {
            print("Co-hosting request sent, waiting for host to respond...")
        }

        override fun onFailure(code: Int, desc: String) {
            print("Failed to send request: $desc")
        }
    })
}

import io.trtc.tuikit.atomicxcore.api.device.DeviceStore
import io.trtc.tuikit.atomicxcore.api.live.GuestListener
import io.trtc.tuikit.atomicxcore.api.live.LiveUserInfo

// Add listener during Activity/Fragment initialization
fun subscribeGuestEvents() {
    val guestListener = object : GuestListener() {
        override fun onGuestApplicationResponded(isAccept: Boolean, hostUser: LiveUserInfo) {
            if (isAccept) {
                print("Host ${hostUser.userName} approved your request. Preparing to join mic.")
                // 1. Enable camera and microphone
                DeviceStore.shared().openLocalCamera(true, null)
                DeviceStore.shared().openLocalMicrophone(null)
                // 2. Update UI, e.g., disable request button, show co-hosting status
            } else {
                print("Host ${hostUser.userName} rejected your request.")
                // Notify user of rejection
            }
        }
    }
    guestStore.addGuestListener(guestListener)
}

// User taps "Leave Mic"
fun leaveSeat() {
    guestStore.disconnect(object : CompletionHandler {
        override fun onSuccess() {
            print("Successfully left the mic")
        }

        override fun onFailure(code: Int, desc: String) {
            print("Failed to leave mic: $desc")
        }
    })
}

// User taps "Cancel Request" while waiting
fun cancelRequest() {
    guestStore.cancelApplication(object : CompletionHandler {
        override fun onSuccess() {
            print("Request cancelled")
        }

        override fun onFailure(code: Int, desc: String) {
            print("Failed to cancel request: $desc")
        }
    })
}

import io.trtc.tuikit.atomicxcore.api.live.CoGuestStore
import io.trtc.tuikit.atomicxcore.api.live.HostListener
import io.trtc.tuikit.atomicxcore.api.live.LiveUserInfo

val liveId = "Room ID"
val guestStore = CoGuestStore.create(liveId)

// Subscribe to host events
val hostListener = object : HostListener() {
    override fun onGuestApplicationReceived(guestUser: LiveUserInfo) {
        print("Received co-hosting request from ${guestUser.userName}")
        // Update UI, e.g., show notification on "Request List" button
    }
    // ... Override other needed callback methods
}
guestStore.addHostListener(hostListener)

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

// Subscribe to state changes
fun observeApplicants() {
    CoroutineScope(Dispatchers.Main).launch {
        guestStore.coGuestState.applicants.collect { applicants ->
            print("Current number of applicants: ${applicants.size}")
            // Update "Applicant List" UI
        }
    }
}

// Host taps "Approve"
fun accept(userId: String) {
    guestStore.acceptApplication(
        userId,
        object : CompletionHandler {
            override fun onSuccess() {
                print("Approved $userId's request. They are joining the mic.")
            }

            override fun onFailure(code: Int, desc: String) {
                print("Failed to approve request: $desc")
            }
        }
    )
}

// Host taps "Reject"
fun reject(userId: String) {
    guestStore.rejectApplication(
        userId,
        object : CompletionHandler {
            override fun onSuccess() {
                print("Rejected $userId's request")
            }

            override fun onFailure(code: Int, desc: String) {
                print("Failed to reject request: $desc")
            }
        }
    )
}

// Host selects audience and sends invitation
fun invite(userId: String) {
    // timeout: invitation timeout
    guestStore.inviteToSeat(userId, -1, 30, null, object : CompletionHandler {
        override fun onSuccess() {
            print("Invitation sent to $userId, waiting for response...")
        }

        override fun onFailure(code: Int, desc: String) {
            print("Failed to send invitation: $desc")
        }
    })
}

// Add to hostListener implementation
override fun onHostInvitationResponded(isAccept: Boolean, guestUser: LiveUserInfo) {
    if (isAccept) {
        print("Audience ${guestUser.userName} accepted your invitation")
    } else {
        print("Audience ${guestUser.userName} rejected your invitation")
    }
}

// Add to guestListener implementation
override fun onHostInvitationReceived(hostUser: LiveUserInfo) {
    print("Received co-hosting invitation from host ${hostUser.userName}")
    // Show dialog for user to accept or reject
}

val inviterId = "Host ID who sent the invitation" // From onHostInvitationReceived

// User taps "Accept"
fun accept() {
    guestStore.acceptInvitation(inviterId, object : CompletionHandler {
        override fun onSuccess() {
            // Enable microphone
            DeviceStore.shared().openLocalMicrophone(null)
        }

        override fun onFailure(code: Int, desc: String) {
            print("Failed to accept invitation: $desc")
        }
    })
}

// User taps "Reject"
fun reject() {
    guestStore.rejectInvitation(inviterId, object : CompletionHandler {
        override fun onSuccess() {
            // ...
        }
        override fun onFailure(code: Int, desc: String) {
            // ...
        }
    })
}

import io.trtc.tuikit.atomicxcore.api.live.LiveSeatStore

val seatStore = LiveSeatStore.create(liveId)

seatStore.muteMicrophone() // Mute

seatStore.unmuteMicrophone(null) // Unmute

import io.trtc.tuikit.atomicxcore.api.CompletionHandler
import io.trtc.tuikit.atomicxcore.api.live.DeviceControlPolicy

val targetUserId = "userD"

// 1. Force mute and lock
seatStore.closeRemoteMicrophone(targetUserId, object : CompletionHandler {
    override fun onSuccess() {
        print("$targetUserId has been muted and locked")
    }
    override fun onFailure(code: Int, desc: String) {
        print("Operation failed: $desc")
    }
})

// 2. Unlock mic permissions (userD remains muted)
seatStore.openRemoteMicrophone(targetUserId, DeviceControlPolicy.UNLOCK_ONLY, object : CompletionHandler {
    override fun onSuccess() {
        print("Invited $targetUserId to unmute (unlocked)")
    }
    override fun onFailure(code: Int, desc: String) {
        print("Operation failed: $desc")
    }
})

import io.trtc.tuikit.atomicxcore.api.live.DeviceControlPolicy
import io.trtc.tuikit.atomicxcore.api.live.LiveSeatListener

// userD listens for host actions
val seatListener = object : LiveSeatListener() {
    override fun onLocalMicrophoneClosedByAdmin() {
        print("Muted by host")
    }

    override fun onLocalMicrophoneOpenedByAdmin(policy: DeviceControlPolicy) {
        print("Host has unlocked mute")
    }
}
seatStore.addLiveSeatEventListener(seatListener)

// Remove "userB" from mic seat
val targetUserId = "userB"
seatStore.kickUserOutOfSeat(targetUserId, object : CompletionHandler {
    override fun onSuccess() {
        print("$targetUserId has been removed from the mic seat")
    }
    override fun onFailure(code: Int, desc: String) {
        print("Failed to remove user: $desc")
    }
})

// "userB" receives the event in GuestListener
override fun onKickedOffSeat(seatIndex: Int, hostUser: LiveUserInfo) {
    // Show notification
}

// Lock mic seat 2
seatStore.lockSeat(2, object : CompletionHandler {
    override fun onSuccess() {
        print("Mic seat 2 locked")
    }
    override fun onFailure(code: Int, desc: String) {
        print("Failed to lock: $desc")
    }
})

// Unlock mic seat 2
seatStore.unlockSeat(2, object : CompletionHandler {
    override fun onSuccess() {
        print("Mic seat 2 unlocked")
    }
    override fun onFailure(code: Int, desc: String) {
        print("Failed to unlock: $desc")
    }
})

import io.trtc.tuikit.atomicxcore.api.CompletionHandler
import io.trtc.tuikit.atomicxcore.api.live.MoveSeatPolicy

seatStore.moveUserToSeat("userC",
    newSeatIndex,
    MoveSeatPolicy.ABORT_WHEN_OCCUPIED,
    object : CompletionHandler {
        override fun onSuccess() {
            print("Successfully moved to mic seat $newSeatIndex")
        }
        override fun onFailure(code: Int, desc: String) {
            print("Failed to switch seat, seat may be occupied: $desc")
        }
})