import Immutable from 'immutable';

// TODO need to find a way to reference Redux's init for compatability
const ActionTypes = { INIT: 'INIT' };
const isImmutable = (obj) => {
  return Immutable.Iterable.isIterable(obj);
};

/* eslint-disable no-console */

function getErrorMessage(key, action) {
  var actionType = action && action.type;
  var actionName = actionType && `"${actionType.toString()}"` || 'an action';

  return (
    `Reducer "${key}" returned undefined handling ${actionName}. ` +
    `To ignore an action, you must explicitly return the previous state.`
  );
}

function verifyStateShape(initialState, currentState) {
  var reducerKeys = currentState.keySeq();

  if (reducerKeys.size === 0) {
    console.error(
      'Store does not have a valid reducer. Make sure the argument passed ' +
      'to combineReducers is an object whose values are reducers.'
    );
    return;
  }

  if (!isImmutable(initialState)) {
    console.error(
      'initialState has unexpected type of "' +
      ({}).toString.call(initialState).match(/\s([a-z|A-Z]+)/)[1] +
      '". Expected initialState to be an instance of Immutable.Iterable with the following ' +
      `keys: "${reducerKeys.join('", "')}"`
    );
    return;
  }

  const unexpectedKeys = initialState.keySeq().filter(
   key => reducerKeys.indexOf(key) < 0
  );

  if (unexpectedKeys.size > 0) {
    console.error(
      `Unexpected ${unexpectedKeys.length > 1 ? 'keys' : 'key'} ` +
      `"${unexpectedKeys.join('", "')}" in initialState will be ignored. ` +
      `Expected to find one of the known reducer keys instead: "${reducerKeys.join('", "')}"`
    );
  }
}

/**
 * Turns an object whose values are different reducer functions, into a single
 * reducer function. It will call every child reducer, and gather their results
 * into a single state object, whose keys correspond to the keys of the passed
 * reducer functions.
 *
 * @param {Object} reducers An object whose values correspond to different
 * reducer functions that need to be combined into one. One handy way to obtain
 * it is to use ES6 `import * as reducers` syntax. The reducers may never return
 * undefined for any action. Instead, they should return their initial state
 * if the state passed to them was undefined, and the current state for any
 * unrecognized action.
 *
 * @returns {Function} A reducer function that invokes every reducer inside the
 * passed object, and builds a state object with the same shape.
 */

export default function combineReducers(reducers) {
  reducers = isImmutable(reducers) ? reducers : Immutable.fromJS(reducers);
  const finalReducers = reducers.filter(v => typeof v === 'function');

  finalReducers.forEach((reducer, key) => {
    if (typeof reducer(undefined, { type: ActionTypes.INIT }) === 'undefined') {
      throw new Error(
        `Reducer "${key}" returned undefined during initialization. ` +
        `If the state passed to the reducer is undefined, you must ` +
        `explicitly return the initial state. The initial state may ` +
        `not be undefined.`
      );
    }

    var type = Math.random().toString(36).substring(7).split('').join('.');
    if (typeof reducer(undefined, { type }) === 'undefined') {
      throw new Error(
        `Reducer "${key}" returned undefined when probed with a random type. ` +
        `Don't try to handle ${ActionTypes.INIT} or other actions in "redux/*" ` +
        `namespace. They are considered private. Instead, you must return the ` +
        `current state for any unknown actions, unless it is undefined, ` +
        `in which case you must return the initial state, regardless of the ` +
        `action type. The initial state may not be undefined.`
      );
    }
  });

  var defaultState = finalReducers.map(r => undefined);
  var stateShapeVerified;

  return function combination(state = defaultState, action) {
    var dirty = false;
    var finalState = finalReducers.map((reducer, key) => {
      var oldState = state.get(key);
      var newState = reducer(oldState, action);
      dirty = dirty || (oldState !== newState)
      if (typeof newState === 'undefined') {
        throw new Error(getErrorMessage(key, action));
      }
      return newState;
    });

    if ((
      // Node-like CommonJS environments (Browserify, Webpack)
      typeof process !== 'undefined' &&
      typeof process.env !== 'undefined' &&
      process.env.NODE_ENV !== 'production'
    ) ||
      // React Native
      typeof __DEV__ !== 'undefined' &&
      __DEV__ // eslint-disable-line no-undef
    ) {
      if (!stateShapeVerified) {
        verifyStateShape(state, finalState);
        stateShapeVerified = true;
      }
    }

    return (dirty) ? finalState : state;
  };
}

