/**
 * @copyright 2017-present, Charlike Mike Reagent <[email protected]>
 * @license Apache-2.0
 */
import createElement from 'minscript'
import morph from 'minmorph'

const h = createElement
// state management
import createView from './view.js'
import createStore from './store.js'
import createEffects from './effects.js'
import createReducers from './reducers.js'

export { h, createElement, morph, createView, createStore, createEffects, createReducers }

/**
 * @copyright 2017-present, Charlike Mike Reagent <[email protected]>
 * @license Apache-2.0
 */
import assert from 'assert'
import { isObject } from './utils.js'

export default function createView (store, actions, viewFn) {
  assert(isObject(store), 'expect `store` to be an object')
  assert(isObject(actions), 'expect `actions` to be an object')
  assert(typeof viewFn === 'function', 'expect `viewFn` to be a function')

  let el = null
  let context = {
    state: store.getState(),
    actions,
    done: (er) => {
      store.emit('error', er)
    },
  }

  let view = (...args) => {
    try {
      return viewFn(...args)
    } catch (er) {
      context.done(er)
    }
  }

  store.off('stateChange')
  store.on('stateChange', (ctx) => {
    console.log(ctx.state)
    context = Object.assign({}, context, ctx)
    console.log(context.state)
    store.emit('render', view, context, (fn) => (el = fn(el)))
  })

  store.emit('render', view, context, (fn) => (el = fn(el)))

  return el
}

const isObject = (val) => val && typeof val === 'object' && !Array.isArray(val)

export { isObject }

/**
 * @copyright 2017-present, Charlike Mike Reagent <[email protected]>
 * @license Apache-2.0
 */
import createEmitter from './emitter.js'

export default function createStore (state) {
  const store = createEmitter()

  store._state = state

  // always freezed state object
  store.getState = () => Object.freeze(Object.assign({}, store._state))

  // 1. if `next` function, pass freezed state to it,
  //    and "hard update" the whole state from the return
  // 2. if `next` not function, "soft update" the whole state
  // 3. if `next` nothing, return freezed old state
  store.setState = (nextState, hardUpdate) => {
    if (!nextState) {
      return null
    }

    if (typeof nextState === 'function') {
      return store.setState(nextState({ state: store.getState() }), true)
    }

    const prevState = store.getState()
    const state = hardUpdate
      ? Object.assign({}, nextState)
      : Object.assign({}, prevState, nextState)

    store.emit('stateChange', { prevState, state, nextState })

    // !! Intentionally after the emitting !!
    // User should not expect `store.getState()` from the listener to work.
    // You get any kind of state in that listener's arguments, so - don't!
    store._state = state

    return store._state
  }

  return store
}

/**
 * @copyright 2017-present, Charlike Mike Reagent <[email protected]>
 * @license Apache-2.0
 */
export default function createEmitter (events) {
  events = Object.assign({}, events)

  const app = {
    events,
    on (name, listener) {
      ;(events[name] || (events[name] = [])).push(listener)
    },

    off (name, listener) {
      if (events[name] && listener) {
        events[name].splice(events[name].indexOf(listener) >>> 0, 1)
      } else if (name && !listener) {
        app.events[name] = events[name] = []
      } else {
        app.events = events = {}
      }
    },

    // eslint-disable-next-line
    emit(name, ...args) {
      ;(events[name] || []).map((listener) => {
        listener(...args)
      })
    },
  }

  return app
}

/**
 * @copyright 2017-present, Charlike Mike Reagent <[email protected]>
 * @license Apache-2.0
 */
import assert from 'assert'
import { isObject } from './utils.js'

// effect signature: ({ state, actions }, a, b) => any
export default function createEffects (store, effects, reducers) {
  assert(isObject(store), 'expect `store` to be an object')
  assert(isObject(effects), 'expect `effects` to be an object')

  const context = { emit: store.emit }
  context.actions = Object.assign({}, reducers)

  Object.keys(effects).map((name) => {
    context.actions[name] = (a, b) => {
      store.emit('action', name, a, b)
      store.emit('effect', name, a, b)

      const effectPromise = new Promise((resolve) => {
        context.state = store.getState()
        resolve(effects[name](context, a, b))
      })

      return effectPromise.catch((er) => {
        store.emit('error', er)
      })
    }
  })

  return context.actions
}

/**
 * @copyright 2017-present, Charlike Mike Reagent <[email protected]>
 * @license Apache-2.0
 */
import assert from 'assert'
import { isObject } from './utils.js'

// reducer signature: ({ state }, a, b) => Object or Function returning an object
export default function createReducers (store, reducers) {
  assert(isObject(store), 'expect `store` to be an object')
  assert(isObject(reducers), 'expect `reducers` to be an object')

  return Object.keys(reducers).reduce((memo, name) => {
    memo[name] = (a, b) => {
      const context = { state: store.getState() }

      store.emit('action', name, a, b)
      store.emit('reducer', name, a, b)

      let next = null

      try {
        next = reducers[name](context, a, b)
      } catch (er) {
        store.emit('error', er)
        return null
      }

      return store.setState(next)
    }
    return memo
  }, {})
}