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,
  CreateTranslatedPagePayload,
  NamedSchemaItems
} from '../../types/api';
import PageTree from '../../tools/page-tree';
import PageApi from '../../api/page-api';

const namespaced = true;

const state: PageStoreModel = {
  pages: [],
  publishedPageIds: [],
  isLoadingPages: false,
  isLoadingPublishedPages: false,
  schema: { properties: {}, oneOf: [] },
  expandedPageIds: new Set(),
  collapsedPageIds: new Set()
};

const actions: ActionTree<PageStoreModel, RootState> = {
  async $init({ dispatch }) {
    dispatch('fetchPages');
    dispatch('fetchSchema');
  },
  async fetchPages({ state, commit, dispatch }) {
    try {
      commit('isLoadingPages', true);

      const pages = await PageApi.getPages(Array.from(state.expandedPageIds));

      commit('pages', pages);

      dispatch('fetchPublishedPageIds');
    } catch (error) {
      console.warn(error.message);
    }

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

    commit('publishedPageIds', [...publishedPages, ...folders]);
    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('fetchPages');

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

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

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

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

    return pageVersion;
  },
  async deleteVersion({ dispatch }, version: Version): Promise<void> {
    await PageApi.deleteVersion(version);
    dispatch('fetchPages');
  },
  async move({ dispatch }, payload: MovePagePayload) {
    const updatedPage = await PageApi.move(payload);
    dispatch('fetchPages');

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

    return updatedPage;
  },
  async deletePage({ dispatch }, page: Page): Promise<void> {
    await PageApi.delete(page);
    dispatch('fetchPages');
  },

  expandPage({ state, dispatch }, id) {
    state.expandedPageIds.add(id);
    state.collapsedPageIds.delete(id);

    dispatch('fetchPages');
  },

  collapsePage({ state }, id) {
    state.collapsedPageIds.add(id);
    state.expandedPageIds.delete(id);
  },

  isPageCollapsed({ state }, id) {
    return state.collapsedPageIds.has(id);
  },

  isPageExpanded({ state }, id) {
    return state.expandedPageIds.has(id);
  }
};

const getters: GetterTree<PageStoreModel, RootState> = {
  pageTree(state): Page[] {
    return new PageTree(state.pages).items;
  },
  isPageExpanded:
    (state) =>
    (id: string): boolean => {
      return state.expandedPageIds.has(id);
    },
  isPageCollapsed:
    (state) =>
    (id: string): boolean => {
      return state.collapsedPageIds.has(id);
    },
  types(state): NamedSchemaItems {
    const types: NamedSchemaItems = {};

    state.schema.oneOf.forEach((schemaItem) => {
      if (schemaItem.properties.$type.enum?.length) {
        types[schemaItem.properties.$type.enum[0]] = schemaItem;
      }
    });

    return types;
  }
};

const mutations: MutationTree<PageStoreModel> = {
  pages(state, pages: Page[]) {
    state.pages = pages;
  },
  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
};