index.ts

import {isEqual, assignWith, cloneDeep, isEmpty} from 'lodash';
import uuid from 'uuid';
import {webexTrackingIdSequenceNumbers} from '@webex/webex-core';

import LoggerProxy from '../common/logs/logger-proxy';
import EventsScope from '../common/events/events-scope';
import {
  EVENTS,
  LOCUSEVENT,
  _USER_,
  _CALL_,
  _SIP_BRIDGE_,
  MEETING_STATE,
  _MEETING_,
  _SPACE_SHARE_,
  LOCUSINFO,
  LOCUS,
  _LEFT_,
  MEETING_REMOVED_REASON,
  CALL_REMOVED_REASON,
  RECORDING_STATE,
  Enum,
  SELF_ROLES,
} from '../constants';

import InfoUtils from './infoUtils';
import FullState from './fullState';
import SelfUtils from './selfUtils';
import HostUtils from './hostUtils';
import ControlsUtils from './controlsUtils';
import EmbeddedAppsUtils from './embeddedAppsUtils';
import MediaSharesUtils from './mediaSharesUtils';
import LocusDeltaParser from './parser';
import Metrics from '../metrics';
import BEHAVIORAL_METRICS from '../metrics/constants';
import HashTreeParser, {
  DataSet,
  HashTreeMessage,
  LocusInfoUpdate,
  LocusInfoUpdateType,
  Metadata,
  SyncLatencyTracker,
} from '../hashTree/hashTreeParser';
import {HashTreeObject, ObjectType, ObjectTypeToLocusKeyMap} from '../hashTree/types';
import {isMetadata, isSelf} from '../hashTree/utils';
import {Links, LocusDTO, ReplacesInfo} from './types';
import MeetingsUtil from '../meetings/util';
import {MEETING_KEY} from '../meetings/meetings.types';
import MeetingCollection from '../meetings/collection';

export type LocusLLMEvent = {
  trackingId?: string;
  data: {
    eventType: typeof LOCUSEVENT.HASH_TREE_DATA_UPDATED;
    stateElementsMessage: HashTreeMessage;
  };
};

// list of top level keys in Locus DTO relevant for Hash Tree DTOs processing
// it does not contain fields specific to classic Locus DTOs like sequence or baseSequence
const LocusDtoTopLevelKeys = [
  'controls',
  'fullState',
  'embeddedApps',
  'host',
  'info',
  'links',
  'mediaShares',
  'meetings',
  'participants',
  'replaces',
  'self',
  'sequence',
  'syncUrl',
  'url',
  'htMeta', // only exists when hash trees are used
];

export type LocusApiResponseBody =
  | {
      dataSets?: DataSet[];
      locus: LocusDTO; // this LocusDTO here might not be the full one (for example it won't have all the participants, but it should have self)
      metadata?: Metadata;
    }
  | LocusDTO; // when we invoke APIs on the whole Locus like "mute all" backend returns the whole Locus in the response like this

const LocusObjectStateAfterUpdates = {
  unchanged: 'unchanged',
  removed: 'removed',
  updated: 'updated',
} as const;

type LocusObjectStateAfterUpdates = Enum<typeof LocusObjectStateAfterUpdates>;

export type HashTreeParserEntry = {
  parser: HashTreeParser;
  replacedAt?: string;
  initializedFromHashTree: boolean;
};

export type LocusInfoCallbacks = {
  updateMeeting: (object: any) => void;
  syncLatencyTracker?: SyncLatencyTracker;
};

/**
 * Gets the replacement information
 *
 * @param {any} self - "self" object from Locus DTO
 * @param {string} deviceUrl - The URL of the specified device
 * @returns {any} The replace information if available, otherwise undefined
 */
function getReplaceInfoFromSelf(self: any, deviceUrl: string): ReplacesInfo | undefined {
  if (self) {
    const device = MeetingsUtil.getThisDevice({self}, deviceUrl);

    if (device?.replaces?.length > 0) {
      return device.replaces[0];
    }
  }

  return undefined;
}

/**
 * Finds a meeting by its locus URL in meeting collection. It checks all HashTreeParsers of all meetings in the collection.
 *
 * @param {MeetingCollection} meetingCollection - The collection of meetings to search
 * @param {string} locusUrl - The locus URL to search for
 * @returns {any} The meeting if found, otherwise undefined
 */
function findLocusUrlInAnyHashTreeParser(
  meetingCollection: MeetingCollection,
  locusUrl: string
): any {
  for (const meeting of Object.values(meetingCollection.getAll()) as any[]) {
    if (meeting?.locusInfo?.hashTreeParsers?.has(locusUrl)) {
      return meeting;
    }
  }

  return undefined;
}

/**
 * Finds a meeting for a given hash tree message.
 *
 * @param {HashTreeMessage} message - The hash tree message to find the meeting for
 * @param {MeetingCollection} meetingCollection - The collection of meetings to search
 * @returns {any} The meeting if found, otherwise undefined
 */
export function findMeetingForHashTreeMessage(
  message: HashTreeMessage | undefined,
  meetingCollection: MeetingCollection
): any {
  if (!message) {
    return undefined;
  }
  let foundMeeting = findLocusUrlInAnyHashTreeParser(meetingCollection, message.locusUrl);

  if (foundMeeting) {
    return foundMeeting;
  }

  // if we haven't found anything, it may mean that message has a new locusUrl
  // check if it indicates that it replaces some existing current locusUrl (this is indicated in "self")
  const self = message.locusStateElements?.find((el) => isSelf(el))?.data;
  const replaces = getReplaceInfoFromSelf(self, self?.deviceUrl);

  if (replaces?.locusUrl) {
    foundMeeting = findLocusUrlInAnyHashTreeParser(meetingCollection, replaces.locusUrl);

    return foundMeeting;
  }

  return undefined;
}

/**
 * Creates a locus object from the objects received in a hash tree message. It usually will be
 * incomplete, because hash tree messages only contain the parts of locus that have changed,
 * and some updates come separately over Mercury or LLM in separate messages.
 *
 * @param {HashTreeMessage} message hash tree message to created the locus from
 * @returns {Object} the created locus object and metadata if present
 */
export function createLocusFromHashTreeMessage(message: HashTreeMessage): {
  locus: LocusDTO;
  metadata?: Metadata;
} {
  const locus: LocusDTO = {
    participants: [],
    url: message.locusUrl,
  };
  let metadata: Metadata | undefined;

  if (!message.locusStateElements) {
    return {locus, metadata};
  }

  for (const element of message.locusStateElements) {
    if (!element.data) {
      // eslint-disable-next-line no-continue
      continue;
    }

    const type = element.htMeta.elementId.type.toLowerCase();

    switch (type) {
      case ObjectType.locus: {
        // spread locus object data onto the top level, but remove keys managed by other ObjectTypes
        const locusObjectData = {...element.data};

        Object.values(ObjectTypeToLocusKeyMap).forEach((locusDtoKey) => {
          delete locusObjectData[locusDtoKey];
        });

        Object.assign(locus, locusObjectData);
        break;
      }
      case ObjectType.participant:
        locus.participants.push(element.data);
        break;
      case ObjectType.mediaShare:
        if (!locus.mediaShares) {
          locus.mediaShares = [];
        }
        locus.mediaShares.push(element.data);
        break;
      case ObjectType.embeddedApp:
        if (!locus.embeddedApps) {
          locus.embeddedApps = [];
        }
        locus.embeddedApps.push(element.data);
        break;
      case ObjectType.control:
        if (!locus.controls) {
          locus.controls = {};
        }
        Object.assign(locus.controls, element.data);
        break;
      case ObjectType.links:
      case ObjectType.info:
      case ObjectType.fullState:
      case ObjectType.self: {
        const locusDtoKey = ObjectTypeToLocusKeyMap[type];
        locus[locusDtoKey] = element.data;
        break;
      }
      case ObjectType.metadata:
        // metadata is not part of Locus DTO
        metadata = {...element.data, htMeta: element.htMeta} as Metadata;
        break;
      default:
        break;
    }
  }

  return {locus, metadata};
}

/**
 * @description LocusInfo extends ChildEmitter to convert locusInfo info a private emitter to parent object
 * @export
 * @private
 * @class LocusInfo
 */
export default class LocusInfo extends EventsScope {
  compareAndUpdateFlags: any;
  emitChange: any;
  locusParser: any;
  meetingId: any;
  parsedLocus: any;
  webex: any;
  aclUrl: any;
  baseSequence: any;
  created: any;
  participants: any;
  replaces: any;
  scheduledMeeting: any;
  sequence: any;
  controls: any;
  conversationUrl: any;
  embeddedApps: any;
  fullState: any;
  host: any;
  info: any;
  roles: any;
  mediaShares: any;
  url: any;
  links?: Links;
  mainSessionLocusCache: any;
  self: any;
  hashTreeParsers: Map<string, HashTreeParserEntry>;
  hashTreeObjectId2ParticipantId: Map<number, string>; // mapping of hash tree object ids to participant ids
  classicVsHashTreeMismatchMetricCounter = 0;
  private callbacks: LocusInfoCallbacks;
  private destroyMeetingSuspended = false;

  /**
   * Constructor
   * @param {Object} callbacks callbacks used by LocusInfo
   * @param {function} callbacks.updateMeeting callback to update the meeting object from an object
   * @param {object} webex
   * @param {string} meetingId
   * @returns {undefined}
   */
  constructor(callbacks: LocusInfoCallbacks, webex: any, meetingId: any) {
    super();
    this.parsedLocus = {
      states: [],
    };
    this.callbacks = callbacks;
    this.webex = webex;
    this.emitChange = false;
    this.compareAndUpdateFlags = {};
    this.meetingId = meetingId;
    this.locusParser = new LocusDeltaParser();
    this.hashTreeParsers = new Map();
    this.hashTreeObjectId2ParticipantId = new Map();
  }