import Immutable from 'immutable';
// TODO need to find a way to reference Redux's init for compatability
const ActionTypes = { INIT: 'INIT' };
const isImmutable = (obj) => {
  return Immutable.Iterable.isIterable(obj);
};

/* eslint-disable no-console */

function getUndefinedStateErrorMessage(key, action) {
  var actionType = action && action.type;
  var actionName = actionType && `"${actionType.toString()}"` || 'an action';

  return (
    `Reducer "${key}" returned undefined handling ${actionName}. ` +
    `To ignore an action, you must explicitly return the previous state.`
  );
}

function getUnexpectedStateKeyWarningMessage(inputState, outputState, action) {
  var reducerKeys = Object.keys(outputState);
  var argumentName = action && action.type === ActionTypes.INIT ?
    'initialState argument passed to createStore' :
    'previous state received by the reducer';

  if (reducerKeys.length === 0) {
    return (
      'Store does not have a valid reducer. Make sure the argument passed ' +
      'to combineReducers is an object whose values are reducers.'
    );
  }

  if (!isImmutable(inputState)) {
    return (
      `The ${argumentName} has unexpected type of "` +
      ({}).toString.call(inputState).match(/\s([a-z|A-Z]+)/)[1] +
      `". Expected argument to be an object with the following ` +
      `keys: "${reducerKeys.join('", "')}"`
    );
  }

  var unexpectedKeys = inputState.keySeq().filter(
    key => reducerKeys.indexOf(key) < 0
  );

  if (unexpectedKeys.size > 0) {
    return (
      `Unexpected ${unexpectedKeys.length > 1 ? 'keys' : 'key'} ` +
      `"${unexpectedKeys.join('", "')}" found in ${argumentName}. ` +
      `Expected to find one of the known reducer keys instead: ` +
      `"${reducerKeys.join('", "')}". Unexpected keys will be ignored.`
    );
  }
}

function assertReducerSanity(reducers) {
  reducers.keySeq().forEach(key => {
    var reducer = reducers.get(key);
    var initialState = reducer(undefined, { type: ActionTypes.INIT });

    if (typeof initialState === 'undefined') {
      throw new Error(
        `Reducer "${key}" returned undefined during initialization. ` +
        `If the state passed to the reducer is undefined, you must ` +
        `explicitly return the initial state. The initial state may ` +
        `not be undefined.`
      );
    }

    var type = '@@redux/PROBE_UNKNOWN_ACTION_' + Math.random().toString(36).substring(7).split('').join('.');
    if (typeof reducer(undefined, { type }) === 'undefined') {
      throw new Error(
        `Reducer "${key}" returned undefined when probed with a random type. ` +
        `Don't try to handle ${ActionTypes.INIT} or other actions in "redux/*" ` +
        `namespace. They are considered private. Instead, you must return the ` +
        `current state for any unknown actions, unless it is undefined, ` +
        `in which case you must return the initial state, regardless of the ` +
        `action type. The initial state may not be undefined.`
      );
    }
  });
}

/**
 * Turns an object whose values are different reducer functions, into a single
 * reducer function. It will call every child reducer, and gather their results
 * into a single state object, whose keys correspond to the keys of the passed
 * reducer functions.
 *
 * @param {Object} reducers An object whose values correspond to different
 * reducer functions that need to be combined into one. One handy way to obtain
 * it is to use ES6 `import * as reducers` syntax. The reducers may never return
 * undefined for any action. Instead, they should return their initial state
 * if the state passed to them was undefined, and the current state for any
 * unrecognized action.
 *
 * @returns {Function} A reducer function that invokes every reducer inside the
 * passed object, and builds a state object with the same shape.
 */

