import AtomicXCore

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

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

import AtomicXCore
import Combine

// Subscribe to events during view controller 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 join mic")
                  // 1. Open microphone
                  DeviceStore.shared.openLocalMicrophone(completion: nil)
                  // 2. Update UI, e.g., disable request button, show "on mic" status
              } else {
                  print("Host \\(hostUser.userName) rejected your request")
                  // Show popup to inform user of rejection
              }
          }
      }
      .store(in: &cancellables) // Manage subscription lifecycle
}

// User taps "Leave Mic" button
func leaveSeat() {
    guestStore.disConnect { result in
      switch result {
      case .success():
          print("Successfully left mic")
      case .failure(let error):
          print("Failed to leave 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
import Combine

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

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

import AtomicXCore
import Combine

// Subscribe to state changes
guestStore.state
    .subscribe(StatePublisherSelector(keyPath: \\CoGuestState.applicants)) // Only care about applicant list changes
    .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 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 the mic")
        }
    }
}

// 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 audience and initiates invitation
func invite(userId: String) {
    // timeout: Invitation timeout
    guestStore.inviteToSeat(userID: userId, timeout: 30.0, extraInfo: nil) { result in
        if case .success = result {
            print("Invitation sent to \\(userId), waiting for response...")
        }
    }
}

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

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

let inviterId = "Host ID who sent the invitation" // Get from onHostInvitationReceived event

// User taps "Accept"
func accept() {
    guestStore.acceptInvitation(inviterID: inviterId) { result in
        if case .success = result {
            // 2. Open microphone
            DeviceStore.shared.openLocalMicrophone(completion: nil)
        }
    }
}

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