  /**
   * Does a Locus sync. It tries to get the latest delta DTO or if it can't, it falls back to getting the full Locus DTO.
   * WARNING: This function must not be used for hash tree based Locus meetings.
   *
   * @param {Meeting} meeting
   * @param {boolean} isLocusUrlChanged
   * @param {Locus} locus
   * @returns {undefined}
   */
  private doLocusSync(meeting: any, isLocusUrlChanged: boolean, locus: any) {
    let url;
    let isDelta = false;
    let meetingDestroyed = false;

    if (isLocusUrlChanged) {
      // for the locus url changed case from breakout to main session, we should always do a full sync, in this case, the url from locus is always on main session,
      // so use the main session locus url to get the full locus(full participants list in the response).
      // for the locus url changed case from main session to breakout, we don't need to care about it here,
      // because it is a USE_INCOMING case, it will not be executed here.
      url = locus.url;
    } else if (this.locusParser.workingCopy?.syncUrl) {
      url = this.locusParser.workingCopy.syncUrl;
      isDelta = true;
    } else {
      url = meeting.locusUrl;
    }

    LoggerProxy.logger.info(
      `Locus-info:index#doLocusSync --> doing Locus sync (getting ${
        isDelta ? 'delta' : 'full'
      } DTO)`
    );

    // return value ignored on purpose
    meeting.meetingRequest
      .getLocusDTO({url})
      .catch((e) => {
        if (isDelta) {
          LoggerProxy.logger.info(
            'Locus-info:index#doLocusSync --> delta sync failed, falling back to full sync'
          );

          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_DELTA_SYNC_FAILED, {
            correlationId: meeting.correlationId,
            url,
            reason: e.message,
            errorName: e.name,
            stack: e.stack,
            code: e.code,
          });

          isDelta = false;

          // Locus sometimes returns 403, for example if meeting has ended, no point trying the fallback to full sync in that case
          if (e.statusCode !== 403) {
            return meeting.meetingRequest.getLocusDTO({url: meeting.locusUrl}).catch((err) => {
              LoggerProxy.logger.info(
                'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
              );
              this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
              meetingDestroyed = true;
              throw err;
            });
          }
          LoggerProxy.logger.info(
            'Locus-info:index#doLocusSync --> got 403 from Locus, skipping fallback to full sync, destroying the meeting'
          );
        } else {
          LoggerProxy.logger.info(
            'Locus-info:index#doLocusSync --> fallback full sync failed, destroying the meeting'
          );
        }
        this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.LOCUS_DTO_SYNC_FAILED);
        meetingDestroyed = true;
        throw e;
      })
      .then((res) => {
        if (isEmpty(res.body)) {
          if (isDelta) {
            LoggerProxy.logger.info(
              'Locus-info:index#doLocusSync --> received empty body from syncUrl, so we already have latest Locus DTO'
            );
          } else {
            LoggerProxy.logger.info(
              'Locus-info:index#doLocusSync --> received empty body from full DTO sync request'
            );
          }

          return;
        }

        if (isDelta) {
          if (res.body.baseSequence) {
            meeting.locusInfo.handleLocusDelta(res.body, meeting);

            return;
          }
          // in some cases Locus might return us full DTO even when we asked for a delta
          LoggerProxy.logger.info(
            'Locus-info:index#doLocusSync --> got full DTO when we asked for delta'
          );
        }
        meeting.locusInfo.onFullLocus('classic Locus sync', res.body);
      })
      .catch((e) => {
        LoggerProxy.logger.info(
          `Locus-info:index#doLocusSync --> getLocusDTO succeeded but failed to handle result, locus parser will resume but not all data may be synced (${e.toString()})`
        );

        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_SYNC_HANDLING_FAILED, {
          correlationId: meeting.correlationId,
          url,
          reason: e.message,
          errorName: e.name,
          stack: e.stack,
          code: e.code,
        });
      })
      .finally(() => {
        if (!meetingDestroyed) {
          // Notify parser to resume processing delta events.
          // Any deltas in the queue that have now been superseded by this sync will simply be ignored
          this.locusParser.resume();
        }
      });
  }

  /**
   * Apply locus delta data to meeting
   * @param {string} action Locus delta action
   * @param {Locus} locus
   * @param {Meeting} meeting
   * @returns {undefined}
   */
  applyLocusDeltaData(action: string, locus: any, meeting: any) {
    const {DESYNC, USE_CURRENT, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = LocusDeltaParser.loci;
    const isLocusUrlChanged = action === LOCUS_URL_CHANGED;

    switch (action) {
      case USE_INCOMING:
        meeting.locusInfo.onDeltaLocus(locus);
        break;
      case USE_CURRENT:
      case WAIT:
        // do nothing
        break;
      case DESYNC:
      case LOCUS_URL_CHANGED:
        this.doLocusSync(meeting, isLocusUrlChanged, locus);
        break;
      default:
        LoggerProxy.logger.info(
          `Locus-info:index#applyLocusDeltaData --> Unknown locus delta action: ${action}`
        );
    }
  }

  /**
   * Adds locus delta to parser's queue
   * and registers a function handler
   * to recieve parsed actions from queue.
   * @param {Locus} locus
   * @param {Meeting} meeting
   * @returns {undefined}
   */
  handleLocusDelta(locus: any, meeting: any) {
    // register a function to process delta actions
    if (!this.locusParser.onDeltaAction) {
      // delta action, along with associated loci
      // is passed into the function.
      this.locusParser.onDeltaAction = (action, parsedLoci) => {
        this.applyLocusDeltaData(action, parsedLoci, meeting);
      };
    }
    // queue delta event with parser
    this.locusParser.onDeltaEvent(locus);
  }

  /**
   * @param {Locus} locus
   * @returns {undefined}
   * @memberof LocusInfo
   */
  init(locus: any = {}) {
    this.created = locus.created || null;
    this.scheduledMeeting = locus.meeting || null;
    this.replaces = locus.replaces || null;
    this.aclUrl = locus.aclUrl || null;
    this.baseSequence = locus.baseSequence || null;
    this.sequence = locus.sequence || null;
    this.participants = locus.participants || null;

    /**
     * Stores the delta values for a changed participant.
     *
     * @typedef {Object} DeltaParticipant
     * @property {Record<string, boolean>} delta - Contains changed streams.
     * @property {Object} person - Contains person data.
     */

    this.updateLocusCache(locus);
    // above section only updates the locusInfo object
    // The below section makes sure it updates the locusInfo as well as updates the meeting object
    this.updateParticipants(locus.participants, []);
    // For 1:1 space meeting the conversation Url does not exist in locus.conversation
    this.updateConversationUrl(locus.conversationUrl, locus.info);
    this.updateControls(locus.controls, locus.self);
    this.updateLocusUrl(locus.url, ControlsUtils.isMainSessionDTO(locus));
    this.updateFullState(locus.fullState);
    this.updateMeetingInfo(locus.info, locus.self);
    this.updateEmbeddedApps(locus.embeddedApps);
    // self and participants generate sipUrl for 1:1 meeting
    this.updateSelf(locus.self);
    this.updateHostInfo(locus.host);
    this.updateMediaShares(locus.mediaShares);
    this.updateLinks(locus.links);
  }

  /**
   * Creates a HashTreeParser instance for a given locusUrl and stores it in the map.
   * @param {Object} params
   * @param {string} params.locusUrl - the locus URL used as the map key
   * @param {Object} params.initialLocus - initial locus data
   * @param {Object} params.metadata - hash tree metadata
   * @param {string} params.replacedAt - timestamp from Locus indicating when the replacement happened
   * @returns {HashTreeParser} the newly created parser
   */
  private createHashTreeParser({
    locusUrl,
    initialLocus,
    metadata,
    replacedAt,
  }: {
    locusUrl: string;
    initialLocus: {
      dataSets: Array<DataSet>;
      locus: any;
    };
    metadata: Metadata | null;
    replacedAt?: string;
  }): HashTreeParser {
    const parser = new HashTreeParser({
      initialLocus,
      metadata,
      webexRequest: this.webex.request.bind(this.webex),
      callbacks: {
        locusInfoUpdateCallback: this.updateFromHashTree.bind(this, locusUrl),
        syncLatencyTracker: this.callbacks.syncLatencyTracker,
        isLlmExpected: () => this.parsedLocus.self?.joinedWith?.state === 'JOINED',
        // Reuse webex-core's tracking-id interceptor sequence (exposed publicly via
        // webexTrackingIdSequenceNumbers) so Locus requests share the client's unified
        // ${sessionId}_${sequence} tracking id space instead of minting an unrelated id. Fall
        // back to a uuid on the rare chance the interceptor hasn't issued any request yet (and so
        // isn't in the map). The value is opaque to the metrics layer and is forced onto the
        // /hashtree and /sync request headers.
        generateTrackingId: () => {
          const interceptor = [...webexTrackingIdSequenceNumbers.keys()].find(
            (candidate) => candidate?.webex === this.webex
          );

          return `${this.webex.sessionId}_${interceptor ? interceptor.sequence : uuid.v4()}`;
        },
      },
      debugId: `HT-${locusUrl.split('/')?.pop()?.substring(0, 4)}`,
      excludedDataSets: this.webex.config.meetings.locus?.excludedDataSets,
      syncLatencyMeetingId: this.meetingId,
    });

    // When a new HashTreeParser is created, previous one should be stopped.
    // Locus will only be sending us updates for the current one.
    for (const [existingLocusUrl, existingEntry] of this.hashTreeParsers) {
      if (existingEntry.parser.state !== 'stopped') {
        existingEntry.parser.stop();
        if (replacedAt) {
          existingEntry.replacedAt = replacedAt;
        } else {
          LoggerProxy.logger.warn(
            `Locus-info:index#createHashTreeParser --> no replacedAt timestamp provided for new HashTreeParser with locusUrl ${locusUrl}, replacing ${existingLocusUrl}`
          );
        }
      }
    }

    this.hashTreeParsers.set(locusUrl, {parser, initializedFromHashTree: false});
    this.hashTreeObjectId2ParticipantId.clear();

    return parser;
  }

  /**
   * @param {Object} data - data to initialize locus info with. It may be from a join or GET /loci response or from a Mercury event that triggers a creation of meeting object
   * @param {Function} [onLocusSynced] - optional callback that will be called at the end of initial setup, when locus info is fully synced. It will be called with the full locus snapshot as an argument (which may be null if we haven't received any full locus DTOs during the initial setup, for example in case we receive only hash tree messages without full locus DTOs)
   * @returns {undefined}
   * @memberof LocusInfo
   */
  async initialSetup(
    data:
      | {
          trigger: 'join-response';
          locus: LocusDTO;
          dataSets?: DataSet[];
          metadata?: Metadata;
        }
      | {
          trigger: 'locus-message';
          locus?: LocusDTO;
          hashTreeMessage?: HashTreeMessage;
        }
      | {
          trigger: 'get-loci-response';
          locus?: LocusDTO;
        },
    onLocusSynced?: (locus: LocusDTO) => void
  ) {
    let initialFullLocus: LocusDTO | null = null;
    switch (data.trigger) {
      case 'locus-message':
        if (data.hashTreeMessage) {
          // we need the Metadata object to be in the received message, because it contains visibleDataSets
          // and these are needed to initialize all the hash trees
          const metadataObject = data.hashTreeMessage.locusStateElements?.find((el) =>
            isMetadata(el)
          );

          if (!metadataObject?.data?.visibleDataSets) {
            // this is a common case (not an error)
            // it happens for example after we leave the meeting and still get some heartbeats or delayed messages
            LoggerProxy.logger.info(
              `Locus-info:index#initialSetup --> cannot initialize HashTreeParser, Metadata object with visibleDataSets is missing in the message`
            );

            // throw so that handleLocusEvent() catches it and destroys the partially created meeting object
            throw new Error('Metadata object with visibleDataSets is missing in the message');
          }

          LoggerProxy.logger.info(
            'Locus-info:index#initialSetup --> creating HashTreeParser from message'
          );
          // first create the HashTreeParser, but don't initialize it with any data yet
          const hashTreeParser = this.createHashTreeParser({
            locusUrl: data.hashTreeMessage.locusUrl,
            initialLocus: {
              locus: null,
              dataSets: data.hashTreeMessage.dataSets,
            },
            metadata: {
              htMeta: metadataObject.htMeta,
              visibleDataSets: metadataObject.data.visibleDataSets,
            },
          });

          // now handle the message - that should populate all the visible datasets
          await hashTreeParser.initializeFromMessage(data.hashTreeMessage);
        } else {
          // "classic" Locus case, no hash trees involved
          this.updateLocusCache(data.locus);
          this.onFullLocus('classic locus message', data.locus, undefined);
        }
        break;
      case 'join-response':
        this.updateLocusCache(data.locus);
        this.onFullLocus('join response', data.locus, undefined, data.dataSets, data.metadata);
        initialFullLocus = data.locus;
        break;
      case 'get-loci-response':
        if (data.locus?.links?.resources?.visibleDataSets?.url) {
          LoggerProxy.logger.info(
            'Locus-info:index#initialSetup --> creating HashTreeParser from get-loci-response'
          );
          // first create the HashTreeParser, but don't initialize it with any data yet
          const hashTreeParser = this.createHashTreeParser({
            locusUrl: data.locus.url as string,
            initialLocus: {
              locus: null,
              dataSets: [], // empty, because we don't have them yet
            },
            metadata: null, // get-loci-response doesn't contain Metadata object
          });

          // now initialize all the data
          await hashTreeParser.initializeFromGetLociResponse(data.locus);
        } else {
          // "classic" Locus case, no hash trees involved
          this.updateLocusCache(data.locus);
          this.onFullLocus('classic get-loci-response', data.locus, undefined);
          initialFullLocus = data.locus || null;
        }
    }

    if (onLocusSynced) {
      try {
        onLocusSynced(initialFullLocus || this.getCurrentLocusSnapshot());
      } catch (error) {
        LoggerProxy.logger.warn(
          `Locus-info:index#initialSetup --> onLocusSynced callback failed: ${error}`
        );
      }
    }

    // Change it to true after it receives it first locus object
    this.emitChange = true;
  }

  /**
   * Builds a full locus DTO snapshot from current internal locus state.
   *
   * @returns {LocusDTO}
   */
  private getCurrentLocusSnapshot(): LocusDTO {
    const locus: Record<string, any> = {};

    LocusDtoTopLevelKeys.forEach((key) => {
      const value = (this as Record<string, any>)[key];

      if (value !== undefined && value !== null) {
        locus[key] = cloneDeep(value);
      }
    });

    if (!Array.isArray(locus.participants)) {
      locus.participants = [];
    }

    return locus as LocusDTO;
  }

  /**
   * Handles HTTP response from Locus API call.
   * @param {Meeting} meeting meeting object
   * @param {LocusApiResponseBody} responseBody body of the http response from Locus API call
   * @returns {void}
   */
  handleLocusAPIResponse(meeting: any, responseBody: LocusApiResponseBody): void {
    const isWrapped = 'locus' in responseBody;
    const locusUrl = isWrapped ? responseBody.locus?.url : responseBody.url;
    const hashTreeParserEntry = locusUrl && this.hashTreeParsers.get(locusUrl);
    const locus = isWrapped
      ? (responseBody as {locus: LocusDTO}).locus
      : (responseBody as LocusDTO);

    if (this.hashTreeParsers.size > 0) {
      // We are in hash tree mode. Check if we need to create/reactivate a parser for this locusUrl.
      if (!hashTreeParserEntry || hashTreeParserEntry.parser.state === 'stopped') {
        if (!locusUrl) {
          LoggerProxy.logger.warn(
            'Locus-info:index#handleLocusAPIResponse --> API response has no locusUrl, cannot handle hash tree parser switch'
          );

          return;
        }

        this.handleHashTreeParserSwitchForAPIResponse(locusUrl, locus);

        return;
      }

      // Active parser found - pass the API response to it
      if (isWrapped) {
        // update the data in our hash trees
        hashTreeParserEntry.parser.handleLocusUpdate(responseBody);
      } else {
        // LocusDTO without wrapper - pass it through as if it had no dataSets nor metadata
        hashTreeParserEntry.parser.handleLocusUpdate({locus: responseBody});
      }

      return;
    }

    // No hash tree parsers - classic Locus mode
    if (isWrapped && responseBody.dataSets) {
      this.sendClassicVsHashTreeMismatchMetric(
        meeting,
        `unexpected hash tree dataSets in API response`
      );
    }

    // classic Locus delta
    this.handleLocusDelta(locus, meeting);
  }

  /**
   * @param {HashTreeObject} object data set object
   * @param {any} locus
   * @returns {void}
   */
  updateLocusFromHashTreeObject(object: HashTreeObject, locus: LocusDTO): LocusDTO {
    const type = object.htMeta.elementId.type.toLowerCase();

    const addParticipantObject = (obj: HashTreeObject) => {
      if (!locus.participants) {
        locus.participants = [];
      }
      locus.participants.push(obj.data);
      this.hashTreeObjectId2ParticipantId.set(obj.htMeta.elementId.id, obj.data.id);
    };

    switch (type) {
      case ObjectType.locus: {
        if (!object.data) {
          // not doing anything here, as we need Locus to always be there (at least some fields)
          // and that's already taken care of in updateFromHashTree()
          LoggerProxy.logger.info(
            `Locus-info:index#updateLocusFromHashTreeObject --> LOCUS object removed, version=${object.htMeta.elementId.version}`
          );

          return locus;
        }
        // replace the main locus

        // The Locus object we receive from backend has empty participants array,
        // and may have (although it shouldn't) other fields that are managed by other ObjectTypes
        // like "fullState" or "info", so we're making sure to delete them here
        const locusObjectFromData = object.data;

        Object.values(ObjectTypeToLocusKeyMap).forEach((locusDtoKey) => {
          delete locusObjectFromData[locusDtoKey];
        });

        locus = {...locus, ...locusObjectFromData};
        LoggerProxy.logger.info(
          `Locus-info:index#updateLocusFromHashTreeObject --> LOCUS object updated to version=${object.htMeta.elementId.version}`
        );
        break;
      }
      case ObjectType.mediaShare:
        if (object.data) {
          LoggerProxy.logger.info(
            `Locus-info:index#updateLocusFromHashTreeObject --> mediaShare id=${
              object.htMeta.elementId.id
            } name='${object.data.name}' updated ${
              object.data.name === 'content'
                ? `floor=${object.data.floor?.disposition}, ${object.data.floor?.beneficiary?.id}`
                : ''
            } version=${object.htMeta.elementId.version}`
          );
          const existingMediaShare = locus.mediaShares?.find(
            (ms) => ms.htMeta.elementId.id === object.htMeta.elementId.id
          );

          if (existingMediaShare) {
            Object.assign(existingMediaShare, object.data);
          } else {
            locus.mediaShares = locus.mediaShares || [];
            locus.mediaShares.push(object.data);
          }
        } else {
          LoggerProxy.logger.info(
            `Locus-info:index#updateLocusFromHashTreeObject --> mediaShare id=${object.htMeta.elementId.id} removed, version=${object.htMeta.elementId.version}`
          );
          locus.mediaShares = locus.mediaShares?.filter(
            (ms) => ms.htMeta.elementId.id !== object.htMeta.elementId.id
          );
        }
        break;
      case ObjectType.embeddedApp:
        if (object.data) {
          LoggerProxy.logger.info(
            `Locus-info:index#updateLocusFromHashTreeObject --> embeddedApp id=${object.htMeta.elementId.id} url='${object.data.url}' updated version=${object.htMeta.elementId.version}:`,
            object.data
          );
          const existingEmbeddedApp = locus.embeddedApps?.find(
            (ms) => ms.htMeta.elementId.id === object.htMeta.elementId.id
          );

          if (existingEmbeddedApp) {
            Object.assign(existingEmbeddedApp, object.data);
          } else {
            locus.embeddedApps = locus.embeddedApps || [];
            locus.embeddedApps.push(object.data);
          }
        } else {
          LoggerProxy.logger.info(
            `Locus-info:index#updateLocusFromHashTreeObject --> embeddedApp id=${object.htMeta.elementId.id} removed, version=${object.htMeta.elementId.version}`
          );
          locus.embeddedApps = locus.embeddedApps?.filter(
            (ms) => ms.htMeta.elementId.id !== object.htMeta.elementId.id
          );
        }
        break;
      case ObjectType.participant:
        LoggerProxy.logger.info(
          `Locus-info:index#updateLocusFromHashTreeObject --> participant id=${
            object.htMeta.elementId.id
          } ${object.data ? 'updated' : 'removed'} version=${object.htMeta.elementId.version}`
        );
        if (object.data) {
          addParticipantObject(object);
        } else {
          const participantId = this.hashTreeObjectId2ParticipantId.get(object.htMeta.elementId.id);

          if (!locus.jsSdkMeta) {
            locus.jsSdkMeta = {removedParticipantIds: []};
          }
          locus.jsSdkMeta.removedParticipantIds.push(participantId);
          this.hashTreeObjectId2ParticipantId.delete(object.htMeta.elementId.id);
        }
        // Create self from the participant if it matches self identity and is being moved.
        // We need this, because participant update comes in LLM message often before the self update from Mercury.
        // Other parts of the code detect move only by looking at self, while some other parts of the SDK/webapp code
        // look at participant for roles etc, so if participant is updated but not self, then it looks like we our lost roles temporarily
        // (until self is updated)
        // This will be fixed properly in SPARK-790239
        if (
          object.data &&
          object.data.identity === locus.self?.identity &&
          object.data.state === 'LEFT' &&
          object.data.reason === 'MOVED'
        ) {
          LoggerProxy.logger.info(
            `Locus-info:index#updateLocusFromHashTreeObject --> FOUND a match for MOVED self in participant object ${object.htMeta.elementId.id}`
          );
          Object.assign(locus[ObjectTypeToLocusKeyMap[ObjectType.self]], object.data);
        }
        break;
      case ObjectType.control:
        if (object.data) {
          Object.keys(object.data).forEach((controlKey) => {
            LoggerProxy.logger.info(
              `Locus-info:index#updateLocusFromHashTreeObject --> control ${controlKey} updated:`,
              object.data[controlKey]
            );
            if (!locus.controls) {
              locus.controls = {};
            }
            locus.controls[controlKey] = object.data[controlKey];
          });
        } else {
          LoggerProxy.logger.warn(
            `Locus-info:index#updateLocusFromHashTreeObject --> control object update without data - this is not expected!`
          );
        }
        break;
      case ObjectType.links:
      case ObjectType.info:
      case ObjectType.fullState:
      case ObjectType.self:
        if (!object.data) {
          // self without data is handled inside HashTreeParser and results in LocusInfoUpdateType.MEETING_ENDED, so we should never get here
          // all other types info, fullstate, etc - Locus should never send them without data
          // but we end up with this method being called without the data for them when the main dataset is removed from visible datasets list
          LoggerProxy.logger.info(
            `Locus-info:index#updateLocusFromHashTreeObject --> received ${type} object without data, version=${object.htMeta.elementId.version}`
          );
        } else {
          LoggerProxy.logger.info(
            `Locus-info:index#updateLocusFromHashTreeObject --> ${type} object updated to version ${object.htMeta.elementId.version}`
          );

          if (type === ObjectType.self) {
            LoggerProxy.logger.info(
              `Locus-info:index#updateLocusFromHashTreeObject --> self data: removed=${object.data.removed} state=${object.data.state} reason=${object.data.reason}`
            );
          }

          const locusDtoKey = ObjectTypeToLocusKeyMap[type] as keyof LocusDTO;
          locus[locusDtoKey] = object.data;

          /* Hash tree based webinar attendees don't receive a Participant object for themselves from Locus,
             but a lot of existing code in SDK and web app expects a member object for self to exist,
             so whenever SELF changes for a webinar attendee, we copy it into a participant object.
             We can do it, because SELF has always all the same properties as a participant object.
          */
          if (
            type === ObjectType.self &&
            locus.info?.isWebinar &&
            object.data.controls?.role?.roles?.find(
              (r) => r.type === SELF_ROLES.ATTENDEE && r.hasRole
            )
          ) {
            LoggerProxy.logger.info(
              `Locus-info:index#updateLocusFromHashTreeObject --> webinar attendee: creating participant object from self`
            );
            addParticipantObject(object);
          }
        }
        break;
      case ObjectType.metadata:
        LoggerProxy.logger.info(
          `Locus-info:index#updateLocusFromHashTreeObject --> metadata object updated to version ${object.htMeta.elementId.version}`
        );
        // we don't use hash tree metadata right now for anything, it's mainly used internally by HashTreeParser
        break;
      default:
        LoggerProxy.logger.warn(
          `Locus-info:index#updateLocusFromHashTreeObject --> received unsupported object type ${type}`
        );
        break;
    }

    return locus;
  }

  /**
   * Sends a metric when we receive something from Locus that uses hash trees while we
   * expect classic deltas or the other way around.
   * @param {Meeting} meeting
   * @param {string} message
   * @returns {void}
   */
  sendClassicVsHashTreeMismatchMetric(meeting: any, message: string) {
    LoggerProxy.logger.warn(
      `Locus-info:index#sendClassicVsHashTreeMismatchMetric --> classic vs hash tree mismatch! ${message}`
    );

    // we don't want to flood the metrics system
    if (this.classicVsHashTreeMismatchMetricCounter < 5) {
      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.LOCUS_CLASSIC_VS_HASH_TREE_MISMATCH, {
        correlationId: meeting.correlationId,
        message,
      });
      this.classicVsHashTreeMismatchMetricCounter += 1;
    }
  }

  /**
   * Helper that handles the common logic for reactivating a stopped HashTreeParser when
   * a newer "replaces" is detected. Used by both the message and API response parser switch methods.
   *
   * @param {string} callerName - name of the calling method, used in log messages
   * @param {string} locusUrl - the locus URL of the stopped parser
   * @param {HashTreeParserEntry} stoppedEntry - the stopped parser entry
   * @param {ReplacesInfo} replaces - replacement info extracted from self
   * @param {Function} resumeCallback - callback to invoke after reactivation to resume the parser
   * @returns {void}
   */
  private resumeStoppedParser(
    callerName: string,
    locusUrl: string,
    stoppedEntry: HashTreeParserEntry,
    replaces: ReplacesInfo | undefined,
    resumeCallback: () => void
  ): void {
    // this check is just for typescript, it should never happen, replaces should always be defined
    if (!replaces) {
      LoggerProxy.logger.info(
        `Locus-info:index#${callerName} --> received data for stopped HashTreeParser with locusUrl ${locusUrl}, but no replaces info provided, so not re-activating the parser`
      );

      return;
    }

    if (replaces.replacedAt <= (stoppedEntry.replacedAt || '')) {
      LoggerProxy.logger.info(
        `Locus-info:index#${callerName} --> received data for stopped HashTreeParser with locusUrl ${locusUrl}, but replaces info provided is not newer, so not re-activating the parser`
      );

      return;
    }

    LoggerProxy.logger.info(
      `Locus-info:index#${callerName} --> reactivating HashTreeParser for locusUrl=${locusUrl}, which replaces ${replaces.locusUrl}`
    );

    const replacedEntry = this.hashTreeParsers.get(replaces.locusUrl);

    if (replacedEntry) {
      replacedEntry.replacedAt = replaces.replacedAt;
      replacedEntry.parser.stop();
    } else {
      LoggerProxy.logger.warn(
        `Locus-info:index#${callerName} --> the parser that is supposed to be replaced with the currently reactivated parser is not found, locusUrl=${replaces.locusUrl}`
      );
    }

    stoppedEntry.initializedFromHashTree = false;
    this.hashTreeObjectId2ParticipantId.clear();

    resumeCallback();
  }

  /**
   * Handles an API response whose locusUrl doesn't match any active HashTreeParser
   * (either no entry exists, or the existing entry is stopped).
   * Creates a new parser or reactivates a stopped one using initializeFromGetLociResponse.
   *
   * @param {string} locusUrl - the locus URL from the API response
   * @param {LocusDTO} locus - the locus DTO from the API response
   * @returns {void}
   */
  private handleHashTreeParserSwitchForAPIResponse(locusUrl: string, locus: LocusDTO): void {
    const entry = this.hashTreeParsers.get(locusUrl);

    const replaces = getReplaceInfoFromSelf(
      locus.self,
      // @ts-ignore
      this.webex.internal.device.url
    );

    if (!entry) {
      LoggerProxy.logger.info(
        `Locus-info:index#handleHashTreeParserSwitchForAPIResponse --> no parser for locusUrl ${locusUrl}, creating a new one`
      );

      const parser = this.createHashTreeParser({
        locusUrl,
        initialLocus: {locus: null, dataSets: []},
        metadata: null,
        replacedAt: replaces?.replacedAt,
      });

      parser.initializeFromGetLociResponse(locus);

      return;
    }

    if (entry.parser.state !== 'stopped') {
      LoggerProxy.logger.warn(
        `Locus-info:index#handleHashTreeParserSwitchForAPIResponse --> unexpected parser state "${entry.parser.state}" for locusUrl ${locusUrl}`
      );

      return;
    }

    this.resumeStoppedParser(
      'handleHashTreeParserSwitchForAPIResponse',
      locusUrl,
      entry,
      replaces,
      () => entry.parser.resumeFromApiResponse(locus)
    );
  }

  /**
   * Checks if the hash tree message should trigger a switch to a different HashTreeParser
   *
   * @param {HashTreeMessage} message incoming hash tree message
   * @returns {boolean} true if the message was handled as a parser switch, false otherwise
   */
  private handleHashTreeParserSwitch(message: HashTreeMessage): boolean {
    const entry = this.hashTreeParsers.get(message.locusUrl);

    const self = message.locusStateElements?.find((el) => isSelf(el))?.data;
    const replaces = getReplaceInfoFromSelf(
      self,
      // @ts-ignore
      this.webex.internal.device.url
    );

    if (!entry) {
      // Metadata object that contains information about visible datasets is needed to initialize the HashTreeParser,
      // but it's buried inside the message, we need to find it and pass it to HashTreeParser constructor
      const metadata = message.locusStateElements?.find((el) => isMetadata(el));

      if (metadata && metadata.data?.visibleDataSets?.length > 0) {
        LoggerProxy.logger.info(
          `Locus-info:index#handleHashTreeParserSwitch --> no hash tree parser found for locusUrl ${message.locusUrl}, creating a new one`
        );

        const parser = this.createHashTreeParser({
          locusUrl: message.locusUrl,
          initialLocus: {
            locus: null,
            dataSets: message.dataSets,
          },
          metadata: {
            htMeta: metadata.htMeta,
            visibleDataSets: metadata.data.visibleDataSets,
          },
          replacedAt: replaces?.replacedAt,
        });

        // handle the message with the new parser
        parser.handleMessage(message);
      }

      return true;
    }
    if (entry.parser.state === 'stopped') {
      // the message matches a stopped parser, we need to check if maybe this is a new "replacement" and we need to re-activate the parser
      // this happens when you move from breakout A -> breakout B -> back to breakout A
      this.resumeStoppedParser(
        'handleHashTreeParserSwitch',
        message.locusUrl,
        entry,
        replaces,
        () => entry.parser.resumeFromMessage(message)
      );

      return true;
    }

    return false;
  }

  /**
   * Handles a hash tree message received from Locus.
   *
   * @param {Meeting} meeting - The meeting object
   * @param {eventType} eventType - The event type
   * @param {HashTreeMessage} message incoming hash tree message
   * @returns {void}
   */
  private handleHashTreeMessage(meeting: any, eventType: LOCUSEVENT, message: HashTreeMessage) {
    if (eventType !== LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
      this.sendClassicVsHashTreeMismatchMetric(
        meeting,
        `got ${eventType}, expected ${LOCUSEVENT.HASH_TREE_DATA_UPDATED}`
      );

      return;
    }

    const parserSwitched = this.handleHashTreeParserSwitch(message);

    if (parserSwitched) {
      return;
    }

    const entry = this.hashTreeParsers.get(message.locusUrl);

    // the check is just for typescript, the case of no entry in hashTreeParsers is handled in handleHashTreeParserSwitch() above
    if (entry) {
      entry.parser.handleMessage(message);
    }
  }

  /**
   * Triggers a sync of all hash tree datasets for all hash tree parsers associated with this meeting.
   * The syncs are executed sequentially within each parser.
   *
   * @param {Object} [options={}] - Options for syncing
   * @param {boolean} [options.onlyLLM=false] - Whether to sync only LLM based data sets
   * @returns {Promise<void>}
   */
  async syncAllHashTreeDatasets(options: {onlyLLM?: boolean} = {}): Promise<void> {
    for (const [, entry] of this.hashTreeParsers) {
      if (entry.parser) {
        // eslint-disable-next-line no-await-in-loop
        await entry.parser.syncAllDatasets(options);
      }
    }
  }

  /**
   * Callback registered with HashTreeParser to receive locus info updates.
   * Updates our locus info based on the data parsed by the hash tree parser.
   *
   * @param {string} locusUrl - the locus URL for which the update is received
   * @param {LocusInfoUpdate} update - Details about the update.
   * @returns {void}
   */
  private updateFromHashTree(locusUrl: string, update: LocusInfoUpdate) {
    switch (update.updateType) {
      case LocusInfoUpdateType.OBJECTS_UPDATED: {
        // initialize our new locus
        let locus: LocusDTO = {
          participants: [],
          jsSdkMeta: {
            removedParticipantIds: [],
            forceReplaceMembers: false,
          },
        };

        // first go over all the updates and check what happens with the main locus object
        let locusObjectStateAfterUpdates: LocusObjectStateAfterUpdates =
          LocusObjectStateAfterUpdates.unchanged;
        update.updatedObjects.forEach((object) => {
          if (object.htMeta.elementId.type.toLowerCase() === ObjectType.locus) {
            if (locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.updated) {
              // this code doesn't supported it right now,
              // cases for "updated" followed by "removed", or multiple "updated" would need more handling
              // but these should never happen
              LoggerProxy.logger.warn(
                `Locus-info:index#updateFromHashTree --> received multiple LOCUS objects in one update, this is unexpected!`
              );
              Metrics.sendBehavioralMetric(
                BEHAVIORAL_METRICS.LOCUS_HASH_TREE_UNSUPPORTED_OPERATION,
                {
                  locusUrl: object.data?.url || this.url,
                  message: object.data
                    ? 'multiple LOCUS object updates'
                    : 'LOCUS object update followed by removal',
                }
              );
            }
            if (object.data) {
              locusObjectStateAfterUpdates = LocusObjectStateAfterUpdates.updated;
            } else {
              locusObjectStateAfterUpdates = LocusObjectStateAfterUpdates.removed;
            }
          }
        });

        const hashTreeParserEntry = this.hashTreeParsers.get(locusUrl);

        if (!hashTreeParserEntry) {
          LoggerProxy.logger.warn(
            `Locus-info:index#updateFromHashTree --> no HashTreeParser found for locusUrl ${locusUrl} when trying to apply updates from hash tree`
          );

          return;
        }

        if (!hashTreeParserEntry.initializedFromHashTree) {
          // this is the first time we're getting an update for this locusUrl,
          // so it's probably a move to/from breakout. We need to start from a clean state,
          // so empty locus and we rely on Locus giving us sufficient data in the updates to populate it.
          LoggerProxy.logger.info(
            `Locus-info:index#updateFromHashTree --> first INITIAL update for locusUrl ${locusUrl}, starting from empty state`
          );
          hashTreeParserEntry.initializedFromHashTree = true;
          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
          locus.jsSdkMeta!.forceReplaceMembers = true;
        } else if (
          // if Locus object is unchanged or removed, we need to keep using the existing locus
          // because the rest of the locusInfo code expects locus to always be present (with at least some of the fields)
          // if it gets updated, we only need to have the fields that are not part of "locus" object (like "info" or "mediaShares")
          // so that when Locus object gets updated, if the new one is missing some field, that field will
          // be removed from our locusInfo
          locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.unchanged ||
          locusObjectStateAfterUpdates === LocusObjectStateAfterUpdates.removed
        ) {
          // copy over all of existing locus except participants
          LocusDtoTopLevelKeys.forEach((key) => {
            if (key !== 'participants') {
              (locus as Record<string, any>)[key] = cloneDeep((this as Record<string, any>)[key]);
            }
          });
        } else {
          // initialize only the fields that are not part of main "Locus" object
          // (except participants, which need to stay empty - that means "no participant changes")
          Object.values(ObjectTypeToLocusKeyMap).forEach((locusDtoKey) => {
            if (locusDtoKey !== 'participants') {
              (locus as Record<string, any>)[locusDtoKey] = cloneDeep(
                (this as Record<string, any>)[locusDtoKey]
              );
            }
          });
        }

        LoggerProxy.logger.info(
          `Locus-info:index#updateFromHashTree --> LOCUS object is ${locusObjectStateAfterUpdates}, all updates: ${JSON.stringify(
            update.updatedObjects.map((o) => ({
              type: o.htMeta.elementId.type,
              id: o.htMeta.elementId.id,
              hasData: !!o.data,
            }))
          )}`
        );
        // now apply all the updates from the hash tree onto the locus
        update.updatedObjects.forEach((object) => {
          locus = this.updateLocusFromHashTreeObject(object, locus);
        });

        // update our locus info with the new locus
        this.onDeltaLocus(locus);

        break;
      }

      case LocusInfoUpdateType.MEETING_ENDED: {
        const meeting = this.webex.meetings.meetingCollection.get(this.meetingId);

        if (meeting) {
          LoggerProxy.logger.info(
            `Locus-info:index#updateFromHashTree --> received signal that meeting ended, destroying meeting ${this.meetingId}`
          );
          this.webex.meetings.destroy(meeting, MEETING_REMOVED_REASON.SELF_REMOVED);
        }
        break;
      }

      case LocusInfoUpdateType.LOCUS_NOT_FOUND: {
        LoggerProxy.logger.info(
          `Locus-info:index#updateFromHashTree --> received LOCUS_NOT_FOUND for ${locusUrl}, triggering syncMeetings`
        );
        this.webex.meetings
          .syncMeetings({keepOnlyLocusMeetings: false, skipHashTreeSync: true})
          .catch((syncError) => {
            LoggerProxy.logger.error(
              `Locus-info:index#updateFromHashTree --> syncMeetings failed after LOCUS_NOT_FOUND: ${syncError}`
            );
          });
        break;
      }
    }
  }

  /**
   * @param {Meeting} meeting
   * @param {Object} data
   * @returns {undefined}
   * @memberof LocusInfo
   */
  parse(meeting: any, data: any) {
    if (this.hashTreeParsers.size > 0) {
      if (data.eventType === LOCUSEVENT.SDK_LOCUS_FROM_SYNC_MEETINGS) {
        // sync meetings response follows the format of "not wrapped" locus API responses,
        // so has no dataSets nor Metadata
        this.handleLocusAPIResponse(meeting, {...data.locus});
      } else {
        this.handleHashTreeMessage(
          meeting,
          data.eventType,
          data.stateElementsMessage as HashTreeMessage
        );
      }
    } else {
      const {eventType} = data;

      if (eventType === LOCUSEVENT.HASH_TREE_DATA_UPDATED) {
        // this can happen when we get an event before join http response
        // it's OK to just ignore it
        LoggerProxy.logger.info(
          `Locus-info:index#parse --> received locus hash tree event before hashTreeParser is created`
        );

        return;
      }

      const locus = this.getTheLocusToUpdate(data.locus);
      LoggerProxy.logger.info(`Locus-info:index#parse --> received locus data: ${eventType}`);

      locus.jsSdkMeta = {removedParticipantIds: []};

      switch (eventType) {
        case LOCUSEVENT.PARTICIPANT_JOIN:
        case LOCUSEVENT.PARTICIPANT_LEFT:
        case LOCUSEVENT.CONTROLS_UPDATED:
        case LOCUSEVENT.PARTICIPANT_AUDIO_MUTED:
        case LOCUSEVENT.PARTICIPANT_AUDIO_UNMUTED:
        case LOCUSEVENT.PARTICIPANT_VIDEO_MUTED:
        case LOCUSEVENT.PARTICIPANT_VIDEO_UNMUTED:
        case LOCUSEVENT.SELF_CHANGED:
        case LOCUSEVENT.PARTICIPANT_UPDATED:
        case LOCUSEVENT.PARTICIPANT_CONTROLS_UPDATED:
        case LOCUSEVENT.PARTICIPANT_ROLES_UPDATED:
        case LOCUSEVENT.PARTICIPANT_DECLINED:
        case LOCUSEVENT.FLOOR_GRANTED:
        case LOCUSEVENT.FLOOR_RELEASED:
          this.onFullLocus(`classic locus event ${eventType}`, locus, eventType);
          break;
        case LOCUSEVENT.DIFFERENCE:
          this.handleLocusDelta(locus, meeting);
          break;

        default:
          // Why will there be a event with no eventType ????
          // we may not need this, we can get full locus
          this.handleLocusDelta(locus, meeting);
      }
    }
  }

  /**
   * @param {String} scope
   * @param {String} eventName
   * @param {Array} args
   * @returns {undefined}
   * @memberof LocusInfo
   */
  emitScoped(scope?: any, eventName?: string, args?: any) {
    return this.emit(scope, eventName, args);
  }

  /**
   * Function for handling full locus when it's using hash trees (so not the "classic" one).
   *
   * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
   * @param {object} locus locus object
   * @param {object} metadata locus hash trees metadata
   * @param {DataSet[]} dataSets
   * @param {string} eventType locus event
   * @returns {void}
   */
  private onFullLocusWithHashTrees(
    debugText: string,
    locus: any,
    metadata: Metadata,
    dataSets: Array<DataSet>,
    eventType?: string
  ) {
    if (!this.hashTreeParsers.has(locus.url)) {
      LoggerProxy.logger.info(
        `Locus-info:index#onFullLocus (${debugText}) --> creating hash tree parser for locusUrl=${locus.url}`
      );
      LoggerProxy.logger.info(
        `Locus-info:index#onFullLocus (${debugText}) --> dataSets:`,
        dataSets,
        ' and locus:',
        locus,
        ' and metadata:',
        metadata
      );
      this.createHashTreeParser({
        locusUrl: locus.url,
        initialLocus: {locus, dataSets},
        metadata,
      });
      // we have a full locus to start with, so we consider Locus info to be "initialized"
      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
      this.hashTreeParsers.get(locus.url)!.initializedFromHashTree = true;
      this.onFullLocusCommon(locus, eventType);
    } else {
      // in this case the Locus we're getting is not necessarily the full one
      // so treat it like if we just got it in any api response

      LoggerProxy.logger.info(
        `Locus-info:index#onFullLocus (${debugText}) --> hash tree parser already exists, handling it like a normal API response`
      );
      this.handleLocusAPIResponse(undefined, {dataSets, locus, metadata});
    }
  }

  /**
   * Function for handling full locus when it's the "classic" one (not hash trees)
   *
   * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
   * @param {object} locus locus object
   * @param {string} eventType locus event
   * @returns {void}
   */
  private onFullLocusClassic(debugText: string, locus: any, eventType?: string) {
    if (!this.locusParser.isNewFullLocus(locus)) {
      LoggerProxy.logger.info(
        `Locus-info:index#onFullLocus (${debugText}) --> ignoring old full locus DTO, eventType=${eventType}`
      );

      return;
    }
    this.onFullLocusCommon(locus, eventType);
  }

  /**
   * updates the locus with full locus object
   * @param {string} debugText string explaining the trigger for this call, added to logs for debugging purposes
   * @param {object} locus locus object
   * @param {string} eventType locus event
   * @param {DataSet[]} dataSets
   * @param {object} metadata locus hash trees metadata
   * @returns {object} null
   * @memberof LocusInfo
   */
  onFullLocus(
    debugText: string,
    locus: any,
    eventType?: string,
    dataSets?: Array<DataSet>,
    metadata?: Metadata
  ) {
    if (!locus) {
      LoggerProxy.logger.error(
        `Locus-info:index#onFullLocus (${debugText}) --> object passed as argument was invalid, continuing.`
      );
    }

    if (dataSets) {
      if (!metadata) {
        throw new Error(
          `Locus-info:index#onFullLocus (${debugText}) --> hash tree metadata is missing with full Locus`
        );
      }
      // this is the new hashmap Locus DTO format (only applicable to webinars for now)
      this.onFullLocusWithHashTrees(debugText, locus, metadata, dataSets, eventType);
    } else {
      this.onFullLocusClassic(debugText, locus, eventType);
    }
  }

  /**
   * Common part of handling full locus, used by both classic and hash tree based locus handling
   * @param {object} locus locus object
   * @param {string} eventType locus event
   * @returns {void}
   */
  private onFullLocusCommon(locus: any, eventType?: string) {
    this.scheduledMeeting = locus.meeting || null;
    this.participants = locus.participants;
    this.participants?.forEach((participant) => {
      // participant.htMeta is set only for hash tree based locus
      if (typeof participant.htMeta?.elementId.id === 'number') {
        this.hashTreeObjectId2ParticipantId.set(participant.htMeta.elementId.id, participant.id);
      }
    });
    const isReplaceMembers = ControlsUtils.isNeedReplaceMembers(this.controls, locus.controls);
    this.updateLocusInfo(locus);
    this.updateParticipants(
      locus.participants,
      locus.jsSdkMeta?.removedParticipantIds,
      isReplaceMembers
    );
    this.isMeetingActive();
    this.handleOneOnOneEvent(eventType);
    this.updateEmbeddedApps(locus.embeddedApps);
    // set current (working copy) for parser
    this.locusParser.workingCopy = locus;
  }

  // used for ringing stops on one on one
  /**
   * @param {String} eventType
   * @returns {undefined}
   * @memberof LocusInfo
   */
  // eslint-disable-next-line @typescript-eslint/no-shadow
  handleOneOnOneEvent(eventType: string) {
    if (
      this.parsedLocus.fullState?.type === _CALL_ ||
      this.parsedLocus.fullState?.type === _SIP_BRIDGE_
    ) {
      // for 1:1 bob calls alice and alice declines, notify the meeting state
      if (eventType === LOCUSEVENT.PARTICIPANT_DECLINED) {
        // trigger the event for stop ringing
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'handleOneonOneEvent',
          },
          EVENTS.REMOTE_RESPONSE,
          {
            remoteDeclined: true,
            remoteAnswered: false,
          }
        );
      }
      // for 1:1 bob calls alice and alice answers, notify the meeting state
      if (eventType === LOCUSEVENT.PARTICIPANT_JOIN) {
        // trigger the event for stop ringing
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'handleOneonOneEvent',
          },
          EVENTS.REMOTE_RESPONSE,
          {
            remoteDeclined: false,
            remoteAnswered: true,
          }
        );
      }
    }
  }

  /**
   * Makes sure that passed in locus object has a participant object for self.
   *
   * @param {LocusDTO} locus The locus object to check and modify if needed
   * @returns {void}
   */
  ensureSelfParticipantExists(locus: any) {
    const {self} = locus;

    // sanity check, this should never fail
    if (!self?.identity || !Array.isArray(locus.participants)) {
      LoggerProxy.logger.warn(
        `Locus-info:index#ensureSelfParticipantExists --> locus object is missing required fields, cannot ensure self participant exists. self?.identity="${self?.identity}"`
      );

      return;
    }

    const selfExists = locus.participants.some(
      (participant) => participant.identity === self.identity
    );

    if (!selfExists) {
      locus.participants.push({...self});
    }
  }

  /**
   * @param {Object} locus
   * @returns {undefined}
   * @memberof LocusInfo
   */
  onDeltaLocus(locus: any) {
    const isReplaceMembers =
      locus.jsSdkMeta?.forceReplaceMembers !== undefined
        ? locus.jsSdkMeta.forceReplaceMembers
        : ControlsUtils.isNeedReplaceMembers(this.controls, locus.controls);

    if (isReplaceMembers) {
      // when we're moving between breakouts, Locus sometimes doesn't send us
      // any participants at all for a few seconds
      // Web app relies on having at least the self participant always there
      // so we copy self into participants if it's not there.
      this.ensureSelfParticipantExists(locus);
    }
    this.mergeParticipants(this.participants, locus.participants);
    const updatesApplied = this.updateLocusInfo(locus);

    if (updatesApplied) {
      this.updateParticipants(
        locus.participants,
        locus.jsSdkMeta?.removedParticipantIds,
        isReplaceMembers
      );
    }
    this.isMeetingActive();
  }

  /**
   * @param {Object} locus
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateLocusInfo(locus) {
    if (MeetingsUtil.isSelfMovedOrBreakoutEnded(locus)) {
      // When moved to a breakout session locus sends a message for the previous locus
      // indicating that we have been moved. It isn't helpful to continue parsing this
      // as it gets interpreted as if we have left the call
      return false;
    }

    this.updateControls(locus.controls, locus.self);
    this.updateConversationUrl(locus.conversationUrl, locus.info);
    this.updateCreated(locus.created);
    this.updateFullState(locus.fullState);
    this.updateHostInfo(locus.host);
    this.updateLocusUrl(locus.url, ControlsUtils.isMainSessionDTO(locus));
    this.updateMeetingInfo(locus.info, locus.self);
    this.updateMediaShares(locus.mediaShares);
    this.updateReplaces(locus.replaces);
    this.updateSelf(locus.self);
    this.updateAclUrl(locus.aclUrl);
    this.updateBasequence(locus.baseSequence);
    this.updateSequence(locus.sequence);
    this.updateEmbeddedApps(locus.embeddedApps);
    this.updateLinks(locus.links);
    this.compareAndUpdate();
    // update which required to compare different objects from locus

    return true;
  }

  /**
   * @param {Array} participants
   * @param {Object} self
   * @returns {Array}
   * @memberof LocusInfo
   */
  getLocusPartner(participants: Array<any>, self: any) {
    if (!participants || participants.length === 0) {
      return null;
    }

    return (
      participants.find(
        (participant) =>
          self &&
          participant.identity !== self.identity &&
          (participants.length <= 2 || (participant.type === _USER_ && !participant.removed))
        // @ts-ignore
      ) || this.partner
    );
  }

  // TODO: all the leave states need to be checked
  /**
   * @returns {undefined}
   * @memberof LocusInfo
   */
  isMeetingActive() {
    if (
      this.parsedLocus.fullState?.type === _CALL_ ||
      this.parsedLocus.fullState?.type === _SIP_BRIDGE_ ||
      this.parsedLocus.fullState?.type === _SPACE_SHARE_
    ) {
      // @ts-ignore
      const partner = this.getLocusPartner(this.participants, this.self);

      this.callbacks.updateMeeting({partner});

      // Check if guest user needs to be checked here

      // 1) when bob declines call from bob, (bob='DECLINED')
      // 2) When alice rejects call to bob , (bob='NOTIFIED')

      // When we dont add MEDIA for condition 2. The state of bob='IDLE'

      if (this.fullState && this.fullState.state === LOCUS.STATE.INACTIVE) {
        // TODO: update the meeting state
        LoggerProxy.logger.warn(
          'Locus-info:index#isMeetingActive --> Call Ended, locus state is inactive.'
        );

        // @ts-ignore
        this.webex.internal.newMetrics.submitClientEvent({
          name: 'client.call.remote-ended',
          options: {
            meetingId: this.meetingId,
          },
          payload: {
            eventData: {
              joinInProgress: this.destroyMeetingSuspended,
            },
          },
        });

        if (this.destroyMeetingSuspended) {
          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DESTROY_MEETING_WHILE_SUSPENDED, {
            meetingId: this.meetingId,
            reason: 'CALL_INACTIVE',
          });
        }
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'isMeetingActive',
          },
          EVENTS.DESTROY_MEETING,
          {
            reason: CALL_REMOVED_REASON.CALL_INACTIVE,
            shouldLeave: false,
          }
        );
      } else if (
        partner.state === MEETING_STATE.STATES.LEFT &&
        this.parsedLocus.self &&
        (this.parsedLocus.self.state === MEETING_STATE.STATES.DECLINED ||
          this.parsedLocus.self.state === MEETING_STATE.STATES.NOTIFIED ||
          this.parsedLocus.self.state === MEETING_STATE.STATES.JOINED)
      ) {
        // @ts-ignore
        this.webex.internal.newMetrics.submitClientEvent({
          name: 'client.call.remote-ended',
          options: {
            meetingId: this.meetingId,
          },
          payload: {
            eventData: {
              joinInProgress: this.destroyMeetingSuspended,
            },
          },
        });
        if (this.destroyMeetingSuspended) {
          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DESTROY_MEETING_WHILE_SUSPENDED, {
            meetingId: this.meetingId,
            reason: 'PARTNER_LEFT',
          });
        }
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'isMeetingActive',
          },
          EVENTS.DESTROY_MEETING,
          {
            reason: CALL_REMOVED_REASON.PARTNER_LEFT,
            shouldLeave:
              this.parsedLocus.self.joinedWith && this.parsedLocus.self.joinedWith.state !== _LEFT_,
          }
        );
      } else if (
        this.parsedLocus.self &&
        this.parsedLocus.self.state === MEETING_STATE.STATES.LEFT &&
        (partner.state === MEETING_STATE.STATES.LEFT ||
          partner.state === MEETING_STATE.STATES.DECLINED ||
          partner.state === MEETING_STATE.STATES.NOTIFIED ||
          partner.state === MEETING_STATE.STATES.IDLE) // Happens when user just joins and adds no Media
      ) {
        // @ts-ignore
        this.webex.internal.newMetrics.submitClientEvent({
          name: 'client.call.remote-ended',
          options: {
            meetingId: this.meetingId,
          },
          payload: {
            eventData: {
              joinInProgress: this.destroyMeetingSuspended,
            },
          },
        });

        if (this.destroyMeetingSuspended) {
          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DESTROY_MEETING_WHILE_SUSPENDED, {
            meetingId: this.meetingId,
            reason: 'SELF_LEFT',
          });
        }
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'isMeetingActive',
          },
          EVENTS.DESTROY_MEETING,
          {
            reason: CALL_REMOVED_REASON.SELF_LEFT,
            shouldLeave: false,
          }
        );
      }
    } else if (this.parsedLocus.fullState?.type === _MEETING_) {
      if (this.fullState && MeetingsUtil.isWholeMeetingEnded(this.fullState)) {
        if (this.destroyMeetingSuspended) {
          LoggerProxy.logger.info(
            'Locus-info:index#isMeetingActive --> suppressing DESTROY_MEETING (MEETING_INACTIVE_TERMINATING) because destroyMeeting is suspended'
          );
          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DESTROY_MEETING_WHILE_SUSPENDED, {
            meetingId: this.meetingId,
            reason: 'MEETING_INACTIVE_TERMINATING',
          });
        } else {
          LoggerProxy.logger.warn(
            'Locus-info:index#isMeetingActive --> Meeting is ending due to inactive'
          );

          // @ts-ignore
          this.webex.internal.newMetrics.submitClientEvent({
            name: 'client.call.remote-ended',
            options: {
              meetingId: this.meetingId,
            },
          });

          this.emitScoped(
            {
              file: 'locus-info',
              function: 'isMeetingActive',
            },
            EVENTS.DESTROY_MEETING,
            {
              reason: MEETING_REMOVED_REASON.MEETING_INACTIVE_TERMINATING,
              shouldLeave: false,
            }
          );
        }
      }
      // If you are  guest and you are removed from the meeting
      // You wont get any further events
      else if (this.parsedLocus.self && this.parsedLocus.self.removed) {
        if (this.destroyMeetingSuspended) {
          LoggerProxy.logger.info(
            'Locus-info:index#isMeetingActive --> suppressing DESTROY_MEETING (SELF_REMOVED) because destroyMeeting is suspended'
          );
          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DESTROY_MEETING_WHILE_SUSPENDED, {
            meetingId: this.meetingId,
            reason: 'SELF_REMOVED',
          });
        } else {
          this.emitScoped(
            {
              file: 'locus-info',
              function: 'isMeetingActive',
            },
            EVENTS.DESTROY_MEETING,
            {
              reason: MEETING_REMOVED_REASON.SELF_REMOVED,
              shouldLeave: false,
            }
          );
        }
      }
    } else {
      LoggerProxy.logger.warn('Locus-info:index#isMeetingActive --> Meeting Type is unknown.');
    }
  }

  /**
   * Suspends or resumes the emission of DESTROY_MEETING events in certain situations.
   * Used by joinWithMedia to prevent meeting destruction during retry flows.
   * @param {boolean} suspend - true to suppress, false to resume
   * @returns {undefined}
   * @memberof LocusInfo
   */
  suspendDestroyMeeting(suspend: boolean) {
    this.destroyMeetingSuspended = suspend;
  }

  /**
   * checks if the host permissions have changed while in the meeting
   * This would be the case if your role as host or moderator has been updated
   * @returns {undefined}
   * @memberof LocusInfo
   */
  compareAndUpdate() {
    // TODO: check with locus team on host and moderator doc
    // use host as a validator if needed
    if (
      this.compareAndUpdateFlags.compareSelfAndHost ||
      this.compareAndUpdateFlags.compareHostAndSelf
    ) {
      this.compareSelfAndHost();
    }
  }

  /**
   * compared the self object to check if the user has host permissions
   * @returns {undefined}
   * @memberof LocusInfo
   */
  compareSelfAndHost() {
    // In some cases the host info is not present but the moderator values changes from null to false so it triggers an update
    if (
      this.parsedLocus.self &&
      this.parsedLocus.self.selfIdentity === this.parsedLocus.host?.hostId &&
      this.parsedLocus.self.moderator
    ) {
      this.emitScoped(
        {
          file: 'locus-info',
          function: 'compareSelfAndHost',
        },
        EVENTS.LOCUS_INFO_CAN_ASSIGN_HOST,
        {
          canAssignHost: true,
        }
      );
    } else {
      this.emitScoped(
        {
          file: 'locus-info',
          function: 'compareSelfAndHost',
        },
        EVENTS.LOCUS_INFO_CAN_ASSIGN_HOST,
        {
          canAssignHost: false,
        }
      );
    }
  }

  /**
   * update meeting's members
   * @param {Object} participants new participants object
   * @param {Array} removedParticipantIds list of removed participants
   * @param {Boolean} isReplace is replace the whole members
   * @returns {Array} updatedParticipants
   * @memberof LocusInfo
   */
  updateParticipants(participants: object, removedParticipantIds?: string[], isReplace?: boolean) {
    this.emitScoped(
      {
        file: 'locus-info',
        function: 'updateParticipants',
      },
      EVENTS.LOCUS_INFO_UPDATE_PARTICIPANTS,
      {
        participants,
        removedParticipantIds,
        recordingId: this.parsedLocus.controls && this.parsedLocus.controls.record?.modifiedBy,
        selfIdentity: this.parsedLocus.self && this.parsedLocus.self.selfIdentity,
        selfId: this.parsedLocus.self && this.parsedLocus.self.selfId,
        hostId: this.parsedLocus.host && this.parsedLocus.host.hostId,
        isReplace,
      }
    );

    if (participants && Array.isArray(participants) && participants.length > 0) {
      for (const participant of participants) {
        if (participant && participant?.reason === 'FAILURE') {
          this.emitScoped(
            {
              file: 'locus-info',
              function: 'updateParticipants',
            },
            LOCUSINFO.EVENTS.PARTICIPANT_REASON_CHANGED,
            {
              displayName: participant?.person?.primaryDisplayString,
            }
          );
        }
      }
    }
  }

  /**
   * @param {Object} controls
   * @param {Object} self
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateControls(controls: object, self: object) {
    if (controls && !isEqual(this.controls, controls)) {
      this.parsedLocus.controls = ControlsUtils.parse(controls);
      const {
        updates: {
          hasRecordingChanged,
          hasRecordingPausedChanged,
          hasMeetingContainerChanged,
          hasTranscribeChanged,
          hasHesiodLLMIdChanged,
          hasAiSummaryNotificationChanged,
          hasTranscribeSpokenLanguageChanged,
          hasManualCaptionChanged,
          hasEntryExitToneChanged,
          hasBreakoutChanged,
          hasVideoEnabledChanged,
          hasMuteOnEntryChanged,
          hasShareControlChanged,
          hasDisallowUnmuteChanged,
          hasReactionsChanged,
          hasReactionDisplayNamesChanged,
          hasViewTheParticipantListChanged,
          hasRaiseHandChanged,
          hasVideoChanged,
          hasInterpretationChanged,
          hasWebcastChanged,
          hasMeetingFullChanged,
          hasPracticeSessionEnabledChanged,
          hasStageViewChanged,
          hasAnnotationControlChanged,
          hasRemoteDesktopControlChanged,
          hasPollingQAControlChanged,
          hasAutoEndMeetingChanged,
        },
        current,
      } = ControlsUtils.getControls(this.controls, controls);

      if (hasMuteOnEntryChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_MUTE_ON_ENTRY_CHANGED,
          {state: current.muteOnEntry}
        );
      }

      if (hasShareControlChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_SHARE_CONTROL_CHANGED,
          {state: current.shareControl}
        );
      }

      if (hasDisallowUnmuteChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_DISALLOW_UNMUTE_CHANGED,
          {state: current.disallowUnmute}
        );
      }

      if (hasReactionsChanged || hasReactionDisplayNamesChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_REACTIONS_CHANGED,
          {state: current.reactions}
        );
      }

      if (hasViewTheParticipantListChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_VIEW_THE_PARTICIPANTS_LIST_CHANGED,
          {state: current.viewTheParticipantList}
        );
      }

      if (hasRaiseHandChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_RAISE_HAND_CHANGED,
          {state: current.raiseHand}
        );
      }

      if (hasVideoChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_VIDEO_CHANGED,
          {state: current.video}
        );
      }

      if (hasRecordingChanged || hasRecordingPausedChanged) {
        let state = null;

        if (hasRecordingPausedChanged) {
          if (current.record.paused) {
            state = RECORDING_STATE.PAUSED;
          } else {
            // state will be `IDLE` if the recording is not active, even when there is a `pause` status change.
            state = current.record.recording ? RECORDING_STATE.RESUMED : RECORDING_STATE.IDLE;
          }
        } else if (hasRecordingChanged) {
          state = current.record.recording ? RECORDING_STATE.RECORDING : RECORDING_STATE.IDLE;
        }

        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_RECORDING_UPDATED,
          {
            state,
            modifiedBy: current.record.modifiedBy,
            lastModified: current.record.lastModified,
            modifiedByServiceAppName: current.record.modifiedByServiceAppName,
            modifiedByServiceAppId: current.record.modifiedByServiceAppId,
          }
        );
      }

      if (hasMeetingContainerChanged) {
        const {meetingContainerUrl} = current.meetingContainer;

        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_MEETING_CONTAINER_UPDATED,
          {
            meetingContainerUrl,
          }
        );
      }

      if (hasTranscribeChanged) {
        const {transcribing, caption} = current.transcribe;

        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_MEETING_TRANSCRIBE_UPDATED,
          {
            transcribing,
            caption,
          }
        );
      }

      if (hasHesiodLLMIdChanged) {
        const {hesiodLlmId} = current.transcribe;

        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_MEETING_HESIOD_LLM_ID_UPDATED,
          {
            hesiodLlmId,
          }
        );
      }

      if (hasAiSummaryNotificationChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_AI_SUMMARY_NOTIFICATION_UPDATED,
          {
            aiSummaryNotification: current.transcribe.aiSummaryNotification,
          }
        );
      }

      if (hasTranscribeSpokenLanguageChanged) {
        const {spokenLanguage} = current.transcribe;

        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_MEETING_TRANSCRIPTION_SPOKEN_LANGUAGE_UPDATED,
          {
            spokenLanguage,
          }
        );
      }

      if (hasManualCaptionChanged) {
        const {enabled} = current.manualCaptionControl;

        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_MEETING_MANUAL_CAPTION_UPDATED,
          {
            enabled,
          }
        );
      }

      if (hasBreakoutChanged) {
        const {breakout} = current;

        breakout.breakoutMoveId = SelfUtils.getReplacedBreakoutMoveId(
          self,
          this.webex.internal.device.url
        );
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_MEETING_BREAKOUT_UPDATED,
          {
            breakout,
          }
        );
      }

      if (hasInterpretationChanged) {
        const {interpretation} = current;
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_MEETING_INTERPRETATION_UPDATED,
          {
            interpretation,
          }
        );
      }

      if (hasEntryExitToneChanged) {
        const {entryExitTone} = current;

        this.callbacks.updateMeeting({entryExitTone});

        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.CONTROLS_ENTRY_EXIT_TONE_UPDATED,
          {
            entryExitTone,
          }
        );
      }

      // videoEnabled is handled differently than other controls,
      // to fit with audio mute status logic
      if (hasVideoEnabledChanged) {
        const {videoEnabled} = current;

        this.callbacks.updateMeeting({unmuteVideoAllowed: videoEnabled});

        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateControls',
          },
          LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
          {
            // muted: not part of locus.controls
            unmuteAllowed: videoEnabled,
          }
        );
      }

      if (hasWebcastChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_WEBCAST_CHANGED,
          {state: current.webcastControl}
        );
      }

      if (hasMeetingFullChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_MEETING_FULL_CHANGED,
          {state: current.meetingFull}
        );
      }

      if (hasPracticeSessionEnabledChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_PRACTICE_SESSION_STATUS_UPDATED,
          {state: current.practiceSession}
        );
      }

      if (hasStageViewChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_STAGE_VIEW_UPDATED,
          {state: current.videoLayout}
        );
      }

      if (hasAnnotationControlChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_ANNOTATION_CHANGED,
          {state: current.annotationControl}
        );
      }

      if (hasRemoteDesktopControlChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_REMOTE_DESKTOP_CONTROL_CHANGED,
          {state: current.rdcControl}
        );
      }

      if (hasPollingQAControlChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_POLLING_QA_CHANGED,
          {state: current.pollingQAControl}
        );
      }

      if (hasAutoEndMeetingChanged) {
        this.emitScoped(
          {file: 'locus-info', function: 'updateControls'},
          LOCUSINFO.EVENTS.CONTROLS_AUTO_END_MEETING_WARNING_CHANGED,
          {state: current.autoEndMeetingWarning}
        );
      }

      this.controls = controls;
    }
  }

  /**
   * @param {String} conversationUrl
   * @param {Object} info
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateConversationUrl(conversationUrl: string, info: any) {
    if (conversationUrl && !isEqual(this.conversationUrl, conversationUrl)) {
      this.conversationUrl = conversationUrl;
      this.callbacks.updateMeeting({conversationUrl});
    } else if (
      info &&
      info.conversationUrl &&
      !isEqual(this.conversationUrl, info.conversationUrl)
    ) {
      this.conversationUrl = info.conversationUrl;
      this.callbacks.updateMeeting({conversationUrl: info.conversationUrl});
    }
  }

  /**
   * @param {Object} created
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateCreated(created: object) {
    if (created && !isEqual(this.created, created)) {
      this.created = created;
    }
  }

  /**
   * Updates links and emits appropriate events if services or resources have changed
   * @param {Object} links
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateLinks(links?: Links) {
    const {services, resources} = links || {};

    if (services && !isEqual(this.links?.services, services)) {
      this.emitScoped(
        {
          file: 'locus-info',
          function: 'updateLinks',
        },
        LOCUSINFO.EVENTS.LINKS_SERVICES,
        {
          services,
        }
      );
    }

    if (resources && !isEqual(this.links?.resources, resources)) {
      this.emitScoped(
        {
          file: 'locus-info',
          function: 'updateLinks',
        },
        LOCUSINFO.EVENTS.LINKS_RESOURCES,
        {
          resources,
        }
      );
    }

    this.links = links;
  }

  /**
   * @param {Object} fullState
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateFullState(fullState: object) {
    if (fullState && !isEqual(this.fullState, fullState)) {
      const result = FullState.getFullState(this.fullState, fullState);

      this.callbacks.updateMeeting(result.current);

      if (result.updates.meetingStateChangedTo) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateFullState',
          },
          LOCUSINFO.EVENTS.FULL_STATE_MEETING_STATE_CHANGE,
          {
            previousState: result.previous && result.previous.meetingState,
            currentState: result.current.meetingState,
          }
        );
      }

      if (result.updates.meetingTypeChangedTo) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateFullState',
          },
          LOCUSINFO.EVENTS.FULL_STATE_TYPE_UPDATE,
          {
            type: result.current.type,
          }
        );
      }
      this.parsedLocus.fullState = result.current;
      this.fullState = fullState;
    }
  }

  /**
   * handles when the locus.host is updated
   * @param {Object} host the locus.host property
   * @returns {undefined}
   * @memberof LocusInfo
   * emits internal event locus_info_update_host
   */
  updateHostInfo(host: object) {
    if (host && !isEqual(this.host, host)) {
      const parsedHosts = HostUtils.getHosts(this.host, host);

      this.callbacks.updateMeeting(parsedHosts.current);
      this.parsedLocus.host = parsedHosts.current;
      if (parsedHosts.updates.isNewHost) {
        this.compareAndUpdateFlags.compareSelfAndHost = true;
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateHostInfo',
          },
          EVENTS.LOCUS_INFO_UPDATE_HOST,
          {
            newHost: parsedHosts.current,
            oldHost: parsedHosts.previous,
          }
        );
      }
      this.host = host;
    } else {
      this.compareAndUpdateFlags.compareSelfAndHost = false;
    }
  }

  /**
   * @param {Object} info
   * @param {Object} self
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateMeetingInfo(info: object, self?: object) {
    const roles = self ? SelfUtils.getRoles(self) : this.parsedLocus.self?.roles || [];
    const isJoined = SelfUtils.isJoined(self || this.parsedLocus.self);

    // The parsed userDisplayHints depend on info, roles and isJoined, so we must recompute
    // whenever any of them changes. A common case is self transitioning to JOINED via a delta
    // that doesn't carry an info section - in that case we fall back to the previously stored
    // info so the hints get reparsed with the new joined state (e.g. VIEW_THE_PARTICIPANT_LIST).
    const infoToParse = info || this.info;
    const infoChanged = info && !isEqual(this.info, info);
    const rolesChanged = !isEqual(this.roles, roles);
    const isJoinedChanged = SelfUtils.isJoined(this.parsedLocus.self) !== isJoined;

    if (infoToParse && (infoChanged || rolesChanged || isJoinedChanged)) {
      const parsedInfo = InfoUtils.getInfos(this.parsedLocus.info, infoToParse, roles, isJoined);

      if (parsedInfo.updates.isLocked) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateMeetingInfo',
          },
          LOCUSINFO.EVENTS.MEETING_LOCKED,
          info
        );
      }
      if (parsedInfo.updates.isUnlocked) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateMeetingInfo',
          },
          LOCUSINFO.EVENTS.MEETING_UNLOCKED,
          info
        );
      }

      this.info = infoToParse;
      this.parsedLocus.info = parsedInfo.current;
      // Parses the info and adds necessary values
      this.callbacks.updateMeeting(parsedInfo.current);

      this.emitScoped(
        {
          file: 'locus-info',
          function: 'updateMeetingInfo',
        },
        LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
        {
          isInitializing: !self, // if self is undefined, then the update is caused by locus init
        }
      );
    }
    this.roles = roles;
  }

  /**
   * @param {Object} embeddedApps
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateEmbeddedApps(embeddedApps: object) {
    // don't do anything if the arrays of apps haven't changed significantly
    if (EmbeddedAppsUtils.areSimilar(this.embeddedApps, embeddedApps)) {
      return;
    }

    const parsedEmbeddedApps = EmbeddedAppsUtils.parse(embeddedApps);

    this.callbacks.updateMeeting({embeddedApps: parsedEmbeddedApps});

    this.emitScoped(
      {
        file: 'locus-info',
        function: 'updateEmbeddedApps',
      },
      LOCUSINFO.EVENTS.EMBEDDED_APPS_UPDATED,
      parsedEmbeddedApps
    );
    this.embeddedApps = embeddedApps;
  }

  /**
   * handles when the locus.mediaShares is updated
   * @param {Object} mediaShares the locus.mediaShares property
   * @param {boolean} forceUpdate force to update the mediaShares
   * @returns {undefined}
   * @memberof LocusInfo
   * emits internal event locus_info_update_media_shares
   */
  updateMediaShares(mediaShares: object, forceUpdate = false) {
    if (mediaShares && (!isEqual(this.mediaShares, mediaShares) || forceUpdate)) {
      const parsedMediaShares = MediaSharesUtils.getMediaShares(this.mediaShares, mediaShares);

      this.callbacks.updateMeeting(parsedMediaShares.current);
      this.parsedLocus.mediaShares = parsedMediaShares.current;
      this.mediaShares = mediaShares;
      this.emitScoped(
        {
          file: 'locus-info',
          function: 'updateMediaShares',
        },
        EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES,
        {
          current: parsedMediaShares.current,
          previous: parsedMediaShares.previous,
          forceUpdate,
        }
      );
    }
  }

  /**
   * @param {Object} replaces
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateReplaces(replaces: object) {
    if (replaces && !isEqual(this.replaces, replaces)) {
      this.replaces = replaces;
    }
  }

  /**
   * handles when the locus.self is updated
   * @param {Object} self the new locus.self
   * @returns {undefined}
   * @memberof LocusInfo
   * emits internal events self_admitted_guest, self_unadmitted_guest, locus_info_update_self
   */
  updateSelf(self: any) {
    if (self) {
      // @ts-ignore
      const parsedSelves = SelfUtils.getSelves(
        this.parsedLocus.self,
        self,
        this.webex.internal.device.url,
        this.participants // using this.participants instead of locus.participants here, because with delta DTOs locus.participants will only contain a small subset of participants
      );

      this.callbacks.updateMeeting(parsedSelves.current);
      this.parsedLocus.self = parsedSelves.current;

      const element = this.parsedLocus.states[this.parsedLocus.states.length - 1];

      if (element !== parsedSelves.current.state) {
        this.parsedLocus.states.push(parsedSelves.current.state);
      }

      // TODO: check if we need to save the sipUri here as well
      // this.emit(LOCUSINFO.EVENTS.MEETING_UPDATE, SelfUtils.getSipUrl(this.getLocusPartner(participants, self), this.parsedLocus.fullState?.type, this.parsedLocus.info?.sipUri));
      const result = SelfUtils.getSipUrl(
        this.getLocusPartner(this.participants, self),
        this.parsedLocus.fullState?.type,
        this.parsedLocus.info?.sipUri
      );

      if (result?.sipUri) {
        this.callbacks.updateMeeting(result);
      }

      if (parsedSelves.updates.moderatorChanged) {
        this.compareAndUpdateFlags.compareHostAndSelf = true;
      } else {
        this.compareAndUpdateFlags.compareHostAndSelf = false;
      }

      if (parsedSelves.updates.layoutChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.CONTROLS_MEETING_LAYOUT_UPDATED,
          {layout: parsedSelves.current.layout}
        );
      }

      if (parsedSelves.updates.breakoutsChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_MEETING_BREAKOUTS_CHANGED,
          {breakoutSessions: parsedSelves.current.breakoutSessions}
        );
      }

      if (parsedSelves.updates.brbChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
          {
            brb: parsedSelves.current.brb,
          }
        );
      }

      if (parsedSelves.updates.selfIdChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_ID_CHANGED,
          {
            selfId: parsedSelves.current.selfId,
          }
        );
      }

      if (parsedSelves.updates.interpretationChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_MEETING_INTERPRETATION_CHANGED,
          {
            interpretation: parsedSelves.current.interpretation,
            selfParticipantId: parsedSelves.current.selfId,
          }
        );
      }

      if (parsedSelves.updates.isMediaInactiveOrReleased) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.DISCONNECT_DUE_TO_INACTIVITY,
          {reason: self.reason}
        );
      }

      if (parsedSelves.updates.moderatorChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_MODERATOR_CHANGED,
          self
        );
      }

      if (parsedSelves.updates.isRolesChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_ROLES_CHANGED,
          {oldRoles: parsedSelves.previous?.roles, newRoles: parsedSelves.current?.roles}
        );
      }

      if (parsedSelves.updates.isVideoMutedByOthersChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
          {
            muted: parsedSelves.current.remoteVideoMuted,
            // unmuteAllowed: not part of .self
          }
        );
      }
      if (parsedSelves.updates.localAudioUnmuteRequiredByServer) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.LOCAL_UNMUTE_REQUIRED,
          {
            muted: parsedSelves.current.remoteMuted,
            unmuteAllowed: parsedSelves.current.unmuteAllowed,
          }
        );
      }
      if (parsedSelves.updates.isMutedByOthersChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED,
          {
            muted: parsedSelves.current.remoteMuted,
            unmuteAllowed: parsedSelves.current.unmuteAllowed,
            modifiedBy: parsedSelves.current.modifiedBy ?? null,
          }
        );
      }
      if (parsedSelves.updates.localAudioUnmuteRequestedByServer) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.LOCAL_UNMUTE_REQUESTED,
          {}
        );
      }
      if (parsedSelves.updates.hasUserEnteredLobby) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_UNADMITTED_GUEST,
          self
        );
      }
      if (parsedSelves.updates.hasUserBeenAdmitted) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_ADMITTED_GUEST,
          self
        );
      }

      if (parsedSelves.updates.isMediaInactive) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          // @ts-ignore
          LOCUSINFO.EVENTS.MEDIA_INACTIVITY,
          SelfUtils.getMediaStatus(self.mediaSessions)
        );
      }

      if (
        parsedSelves.updates.audioStateChange ||
        parsedSelves.updates.videoStateChange ||
        parsedSelves.updates.shareStateChange
      ) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.MEDIA_STATUS_CHANGE,
          {
            audioStatus: parsedSelves.current.currentMediaStatus?.audio,
            videoStatus: parsedSelves.current.currentMediaStatus?.video,
            shareStatus: parsedSelves.current.currentMediaStatus?.share,
          }
        );
      }

      if (parsedSelves.updates.isUserObserving) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_OBSERVING
        );
      }

      if (parsedSelves.updates.canNotViewTheParticipantListChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_CANNOT_VIEW_PARTICIPANT_LIST_CHANGE,
          {canNotViewTheParticipantList: parsedSelves.current.canNotViewTheParticipantList}
        );
      }

      if (parsedSelves.updates.isSharingBlockedChanged) {
        this.emitScoped(
          {
            file: 'locus-info',
            function: 'updateSelf',
          },
          LOCUSINFO.EVENTS.SELF_IS_SHARING_BLOCKED_CHANGE,
          {isSharingBlocked: parsedSelves.current.isSharingBlocked}
        );
      }

      this.emitScoped(
        {
          file: 'locus-info',
          function: 'updateSelf',
        },
        EVENTS.LOCUS_INFO_UPDATE_SELF,
        {
          oldSelf: parsedSelves.previous,
          newSelf: parsedSelves.current,
        }
      );
      this.parsedLocus.self = parsedSelves.current;
      // @ts-ignore
      this.self = self;
    } else {
      this.compareAndUpdateFlags.compareHostAndSelf = false;
    }
  }

  /**
   * handles when the locus.url is updated
   * @param {String} url
   * @param {Boolean} isMainLocus
   * @returns {undefined}
   * emits internal event locus_info_update_url
   */
  updateLocusUrl(url: string, isMainLocus = true) {
    if (url && this.url !== url) {
      this.url = url;
      this.callbacks.updateMeeting({locusUrl: url});
      this.emitScoped(
        {
          file: 'locus-info',
          function: 'updateLocusUrl',
        },
        EVENTS.LOCUS_INFO_UPDATE_URL,
        {url, isMainLocus}
      );
    }
  }

  /**
   * @param {String} aclUrl
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateAclUrl(aclUrl: string) {
    if (aclUrl && !isEqual(this.aclUrl, aclUrl)) {
      this.aclUrl = aclUrl;
    }
  }

  /**
   * @param {Number} baseSequence
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateBasequence(baseSequence: number) {
    if (baseSequence && !isEqual(this.baseSequence, baseSequence)) {
      this.baseSequence = baseSequence;
    }
  }

  /**
   * @param {Number} sequence
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateSequence(sequence: number) {
    if (sequence && !isEqual(this.sequence, sequence)) {
      this.sequence = sequence;
    }
  }

  /**
   * check the locus is main session's one or not, if is main session's, update main session cache
   * @param {Object} locus
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateLocusCache(locus: any) {
    const isMainSessionDTO = ControlsUtils.isMainSessionDTO(locus);
    if (isMainSessionDTO) {
      this.updateMainSessionLocusCache(locus);
    }
  }

  /**
   * if return from breakout to main session, need to use cached main session DTO since locus won't send the full locus (participants)
   * if join breakout from main session, main session is not active for the attendee and remove main session locus cache
   * @param {Object} newLocus
   * @returns {Object}
   * @memberof LocusInfo
   */
  getTheLocusToUpdate(newLocus: any) {
    const switchStatus = ControlsUtils.getSessionSwitchStatus(this, newLocus);

    if (switchStatus.isReturnToMain && this.mainSessionLocusCache) {
      return cloneDeep(this.mainSessionLocusCache);
    }
    const isMainSessionDTO =
      this.mainSessionLocusCache && ControlsUtils.isMainSessionDTO(this.mainSessionLocusCache);

    if (isMainSessionDTO) {
      const isActive =
        [LOCUS.STATE.ACTIVE, LOCUS.STATE.INITIALIZING, LOCUS.STATE.TERMINATING].includes(
          this.fullState?.state
        ) && !this.mainSessionLocusCache?.self?.removed;

      if (!isActive) {
        this.clearMainSessionLocusCache();
      }
    }

    return newLocus;
  }

  /**
   * merge participants by participant id
   * @param {Array} participants
   * @param {Array} sourceParticipants
   * @returns {Array} merged participants
   * @memberof LocusInfo
   */
  // eslint-disable-next-line class-methods-use-this
  mergeParticipants(participants, sourceParticipants) {
    if (!sourceParticipants || !sourceParticipants.length) return participants;
    if (!participants || !participants.length) {
      return sourceParticipants;
    }
    sourceParticipants.forEach((participant) => {
      const existIndex = participants.findIndex((p) => p.id === participant.id);
      if (existIndex > -1) {
        participants.splice(existIndex, 1, participant);
      } else {
        participants.push(participant);
      }
    });

    return participants;
  }

  /**
   * need cache main sessions' participants since locus will not send the full list when cohost/host leave breakout
   * @param {Object} mainLocus
   * @returns {undefined}
   * @memberof LocusInfo
   */
  updateMainSessionLocusCache(mainLocus: any) {
    if (!mainLocus) {
      return;
    }
    const locusClone = cloneDeep(mainLocus);
    if (this.mainSessionLocusCache) {
      // shallow merge and do special merge for participants
      assignWith(this.mainSessionLocusCache, locusClone, (objValue, srcValue, key) => {
        if (key === 'participants') {
          return this.mergeParticipants(objValue, srcValue);
        }

        return srcValue || objValue;
      });
    } else {
      this.mainSessionLocusCache = locusClone;
    }
  }

  /**
   * clear main session cache
   * @returns {undefined}
   * @memberof LocusInfo
   */
  clearMainSessionLocusCache() {
    this.mainSessionLocusCache = null;
  }

  /**
   * Cleans up all hash tree parsers and clears internal maps.
   * @returns {void}
   * @memberof LocusInfo
   */
  cleanUp() {
    this.hashTreeParsers.forEach((entry) => {
      entry.parser.cleanUp();
    });
    this.hashTreeParsers.clear();
    this.hashTreeObjectId2ParticipantId.clear();
  }
}