import {MenuItem, MenuItems, IconItem, MENU_LINK_TYPE, MenuGroup, MenuBuilder} from '~/types/menus'
import {RuntimeConfig} from "@nuxt/schema";
import Url from "~/services/utils/url";
import {AnyAbility} from "@casl/ability";
import {accessState, organizationState} from "~/types/interfaces";

/**
 * Classe de base des menus et sous-menus.
 *
 * La méthode principale est la méthode build
 */
abstract class AbstractMenuBuilder implements MenuBuilder{
  protected runtimeConfig: RuntimeConfig;
  protected ability: AnyAbility;
  protected organizationProfile: organizationState;
  protected accessProfile: accessState;

  constructor (
      runtimeConfig: RuntimeConfig,
      ability: AnyAbility,
      organizationProfile: organizationState,
      accessProfile: accessState
  ) {
    this.runtimeConfig = runtimeConfig
    this.ability = ability
    this.organizationProfile = organizationProfile
    this.accessProfile = accessProfile
  }

  /**
   * Retourne un nom court pour désigner le menu que construit ce builder
   */
  abstract name(): string

  /**
   * Construit et retourne un menu ou sous-menu selon le profil de l'utilisateur, le profil de son organisation,
   * et les droits de l'utilisateur.
   *
   * Si le menu comporte plusieurs éléments, retourne une instance de MenuGroup
   * Si le menu ne comporte qu'un seul élément, retourne une instance de MenuItem
   * Si le menu ne comporte aucun élément, retourne null
   */
  abstract build (): MenuItem | MenuGroup | null

  /**
   * Construit et retourne un MenuGroup
   *
   * @param label
   * @param icon
   * @param {Array<MenuItem>} children Tableau d'ItemMenu représentant les sous menu du menu principal
   * @param active
   */
  protected createGroup(
      label: string,
      icon?: IconItem,
      children: MenuItems = [],
      active: boolean = true
  ): MenuGroup {
    return { label, icon, children, active }
  }

  /**
   * Construit et retourne un MenuItem
   *
   * @param {IconItem} icon
   * @param {string} label Titre qui sera traduit
   * @param to
   * @param type
   * @param isAction
   * @param active
   * @return {MenuItem}
   */
  protected createItem (
      label: string,
      icon?: IconItem,
      to: string = '',
      type: MENU_LINK_TYPE = MENU_LINK_TYPE.INTERNAL,
      isAction = false,
      active: boolean = true
  ): MenuItem {
    let url: string

    switch(type) {
      case MENU_LINK_TYPE.V1:
        const v1BaseURL = this.runtimeConfig.baseUrlAdminLegacy ?? this.runtimeConfig.public.baseUrlAdminLegacy
        url = Url.join(v1BaseURL, to ?? '')
        break;
      default:
        url = to
    }

    return { icon, label, to: url, type, active, isAction }
  }

  protected buildSubmenu(menuBuilder: typeof AbstractMenuBuilder) {
    // @ts-ignore
    const builder = new menuBuilder(this.runtimeConfig, this.ability, this.organizationProfile, this.accessProfile)
    return builder.build()

  }
}
export default AbstractMenuBuilder