import { ActionTree, GetterTree, MutationTree, Module } from 'vuex';
import RootState from '../types/RootStateModel';

import CrudStoreModel, { CrudStoreItemsModel, CrudStoreSchemaModel } from '../types/CrudStoreModel';
import { SearchCrudItemPayload } from '../../types/api';
import { CrudSearchReponse } from '../../api/crud-api';
import CrudHelpers from '../../crud/crud-helpers';
import PageApi from '../../api/page-api';

const namespaced = true;

export type PageCrudStoreModel = Omit<CrudStoreModel, 'path'>;

export const state: PageCrudStoreModel = {
  loading: false,
  hasItemsError: false,
  latestSearchResult: undefined,
  schema: undefined,
  itemsCache: [],
  overview: {
    fields: ['language', 'modified'],
    customFields: {
      Titel: 'page-crud-column-title',
      Live: 'page-crud-column-published',
      'Pagina type': 'page-crud-column-page-type',
      '': 'page-crud-column-actions'
    }
  },
  searchState: {
    page: 1,
    sort: '',
    languageFilter: '',
    query: ''
  }
};

export const actions: ActionTree<PageCrudStoreModel, RootState> = {
  $init({ dispatch }) {
    dispatch('fetchItems');
    dispatch('fetchCrudSchema');
  },
  async fetchCrudSchema({ commit }) {
    try {
      const schema = await PageApi.getPageSchema();
      commit('crudSchema', schema);
    } catch (error) {
      console.warn(error.message);
    }
  },
  async fetchItems({ state, commit }) {
    commit('isLoading', true);
    try {
      const result = await PageApi.searchCrud(
        state.searchState.query,
        state.searchState.languageFilter,
        state.searchState.page,
        state.searchState.sort || 'Modified:desc'
      );

      commit('result', result);
      commit('addOrUpdateItemsToCache', result.items);
      commit('hasItemsError', false);
      commit('isLoading', false);

      return result.items;
    } catch (error) {
      console.warn(error.message);
      commit('hasItemsError', true);
    } finally {
      commit('isLoading', false);
    }
  },
  async updateSearchState({ commit, dispatch }, payload: SearchCrudItemPayload) {
    commit('searchState', payload);
    dispatch('fetchItems');
  }
};

export const getters: GetterTree<PageCrudStoreModel, RootState> = {
  result: (state) => (): CrudSearchReponse | undefined => {
    return state.latestSearchResult;
  },
  nextDisabled: (state) => (): boolean => {
    const dataPage = state.latestSearchResult;

    if (dataPage && dataPage.totalPages === 0) {
      return true;
    }

    return dataPage && dataPage.currentPage ? dataPage.currentPage === dataPage.totalPages : true;
  },
  previousDisabled: (state) => (): boolean => {
    const dataPage = state.latestSearchResult;

    if (dataPage && dataPage.totalPages === 0) {
      return true;
    }

    return dataPage && dataPage.currentPage ? dataPage.currentPage === 1 : true;
  },
  searchState: (state) => (): SearchCrudItemPayload => {
    return state.searchState;
  }
};

export const mutations: MutationTree<PageCrudStoreModel> = {
  crudSchema(state, schema: CrudStoreSchemaModel) {
    state.schema = schema;
  },
  addOrUpdateItemsToCache(state, items: CrudStoreItemsModel[]) {
    items.forEach((item) => {
      CrudHelpers.addOrUpdateCrudItem(state.itemsCache, item);
    });
  },
  result(state, result: CrudSearchReponse) {
    state.latestSearchResult = result;
  },
  isLoading(state, loading: boolean) {
    state.loading = loading;
  },
  hasItemsError(state, hasItemsError: boolean) {
    state.hasItemsError = hasItemsError;
  },
  searchState(state, payload: SearchCrudItemPayload) {
    state.searchState = payload;
  }
};

export const pageCrudStore: Module<PageCrudStoreModel, RootState> = {
  namespaced,
  state,
  getters,
  actions,
  mutations
};