import isPlainObject from 'lodash/isPlainObject'
import $$observable from 'symbol-observable'

/**
 * This is a private action type reserved by redux.
 * For any unknown actions, you must return to the current state.
 * If the current state is undefined, you will have to return to an initial state.
 * Do not directly reference these action types in your code.
 */
export const ActionTypes = {
  INIT: '@@redux/INIT'
}

/**
 * Create a redux store with a status tree.
 * Calling dispatch() is the only way to modify a value in the store.
 * There should be only one store in the application.To change logic for different parts of the program state
 * Together, you need to use combineReducers to put together some
 * reducers Merge into a reducer
 *
 * @param {Function} reducer A method to return to the next state tree, which needs to be provided when
 *  The previous status tree and the action to be sent.
 *
 * @param {any} [preloadedState] Initial state.
 * You can choose to specify it to save the state of the server in a common application, or to restore
 * Previously serialized user sessions.
 * If you use the `combineReducers'method to generate the final reducer.So this initial state
 * The structure of the state object must be kept in phase with the structure of the parameter passed in when the `combineReducers` method is called
 * Same.
 *
 * @param {Function} [enhancer] store Enhancer.You can optionally pass in an enhancement letter
 * Counting enhancements to store s, such as middleware, time travel, persistence.This redux is the only one that comes with it
 * Enhancer is applyMiddleware
 *
 * @returns {Store} A redux that lets you read status, publish actions, and subscription changes 
 * store
 */
