// Module ID: 8805
// Function ID: 8806
// Name: ChannelRTCParticipants
// Dependencies: [2044, 4858, 502, 5590, 2045, 1993, 5731, 1372, 8806, 4855, 4857, 1074, 4861, 5740, 4464, 8807, 12, 8808, 8809, 4988, 7661, 4888, 2]
// Exports: activityParticipantIdToApplicationId, areParticipantsEqual, getEmbeddedActivityParticipantId

// Module 8805 (ChannelRTCParticipants)
import _mod12 from "module_12" /* 12 */;
import SecondaryIndexMap from "SecondaryIndexMap" /* 4464 */;
import StreamKeyUtils from "StreamKeyUtils" /* 4888 */;
import NicknameUtilsDefault from "NicknameUtils" /* 4988 */;
import getParticipantUserKeyDefault from "getParticipantUserKey" /* 5740 */;
import useIsSpeaking from "useIsSpeaking" /* 8807 */;
import ContentClassificationEmbeddedActivityFilterExperiment2 from "ContentClassificationEmbeddedActivityFilterExperiment" /* 8808 */;
import ContentClassificationReference from "ContentClassificationReference" /* 8809 */;
import EmbeddedActivitiesStore from "EmbeddedActivitiesStore" /* 2044 */;
import ApplicationStreamingStore from "ApplicationStreamingStore" /* 4858 */;
import AuthenticationStore from "AuthenticationStore" /* 502 */;
import CallStore from "CallStore" /* 5590 */;
import ChannelStore from "ChannelStore" /* 2045 */;
import MediaEngineStore from "MediaEngineStore" /* 1993 */;
import SpeakingStore from "SpeakingStore" /* 5731 */;
import UserStore from "UserStore" /* 1372 */;
import VideoStreamStore from "VideoStreamStore" /* 8806 */;
import VoiceStateStore from "VoiceStateStore" /* 4855 */;