export default function combineReducers(reducers) {
  let finalReducers = isImmutable(reducers) ? reducers : Immutable.fromJS(reducers);
  finalReducers = finalReducers.filter(v => typeof v === 'function');
  var sanityError;

  try {
    assertReducerSanity(finalReducers);
  } catch (e) {
    sanityError = e;
  }

  var defaultState = finalReducers.map(r => undefined);

  return function combination(state = defaultState, action) {
    if (sanityError) {
      throw sanityError;
    }

    var dirty = false;
    var finalState = finalReducers.map((reducer, key) => {
      var oldState = state.get(key);
      var newState = reducer(oldState, action);
      dirty = dirty || (oldState !== newState)
      if (typeof newState === 'undefined') {
        throw new Error(getErrorMessage(key, action));
      }
      return newState;
    });

    if (process.env.NODE_ENV !== 'production') {
      var warningMessage = getUnexpectedStateKeyWarningMessage(state, finalState, action);
      if (warningMessage) {
        console.error(warningMessage);
      }
    }

    return (dirty) ? finalState : state;
  };
}

import Immutable from 'immutable'
import {combineReducers} from 'redux-immutablejs'

import sub1 from './sub1'
import sub2 from './sub2'

class State extends Immutable.Record({
    sub1: null,
    sub2: null
}) {

    // The two methods below allow to trick combineReducers to accept this class
    // instead of Immutable.Map or plain object

    filter() {
        return this;
    }

    map(k, v) {
        return new State(Immutable.Map(this).map(k, v));
    }
}

export default combineReducers(new State({sub1, sub2}));

// redux-immutablejs/lib/utils/combineReducers.js
function combineReducers(reducers) {
  var finalReducers = isImmutable(reducers) ? reducers : _immutable2['default'].fromJS(reducers);
  console.log(`

    reducers was a ${typeof reducers}
    reducers ${isImmutable(reducers) ? 'is' : 'is not' } immutable
    reducers keys: ${Object.keys(reducers).length}

    finalReducers is a ${typeof finalReducers}
    finalReducers ${_immutable2['default'].Map.isMap(finalReducers) ? 'is' : 'is not'} a Map
    fromJS(finalReducers) is a ${
      _immutable2['default'].Map.isMap(
        _immutable2['default'].fromJS(reducers)
      )
      ? 'Map' 
      : _immutable2['default'].List.isList(
        _immutable2['default'].fromJS(reducers)
      )
      ? 'List'
      : 'not list or map?'
    }
    `      
  )
  finalReducers = finalReducers.filter(function (v) {
    return typeof v === 'function';
  });
// ...

var finalReducers = isImmutable(reducers) ? reducers : _immutable2['default'].fromJS(reducers);

  var finalReducers = isImmutable(reducers) ? reducers : _immutable2['default'].Map(reducers);

import { combineReducers } from 'redux-immutablejs';
...
export const rootReducer = combineReducers({
  router: routerStateReducer,
  ...
});

...
const initialState = rootReducer(Immutable.fromJS({}));
const logger = createLogger();
const finalCreateStore = compose(
    applyMiddleware(thunk, api, logger),
    reduxReactRouter({
        routes,
        createHistory
    })
)(createStore);

export default function configureStore(initialState) {
  return finalCreateStore(rootReducer, initialState);
};

function routerStateReducer(state, action) {
  if (state === undefined) state = null;

  var _extends2;

  switch (action.type) { // error 
    case _constants.ROUTER_DID_CHANGE:
      return action.payload;
    case _constants.REPLACE_ROUTES:
      if (!state) return state;
      return _extends({}, state, (_extends2 = {}, _extends2[_constants.DOES_NEED_REFRESH] = true, _extends2));
    default:
      return state;
  }
}