import Immutable from 'immutable';
import * as types from '../constants/actionTypes';
import SessionRecord from '../store/sessionRecord';
import { ActionEnum } from '../constants';

export const sessions = (state = Immutable.List([]), action) => {

  switch (action.type) {

    case types.CREATE_SESSION: {
      return state.push(new SessionRecord(action.session));
    }
    case types.UPDATE_SESSION: {
      const sessionToUpdate = state.find(session => session === action.session);
      const sessionIndex = state.indexOf(action.session);
      if (sessionIndex === -1) {
        return state;
      }
      let newAction;
      switch (sessionToUpdate.get('action')) {
        case ActionEnum.CREATED:
          newAction = ActionEnum.CREATED;
          break;
        case ActionEnum.DELETED: // should not happen, but...
          newAction = ActionEnum.DELETED;
          break;
        default:
          newAction = ActionEnum.UPDATED;
      }

      const updatedSession = sessionToUpdate.merge(action.values, {action: newAction});
      return state.set(sessionIndex, updatedSession);
    }
    case types.DO_DELETE_SESSION: {
      return state.filter((session) => action.sessionId !== session._id)
    }
    case types.DELETE_SESSION: {
      const sessionIndex = state.indexOf(action.session);
      if (sessionIndex === -1) {
        return state;
      }
      const deletedSession = state.get(sessionIndex);
      if(deletedSession.get('action') === ActionEnum.CREATED) {
        // The session was previously created, we can delete it
        return state.delete(sessionIndex);
      } else {
        return state.set(sessionIndex, deletedSession.merge({action: ActionEnum.DELETED}));
      }
    }
    case types.LOAD_SESSIONS: {
      return action.sessions;
    }
    case types.LOAD_SESSION: {
      const sessionRec = action.session;
      const sessionId = sessionRec.get('_id');
      const index = state.findIndex((session) => session.get('_id') === sessionId);
      if(index >= 0) {
        return state.set(index, sessionRec);
      } else {
        return state.push(sessionRec);
      }
    }
    case types.SYNC_RESET_ALL: {
      return state.map((session) => {
        if(session.action !== ActionEnum.NONE) {
          return session.merge({action: ActionEnum.None});
        } else {
          return session;
        }
      });
    }
    case types.RESET_ACTION_SESSION: {
      const sessionId = action.session.get('_id');
      const index = state.findIndex((session) => session.get('_id') === sessionId);
      const session = state.get(index);
      return state.set(index, session.merge({action: ActionEnum.NONE}));
    }
    case types.AUTH_LOGOUT: {
      return Immutable.List(); // empty session list on logout
    }
    default:
      return state;
  }
};