import { ActionTree, GetterTree, Module, MutationTree } from 'vuex';

import RootState from '../types/RootStateModel';
import PageStoreModel from '../types/PageStoreModel';
import {
  Page,
  PublishedPage,
  CreatePagePayload,
  CreatePageFromCopyPayload,
  Version,
  MovePagePayload,
  RenamePagePayload,
  Schema,
  SchemaItem,
  PageBreadCrumbs,
  VersionedPage
} from '../../types/api';
import PageTree from '../../tools/page-tree';
import PageApi from '../../api/page-api';

const namespaced = true;

export const FOLDER_ITEM_NAME = 'Folder';
export const VIRTUALPAGE_ITEM_NAME = 'VirtualPage';

const state: PageStoreModel = {
  initialized: false,
  allPages: [],
  publishedPageIds: [],
  isLoadingPages: false,
  isLoadingPublishedPages: false,
  schema: { properties: {}, oneOf: [] }
};

const actions: ActionTree<PageStoreModel, RootState> = {
  async $init({ commit, dispatch }) {
    await dispatch('fetchAllPages');
    await dispatch('fetchSchema');

    commit('initialized', true);
  },
  async fetchAllPages({ commit, dispatch }) {
    try {
      commit('isLoadingPages', true);
      const allPages = await PageApi.getAllPages();

      commit('allPages', allPages);

      await dispatch('fetchPublishedPageIds');

    } catch (error) {
      dispatch('alerts/addError', error.message);
    }

    commit('isLoadingPages', false);
  },
  async fetchPublishedPageIds({ commit }) {
    commit('isLoadingPublishedPages', true);
    const publishedPages = await PageApi.getPublishedPages();

    commit('publishedPageIds', [...publishedPages]);
    commit('isLoadingPublishedPages', false);
  },
  async fetchSchema({ commit }) {
    commit('isLoadingPages', true);

    const schema = await PageApi.getSchema();

    commit('schema', schema);
    commit('isLoadingPages', false);
  },
  async create({ dispatch }, payload: CreatePagePayload) {
    const pageVersion = await PageApi.create(payload);
    dispatch('fetchAllPages');

    return pageVersion;
  },
  async createFromCopy({ dispatch }, payload: CreatePageFromCopyPayload) {
    const pageVersion = await PageApi.createFromCopy(payload);
    dispatch('fetchAllPages');

    return pageVersion;
  },
  async updateVersion({ dispatch }, version: Version) {
    const pageVersion = await PageApi.updateVersion(version);
    dispatch('fetchAllPages');

    return pageVersion;
  },
  async publishVersion({ dispatch }, version: Version) {
    const pageVersion = await PageApi.publishVersion(version);
    dispatch('fetchAllPages');

    return pageVersion;
  },
  async depublishVersion({ dispatch }, version: Version) {
    const pageVersion = await PageApi.depublishVersion(version);
    dispatch('fetchAllPages');

    return pageVersion;
  },
  async deleteVersion({ dispatch }, version: Version) {
    await PageApi.deleteVersion(version);
    dispatch('fetchAllPages');

    return true;
  },
  async move({ dispatch }, payload: MovePagePayload) {
    const updatedPage = await PageApi.move(payload);
    dispatch('fetchAllPages');

    return updatedPage;
  },
  async rename({ dispatch }, payload: RenamePagePayload) {
    const updatedPage = await PageApi.rename(payload);
    dispatch('fetchAllPages');

    return updatedPage;
  },
  async delete({ dispatch }, page: Page) {
    await PageApi.delete(page);
    dispatch('fetchAllPages');

    return true;
  }
};

const getters: GetterTree<PageStoreModel, RootState> = {
  pageTree(state): Page[] {
    return new PageTree(state.allPages).items;
  },
  breadCrumbsByPage: (state) => (page: Page): PageBreadCrumbs => {
    const parents: Page[] = [];
    const getParentPages = (page: Page) => {
      if (!page.parentId) {
        return;
      }

      const parentPage = state.allPages.find(p => p.id === page.parentId);
      if (!parentPage) {
        return;
      }

      parents.unshift(parentPage);
      getParentPages(parentPage);
    }

    getParentPages(page);

    return { current: page, parents };
  },
  types(state) {
    return state.schema.oneOf.reduce((schema: any, item: SchemaItem) => {
      schema[item.properties.$type.enum[0]] = item;
      return schema;
    }, {});
  },
  pageTypesByItem(state) {
    const pageTypes: Page[] = [];

    for(const page of state.allPages) {

      if (!pageTypes.find((uniquePage) => uniquePage.itemName === page.itemName)) {
        pageTypes.push(page);
      }
    }

    return pageTypes;
  },
  isFolder: (state) => (page: Page | VersionedPage): boolean => {
    return state.allPages.some(p => p.id === page.id && p.itemName === FOLDER_ITEM_NAME);
  },
  isVirtualPage: (state) => (page: Page | VersionedPage): boolean => {
    return state.allPages.some(p => p.id === page.id && p.itemName === VIRTUALPAGE_ITEM_NAME);
  }
};

const mutations: MutationTree<PageStoreModel> = {
  initialized(state, initialized: boolean) {
    state.initialized = initialized;
  },
  allPages(state, allPages: Page[]) {
    state.allPages = allPages;
  },
  publishedPageIds(state, publishedPages: PublishedPage[]) {
    state.publishedPageIds = publishedPages.map(p => p.pageId);
  },
  isLoadingPages(state, isLoadingPages: boolean) {
    state.isLoadingPages = isLoadingPages;
  },
  isLoadingPublishedPages(state, isLoadingPublishedPages: boolean) {
    state.isLoadingPublishedPages = isLoadingPublishedPages;
  },
  schema(state, schema: Schema) {
    state.schema = schema;
  }
};

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