import { assert, } from 'chai';
import redeuceur from '../../src';

const handlerErr = 
  `Invalid handler. Every handler must have a condition and a nextState.`;
const conditionErr = 
  `Invalid handler condition. ` + 
  `A condition must be a string, an array of strings, or a function.`;

describe(`unit > redeuceur`, function () {
  let actionBar;
  let actionBaz;
  let actionFoo;
  let actionQux;
  let actionTypes;
  let initialState;

  before(function () {
    actionTypes = {
      FOO: `FOO`,
      BAR: `BAR`,
      BAZ: `BAZ`,
      QUX: `QUX`,
    };

    const qux = `qux`;

    actionFoo = { type: actionTypes.FOO, qux, };
    actionBar = { type: actionTypes.BAR, qux, };
    actionBaz = { type: actionTypes.BAZ, qux, };

    initialState = null;
  });

  it(`Throws a TypeError if a handler is not an array.`, function () {
    const invalid = [ true, 1, `a`, {}, () => {}, null, ];

    invalid.forEach(x => {
      assert.throws(() => { redeuceur(true, x ); }, Error, handlerErr);

      assert.throws(() => { 
        const handlers = [ [ `foo`, true, ], x, [ `bar`, false, ], ];

        redeuceur(true, ...handlers);
      }, Error, handlerErr);
    });
  });

  it(`Throws an Error if a handler does not have a condition and a nextState.`, function () {
    assert.throws(() => { redeuceur(true, []); }, Error, handlerErr);
    assert.throws(() => { redeuceur(true, [ [], ]); }, Error, handlerErr);
    assert.throws(() => { redeuceur(true, [ [ `a`, ], ]); }, Error, handlerErr);
  });

  it(`Throws a TypeError if a condition is not a valid type.`, function () {
    const nextState = () => ({});
    const invalid = [ true, 1, {}, null, ];

    invalid.forEach(x => {
      assert.throws(() => { 
        redeuceur(true, [ x, nextState, ]);
      }, TypeError, conditionErr);
    });
  });

  it(`Returns a reducer function.`, function () {
    assert.isFunction(redeuceur(true, [ `x`, true, ]));
  });

  it(`Reducer returns the initial state if called without an action argument.`, function () {
    const handler = [ actionTypes.FOO, true, ];
    const reducer = redeuceur(initialState, handler);
  
    assert.deepEqual(reducer(), initialState);
  });

  it(`Reducer matches a string condition against the action type.`, function () {
    const handler = [ 
      actionTypes.FOO, 
      (state, action) => action.qux, 
    ];

    const reducer = redeuceur(initialState, handler);

    assert.strictEqual(actionFoo.qux, reducer(initialState, actionFoo));
  });

  it(`Reducer matches an array of string conditions against the action type.`, function () {
    const handler = [
      [ actionTypes.BAR, actionTypes.BAZ, ],
      (state, action) => action.qux,
    ];
    const reducer = redeuceur(initialState, handler);

    assert.strictEqual(reducer(initialState, actionBar), actionBar.qux);
    assert.strictEqual(reducer(initialState, actionBaz), actionBaz.qux);
    assert.strictEqual(reducer(initialState, actionQux), initialState);
  });

  it(`Reducer returns nextState if the condition function returns a truthy value.`, function () {
    const handler = [
      (state, action) => action.type === actionTypes.FOO,
      (state, action) => action.qux,
    ];

    const reducer = redeuceur(initialState, handler);
    
    assert.strictEqual(reducer(initialState, actionFoo), actionFoo.qux);
  });

  it(`Reducer does not return nextState if the condition function returns a falsey value.`, function () {
    const handler = [
      (state, action) => action.type === actionTypes.BAR,
      (state, action) => action.qux,
    ];

    const reducer = redeuceur(initialState, handler);
    
    assert.strictEqual(reducer(initialState, actionFoo), initialState);
  });
  
  it(`Reducer returns the result of calling nextState if nextState is a function.`, function () {
    const handler = [
      actionTypes.FOO,
      (state, action) => action.qux,
    ];

    const reducer = redeuceur(initialState, handler);

    assert.strictEqual(reducer(initialState, actionFoo), `qux`);
  });

  it(`Reducer returns the nextState value if nextState is not a function.`, function () {
    const nextState = `foo bar baz`;

    const handler = [
      actionTypes.FOO, 
      nextState,
    ]; 

    const reducer = redeuceur(initialState, handler);

    assert.strictEqual(reducer(initialState, actionFoo), nextState);
  });

  it(`Reducer returns the current state if there's no condition match.`, function () {
    const state = `foo bar baz`;
    const getQux = (state, action) => action.qux;

    const handlers = [
      [ actionTypes.FOO, getQux, ],
      [ actionTypes.BAR, getQux, ],
      [ actionTypes.BAZ, getQux, ],
    ];

    const actionQux = { type: actionTypes.QUX, qux: `qux`, };
      
    const reducer = redeuceur(initialState, handlers);

    assert.strictEqual(reducer(state, actionQux), state);
  });
});