/// 100ms SDK provides callbacks to the client app about any change or update happening in the room after a user has joined by implementing HMSUpdateListener.
/// These updates can be used to render the video on the screen or to display other info regarding the room.
abstract class HMSUpdateListener {


  /// This will be called on a successful JOIN of the room by the user
  ///
  /// This is the point where applications can stop showing their loading state
  /// [room]: the room which was joined
  void onJoin({required HMSRoom room});


  /// This will be called whenever there is an update on an existing peer
  /// or a new peer got added/existing peer is removed.
  ///
  /// This callback can be used to keep a track of all the peers in the room
  /// [peer]: the peer who joined/left or was updated
  /// [update]: the triggered update type. Should be used to perform different UI Actions
  void onPeerUpdate({required HMSPeer peer, required HMSPeerUpdate update});


  /// This is called when there are updates on an existing track
  /// or a new track got added/existing track is removed
  ///
  /// This callback can be used to render the video on screen whenever a track gets added
  ///  [track]: the track which was added, removed or updated
  ///  [trackUpdate]: the triggered update type
  ///  [peer]: the peer for which track was added, removed or updated
  void onTrackUpdate({required HMSTrack track, required HMSTrackUpdate trackUpdate, required HMSPeer peer});


  /// This will be called when there is an error in the system
  /// and SDK has already retried to fix the error
  /// [error]: the error that occurred
  void onHMSError({required HMSException error});


  /// This is called when there is a new broadcast message from any other peer in the room
  ///
  /// This can be used to implement chat is the room
  /// [message]: the received broadcast message
  void onMessage({required HMSMessage message});


  /// This is called every 1 second with a list of active speakers
  ///
  /// ## A HMSSpeaker object contains -
  ///    - peerId: the peer identifier of HMSPeer who is speaking
  ///    - trackId: the track identifier of HMSTrack which is emitting audio
  ///    - audioLevel: a number within range 1-100 indicating the audio volume
  ///
  /// A peer who is not present in the list indicates that the peer is not speaking
  ///
  /// This can be used to highlight currently speaking peers in the room
  /// [speakers] the list of speakers
  void onUpdateSpeakers({required List<HMSSpeaker> updateSpeakers});


  /// This is called when there is a change in any property of the Room
  ///
  ///  [room]: the room which was joined
  ///  [update]: the triggered update type. Should be used to perform different UI Actions
  void onRoomUpdate({required HMSRoom room, required HMSRoomUpdate update});


  /// when network or some other error happens it will be called
  void onReconnecting();


  /// when you are back in the room after reconnection
  void onReconnected();


  /// This is called when someone asks for a change or role
  ///
  /// for eg. admin can ask a peer to become host from guest.
  /// this triggers this call on peer's app
  void onRoleChangeRequest({required HMSRoleChangeRequest roleChangeRequest});


  /// when someone requests for track change of yours be it video or audio this will be triggered
  /// [hmsTrackChangeRequest] request instance consisting of all the required info about track change
  void onChangeTrackStateRequest({required HMSTrackChangeRequest hmsTrackChangeRequest});


  /// when someone kicks you out or when someone ends the room at that time it is triggered
  /// [hmsPeerRemovedFromPeer] it consists of info about who removed you and why.
  void onRemovedFromRoom({required HMSPeerRemovedFromPeer hmsPeerRemovedFromPeer});


  /// whenever a new audio device is plugged in or audio output is changed we
  /// get the onAudioDeviceChanged update
  /// This callback is only fired on Android devices. On iOS, this callback will not be triggered.
  /// - Parameters:
  ///   - currentAudioDevice: Current audio output route
  ///   - availableAudioDevice: List of available audio output devices
  void onAudioDeviceChanged(
      {HMSAudioDevice? currentAudioDevice,
      List<HMSAudioDevice>? availableAudioDevice});


  /// Whenever a user joins a room [onSessionStoreAvailable] is fired to get an instance of [HMSSessionStore]
  /// which can be used to perform session metadata operations
  /// - Parameters:
  ///   - hmsSessionStore: An instance of HMSSessionStore which will be used to call session metadata methods
  void onSessionStoreAvailable(
      {HMSSessionStore? hmsSessionStore});


  /// Upon joining a room with existing peers, onPeerListUpdated will be called with the list of peers present
  /// in the room instead of getting onPeerUpdate for each peer in the room.
  /// Subsequent peer joins/leaves would be notified via both onPeerUpdate and onPeerListUpdated
  void onPeerListUpdate(
      {required List<HMSPeer> addedPeers, required List<HMSPeer> removedPeers});
}

  //This returns an object of Future<dynamic> which can be either
  //of HMSException type or String? type based on whether
  //method execution is completed successfully or not

  dynamic authToken = await hmsSDK.getAuthTokenByRoomCode(roomCode: 'YOUR_ROOM_CODE');

  if(authToken is String){
    HMSConfig roomConfig = HMSConfig(
        authToken: authToken,
        userName: userName,
      );

    hmsSDK.join(config: roomConfig);
  }
  else if(authToken is HMSException){
    // Handle the error
  }

