// Module ID: 13328
// Function ID: 101317
// Name: _isNativeReflectConstruct
// Dependencies: []

// Module 13328 (_isNativeReflectConstruct)
function _isNativeReflectConstruct() {
  let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {

  }));
  function _isNativeReflectConstruct() {
    return closure_0;
  }
  const result = _isNativeReflectConstruct();
}
function isPlaybackComplete(duration) {
  if (duration.duration > 0) {
    return duration.duration - duration.time <= closure_18;
  }
}
let closure_3 = importDefault(dependencyMap[0]);
let closure_4 = importDefault(dependencyMap[1]);
let closure_5 = importDefault(dependencyMap[2]);
let closure_6 = importDefault(dependencyMap[3]);
let closure_7 = importDefault(dependencyMap[4]);
({ NativeEventEmitter: closure_8, NativeModules: closure_9 } = arg1(dependencyMap[5]));
let closure_10 = importDefault(dependencyMap[6]);
let closure_11 = importDefault(dependencyMap[7]);
let closure_12 = importDefault(dependencyMap[8]);
let closure_13 = importDefault(dependencyMap[9]);
let closure_14 = importDefault(dependencyMap[10]);
let closure_15 = importDefault(dependencyMap[11]);
const AppStates = arg1(dependencyMap[12]).AppStates;
const ActivityPanelModes = arg1(dependencyMap[13]).ActivityPanelModes;
const tmp2 = arg1(dependencyMap[5]);
({ PLAYBACK_COMPLETION_DETECTION_TOLERANCE: closure_18, PLAYBACK_PROGRESS_UPDATE_INTERVAL: closure_19 } = arg1(dependencyMap[14]));
const Permissions = arg1(dependencyMap[15]).Permissions;
let importDefaultResult = importDefault(dependencyMap[16]);
importDefaultResult = new importDefaultResult("MediaPlayerManager");
let obj = arg1(dependencyMap[17]);
obj = obj.create((arg0) => {
  const arg1 = arg0;
  const obj = {
    rightButton: true,
    receivedTimestamp: true,
    videoLandscapeFullscreen: true,
    firstFrameDecryptedTimestamp: true,
    EXPLICIT_MEDIA_SCAN_CLIENT_TIMING: true,
    maxValues: true,
    minValues: true,
    RECOMMENDATION_BANNER_CARD: "<string:76291905>",
    activeMediaPlayerSource: undefined,
    mediaSourceMessage: undefined,
    progress: undefined,
    closePip() {
      arg0(closure_2[18]).batchUpdates(() => callback({ showPip: false }));
    },
    displayedMediaItemIdsPerChannel: {},
    currentlyDisplayedChannelId: undefined
  };
  return obj;
});
let tmp7 = (arg0) => {
  class MediaPlayerManager {
    constructor() {
      self = this;
      tmp = closure_3(this, MediaPlayerManager);
      obj = closure_6(MediaPlayerManager);
      tmp2 = closure_5;
      if (closure_23()) {
        tmp4 = globalThis;
        _Reflect = Reflect;
        tmp5 = closure_6;
        constructResult = Reflect.construct(obj, [], closure_6(self).constructor);
      } else {
        constructResult = obj.apply(self, undefined);
      }
      tmp2Result = tmp2(self, constructResult);
      tmp2Result.subscriptions = [];
      tmp2Result.voicePanelStoreUnsubscribe = undefined;
      tmp2Result.showPipUnsubscribe = undefined;
      pauseAndClosePip = tmp2Result.pauseAndClosePip;
      tmp2Result.pauseAndClosePip = pauseAndClosePip.bind(tmp2Result);
      handleVoicePanelStateUpdated = tmp2Result.handleVoicePanelStateUpdated;
      tmp2Result.handleVoicePanelStateUpdated = handleVoicePanelStateUpdated.bind(tmp2Result);
      handleEmbeddedActivitiesUpdated = tmp2Result.handleEmbeddedActivitiesUpdated;
      tmp2Result.handleEmbeddedActivitiesUpdated = handleEmbeddedActivitiesUpdated.bind(tmp2Result);
      handleMediaPlayerPlaybackRateChanged = tmp2Result.handleMediaPlayerPlaybackRateChanged;
      tmp2Result.handleMediaPlayerPlaybackRateChanged = handleMediaPlayerPlaybackRateChanged.bind(tmp2Result);
      handleMediaPlayerPlaybackSourceChanged = tmp2Result.handleMediaPlayerPlaybackSourceChanged;
      tmp2Result.handleMediaPlayerPlaybackSourceChanged = handleMediaPlayerPlaybackSourceChanged.bind(tmp2Result);
      handleMediaPlayerViewWillAppear = tmp2Result.handleMediaPlayerViewWillAppear;
      tmp2Result.handleMediaPlayerViewWillAppear = handleMediaPlayerViewWillAppear.bind(tmp2Result);
      handleMediaPlayerViewDidDisappear = tmp2Result.handleMediaPlayerViewDidDisappear;
      tmp2Result.handleMediaPlayerViewDidDisappear = handleMediaPlayerViewDidDisappear.bind(tmp2Result);
      updateDisplayState = tmp2Result.updateDisplayState;
      tmp2Result.updateDisplayState = updateDisplayState.bind(tmp2Result);
      updateMediaPermissions = tmp2Result.updateMediaPermissions;
      tmp2Result.updateMediaPermissions = updateMediaPermissions.bind(tmp2Result);
      return tmp2Result;
    }
  }
  const arg1 = MediaPlayerManager;
  callback2(MediaPlayerManager, arg0);
  let obj = {
    key: "_initialize",
    value() {
      const self = this;
      const obj = new closure_8(closure_9.MediaPlayerManager);
      const items = [obj.addListener("MediaPlayerPlaybackSourceChanged", this.handleMediaPlayerPlaybackSourceChanged), obj.addListener("MediaPlayerPlaybackProgressUpdated", this.handleMediaPlayerPlaybackProgressUpdated), obj.addListener("MediaPlayerPlaybackRateChanged", this.handleMediaPlayerPlaybackRateChanged), obj.addListener("MediaPlayerViewWillAppear", this.handleMediaPlayerViewWillAppear), obj.addListener("MediaPlayerViewDidDisappear", this.handleMediaPlayerViewDidDisappear)];
      this.subscriptions = items;
      const MediaPlayerManager = closure_9.MediaPlayerManager;
      const result = MediaPlayerManager.subscribeToPlaybackEvents();
      const rootNavigationRef = MediaPlayerManager(closure_2[19]).getRootNavigationRef();
      if (null != rootNavigationRef) {
        rootNavigationRef.addListener("state", self.updateDisplayState);
      }
      self.voicePanelStoreUnsubscribe = closure_11.subscribe(self.handleVoicePanelStateUpdated);
      closure_10.addChangeListener(self.handleEmbeddedActivitiesUpdated);
      closure_12.addChangeListener(self.updateMediaPermissions);
      closure_14.addChangeListener(self.updateMediaPermissions);
      const obj2 = MediaPlayerManager(closure_2[19]);
      const subscription = callback(closure_2[20]).subscribe("LOGOUT", self.userDidClosePip);
      const obj4 = callback(closure_2[20]);
      if (obj5.isIOS()) {
        self.showPipUnsubscribe = closure_22.subscribe((showPip, showPip2) => {
          if (showPip2.showPip) {
            if (!showPip.showPip) {
              const MediaPlayerManager = closure_9.MediaPlayerManager;
              MediaPlayerManager.clearNowPlayingInfo();
            }
          }
          let tmp3 = 0 !== showPip2.rate && 0 === showPip.rate && !showPip.showPip;
          if (tmp3) {
            tmp3 = state.getState() === constants.ACTIVE;
          }
          if (tmp3) {
            const MediaPlayerManager2 = closure_9.MediaPlayerManager;
            MediaPlayerManager2.clearNowPlayingInfo();
          }
        });
      }
      closure_21.verbose("Initialized and subscribed to playback events");
    }
  };
  const items = [obj, , , , , , , , , , , , , , , , ];
  obj = {
    key: "updateMediaPermissions",
    value() {
      const MediaPlayerManager = this;
      MediaPlayerManager(closure_2[18]).batchUpdates(() => {
        const activeMediaPlayerSource = store.getState().activeMediaPlayerSource;
        let channelId;
        if (null != activeMediaPlayerSource) {
          channelId = activeMediaPlayerSource.channelId;
        }
        let tmp3 = null;
        if (null != channelId) {
          tmp3 = channelId;
        }
        const channel = channel.getChannel(tmp3);
        if (null != channel) {
          if (!channel.isPrivate()) {
            if (!closure_14.can(constants.VIEW_CHANNEL, channel)) {
              const obj = { canAccessMedia: false };
              store.setState(obj);
              self.pauseCurrentPlayer();
            }
          }
        }
        store.setState({ canAccessMedia: true });
      });
    }
  };
  items[1] = obj;
  obj = {
    key: "_terminate",
    value() {
      const self = this;
      const subscriptions = this.subscriptions;
      const item = subscriptions.forEach((remove) => remove.remove());
      this.subscriptions = [];
      const rootNavigationRef = MediaPlayerManager(closure_2[19]).getRootNavigationRef();
      if (null != rootNavigationRef) {
        rootNavigationRef.removeListener("state", self.updateDisplayState);
      }
      const voicePanelStoreUnsubscribe = self.voicePanelStoreUnsubscribe;
      if (null != voicePanelStoreUnsubscribe) {
        voicePanelStoreUnsubscribe.call(self);
      }
      const showPipUnsubscribe = self.showPipUnsubscribe;
      if (null != showPipUnsubscribe) {
        showPipUnsubscribe.call(self);
      }
      closure_10.removeChangeListener(self.handleEmbeddedActivitiesUpdated);
      closure_12.removeChangeListener(self.updateMediaPermissions);
      closure_14.removeChangeListener(self.updateMediaPermissions);
      const obj = MediaPlayerManager(closure_2[19]);
      callback(closure_2[20]).unsubscribe("LOGOUT", self.userDidClosePip);
    }
  };
  items[2] = obj;
  items[3] = {
    key: "pauseCurrentPlayer",
    value() {
      const MediaPlayerManager = closure_9.MediaPlayerManager;
      MediaPlayerManager.pauseCurrentPlayer();
    }
  };
  items[4] = {
    key: "playCurrentPlayer",
    value() {
      const MediaPlayerManager = closure_9.MediaPlayerManager;
      MediaPlayerManager.playCurrentPlayer();
    }
  };
  items[5] = {
    key: "userDidClosePip",
    value() {
      MediaPlayerManager(closure_2[18]).batchUpdates(() => state.setState({ <string:146367146>: 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021043611947808288, <string:906231122>: 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000053357352779429986 }));
    }
  };
  items[6] = {
    key: "pauseAndClosePip",
    value() {
      const MediaPlayerManager = this;
      MediaPlayerManager(closure_2[18]).batchUpdates(() => {
        self.pauseCurrentPlayer();
        state.setState({ <string:146367146>: 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021043611947808288, <string:906231122>: 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000053357352779429986 });
      });
    }
  };
  items[7] = {
    key: "handleVoicePanelStateUpdated",
    value() {
      const self = this;
      const state = closure_11.getState();
      let result = state.isVoicePanelFullscreen();
      if (!result) {
        result = state.voicePanelsPIP.size > 0;
      }
      if (result) {
        self.pauseAndClosePip();
      }
    }
  };
  items[8] = {
    key: "handleEmbeddedActivitiesUpdated",
    value() {
      const self = this;
      if (closure_10.getActivityPanelMode() === constants.PIP) {
        self.pauseAndClosePip();
      }
    }
  };
  items[9] = {
    key: "handleMediaPlayerPlaybackRateChanged",
    value(arg0) {
      const MediaPlayerManager = this;
      ({ source: closure_1, rate: closure_2 } = arg0);
      MediaPlayerManager(closure_2[18]).batchUpdates(() => {
        let activeMediaPlayerSource;
        let isPlaying;
        let wasPipClosedByUser;
        if (null == lib) {
          store.setState({ "Null": 9035158524362260000000000000000000000000000000000000000000000000000000000000000000000000000000, "Null": -222642488090540470000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 });
        }
        let id;
        if (null != lib) {
          id = lib.id;
        }
        closure_21.verbose("Playback rate changed to " + closure_2 + ": " + id);
        const state = store.getState();
        ({ activeMediaPlayerSource, isPlaying, wasPipClosedByUser } = state);
        let tmp10;
        if (null != lib) {
          tmp10 = lib;
        }
        if (tmp9(activeMediaPlayerSource, tmp10)) {
          let obj = { rate: closure_2, isPlaying: 0 !== closure_2 };
          let tmp18 = false === isPlaying;
          if (tmp18) {
            tmp18 = closure_2 > 0;
          }
          let tmp20 = !tmp18;
          if (!tmp18) {
            tmp20 = wasPipClosedByUser;
          }
          obj.wasPipClosedByUser = tmp20;
          store.setState(obj);
          self.updateDisplayState();
        } else {
          obj = { source: lib };
          const result = self.handleMediaPlayerPlaybackSourceChanged(obj);
          obj = { source: lib, rate: closure_2 };
          const result1 = self.handleMediaPlayerPlaybackRateChanged(obj);
        }
        const tmp4 = closure_2;
        const tmp9 = lib(closure_2[22]);
      });
    }
  };
  items[10] = {
    key: "handleMediaPlayerPlaybackProgressUpdated",
    value(arg0) {
      ({ source: closure_0, time: closure_1, duration: closure_2 } = arg0);
      MediaPlayerManager(closure_2[18]).batchUpdates(() => {
        const state = store.getState();
        let tmp3;
        if (null != channelId) {
          tmp3 = channelId;
        }
        if (tmp2(state.activeMediaPlayerSource, tmp3)) {
          const currentlyDisplayedChannelId = state.currentlyDisplayedChannelId;
          if (state.showPip) {
            let tmp7;
            if (closure_2 > 0) {
              let obj = { time: callback, duration: closure_2 };
              obj = { time: callback, duration: closure_2 };
              const tmp11 = callback2(obj);
              obj.isCompleted = null != tmp11 && tmp11;
              tmp7 = obj;
            }
            const progress = state.progress;
            let tmp12 = null != progress && null != tmp7;
            if (tmp12) {
              const _Math = Math;
              tmp12 = Math.abs(tmp7.time - progress.time) < closure_19;
            }
            if (tmp12) {
              tmp12 = tmp7.time !== tmp7.duration;
            }
            if (!tmp12) {
              obj = { progress: tmp7 };
              store.setState(obj);
            }
          } else if (null != currentlyDisplayedChannelId) {
            let channelId;
            if (null != channelId) {
              channelId = channelId.channelId;
            }
          }
        }
      });
    }
  };
  items[11] = {
    key: "handleMediaPlayerPlaybackSourceChanged",
    value(source) {
      const MediaPlayerManager = this;
      source = source.source;
      MediaPlayerManager(closure_2[18]).batchUpdates(() => {
        let id;
        const state = store.getState();
        if (null != source) {
          id = source.id;
        }
        closure_21.verbose("Playback source changed: " + id);
        const activeMediaPlayerSource = state.activeMediaPlayerSource;
        let tmp7;
        if (null != activeMediaPlayerSource) {
          tmp7 = activeMediaPlayerSource;
        }
        let tmp8;
        if (null != source) {
          tmp8 = source;
        }
        if (!tmp6(tmp7, tmp8)) {
          const obj = { clientThemeSettings: "FRAME_SET_PROXY_TICKET_REFRESHING", captureReactException: "<string:1627463937>", computeWeight: "<string:1361119231>", addOptionsGetter: "<string:809682045>", getCommandContext: "<string:3187671617>", _merge: "<string:1358955081>" };
          let tmp11;
          if (null != source) {
            tmp11 = source;
          }
          obj.activeMediaPlayerSource = tmp11;
          let orFetchMediaSourceMessage;
          if (null != source) {
            orFetchMediaSourceMessage = self.getOrFetchMediaSourceMessage(source);
          }
          obj.mediaSourceMessage = orFetchMediaSourceMessage;
          obj.progress = undefined;
          store.setState(obj);
          const result = self.updateMediaPermissions();
          self.updateDisplayState();
        }
      });
    }
  };
  items[12] = {
    key: "getOrFetchMediaSourceMessage",
    value(arg0) {
      let assetUrl;
      let channelId;
      let messageId;
      const MediaPlayerManager = this;
      ({ channelId, messageId, assetUrl } = arg0);
      if (null != messageId) {
        if (null != channelId) {
          const message = store.getMessage(channelId, messageId);
          if (null != message) {
            return message;
          } else {
            if (null != assetUrl) {
              const messages = store.getMessages(channelId);
              const found = messages.toArray().find((getContentMessage) => {
                const contentMessage = getContentMessage.getContentMessage();
                let someResult;
                if (null != contentMessage) {
                  const attachments = contentMessage.attachments;
                  if (null != attachments) {
                    someResult = attachments.some((url) => url.url === closure_1);
                  }
                }
                return someResult;
              });
              if (null != found) {
                return found;
              }
              const toArrayResult = messages.toArray();
            }
            const obj = { channelId, messageId };
            const message1 = assetUrl(closure_2[23]).fetchMessage(obj);
            message1.then((arg0) => {
              if (null != arg0) {
                const result = self.handleMediaSourceMessageUpdated(arg0);
              }
            });
            const obj2 = assetUrl(closure_2[23]);
          }
        }
      }
    }
  };
  items[13] = {
    key: "handleMediaSourceMessageUpdated",
    value(arg0) {
      const MediaPlayerManager = arg0;
      MediaPlayerManager(closure_2[18]).batchUpdates(() => {
        const activeMediaPlayerSource = store.getState().activeMediaPlayerSource;
        let messageId;
        if (null != activeMediaPlayerSource) {
          messageId = activeMediaPlayerSource.messageId;
        }
        if (messageId === arg0.id) {
          const obj = { mediaSourceMessage: arg0 };
          store.setState(obj);
        }
      });
    }
  };
  items[14] = {
    key: "handleMediaPlayerViewWillAppear",
    value(arg0) {
      const MediaPlayerManager = this;
      ({ mediaItemIds: closure_1, channelId: closure_2 } = arg0);
      MediaPlayerManager(closure_2[18]).batchUpdates(() => {
        const displayedMediaItemIdsPerChannel = store.getState().displayedMediaItemIdsPerChannel;
        let items = displayedMediaItemIdsPerChannel[closure_2];
        if (null == items) {
          items = [];
        }
        const items1 = [...closure_1];
        displayedMediaItemIdsPerChannel[closure_2] = new Set(items1);
        store.setState({ displayedMediaItemIdsPerChannel });
        self.updateDisplayState();
      });
    }
  };
  items[15] = {
    key: "handleMediaPlayerViewDidDisappear",
    value(arg0) {
      const MediaPlayerManager = this;
      ({ mediaItemIds: closure_1, channelId: closure_2 } = arg0);
      MediaPlayerManager(closure_2[18]).batchUpdates(() => {
        const displayedMediaItemIdsPerChannel = store.getState().displayedMediaItemIdsPerChannel;
        let set = displayedMediaItemIdsPerChannel[closure_2];
        if (null == set) {
          const _Set = Set;
          set = new Set();
        }
        const items = [...set];
        const set1 = new Set(items.filter((arg0) => !closure_1.includes(arg0)));
        if (0 === set1.size) {
          delete r4[r2];
        } else {
          displayedMediaItemIdsPerChannel[closure_2] = set1;
        }
        store.setState({ displayedMediaItemIdsPerChannel });
        self.updateDisplayState();
      });
    }
  };
  items[16] = {
    key: "updateDisplayState",
    value() {
      MediaPlayerManager(closure_2[18]).batchUpdates(() => {
        let activeMediaPlayerSource;
        let displayedMediaItemIdsPerChannel;
        let isPlaying;
        let progress;
        const state = store.getState();
        ({ displayedMediaItemIdsPerChannel, activeMediaPlayerSource } = state);
        if (undefined === activeMediaPlayerSource) {
          activeMediaPlayerSource = {};
        }
        const id = activeMediaPlayerSource.id;
        ({ progress, isPlaying } = state);
        if (state.wasPipClosedByUser) {
          let obj = { showPip: false };
          store.setState(obj);
        } else if (isPlaying) {
          if (!isPlaying) {
            let tmp4 = null != progress;
            if (tmp4) {
              tmp4 = !callback2(progress);
            }
            isPlaying = tmp4;
          }
          obj = callback(closure_2[24]);
          const focusedChannelId = obj.getFocusedChannelId();
          if (null != focusedChannelId) {
            if (state.currentlyDisplayedChannelId !== focusedChannelId) {
              for (const key10026 in displayedMediaItemIdsPerChannel) {
                let tmp21 = key10026;
                if (key10026 === focusedChannelId) {
                  continue;
                } else {
                  delete r5[r12];
                  // continue
                }
                continue;
              }
            }
          }
          if (null != id) {
            if (null != focusedChannelId) {
              let obj3 = displayedMediaItemIdsPerChannel[focusedChannelId];
              if (null != obj3) {
                obj = {};
                if (isPlaying) {
                  isPlaying = !obj3.has(id);
                }
                obj.showPip = isPlaying;
                obj.currentlyDisplayedChannelId = focusedChannelId;
                obj.displayedMediaItemIdsPerChannel = displayedMediaItemIdsPerChannel;
                store.setState(obj);
              } else {
                const obj1 = { showPip: isPlaying, currentlyDisplayedChannelId: focusedChannelId, displayedMediaItemIdsPerChannel };
                store.setState(obj1);
              }
            } else {
              const obj2 = { showPip: isPlaying, currentlyDisplayedChannelId: focusedChannelId, displayedMediaItemIdsPerChannel };
              store.setState(obj2);
            }
          } else {
            obj3 = { showPip: isPlaying, currentlyDisplayedChannelId: focusedChannelId, displayedMediaItemIdsPerChannel };
            store.setState(obj3);
          }
        }
      });
    }
  };
  return callback(MediaPlayerManager, items);
}(importDefault(dependencyMap[25]));
tmp7 = new tmp7();
const tmp3 = arg1(dependencyMap[14]);
const result = arg1(dependencyMap[26]).fileFinishedImporting("modules/media/native/MediaPlayerManager.tsx");

export default tmp7;
export const useMediaPlayerManagerStore = obj;
export { isPlaybackComplete };