import { createAction, handleActions } from 'redux-actions';
import { get, reduce, merge, mergeWith, isArray, omitBy, isEmpty, isEqual } from 'lodash/fp';
import { reduce as reduceNonFP } from 'lodash';

import moment from 'moment';
import HashId from '../utils/uid';

import {
  computedRecords,
} from '../utils/data-transformer';

export const databaseRecordsSelector = moduleName => state => computedRecords(get(`database.${moduleName}`, state));
export const rawRecordsSelector = moduleName => state => get(`database.${moduleName}`, state);

export const DB_ADD_OR_UPDATE_RECORD = 'database/addOrUpdateRecord';
export const DB_ADD_OR_UPDATE_RECORDS = 'database/addOrUpdateRecords';
export const DB_DELETE_RECORD = 'database/deleteRecord';
export const DB_DELETE_RECORDS = 'database/deleteRecords';

export const dbAddOrUpdateRecord = createAction(DB_ADD_OR_UPDATE_RECORD);
export const dbAddOrUpdateRecords = createAction(DB_ADD_OR_UPDATE_RECORDS);
export const dbDeleteRecord = createAction(DB_DELETE_RECORD);
export const dbDeleteRecords = createAction(DB_DELETE_RECORDS);


const getId = attrs => (attrs.id ? attrs.id : HashId.generateUnique());

const mergeProcessor = (stateValue = [], actionCS) => {
  switch (actionCS.type) {
    case 'replace':
      return actionCS.value;
    case 'merge':
      if (isArray(stateValue) || isArray(actionCS.value)) {
        return [...stateValue, ...actionCS.value];
      }
      console.error("Can't merge changeset");
      break;
    default:
      return stateValue;
  }
};

const isSame = (d1, d2) => (
  moment(d1).toString() === moment(d2).toString()
);

const cleanUpRecord = ({ changeset, ...attrs }) => {
  const newChangeset = reduceNonFP(changeset, (result, value, key) => {
    if (attrs[key]) {
      if (moment(value).isValid()) {
        if (!isSame(value, attrs[key])) {
          return merge({ [key]: value }, result);
        }
      } else if (!isEqual(value, attrs[key])) {
        return merge({ [key]: value }, result);
      }
    } else {
      return merge({ [key]: value }, result);
    }

    return result;
  }, {});

  return {
    ...attrs,
    changeset: newChangeset,
  };
};

const addOrUpdateRecord = (state, attrs) => {
  const module = attrs.moduleName;
  const recordId = getId(attrs);
  const stateModuleAttrs = get(`${module}.${recordId}`, state);
  const stateModuleChangeset = get(`${module}.${recordId}.changeset`, state);

  const record = cleanUpRecord({
    ...stateModuleAttrs,
    ...attrs,
    changeset: mergeWith(
      mergeProcessor,
      stateModuleChangeset,
      attrs.changeset,
    ),
  });

  return {
    ...state,
    [module]: {
      ...state[module],
      [recordId]: record,
    },
  };
};

const deleteRecord = (state, attrs) => {
  const module = attrs.moduleName;
  const recordId = getId(attrs);
  const stateModuleAttrs = get(`${module}.${recordId}`, state);

  return {
    ...state,
    [module]: {
      ...state[module],
      [recordId]: {
        ...stateModuleAttrs,
        deleted: true,
      },
    },
  };
};

const filterEmptyChange = payload => (
  omitBy(({ changeset, ...others }) => (
    isEmpty(changeset) && isEmpty(others)
  ), payload)
);

const addOrUpdateRecords = (state, { payload }) =>
  reduce((result, attrs) => addOrUpdateRecord(result, attrs), state, filterEmptyChange(payload));

const deleteRecords = (state, { payload }) =>
  reduce((result, attrs) => deleteRecord(result, attrs), state, filterEmptyChange(payload));

const database = handleActions({
  [DB_ADD_OR_UPDATE_RECORDS]: addOrUpdateRecords,
  [DB_ADD_OR_UPDATE_RECORD]: (state, { payload }) => addOrUpdateRecords(state, { payload: [payload] }),
  [DB_DELETE_RECORD]: (state, { payload }) => deleteRecords(state, { payload: [payload] }),
  [DB_DELETE_RECORDS]: deleteRecords,
}, {});

export default { database };