export default function createStore(reducer, preloadedState, enhancer) {
  // If the preloadedState type is function and the enhancer type is undefined, then use
  // The user passes the value of preloadedState to the user without passing in preloadedState  
  // enhancer, preloadedState value set to undefined
  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
    enhancer = preloadedState
    preloadedState = undefined
  }
  // enhancer type must be a function
  if (typeof enhancer !== 'undefined') {
    if (typeof enhancer !== 'function') {
      throw new Error('Expected the enhancer to be a function.')
    }
    // Return to store enhanced with enhancer
    return enhancer(createStore)(reducer, preloadedState)
  }
  // reducer must be a function
  if (typeof reducer !== 'function') {
    throw new Error('Expected the reducer to be a function.')
  }

  let currentReducer = reducer
  let currentState = preloadedState
  let currentListeners = []
  let nextListeners = currentListeners
  let isDispatching = false

  // Copy one before each modification to the listener function array, the actual modification is the new
  // On the copied array.Make sure the listener exists before a dispatch occurs.
  // Can be triggered once after this dispatch.
  function ensureCanMutateNextListeners() {
    if (nextListeners === currentListeners) {
      nextListeners = currentListeners.slice()
    }
  }

  /**
   * Read store managed state tree
   *
   * @returns {any} Returns the current state tree in the application
   */
  function getState() {
    return currentState
  }

  /**
   * Add a change listener.It will be triggered when an action is distributed, and the number of States is a
   * Some parts may have changed.Then you can call getState to read the current one in the callback
   * State Tree.
   *    
   * You can call dispatch() from a change listener, note:
   *
   * 1.The listener array is copied before each call to dispatch().If you're listening to a letter
   * Number of subscriptions or unsubscribes, which will not affect the dispatch() currently in progress.And next time
  * dispatch()Nested calls or not use the latest modified listen list.
   * 2.The listener does not want to see all state changes, such as the state may be before the listener is called
   * The nested dispatch() may be updated too many times.But at one dispatch
   * Registered listener functions before triggering can read the latest status of store s after this diapatch
   * State.
   *
   * @param {Function} listener A callback function that is executed after each dispatch.
   * @returns {Function} Returns a function used to cancel this subscription.
   */
  function subscribe(listener) {
    if (typeof listener !== 'function') {
      throw new Error('Expected listener to be a function.')
    }

    let isSubscribed = true

    ensureCanMutateNextListeners()
    nextListeners.push(listener)

    return function unsubscribe() {
      if (!isSubscribed) {
        return
      }

      isSubscribed = false

      ensureCanMutateNextListeners()
      const index = nextListeners.indexOf(listener)
      nextListeners.splice(index, 1)
    }
  }

  /**
   * Send an action, which is the only way to trigger a state change.
   * Every time an action is sent, the `reducer` used to create the store is called once.Inbound on call
   * The parameters are the current state and the action being sent.The return value of will be treated as the next state
   * State, and the listener will be notified.
   *
   * The underlying implementation only supports actions for simple objects.If you wish to be able to send 
   * Promise，Observable，thunk Fire in other forms of action, you need to use the appropriate middle
   * Component encapsulates store creation functions.For example, you can refer to the documentation for the `redux-thunk` package.
   * These middleware, however, send action s in the form of simple objects through the dispatch method.
   * 
   * @param {Object} action，An object identifying what has changed.This is a good idea
   * Make sure actions are serializable so that you can record and play back user actions, or use
   * Plug-ins that allow shuttle time `redux-devtools'.An action must have a value that is not
   * `undefined`String constants are recommended as action type s.
   *
   * @returns {Object} For convenience, return the incoming action object.
   *
   * Note that if you use a custom middleware, you may return `dispatch()'.
   * The value is encapsulated in something else (for example, a Proise that can await).
   */
  function dispatch(action) {
    // Throw an exception if the action is not a simple object
    if (!isPlainObject(action)) {
      throw new Error(
        'Actions must be plain objects. ' +
        'Use custom middleware for async actions.'
      )
    }

    if (typeof action.type === 'undefined') {
      throw new Error(
        'Actions may not have an undefined "type" property. ' +
        'Have you misspelled a constant?'
      )
    }
    
    // dispatch is not allowed to be called again inside reducer, otherwise an exception is thrown
    if (isDispatching) {
      throw new Error('Reducers may not dispatch actions.')
    }

    try {
      isDispatching = true
      currentState = currentReducer(currentState, action)
    } finally {
      isDispatching = false
    }

    const listeners = currentListeners = nextListeners
    for (let i = 0; i < listeners.length; i++) {
      const listener = listeners[i]
      listener()
    }

    return action
  }

  /**
   * Replace the reducer function currently used by the store.
   *
   * If your program code implements code splitting and you want to load some reducers dynamically.or
   * You will also use redux when you implement a hot load for it.
   *
   * @param {Function} nextReducer Replaced reducer
   * @returns {void}
   */
  function replaceReducer(nextReducer) {
    if (typeof nextReducer !== 'function') {
      throw new Error('Expected the nextReducer to be a function.')
    }

    currentReducer = nextReducer
    dispatch({ type: ActionTypes.INIT })
  }

  /**
   * Interaction interface reserved for observable/reactive libraries.
   * @returns {observable} The simplest observable implementation that identifies a state change.
   * For more information, check out the observable's proposal:
   * https://github.com/tc39/proposal-observable
   */
  function observable() {
    const outerSubscribe = subscribe
    return {
      /**
       * One of the simplest observable subscription methods.
       * @param {Object} observer，Any object that can be used as an observer.
       * observer Object should contain `next'method.
       * @returns {subscription} Returns an object with an `unsubscribe'method for disassembling observable s from store s and stopping receiving values further.
       */
      subscribe(observer) {
        if (typeof observer !== 'object') {
          throw new TypeError('Expected the observer to be an object.')
        }

        function observeState() {
          if (observer.next) {
            observer.next(getState())
          }
        }

        observeState()
        const unsubscribe = outerSubscribe(observeState)
        return { unsubscribe }
      },

      [$$observable]() {
        return this
      }
    }
  }

  // When a store is created, an INIT action is distributed so that each reducer returns
  // Initial state, which effectively populates the initial state tree.
  dispatch({ type: ActionTypes.INIT })

  return {
    dispatch,
    subscribe,
    getState,
    replaceReducer,
    [$$observable]: observable
  }
}