import AtomicXCore

let liveId = "Room ID"
let guestStore = CoGuestStore.create(liveID: liveId)

// User taps "Request to Co-host"
func requestToConnect() {
    // timeout: Request timeout duration, e.g., 30 seconds
    guestStore.applyForSeat(timeout: 30.0, extraInfo: nil) { result in
      switch result {
      case .success():
          print("Co-hosting request sent, waiting for host response...")
      case .failure(let error):
          print("Failed to send request: \\(error.message)")
      }
    }
}

// Subscribe to events during your view controller's initialization
func subscribeGuestEvents() {
    guestStore.guestEventPublisher
      .sink { [weak self] event in
          if case let .onGuestApplicationResponded(isAccept, hostUser) = event {
              if isAccept {
                  print("Host \\(hostUser.userName) accepted your request, preparing to go live")
                  // 1. Enable camera and microphone
                  DeviceStore.shared.openLocalCamera(isFront: true, completion: nil)
                  DeviceStore.shared.openLocalMicrophone(completion: nil)
                  // 2. Update UI, e.g., disable the request button and show co-hosting status
              } else {
                  print("Host \\(hostUser.userName) rejected your request")
                  // Show a popup to notify the user that the request was rejected
              }
          }
      }
      .store(in: &cancellables) // Manage subscription lifecycle
}

// User taps "Leave Mic" button
func leaveSeat() {
    guestStore.disConnect { result in
      switch result {
      case .success():
          print("Successfully left the mic")
      case .failure(let error):
          print("Failed to leave the mic: \\(error.message)")
      }
    }
}

// User taps "Cancel Request" while waiting
func cancelRequest() {
    guestStore.cancelApplication { result in
      switch result {
      case .success():
          print("Request cancelled")
      case .failure(let error):
          print("Failed to cancel request: \\(error.message)")
      }
    }
}

import AtomicXCore

let liveId = "Room ID"
let guestStore = CoGuestStore.create(liveID: liveId)

// Subscribe to host events
guestStore.hostEventPublisher
    .sink { [weak self] event in
        if case let .onGuestApplicationReceived(guestUser) = event {
            print("Received co-hosting request from audience member \\(guestUser.userName)")
            // Update UI, e.g., show a red dot on the "Request List" button
        }
    }
    .store(in: &cancellables)

// Subscribe to state changes
guestStore.state
    .subscribe(StatePublisherSelector(keyPath: \\CoGuestState.applicants)) // Only observe changes to the applicant list
    .removeDuplicates()
    .sink { applicants in
        print("Current number of applicants: \\(applicants.count)")
        // Refresh your "Applicant List" UI here
        // self.applicantListView.update(with: applicants)
    }
    .store(in: &cancellables)

// Host taps "Accept" button, passing in the applicant's userID
func accept(userId: String) {
    guestStore.acceptApplication(userID: userId) { result in
        if case .success = result {
            print("Accepted \\(userId)'s request, they are joining as a co-host")
        }
    }
}

// Host taps "Reject" button
func reject(userId: String) {
    guestStore.rejectApplication(userID: userId) { result in
        if case .success = result {
            print("Rejected \\(userId)'s request")
        }
    }
}

// Host selects an audience member and sends an invite
func invite(userId: String) {
    // timeout: Invitation timeout duration
    guestStore.inviteToSeat(userID: userId, timeout: 30.0, extraInfo: nil) { result in
        if case .success = result {
            print("Invitation sent to \\(userId), waiting for their response...")
        }
    }
}

// Add this in the hostEventPublisher subscription
if case let .onHostInvitationResponded(isAccept, guestUser) = event {
    if isAccept {
        print("Audience member \\(guestUser.userName) accepted your invitation")
    } else {
        print("Audience member \\(guestUser.userName) rejected your invitation")
    }
}

// Add this in the guestEventPublisher subscription
if case let .onHostInvitationReceived(hostUser) = event {
    print("Received co-hosting invitation from host \\(hostUser.userName)")
    // Show a dialog to let the user choose "Accept" or "Reject"
    // self.showInvitationDialog(from: hostUser)
}

let inviterId = "Inviting host's ID" // Obtain from the onHostInvitationReceived event

// User taps "Accept"
func accept() {
    guestStore.acceptInvitation(inviterID: inviterId) { result in
        if case .success = result {
            // Enable camera and microphone
            DeviceStore.shared.openLocalCamera(isFront: true, completion: nil)
            DeviceStore.shared.openLocalMicrophone(completion: nil)
        }
    }
}

// User taps "Reject"
func reject() {
    guestStore.rejectInvitation(inviterID: inviterId) { result in
        // ...
    }
}

import UIKit

// Custom floating user info view (foreground)
class CustomSeatView: UIView {
   lazy var nameLabel: UILabel = {
        let label = UILabel()
        label.textColor = .white
        label.font = .systemFont(ofSize: 14)
        return label
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        backgroundColor = UIColor.black.withAlphaComponent(0.5)
        addSubview(nameLabel)
        nameLabel.snp.makeConstraints { make in
            make.bottom.equalToSuperview().offset(-5)
            make.leading.equalToSuperview().offset(5)
        }
    }
}

import UIKit

// Custom avatar placeholder view (background)
class CustomAvatarView: UIView {
    lazy var avatarImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.tintColor = .gray
        return imageView
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        backgroundColor = .clear
        layer.cornerRadius = 30
        addSubview(avatarImageView)
        avatarImageView.snp.makeConstraints { make in
            make.center.equalToSuperview()
            make.width.height.equalTo(60)
        }
    }
}

import AtomicXCore

// 1. In your view controller, conform to the VideoViewDelegate protocol
class YourViewController: UIViewController, VideoViewDelegate {

    // ... other code ...

    // 2. Implement the protocol method to handle both viewLayer types
    func createCoGuestView(seatInfo: TUISeatFullInfo, viewLayer: ViewLayer) -> UIView? {
        guard let userId = seatInfo.userID, !userId.isEmpty else {
            return nil
        }
        if viewLayer == .foreground {
            // When the user's camera is on, display the foreground view
            let seatView = CustomSeatView()
            seatView.nameLabel.text = seatInfo.userName
            return seatView
        } else { // viewLayer == .background
            // When the user's camera is off, display the background view
            let avatarView = CustomAvatarView()
            // Load the user's avatar here using seatInfo.userAvatar if available
            return avatarView
        }
    }
}