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

import { handleFetch } from '../../api/helpers';
import PermissionStoreModel, { PermissionListModel, PermissionModel, PermissionTypes } from '../types/PermissionStoreModel';
import RootState from '../types/RootStateModel';
import { CrudStoreItemsModel } from '../types/CrudStoreModel';

const namespaced = true;

const state: PermissionStoreModel = {
  permissions: []
};

const actions: ActionTree<PermissionStoreModel, RootState> = {
  $init({ dispatch }) {
    dispatch('fetchUserPermissions');
  },
  async fetchUserPermissions({ commit }) {
    const response = await handleFetch('/authorization/permissions');

    commit('userPermissions', (await response.json()) as PermissionModel[]);
  }
};

const getters: GetterTree<PermissionStoreModel, RootState> = {
  permissionAllows:
    () =>
    (allows: PermissionTypes, entity?: CrudStoreItemsModel): boolean => {
      if (entity == null) return true;

      const userEntityPermission: PermissionTypes = PermissionTypes[String(entity.userEntityPermission)];
      if (userEntityPermission == null) return false;

      return userEntityPermission >= allows;
    },
  findPermission:
    (state) =>
    (itemName: string): PermissionModel | null => {
      let pModel: PermissionModel | null = null;
      for (const permission of state.permissions) {
        const cmsItemName = permission.cmsItemName.match(/[^.]+$/g);

        if (!cmsItemName) {
          throw new Error('Could not convert permission cmsItemName to entity name');
        }

        if (cmsItemName.toString().toLowerCase() === itemName.toLowerCase()) {
          if (pModel == null || permission.permission > pModel.permission) {
            pModel = permission;
          }
        }
      }
      return pModel;
    },
  getPermissions:
    (state, getters) =>
    (itemName: string): PermissionListModel => {
      return {
        canRead: getters.hasPermission(itemName, PermissionTypes.Read),
        canUpdate: getters.hasPermission(itemName, PermissionTypes.Update),
        canCreate: getters.hasPermission(itemName, PermissionTypes.Create),
        canDelete: getters.hasPermission(itemName, PermissionTypes.Delete)
      };
    },
  hasPermission:
    (state, getters) =>
    (itemName: string, permission: PermissionTypes): boolean => {
      const permissionEntity = getters.findPermission(itemName);

      // If no permission was found, default to having no permissions.
      if (!permissionEntity) {
        return false;
      }

      return permissionEntity.permission >= permission;
    },
  canRead:
    (state, getters) =>
    (itemName: string, entity?: CrudStoreItemsModel): boolean => {
      return getters.permissionAllows(PermissionTypes.Read, entity) && getters.hasPermission(itemName, PermissionTypes.Read);
    },
  canUpdate:
    (state, getters) =>
    (itemName: string, entity?: CrudStoreItemsModel): boolean => {
      return getters.permissionAllows(PermissionTypes.Update, entity) && getters.hasPermission(itemName, PermissionTypes.Update);
    },
  canCreate:
    (state, getters) =>
    (itemName: string): boolean => {
      return getters.hasPermission(itemName, PermissionTypes.Create);
    },
  canDelete:
    (state, getters) =>
    (itemName: string, entity?: CrudStoreItemsModel): boolean => {
      return getters.permissionAllows(PermissionTypes.Delete, entity) && getters.hasPermission(itemName, PermissionTypes.Delete);
    }
};

const mutations: MutationTree<PermissionStoreModel> = {
  userPermissions(state, permissions: PermissionModel[]) {
    state.permissions = permissions;
  }
};

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