import {UrlArgs} from "~/types/interfaces";
import {QUERY_TYPE} from "~/types/enums";
import {Model} from "@vuex-orm/core";
import {repositoryHelper} from "~/services/store/repository";

/**
 * @category Services/connection
 * @class ConstructUrl
 * Classe permettant de construire une URL pour l'interrogation d'une API externe
 */
class ConstructUrl{
  static ROOT = '/api/'

  /**
   * Main méthode qui apperlera les méthode privées correspondantes (getDefaultUrl, getEnumUrl, getModelUrl)
   * @param {UrlArgs} args
   * @return {string}
   */
  invoke(args:UrlArgs): string{
    switch (args.type) {
      case QUERY_TYPE.DEFAULT:
        return this.getDefaultUrl(args.url)

      case QUERY_TYPE.ENUM:
        return this.getEnumUrl(args.enumType)

      case QUERY_TYPE.MODEL:
        return this.getModelUrl(args.model, args.root_model, args.root_id)

      default:
        throw new Error('url, model or enum must be defined');
    }
  }

  /**
   * Construction d'une URL "traditionnelle" qui ira concaténer l'url passée en paramètre avec la ROOT Url définie
   * @param {string} url
   * @return {string}
   */
  private getDefaultUrl(url?: string): string{
    if(typeof url === 'undefined')
      throw new Error('url must be defined');
    return String(ConstructUrl.ROOT + url).toString()
  }

  /**
   * Construction d'une URL Type Enum qui ira concaténer le type enum passé en paramètre avec la ROOT Url définie
   * @param {string} enumType
   * @return {string}
   */
  private getEnumUrl(enumType?: string): string{
    if(typeof enumType === 'undefined')
      throw new Error('enumType must be defined');
    return String(ConstructUrl.ROOT + 'enum/' + enumType).toString()
  }

  /**
   * Construction d'une URL Type Model qui ira concaténer le nom de l'entité du model passé en paramètre
   * avec la ROOT Url définie (possibilité de récursivité si le root model est défini)
   *
   * @param {Model} model roles à tester
   * @param {Model} rootModel roles à tester
   * @param {number} rootId roles à tester
   * @return {string}
   */
  private getModelUrl(model?: typeof Model, rootModel?: typeof Model, rootId?: number): string{
    if(typeof model === 'undefined')
      throw new Error('model must be defined');

    const entity = repositoryHelper.getEntity(model)

    if(typeof rootModel !== 'undefined'){
      if(typeof rootId === 'undefined')
        throw new Error('Root ID must be defined');

      const rootUrl = this.getModelUrl(rootModel) as string
      return String(`${rootUrl}/${rootId}/${entity}`).toString()
    }

    return String(ConstructUrl.ROOT  + entity).toString()
  }
}

export default ConstructUrl