import {AnyJson, DataPersisterArgs, DataProviderArgs} from "~/types/interfaces";
import {HTTP_METHOD} from "~/types/enums";
import {NuxtAxiosInstance} from "@nuxtjs/axios";
import {AxiosRequestConfig} from "axios";

/**
 * @category Services/connection
 * @class Connection
 * Classe Wrapper du connecteur de requete (Axios dans notre cas)
 */
class Connection{
  static connector:NuxtAxiosInstance;

  /**
   * Initialisation du connecteur (Axios dans notre cas)
   * @param {NuxtAxiosInstance} connector
   */
  static initConnector(connector: NuxtAxiosInstance){
    Connection.connector = connector
  }

  /**
   * Main méthode qui apperlera les méthode privées correspondantes (getItem, getCollection, put, post, delete)
   * @param {HTTP_METHOD} method de requetage
   * @param {string} url
   * @param {DataProviderArgs|DataPersisterArgs} args
   * @return {Promise<any>}
   */
  invoke(method: HTTP_METHOD, url: string, args:DataProviderArgs|DataPersisterArgs): Promise<any>{
    switch (method) {
      case HTTP_METHOD.GET:
        if(args.id)
          return this.getItem(url, args.id)
        else
          return this.getCollection(url)

      case HTTP_METHOD.PUT:
        if(this.isArgsIsDataPersisterArgs(args)){
          if(!args.data)
            throw new Error('data not found')

          return this.put(url, args.id, args.data)
        }

      case HTTP_METHOD.DELETE:
        return this.deleteItem(url, args.id)
    }

    throw new Error('Method unknown')
  }

  /**
   * GET Item : préparation de la config pour la récupération d'un item
   * @param {string} url
   * @param {number} id
   * @return {Promise<any>}
   */
  private getItem(url: string, id: number): Promise<any>{
    const config:AxiosRequestConfig = {
      url: `${url}/${id}`,
      method: HTTP_METHOD.GET,
    }
    return this.request(config)
  }

  /**
   * Get collection : préparation de la config pour la récupération d'une collection d'items
   * @param {string} url
   * @return {Promise<any>}
   */
  private getCollection(url: string): Promise<any>{
    const config:AxiosRequestConfig = {
      url: `${url}`,
      method: HTTP_METHOD.GET,
    }
    return this.request(config)
  }

  /**
   * Put : préparation de la config pour la mise à jour d'un item
   * @param {string} url
   * @param {number} id
   * @param {AnyJson} data
   * @return {Promise<any>}
   */
  private put(url: string, id: number, data: AnyJson): Promise<any>{
    const config:AxiosRequestConfig = {
      url: `${url}/${id}`,
      method: HTTP_METHOD.PUT,
      data: data
    }
    return this.request(config)
  }

  /**
   * DELETE Item : préparation de la config pour la suppression d'un item
   * @param {string} url
   * @param {number} id
   * @return {Promise<any>}
   */
  private deleteItem(url: string, id: number): Promise<any>{
    const config:AxiosRequestConfig = {
      url: `${url}/${id}`,
      method: HTTP_METHOD.DELETE,
    }
    return this.request(config)
  }

  /**
   * Exécution de la requete
   * @param {AxiosRequestConfig} config
   * @return {Promise<any>}
   */
  private async request(config:AxiosRequestConfig): Promise<any>{
    return await Connection.connector.$request(config)
  }

  /**
   * Test si l'argument est bien de type DataPersister
   * @param args
   */
  private isArgsIsDataPersisterArgs(args:DataProviderArgs|DataPersisterArgs): args is DataPersisterArgs{
    return (args as DataPersisterArgs).data !== undefined
  }
}

export default Connection