import {NuxtAxiosInstance} from '@nuxtjs/axios'
import {AxiosRequestConfig} from 'axios'
import {AnyJson, DataPersisterArgs, DataProviderArgs, UrlArgs} from '~/types/interfaces'
import {HTTP_METHOD, QUERY_TYPE} from '~/types/enums'

/**
 * @category Services/connection
 * @class Connection
 *
 * Classe Wrapper du connecteur de requête (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 appellera les méthodes privées correspondantes (getItem, getCollection, put, post, delete)
   * @param {HTTP_METHOD} method Mode de requêtage (GET, PUT, DELETE...)
   * @param {string} url
   * @param {DataProviderArgs|DataPersisterArgs} args
   * @return {Promise<any>}
   */
  public static invoke (method: HTTP_METHOD, url: string, args: UrlArgs): Promise<any> {
    switch (method) {
      case HTTP_METHOD.GET:
        if (args.id) {
          return Connection.getItem(url, args.id, args.showProgress)
        } else {
          return Connection.getCollection(url, args.showProgress, args.type)
        }

      case HTTP_METHOD.PUT:
        if (!Connection.isDataPersisterArgs(args)) {
          throw new Error('*args* is not a dataPersisterArgs')
        }
        if (!args.data) {
          throw new Error('*args* has no data')
        }
        return Connection.put(url, args.id, args.data, args.showProgress)

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

    throw new Error('Unknown connection method was invoked')
  }

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

  /**
   * Get collection : préparation de la config pour la récupération d'une collection d'items
   * @param {string} url
   * @param {boolean} progress
   * @param {QUERY_TYPE} type
   * @return {Promise<any>}
   */
  public static getCollection (url: string, progress: boolean = true, type: QUERY_TYPE): Promise<any> {
    let config: AxiosRequestConfig = {
      url: `${url}`,
      method: HTTP_METHOD.GET,
      progress
    }
    if(type === QUERY_TYPE.IMAGE)
      config = {...config, responseType: 'blob'}

    return Connection.request(config)
  }

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

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

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

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

export default Connection