app/stores/accessProfile.ts

import { defineStore } from 'pinia'

import { computed, ref } from 'vue'
import type { Ref } from 'vue'
import * as _ from 'lodash-es'
import RoleUtils from '~/services/rights/roleUtils'
import type {
  AbilitiesType,
  Historical,
  BaseOrganizationProfile,
  BaseAccessProfile,
  OrignalAccessProfile,
  AccessProfile,
} from '~/types/interfaces'

export const useAccessProfileStore = defineStore('accessProfile', () => {
  // State
  const bearer: Ref<string | null> = ref(null)
  const id: Ref<number | null> = ref(null)
  const switchId: Ref<number | null> = ref(null)
  const name: Ref<string | null> = ref(null)
  const givenName: Ref<string | null> = ref(null)
  const gender: Ref<string | null> = ref(null)
  const avatarId: Ref<number | null> = ref(null)
  const activityYear: Ref<number | null> = ref(null)
  const historical: Ref<Historical> = ref({
    future: false,
    past: false,
    present: true,
  })
  const roles: Ref<Array<string>> = ref([])
  const abilities: Ref<Array<AbilitiesType>> = ref([])
  const isAdminAccess: Ref<boolean | null> = ref(false)
  const isSuperAdminAccess: Ref<boolean | null> = ref(false)
  const isAdmin: Ref<boolean | null> = ref(false)
  const isAdministratifManager: Ref<boolean | null> = ref(false)
  const isPedagogicManager: Ref<boolean | null> = ref(false)
  const isFinancialManager: Ref<boolean | null> = ref(false)
  const isCaMember: Ref<boolean | null> = ref(false)
  const isStudent: Ref<boolean | null> = ref(false)
  const isTeacher: Ref<boolean | null> = ref(false)
  const isMember: Ref<boolean | null> = ref(false)
  const isOther: Ref<boolean | null> = ref(false)
  const isGuardian: Ref<boolean | null> = ref(false)
  const isPayer: Ref<boolean | null> = ref(false)
  const multiAccesses: Ref<Array<BaseOrganizationProfile>> = ref([])
  const familyAccesses: Ref<Array<BaseAccessProfile>> = ref([])
  const originalAccess: Ref<OrignalAccessProfile | null> = ref(null)

  // Getters
  /**
   * Retourne l'id de la session en cours
   * @return {boolean}
   */
  const currentAccessId = computed((): number => {
    return !switchId.value || isNaN(switchId.value) ? id.value! : switchId.value
  })

  /**
   * Est-ce que l'utilisateur possède un compte administrateur
   * @return {boolean}
   */
  const isAdminAccount = computed((): boolean => {
    return isAdminAccess.value ?? false
  })

  // Actions
  const setMultiAccesses = (organizations: Array<BaseOrganizationProfile>) => {
    _.each(organizations, (organization: BaseOrganizationProfile) => {
      multiAccesses.value.push({
        id: organization.id,
        name: organization.name,
      })
    })
  }

  const setFamilyAccesses = (accesses: Array<BaseAccessProfile>) => {
    _.each(accesses, (access: BaseAccessProfile) => {
      const a: BaseAccessProfile = {
        id: access.id,
        name: access.name,
        givenName: access.givenName,
        gender: access.gender,
        avatarId: access.avatarId,
      }
      familyAccesses.value.push(a)
    })
  }

  /**
   * Est-ce que l'utilisateur possède le rôle donné ?
   *
   * @return {boolean}
   * @param role
   */
  const hasRole = (role: string): boolean => {
    return roles.value && roles.value.includes(role)
  }

  /**
   * /!\ Server-side only
   *
   * @param profile
   */
  const initiateProfile = (profile: AccessProfile): void => {
    const profileRoles: Array<string> = Array.from(Object.values(profile.roles))

    // TODO: pqoi est-ce qu'on ne conserve pas les roles fonction et qu'on ne fait pas de ces méthodes des computed?
    //       est-ce que ce ne serait pas plus intuitif? si on fait ça, attention à maj l'abilityBuilder
    isAdmin.value = RoleUtils.isA('ADMIN', profileRoles)
    isAdministratifManager.value = RoleUtils.isA(
      'ADMINISTRATIF_MANAGER',
      profileRoles,
    )
    isPedagogicManager.value = RoleUtils.isA('PEDAGOGICS_MANAGER', profileRoles)
    isFinancialManager.value = RoleUtils.isA('FINANCIAL_MANAGER', profileRoles)
    isCaMember.value = RoleUtils.isA('CA', profileRoles)
    isStudent.value = RoleUtils.isA('STUDENT', profileRoles)
    isTeacher.value = RoleUtils.isA('TEACHER', profileRoles)
    isMember.value = RoleUtils.isA('MEMBER', profileRoles)
    isOther.value = RoleUtils.isA('OTHER', profileRoles)
    roles.value = RoleUtils.filterFunctionRoles(profileRoles)

    setProfile(profile)
  }

  const setProfile = (profile: AccessProfile): void => {
    name.value = profile.name
    givenName.value = profile.givenName
    gender.value = profile.gender
    avatarId.value = profile.avatarId
    activityYear.value = profile.activityYear
    historical.value = profile.historical
    isAdminAccess.value = profile.isAdminAccess
    isGuardian.value = profile.isGuardian
    isPayer.value = profile.isPayer

    // Add the original Access (switch User case)
    if (profile.originalAccess !== null) {
      originalAccess.value = {
        id: profile.originalAccess.id,
        name: profile.originalAccess.name,
        givenName: profile.originalAccess.givenName,
        gender: profile.originalAccess.gender,
        isSuperAdminAccess: profile.originalAccess.isSuperAdminAccess,
        avatarId: profile.originalAccess.avatarId,
        organization: {
          id: profile.originalAccess.organization.id,
          name: profile.originalAccess.organization.name,
        } as BaseOrganizationProfile,
      } as OrignalAccessProfile
    }

    // Set multi-accesses
    setMultiAccesses(Array.from(profile.multiAccesses))

    // Set family-accesses
    setFamilyAccesses(Array.from(profile.familyAccesses))
  }

  const setHistorical = (past: boolean, present: boolean, future: boolean) => {
    historical.value = <Historical>{
      past,
      present,
      future,
    }
  }

  const setHistoricalRange = (dateStart: string, dateEnd: string) => {
    historical.value = <Historical>{
      past: false,
      present: false,
      future: false,
      dateStart,
      dateEnd,
    }
  }

  return {
    bearer,
    id,
    switchId,
    name,
    givenName,
    gender,
    avatarId,
    activityYear,
    historical,
    roles,
    abilities,
    isAdminAccess,
    isSuperAdminAccess,
    isAdmin,
    isAdministratifManager,
    isPedagogicManager,
    isFinancialManager,
    isCaMember,
    isStudent,
    isTeacher,
    isMember,
    isOther,
    isGuardian,
    isPayer,
    multiAccesses,
    familyAccesses,
    originalAccess,
    isAdminAccount,
    currentAccessId,
    hasRole,
    setMultiAccesses,
    setFamilyAccesses,
    initiateProfile,
    setProfile,
    setHistorical,
    setHistoricalRange,
  }
})