import 'package:atomic_x_core/atomicxcore.dart';

final String liveId = "room ID";
late CoGuestStore guestStore;

@override
void initState() {
  super.initState();
  guestStore = CoGuestStore.create(liveId);
}

// User click "Apply for Mic Connection"
Future<void> requestToConnect() async {
  // seatIndex: The seat index, starting from 0, represents the applied microphone position. 0 means the first seat. View seat status via LiveSeatState.seatList.value and select an idle seat.
  // timeout: Request timeout (seconds). The audience can call cancelApplication to cancel the request to speak within the timeout period.
  // The request will expire if it hasn't been processed after reaching the timeout period
  final result = await guestStore.applyForSeat(
    seatIndex: 0,
    timeout: 30,
    extraInfo: null,
  );
  if (result.isSuccess) {
    debugPrint('Mic connection request sent, waiting for anchor processing...');
  } else {
    debugPrint('Failed to send request: ${result.message}');
  }
}

late GuestListener _guestListener;

// Subscribe to events when your Widget initializes
void subscribeGuestEvents() {
  _guestListener = GuestListener(
    onGuestApplicationResponded: (isAccept, hostUser) {
      if (isAccept) {
        debugPrint('Anchor ${hostUser.userName} granted your request, preparing to join the mic');
        // 1. Turn on microphone
        // DeviceStore is the device management module provided by AtomicXCore, used for managing microphones, cameras and other physical devices.
        // When the host agrees to connect mic, turn on microphone to start collecting audio.
        DeviceStore.shared.openLocalMicrophone();
        // 2. Update UI herein, such as disabling the apply button and displaying the mic connection state
      } else {
        debugPrint('Anchor ${hostUser.userName} refused your request');
        // Pop-up prompts user that the application was rejected
      }
    },
  );
  guestStore.addGuestListener(_guestListener);
}

@override
void dispose() {
  guestStore.removeGuestListener(_guestListener);
  super.dispose();
}

// User click "Disconnect" button
Future<void> leaveSeat() async {
  final result = await guestStore.disconnect();
  if (result.isSuccess) {
    debugPrint('Disconnected successfully');
  } else {
    debugPrint('Failed to leave the seat: ${result.message}');
  }
}

// While waiting, the user clicks "Cancel Application"
Future<void> cancelApplication() async {
  final result = await guestStore.cancelApplication();
  if (result.isSuccess) {
    debugPrint('Request canceled');
  } else {
    debugPrint('Failed to cancel request: ${result.message}');
  }
}

import 'package:atomic_x_core/atomicxcore.dart';

final String liveId = "room ID";
late CoGuestStore guestStore;
late HostListener _hostListener;

@override
void initState() {
  super.initState();
  guestStore = CoGuestStore.create(liveId);

  // Subscribe to anchor event
  _hostListener = HostListener(
    onGuestApplicationReceived: (guestUser) {
      debugPrint('Received mic connection request from audience ${guestUser.userName}');
      // Update the UI here, for example display a red dot on the "application list" button
    },
  );
  guestStore.addHostListener(_hostListener);
}

@override
void dispose() {
  guestStore.removeHostListener(_hostListener);
  super.dispose();
}

late final VoidCallback _applicantsListener = _onApplicantsChanged;

// Subscribe to status change
void subscribeApplicants() {
  guestStore.coGuestState.applicants.addListener(_applicantsListener);
}

void _onApplicantsChanged() {
  final applicants = guestStore.coGuestState.applicants.value;
  debugPrint('Current number of applicants: ${applicants.length}');
  // Update your "applicant list" UI here
}

@override
void dispose() {
  guestStore.coGuestState.applicants.removeListener(_applicantsListener);
  super.dispose();
}

// Anchor clicks the "Grant" button and imports the applicant's userID
Future<void> accept(String userId) async {
  final result = await guestStore.acceptApplication(userId);
  if (result.isSuccess) {
    debugPrint('Approved $userId\\'s request, the other party is joining the mic');
  }
}

// Anchor clicks the "Reject" button
Future<void> reject(String userId) async {
  final result = await guestStore.rejectApplication(userId);
  if (result.isSuccess) {
    debugPrint('$userId\\'s application denied');
  }
}

// Anchor selects audience and initiates invitation
Future<void> invite(String userId) async {
  // inviteeID: The ID of the invitee, seatIndex: The seat index, timeout: The invitation timeout duration
  final result = await guestStore.inviteToSeat(
    inviteeID: userId,
    seatIndex: 0,
    timeout: 30,
    extraInfo: null,
  );
  if (result.isSuccess) {
    debugPrint('Sent invitation to $userId, waiting for peer response...');
  }
}

// Add to the HostListener configuration
_hostListener = HostListener(
  onHostInvitationResponded: (isAccept, guestUser) {
    if (isAccept) {
      debugPrint('Audience ${guestUser.userName} accepted your invitation');
    } else {
      debugPrint('Audience ${guestUser.userName} refused your invitation');
    }
  },
);

// Add to the GuestListener configuration
_guestListener = GuestListener(
  onHostInvitationReceived: (hostUser) {
    debugPrint('Received mic connection invitation from Anchor ${hostUser.userName}');
    // Pop up a dialog box for user selection between "Accept" or "Reject"
    // showInvitationDialog(hostUser);
  },
);

final String inviterId = "anchor ID who initiates invitation"; // obtain from onHostInvitationReceived event

// User clicks "Accept"
Future<void> accept() async {
  final result = await guestStore.acceptInvitation(inviterId);
  if (result.isSuccess) {
    // Turn the mic on
    // DeviceStore is the device management module provided by AtomicXCore, used for managing microphones, cameras and other physical devices.
    // After accepting the invitation, turn on microphone to start collecting audio
    DeviceStore.shared.openLocalMicrophone();
  }
}

// User click "Reject"
Future<void> reject() async {
  await guestStore.rejectInvitation(inviterId);
}