import BaseAudioBridge from './base';
import Auth from '/imports/ui/services/auth';
import logger from '/imports/startup/client/logger';
import ListenOnlyBroker from '/imports/ui/services/bbb-webrtc-sfu/listenonly-broker';
import loadAndPlayMediaStream from '/imports/ui/services/bbb-webrtc-sfu/load-play';
import {
  fetchWebRTCMappedStunTurnServers,
  getMappedFallbackStun
} from '/imports/utils/fetchStunTurnServers';
import getFromMeetingSettings from '/imports/ui/services/meeting-settings';

const SFU_URL = Meteor.settings.public.kurento.wsUrl;
const DEFAULT_LISTENONLY_MEDIA_SERVER = Meteor.settings.public.kurento.listenOnlyMediaServer;
const MEDIA = Meteor.settings.public.media;
const MEDIA_TAG = MEDIA.mediaTag.replace(/#/g, '');
const GLOBAL_AUDIO_PREFIX = 'GLOBAL_AUDIO_';
const RECONNECT_TIMEOUT_MS = MEDIA.listenOnlyCallTimeout || 15000;
const OFFERING = MEDIA.listenOnlyOffering;
const RECV_ROLE = 'recv';
const BRIDGE_NAME = 'kurento';

// SFU's base broker has distinct error codes so that it can be reused by different
// modules. Errors that have a valid, localized counterpart in audio manager are
// mapped so that the user gets a localized error message.
// The ones that haven't (ie SFU's servers-side errors), aren't mapped.
const errorCodeMap = {
  1301: 1001,
  1302: 1002,
  1305: 1005,
  1307: 1007,
}
const mapErrorCode = (error) => {
  const { errorCode } = error;
  const mappedErrorCode = errorCodeMap[errorCode];
  if (errorCode == null || mappedErrorCode == null) return error;
  error.errorCode = mappedErrorCode;
  return error;
}

// TODO Would be interesting to move this to a service along with the error mapping
const getMediaServerAdapter = () => {
  return getFromMeetingSettings('media-server-listenonly', DEFAULT_LISTENONLY_MEDIA_SERVER);
};

export default class KurentoAudioBridge extends BaseAudioBridge {
  constructor(userData) {
    super();
    this.internalMeetingID = userData.meetingId;
    this.voiceBridge = userData.voiceBridge;
    this.userId = userData.userId;
    this.name = userData.username;
    this.sessionToken = userData.sessionToken;
    this.media = {
      inputDevice: {},
    };
    this.broker;
    this.reconnecting = false;
  }

  async changeOutputDevice(value) {
    const audioContext = document.querySelector(`#${MEDIA_TAG}`);
    if (audioContext.setSinkId) {
      try {
        await audioContext.setSinkId(value);
        this.media.outputDeviceId = value;
      } catch (error) {
        logger.error({
          logCode: 'listenonly_changeoutputdevice_error',
          extraInfo: { error, bridge: BRIDGE_NAME }
        }, 'Audio bridge failed to change output device');
        throw new Error(this.baseErrorCodes.MEDIA_ERROR);
      }
    }

    return this.media.outputDeviceId || value;
  }

  getPeerConnection() {
    if (!this.broker) return null;

    const webRtcPeer = this.broker.webRtcPeer;
    if (webRtcPeer) return webRtcPeer.peerConnection;
    return null;
  }

  handleTermination() {
    return this.callback({ status: this.baseCallStates.ended, bridge: BRIDGE_NAME });
  }

  clearReconnectionTimeout() {
    this.reconnecting = false;
    if (this.reconnectionTimeout) {
      clearTimeout(this.reconnectionTimeout);
      this.reconnectionTimeout = null;
    }
  }

  reconnect() {
    this.broker.stop();
    this.callback({ status: this.baseCallStates.reconnecting, bridge: BRIDGE_NAME });
    this.reconnecting = true;
    // Set up a reconnectionTimeout in case the server is unresponsive
    // for some reason. If it gets triggered, end the session and stop
    // trying to reconnect
    this.reconnectionTimeout = setTimeout(() => {
      this.callback({
        status: this.baseCallStates.failed,
        error: 1010,
        bridgeError: 'Reconnection timeout',
        bridge: BRIDGE_NAME,
      });
      this.broker.stop();
      this.clearReconnectionTimeout();
    }, RECONNECT_TIMEOUT_MS);

    this.joinAudio({ isListenOnly: true }, this.callback).then(() => {
      this.clearReconnectionTimeout();
    }).catch(error => {
      // Error handling is a no-op because it will be "handled" in handleBrokerFailure
      logger.debug({
        logCode: 'listenonly_reconnect_failed',
        extraInfo: {
          errorMessage: error.errorMessage,
          reconnecting: this.reconnecting,
          bridge: BRIDGE_NAME
        },
      }, 'Listen only reconnect failed');
    });
  }

  handleBrokerFailure(error) {
    return new Promise((resolve, reject) => {
      mapErrorCode(error);
      const { errorMessage, errorCause, errorCode } = error;

      if (this.broker.started && !this.reconnecting) {
        logger.error({
          logCode: 'listenonly_error_try_to_reconnect',
          extraInfo: { errorMessage, errorCode, errorCause, bridge: BRIDGE_NAME },
        }, 'Listen only failed, try to reconnect');
        this.reconnect();
        return resolve();
      } else {
        // Already tried reconnecting once OR the user handn't succesfully
        // connected firsthand. Just finish the session and reject with error
        logger.error({
          logCode: 'listenonly_error',
          extraInfo: {
            errorMessage, errorCode, errorCause,
            reconnecting: this.reconnecting,
            bridge: BRIDGE_NAME
          },
        }, 'Listen only failed');
        this.clearReconnectionTimeout();
        this.broker.stop();
        this.callback({
          status: this.baseCallStates.failed,
          error: errorCode,
          bridgeError: errorMessage,
          bridge: BRIDGE_NAME,
        });
        return reject(error);
      }
    });
  }

  dispatchAutoplayHandlingEvent(mediaElement) {
    const tagFailedEvent = new CustomEvent('audioPlayFailed', {
      detail: { mediaElement }
    });
    window.dispatchEvent(tagFailedEvent);
    this.callback({ status: this.baseCallStates.autoplayBlocked, bridge: BRIDGE_NAME });
  }

  handleStart() {
    const stream = this.broker.webRtcPeer.getRemoteStream();
    const mediaElement = document.getElementById(MEDIA_TAG);

    return loadAndPlayMediaStream(stream, mediaElement, false).then(() => {
      return this.callback({ status: this.baseCallStates.started, bridge: BRIDGE_NAME });
    }).catch(error => {
      // NotAllowedError equals autoplay issues, fire autoplay handling event.
      // This will be handled in audio-manager.
      if (error.name === 'NotAllowedError') {
        logger.error({
          logCode: 'listenonly_error_autoplay',
          extraInfo: { errorName: error.name, bridge: BRIDGE_NAME },
        }, 'Listen only media play failed due to autoplay error');
        this.dispatchAutoplayHandlingEvent(mediaElement);
      } else {
        const normalizedError = {
          errorCode: 1004,
          errorMessage: error.message || 'AUDIO_PLAY_FAILED',
        };
        this.callback({
          status: this.baseCallStates.failed,
          error: normalizedError.errorCode,
          bridgeError: normalizedError.errorMessage,
          bridge: BRIDGE_NAME,
        })
        throw normalizedError;
      }
    });
  }

  trickleIce() {
    return new Promise((resolve, reject) => {
      try {
        fetchWebRTCMappedStunTurnServers(this.sessionToken)
          .then((iceServers) => {
            const options = {
              userName: this.name,
              caleeName: `${GLOBAL_AUDIO_PREFIX}${this.voiceBridge}`,
              iceServers,
              offering: OFFERING,
            };

            this.broker = new ListenOnlyBroker(
              Auth.authenticateURL(SFU_URL),
              this.voiceBridge,
              this.userId,
              this.internalMeetingID,
              RECV_ROLE,
              options,
            );

            this.broker.onstart = () => {
              const { peerConnection } = this.broker.webRtcPeer;

              if (!peerConnection) return resolve(null);

              const selectedCandidatePair = peerConnection.getReceivers()[0]
                .transport.iceTransport.getSelectedCandidatePair();

              const validIceCandidate = [selectedCandidatePair.local];

              this.broker.stop();
              return resolve(validIceCandidate);
            };

            this.broker.listen();
          });
      } catch (e) {
        reject(e);
      }
    });
  }

  joinAudio({ isListenOnly }, callback) {
    return new Promise(async (resolve, reject) => {
      if (!isListenOnly) return reject(new Error('Invalid bridge option'));
      this.callback = callback;
      let iceServers = [];

      try {
        iceServers = await fetchWebRTCMappedStunTurnServers(this.sessionToken);
      } catch (error) {
        logger.error({ logCode: 'listenonly_stunturn_fetch_failed' },
          'SFU audio bridge failed to fetch STUN/TURN info, using default servers');
        iceServers = getMappedFallbackStun();
      } finally {
        const options = {
          userName: this.name,
          caleeName: `${GLOBAL_AUDIO_PREFIX}${this.voiceBridge}`,
          iceServers,
          offering: OFFERING,
          mediaServer: getMediaServerAdapter(),
        };

        this.broker = new ListenOnlyBroker(
          Auth.authenticateURL(SFU_URL),
          this.voiceBridge,
          this.userId,
          this.internalMeetingID,
          RECV_ROLE,
          options,
        );

        this.broker.onended = this.handleTermination.bind(this);
        this.broker.onerror = (error) => {
          this.handleBrokerFailure(error).catch(reject);
        }
        this.broker.onstart = () => {
          this.handleStart().then(resolve).catch(reject);
        };

       this.broker.listen().catch(reject);
      }
    });
  }

  exitAudio() {
    const mediaElement = document.getElementById(MEDIA_TAG);

    this.broker.stop();
    this.clearReconnectionTimeout();

    if (mediaElement && typeof mediaElement.pause === 'function') {
      mediaElement.pause();
      mediaElement.srcObject = null;
    }

    return Promise.resolve();
  }
}

module.exports = KurentoAudioBridge;