/**
 * Created by jimsugg on 9/11/16.
 */

import { combineReducers } from 'redux';
import { createSelector } from 'reselect';

import { BaDmId } from '../baDmDataTypes';
import { DmContentItem, DmMediaStateState, DmMediaState, DmMediaStateContainer } from '../baDmInterfaces';
import { DmInternal } from "../baDmClasses";
import { MediaStateAction } from '../baDmActions'
import { NEW_SIGN, ADD_MEDIA_STATE, UPDATE_MEDIA_STATE, DELETE_MEDIA_STATE } from "../baDmActions";

var _ = require('lodash/omit');

// TODO: for super states, add reducer for SET_INITIAL_MEDIA_STATE
// TODO: important! - add mechanism to disambiguate names (i.e., no duplicate names)

type DmState = DmInternal.DmState;
type DmMediaStateMap = DmInternal.DmMap<DmMediaStateState>;

// Return a simple object conforming to DmMediaStateState
const createMediaStateState =
    (id: BaDmId, name: string, container: DmMediaStateContainer, contentItem: DmContentItem) =>
        ({
            id: id,
            name: name,
            container: container,
            contentItem: contentItem
        });

const mediaStatesById = (state : DmMediaStateMap = {}, {type, id, payload} : MediaStateAction) => {
    switch (type) {
        case NEW_SIGN :
            return {};
        case ADD_MEDIA_STATE :
            let {name, container, contentItem} = payload;
            return Object.assign({}, state, {[id]: createMediaStateState(id, name, container, contentItem)});
        case UPDATE_MEDIA_STATE :
            let updatedMediaState = Object.assign({}, state[id], payload);
            return Object.assign({}, state, {[id]: updatedMediaState});
        case DELETE_MEDIA_STATE :
            return _.omit(state, id);
    }
    return state;
};

const mediaStateReducer = mediaStatesById;

export default mediaStateReducer;

// Selectors

export const getMediaStateById = (state: DmState, props: any) => {
    let mediaStateState = state.mediaStates[props.id];
    return mediaStateState ? new DmInternal.MediaState(mediaStateState) : undefined;
}

const getStatesById = (state: DmState) => state.mediaStates;

const getStateNameProp = (state: DmState, props : any) : string => <string>(props.name);
const getZoneIdProp = (state: DmState, props : any) : BaDmId => <BaDmId>(props.id);

export const getMediaStateByName = createSelector<DmState, DmMediaState, DmMediaStateMap, string> (
    getStatesById, getStateNameProp,
    (states, name) => {
        let mediaStateState : DmMediaStateState = undefined;
        Object.keys(states).some((id, index, idArray): boolean => {
            if (states[id].name === name) {
                mediaStateState = states[id];
                return true;
            }
        });
        return mediaStateState ? new DmInternal.MediaState(mediaStateState) : undefined;
    }
);

export const getMediaStatesForZone = createSelector<DmState, BaDmId[], DmMediaStateMap, BaDmId> (
    getStatesById, getZoneIdProp,
    (states, zone) => {
        return Object.keys(states).filter((id, index, idArray): boolean => states[id].container.id === zone);
    }
);

// To be used in React Redux mapStateToProps, so that zone list memoization will be efficient for multiple zones
export const makeGetMediaStatesForZone = () => {
    return getMediaStatesForZone;
};