require = fn;
function sortKey(type) {
  type = type.type;
  if (constants.ACTIVITY === type) {
    const _HermesInternal3 = HermesInternal;
    return "\u0001" + type.sortKey;
  } else {
    if (tmp.HIDDEN_STREAM !== type) {
      if (tmp.STREAM !== type) {
        if (tmp.USER === type) {
          const voiceState = type.voiceState;
          let selfVideo;
          if (voiceState != null) {
            selfVideo = voiceState.selfVideo;
          }
          let str = "\u0003";
          if (!selfVideo) {
            const voiceState2 = type.voiceState;
            let selfStream;
            if (voiceState2 != null) {
              selfStream = voiceState2.selfStream;
            }
            str = "\u0005";
            if (selfStream) {
              str = "\u0004";
            }
          }
          const _HermesInternal = HermesInternal;
          return "" + str + getParticipantUserKeyDefault(type.userNick, type.user);
        }
      }
    }
    let str4 = "\u0003";
    if (type.userVideo) {
      str4 = "\u0002";
    }
    const _HermesInternal2 = HermesInternal;
    return "" + str4 + getParticipantUserKeyDefault(type.userNick, type.user) + "\u0003";
  }
}
const CallConstants = fn(4857);
({ isStreamParticipant: map1, ParticipantTypes: closure_14 } = CallConstants);
let Constants = fn(1074);
({ ActivityTypes: closure_15, ChannelTypes: closure_16 } = Constants);
Constants = fn(4861);
({ MediaEngineContextTypes: closure_17, Features: closure_18 } = Constants);
const __EMBEDDED_ACTIVITIES__ = "__EMBEDDED_ACTIVITIES__";
const ChannelRTCParticipantsIndexes = { VIDEO: "VIDEO", STREAM: "STREAM", FILTERED: "FILTERED", SPEAKING: "SPEAKING", ACTIVITY: "ACTIVITY", NOT_POPPED_OUT: "NOT_POPPED_OUT" };
const size = fn(2);
let result = size.fileFinishedImporting("modules/calls/ChannelRTCParticipants.tsx");
class ChannelRTCParticipants {
  constructor(arg0) {
    merged = Object.assign({ participants: null, lastSpoke: null, poppedOutParticipants: null, participantByIndex: null });
    merged[0] = {};
    merged[1] = {};
    set = new Set();
    merged[2] = set;
    secondaryIndexMap = new closure_0(closure_2[14]).SecondaryIndexMap((type) => {
      const items = [];
      if (tmp2) {
        items.push(constants2.SPEAKING);
      }
      if (type.type === constants.USER) {
        const voiceState = type.voiceState;
        let selfVideo;
        if (voiceState != null) {
          selfVideo = voiceState.selfVideo;
        }
        if (selfVideo) {
          items.push(constants2.VIDEO);
          if (!tmp13) {
            items.push(tmp11.FILTERED);
          }
          tmp11 = constants2;
          tmp13 = type.localVideoDisabled || type.isPoppedOut;
        }
        if (type.type === tmp.ACTIVITY) {
          items.push(constants2.ACTIVITY);
        }
        if (!tmp17) {
          items.push(constants2.NOT_POPPED_OUT);
        }
        return items;
      }
      if (closure_1_13(type)) {
        items.push(constants2.STREAM);
        let isPoppedOut = type.type === tmp.HIDDEN_STREAM;
        if (!isPoppedOut) {
          isPoppedOut = null == type.streamId;
        }
        if (!isPoppedOut) {
          isPoppedOut = type.isPoppedOut;
        }
        if (!isPoppedOut) {
          items.push(tmp7.FILTERED);
        }
        tmp7 = constants2;
      }
    }, sortKey);
    merged[3] = secondaryIndexMap;
    merged.channelId = global;
    return merged;
  }
}
const prototype = ChannelRTCParticipants.prototype;
Object.defineProperty(prototype, "version", {
  get: function version() {
    return this.participantByIndex.version;
  },
  set: undefined
});
prototype["size"] = function size(arg0) {
  const participantByIndex = this.participantByIndex;
  return participantByIndex.size(arg0);
};
prototype["toArray"] = function toArray(arg0) {
  const participantByIndex = this.participantByIndex;
  return participantByIndex.values(arg0, true);
};
prototype["rebuild"] = function rebuild() {
  const self = this;
  const channel = ChannelStore.getChannel(this.channelId);
  if (null != channel) {
    if (channel.type !== constants3.GUILD_TEXT) {
      self.call = CallStore.getCall(self.channelId);
      if (channel.isPrivate()) {
        return false;
      }
      if (channel.isGuildVocalOrThread()) {
        const _Object = Object;
        let recipients = Object.keys(VoiceStateStore.getVoiceStatesForChannel(channel.id));
      } else {
        recipients = channel.recipients;
      }
      const set = new Set(recipients);
      set.add(AuthenticationStore.getId());
      const allActiveStreamsForChannel = ApplicationStreamingStore.getAllActiveStreamsForChannel(self.channelId);
      const item = allActiveStreamsForChannel.forEach((ownerId) => set.add(ownerId.ownerId));
      const participantByIndex = self.participantByIndex;
      participantByIndex.clear();
      self.participants = {};
      const item1 = set.forEach((item) => self.updateParticipant(item));
      const result = self.updateEmbeddedActivities();
      return true;
    }
  }
  return false;
};
prototype["getParticipant"] = function getParticipant(arg0) {
  const participantByIndex = this.participantByIndex;
  value = participantByIndex.get(arg0);
  if (value == null) {
    value = null;
  }
  return value;
};
prototype["updateEmbeddedActivities"] = function updateEmbeddedActivities() {
  return this.updateParticipant(__EMBEDDED_ACTIVITIES__);
};
prototype["hasEmbeddedActivity"] = function hasEmbeddedActivity() {
  return this.size(obj.ACTIVITY) > 0;
};
prototype["updateParticipant"] = function updateParticipant(arg0) {
  const self = this;
  if (arg0 === __EMBEDDED_ACTIVITIES__) {
    let result = self._getParticipantsForEmbeddedActivities();
  } else {
    result = self._getParticipantsForUser(arg0);
  }
  let flag = null != arr;
  if (!flag) {
    flag = 0 !== result.length;
  }
  if (flag) {
    if (arr != null) {
      const item = arr.forEach((id) => {
        const participantByIndex = self.participantByIndex;
        participantByIndex.delete(id.id);
      });
    }
    const item1 = result.forEach((id) => {
      const participantByIndex = self.participantByIndex;
      const result = participantByIndex.set(id.id, id);
    });
    self.participants[arg0] = result;
    flag = true;
  }
  return flag;
};
prototype["updateParticipantSpeaking"] = function updateParticipantSpeaking(f79482) {
  const self = this;
  const userId = f79482;
  let flag;
  if (this.participants[f79482] != null) {
    flag = arr.reduce((acc, type) => {
      let flag = acc;
      if (type.type === constants.USER) {
        const obj2 = { userId, checkIsMuted: true };
        const isSpeaking = useIsSpeaking.getIsSpeaking(obj2);
        const isSoundSharingResult = SpeakingStore.isSoundSharing(userId);
        const participantByIndex = self.participantByIndex;
        value = participantByIndex.get(type.id);
        type = undefined;
        if (value != null) {
          type = value.type;
        }
        if (type === tmp.USER) {
          return flag;
        }
        if (isSpeaking) {
          const _Date = Date;
          tmp8.lastSpoke[tmp4] = Date.now();
        }
        const participantByIndex2 = tmp8.participantByIndex;
        const obj3 = {};
        const merged = Object.assign(type);
        obj3.speaking = isSpeaking;
        obj3.lastSpoke = self.lastSpoke[userId];
        obj3.soundsharing = isSoundSharingResult;
        const result = participantByIndex2.set(type.id, obj3);
        flag = true;
      } else {
        return flag;
      }
    }, false);
  }
  if (flag == null) {
    flag = false;
  }
  return flag;
};
prototype["updateParticipantQuality"] = function updateParticipantQuality(f79488, maxResolution, maxFrameRate) {
  const self = this;
  let flag;
  if (this.participants[f79488] != null) {
    flag = arr.reduce((acc, type) => {
      let flag = acc;
      if (type.type === constants.STREAM) {
        const participantByIndex = self.participantByIndex;
        const obj = {};
        const merged = Object.assign(type);
        obj.maxResolution = maxResolution;
        obj.maxFrameRate = maxFrameRate;
        const result = participantByIndex.set(type.id, obj);
        flag = true;
      }
      return flag;
    }, false);
  }
  if (flag == null) {
    flag = false;
  }
  return flag;
};
prototype["updateParticipantPoppedOut"] = function updateParticipantPoppedOut(participantId, arg1) {
  const poppedOutParticipants = this.poppedOutParticipants;
  if (arg1) {
    poppedOutParticipants.add(participantId);
  } else {
    poppedOutParticipants.delete(participantId);
  }
};
prototype["_getEmbeddedActivities"] = function _getEmbeddedActivities() {
  const embeddedActivitiesForChannelIncludingHidden = EmbeddedActivitiesStore.getEmbeddedActivitiesForChannelIncludingHidden(this.channelId);
  const selfEmbeddedActivityForChannel = EmbeddedActivitiesStore.getSelfEmbeddedActivityForChannel(this.channelId);
  let uniqByResult = embeddedActivitiesForChannelIncludingHidden;
  if (null != selfEmbeddedActivityForChannel) {
    const items = [];
    items[HermesBuiltin.arraySpread(embeddedActivitiesForChannelIncludingHidden, 0)] = selfEmbeddedActivityForChannel;
    uniqByResult = _mod12.uniqBy(items, (compositeInstanceId) => compositeInstanceId.compositeInstanceId);
  }
  const ContentClassificationEmbeddedActivityFilterExperiment = ContentClassificationEmbeddedActivityFilterExperiment2.ContentClassificationEmbeddedActivityFilterExperiment;
  const currentUser = UserStore.getCurrentUser();
  let nsfwAllowed;
  if (currentUser != null) {
    nsfwAllowed = currentUser.nsfwAllowed;
  }
  let found = uniqByResult;
  if (!nsfwAllowed) {
    found = uniqByResult;
    if (ContentClassificationEmbeddedActivityFilterExperiment.getConfig({ location: "rtc_participants" }).enabled) {
      found = uniqByResult.filter((contentClassification) => !ContentClassificationReference.isAgeRestrictedClassificationReference(contentClassification.contentClassification));
    }
  }
  return found;
};
prototype["_getParticipantsForEmbeddedActivities"] = function _getParticipantsForEmbeddedActivities() {
  const self = this;
  const result = this._getEmbeddedActivities();
  return result.map((applicationId, index) => {
    const obj = { type: constants.ACTIVITY, id: null, applicationId: null, activityType: null, activityUrl: null, participants: null, guildId: null, sortKey: null };
    ({ applicationId, compositeInstanceId } = applicationId);
    if (null != compositeInstanceId) {
      const _HermesInternal2 = HermesInternal;
      let combined = "activity-" + applicationId + "-" + compositeInstanceId;
    } else {
      const _HermesInternal = HermesInternal;
      combined = "activity-" + applicationId;
    }
    obj.id = combined;
    obj.applicationId = applicationId.applicationId;
    obj.activityType = constants2.PLAYING;
    ({ url: obj.activityUrl, participants } = applicationId);
    if (participants == null) {
      participants = [];
    }
    const items = [...participants];
    obj.participants = items;
    const channel = ChannelStore.getChannel(self.channelId);
    let guildId;
    if (channel != null) {
      guildId = channel.getGuildId();
    }
    if (guildId == null) {
      guildId = null;
    }
    obj.guildId = guildId;
    obj.sortKey = index.toString();
    return obj;
  });
};
prototype["_getParticipantsForUser"] = function _getParticipantsForUser(userId) {
  const items = [];
  const user = UserStore.getUser(userId);
  if (null == user) {
    return items;
  } else {
    const self = this;
    const voiceStateForChannel = VoiceStateStore.getVoiceStateForChannel(this.channelId, userId);
    const voicePlatformForChannel = VoiceStateStore.getVoicePlatformForChannel(this.channelId, userId);
    const channel = ChannelStore.getChannel(this.channelId);
    let guildId;
    if (channel != null) {
      guildId = channel.getGuildId();
    }
    const call = self.call;
    let flag;
    if (call != null) {
      const ringing = call.ringing;
      if (ringing != null) {
        flag = ringing.includes(userId);
      }
    }
    if (flag == null) {
      flag = false;
    }
    if (tmp3) {
      const obj = { type: constants.USER };
      const merged = Object.assign(VideoStreamStore.getUserStreamData(userId, guildId));
      obj.user = user;
      obj.id = user.id;
      obj.voiceState = voiceStateForChannel;
      obj.voicePlatform = voicePlatformForChannel;
      const obj3 = { userId, checkIsMuted: true };
      obj.speaking = useIsSpeaking.getIsSpeaking(obj3);
      let num = self.lastSpoke[userId];
      if (num == null) {
        num = 0;
      }
      obj.lastSpoke = num;
      obj.soundsharing = SpeakingStore.isSoundSharing(userId);
      obj.ringing = flag;
      const tmp8 = require;
      obj.userNick = NicknameUtilsDefault.getName(guildId, self.channelId, user);
      obj.userAvatarDecoration = tmp8(7661).getAvatarDecoration(user, guildId);
      obj.localVideoDisabled = MediaEngineStore.isLocalVideoDisabled(user.id);
      const poppedOutParticipants = self.poppedOutParticipants;
      obj.isPoppedOut = poppedOutParticipants.has(user.id);
      items.push(obj);
      const tmp8Result = tmp8(7661);
    }
    let streamForUser = ApplicationStreamingStore.getStreamForUser(userId, guildId);
    if (streamForUser == null) {
      streamForUser = obj6.getActiveStreamForUser(userId, guildId);
    }
    if (MediaEngineStore.supports(constants5.VIDEO)) {
      if (null != streamForUser) {
        if (streamForUser.channelId === self.channelId) {
          const encodeStreamKeyResult = StreamKeyUtils.encodeStreamKey(streamForUser);
          const participant = self.getParticipant(encodeStreamKeyResult);
          let type;
          if (participant != null) {
            type = participant.type;
          }
          let tmp20 = null;
          if (type === constants.STREAM) {
            let tmp21;
            if (null != participant.maxResolution) {
              const obj5 = {};
              const merged1 = Object.assign(participant.maxResolution);
              tmp21 = obj5;
            }
            const obj7 = { maxResolution: tmp21, maxFrameRate: participant.maxFrameRate };
            tmp20 = obj7;
          }
          const obj8 = {};
          const merged2 = Object.assign(VideoStreamStore.getUserStreamData(userId, guildId, constants4.STREAM));
          const merged3 = Object.assign(tmp20);
          obj8.type = streamForUser.ownerId === AuthenticationStore.getId() && obj6.isSelfStreamHidden(self.channelId) ? constants.HIDDEN_STREAM : constants.STREAM;
          obj8.id = encodeStreamKeyResult;
          let flag2;
          if (voiceStateForChannel != null) {
            flag2 = voiceStateForChannel.selfVideo;
          }
          if (flag2 == null) {
            flag2 = false;
          }
          obj8.userVideo = flag2;
          obj8.user = user;
          const tmp17 = streamForUser.ownerId === AuthenticationStore.getId() && obj6.isSelfStreamHidden(self.channelId);
          obj8.userNick = NicknameUtilsDefault.getName(guildId, self.channelId, user);
          obj8.stream = streamForUser;
          const poppedOutParticipants2 = self.poppedOutParticipants;
          obj8.isPoppedOut = poppedOutParticipants2.has(encodeStreamKeyResult);
          items.push(obj8);
        }
      }
    }
    return items;
  }
};

export default ChannelRTCParticipants;
export const getEmbeddedActivityParticipantId = function getEmbeddedActivityParticipantId(arg0) {
  ({ applicationId, instanceId } = arg0);
  if (null != instanceId) {
    const _HermesInternal2 = HermesInternal;
    let combined = "activity-" + applicationId + "-" + instanceId;
  } else {
    const _HermesInternal = HermesInternal;
    combined = "activity-" + applicationId;
  }
  return combined;
};
export const activityParticipantIdToApplicationId = function activityParticipantIdToApplicationId(id) {
  let tmp = id;
  if (null != id) {
    tmp = id.split("-")[1];
  }
  return tmp;
};
export { sortKey };
export const areParticipantsEqual = function areParticipantsEqual(arg0, arg1) {
  [, tmp] = arg0;
  [, tmp2] = arg1;
  return tmp === tmp2;
};
export { ChannelRTCParticipantsIndexes };