// create a class that implements `HMSUpdateListener` and acts as a data source for our UI
class Meeting implements HMSUpdateListener {

    late HMSSDK hmsSDK;

    Meeting() {
        initHMSSDK();
    }

    void initHMSSDK() async {
        hmsSDK = HMSSDK(); // create an instance of `HMSSDK` by invoking it's constructor
        await hmsSDK.build(); // ensure to await while invoking the `build` method
        hmsSDK.addUpdateListener(this); // `this` value corresponds to the instance implementing HMSUpdateListener
        HMSConfig config = HMSConfig(authToken: 'eyJH5c', // client-side token generated from your token service
                                userName: 'John Appleseed');
        hmsSDK.join(config: config); // Now, we are primed to join the room. All you have to do is call `join` by passing the `config` object.
    }

    ... // implement methods of HMSUpdateListener
}

HMSVideoView(
  track: videoTrack,
  key: Key(videoTrack.trackId),
),

// updateListener is the instance of class in which HMSUpdateListener is implemented
hmsSDK.removeUpdateListener(updateListener);

class Meeting implements HMSActionResultListener{
//this is the instance of class implementing HMSActionResultListener
await hmsSDK.leave(hmsActionResultListener: this);

@override
  void onSuccess(
      {HMSActionResultListenerMethod methodType = HMSActionResultListenerMethod.unknown, Map<String, dynamic>? arguments}) {
        switch (methodType) {
          case HMSActionResultListenerMethod.leave:
          // Room leaved successfully
          // Clear the local room state
          break;
          ...
        }
      }
}

HMSTrack
    - AudioTrack
        - LocalAudioTrack
        - RemoteAudioTrack
    - VideoTrack
        - LocalVideoTrack
        - RemoteVideoTrack

// onMessage is HMSUpdateListener method called when a new message is received
@override
void onMessage({required HMSMessage message}) {
  //Here we will receive messages sent by other peers
}


///[message]: Message to be sent
///[type]: Message type(More about this at the end)
///[hmsActionResultListener]: instance of class implementing HMSActionResultListener
//Here this is an instance of class that implements HMSActionResultListener i.e. Meeting
hmsSDK.sendBroadcastMessage(
  message: message,
  type: type,
  hmsActionResultListener: this);


///[message]: Message to be sent
///[peerTo]: Peer to whom message needs to be sent
///[type]: Message type(More about this at the end)
///[hmsActionResultListener]: instance of class implementing HMSActionResultListener
//Here this is an instance of class that implements HMSActionResultListener i.e. Meeting
hmsSDK.sendDirectMessage(
  message: message,
  peerTo: peerTo,
  type: type,
  hmsActionResultListener: this);


///[message]: Message to be sent
///[hmsRolesTo]: Roles to which this message needs to be sent
///[type]: Message type(More about this at the end)
///[hmsActionResultListener]: instance of class implementing HMSActionResultListener
//Here this is an instance of class that implements HMSActionResultListener i.e. Meeting
hmsSDK.sendGroupMessage(
    message: message,
    hmsRolesTo: rolesToSendMessage,
    type: type,
    hmsActionResultListener: this);



@override
void onSuccess(
  {HMSActionResultListenerMethod methodType =
    HMSActionResultListenerMethod.unknown,
    Map<String, dynamic>? arguments}) {

    switch (methodType) {

      case HMSActionResultListenerMethod.sendBroadcastMessage:
      //Broadcast Message sent successfully
      break;

      case HMSActionResultListenerMethod.sendGroupMessage:
      //Group Message sent successfully
      break;

      case HMSActionResultListenerMethod.sendDirectMessage:
      //Direct Message sent successfully
      break;
      ...
    }
  }


@override
void onException(
  {HMSActionResultListenerMethod methodType =
    HMSActionResultListenerMethod.unknown,
    Map<String, dynamic>? arguments,
    required HMSException hmsException}) {

    switch (methodType) {

      case HMSActionResultListenerMethod.sendBroadcastMessage:
      // Check the HMSException object for details about the error
      break;

      case HMSActionResultListenerMethod.sendGroupMessage:
      // Check the HMSException object for details about the error
      break;

      case HMSActionResultListenerMethod.sendDirectMessage:
      // Check the HMSException object for details about the error
      break;
      ...
    }

  }