/* @flow */

import {
    createStartAudioOnlyEvent,
    createStartMutedConfigurationEvent,
    createSyncTrackStateEvent,
    sendAnalytics
} from '../../analytics';
import { SET_ROOM, setAudioOnly } from '../conference';
import JitsiMeetJS from '../lib-jitsi-meet';
import { getPropertyValue } from '../profile';
import { MiddlewareRegistry } from '../redux';
import { setTrackMuted, TRACK_ADDED } from '../tracks';

import { setAudioMuted, setCameraFacingMode, setVideoMuted } from './actions';
import { CAMERA_FACING_MODE } from './constants';

const logger = require('jitsi-meet-logger').getLogger(__filename);

/**
 * Implements the entry point of the middleware of the feature base/media.
 *
 * @param {Store} store - The redux store.
 * @returns {Function}
 */
MiddlewareRegistry.register(store => next => action => {
    switch (action.type) {
    case SET_ROOM:
        return _setRoom(store, next, action);

    case TRACK_ADDED: {
        const result = next(action);

        action.track.local && _syncTrackMutedState(store, action.track);

        return result;
    }
    }

    return next(action);
});

/**
 * Notifies the feature base/media that the action {@link SET_ROOM} is being
 * dispatched within a specific redux {@code store}.
 *
 * @param {Store} store - The redux store in which the specified {@code action}
 * is being dispatched.
 * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
 * specified {@code action} to the specified {@code store}.
 * @param {Action} action - The redux action, {@code SET_ROOM}, which is being
 * dispatched in the specified {@code store}.
 * @private
 * @returns {Object} The new state that is the result of the reduction of the
 * specified {@code action}.
 */
function _setRoom({ dispatch, getState }, next, action) {
    const { room } = action;

    // Read the config.

    const state = getState();
    const hasRoom = Boolean(room);

    const audioMuted = Boolean(getPropertyValue(state, 'startWithAudioMuted', {
        urlParams: hasRoom
    }));
    const videoMuted = Boolean(getPropertyValue(state, 'startWithVideoMuted', {
        urlParams: hasRoom
    }));

    sendAnalytics(createStartMutedConfigurationEvent(
        'local', audioMuted, videoMuted));

    logger.log(`Start muted: ${audioMuted ? 'audio, ' : ''}${
        videoMuted ? 'video' : ''}`);

    // Unconditionally express the desires/expectations/intents of the app and
    // the user i.e. the state of base/media. Eventually, practice/reality i.e.
    // the state of base/tracks will or will not agree with the desires.
    dispatch(setAudioMuted(audioMuted));
    dispatch(setCameraFacingMode(CAMERA_FACING_MODE.USER));
    dispatch(setVideoMuted(videoMuted));

    // config.startAudioOnly
    //
    // FIXME Technically, the audio-only feature is owned by base/conference,
    // not base/media so the following should be in base/conference.
    // Practically, I presume it was easier to write the source code here
    // because it looks like config.startWithAudioMuted and
    // config.startWithVideoMuted.
    if (room) {
        let audioOnly;

        if (JitsiMeetJS.mediaDevices.supportsVideo()) {
            audioOnly = Boolean(getPropertyValue(state, 'startAudioOnly'));
        } else {
            // Always default to being audio only if the current environment
            // does not support sending or receiving video.
            audioOnly = true;
        }

        sendAnalytics(createStartAudioOnlyEvent(audioOnly));
        logger.log(`Start audio only set to ${audioOnly.toString()}`);
        dispatch(setAudioOnly(audioOnly));
    }

    return next(action);
}

/**
 * Syncs muted state of local media track with muted state from media state.
 *
 * @param {Store} store - The redux store.
 * @param {Track} track - The local media track.
 * @private
 * @returns {void}
 */
function _syncTrackMutedState({ getState }, track) {
    const state = getState()['features/base/media'];
    const muted = Boolean(state[track.mediaType].muted);

    // XXX If muted state of track when it was added is different from our media
    // muted state, we need to mute track and explicitly modify 'muted' property
    // on track. This is because though TRACK_ADDED action was dispatched it's
    // not yet in redux state and JitsiTrackEvents.TRACK_MUTE_CHANGED may be
    // fired before track gets to state.
    if (track.muted !== muted) {
        sendAnalytics(createSyncTrackStateEvent(track.mediaType, muted));
        logger.log(`Sync ${track.mediaType} track muted state to ${
            muted ? 'muted' : 'unmuted'}`);
        track.muted = muted;
        setTrackMuted(track.jitsiTrack, muted);
    }
}