import { Context } from '@nuxt/types/app'
import { UrlArgs } from '~/types/interfaces'
import Connection from '~/services/connection/connection'
import Hookable from '~/services/data/hookable'
import { HTTP_METHOD, QUERY_TYPE } from '~/types/enums'
import ApiError from '~/services/utils/apiError'

/**
 * Base class for data providers, persisters or deleters
 */
abstract class BaseDataManager extends Hookable implements BaseDataManager {
  protected ctx!: Context
  protected arguments!: UrlArgs
  protected defaultArguments: object = {
    type: QUERY_TYPE.MODEL,
    showProgress: true
  }

  /**
   * Initialise le contexte (la connection en particulier)
   * @param ctx
   */
  public initCtx (ctx: Context) {
    Connection.initConnector(ctx.$axios)
    this.ctx = ctx
  }

  /**
   * Exécute la requête et retourne la réponse désérialisée
   * @param _args
   */
  // eslint-disable-next-line require-await
  protected async _invoke (_args: UrlArgs): Promise<any> {
    throw new Error('Not implemented')
  }

  /**
   * Exécute la requête
   * @param args
   */
  public async invoke (args: UrlArgs): Promise<any> {
    this.arguments = { ...this.defaultArguments, ...args }
    BaseDataManager.startLoading(this.arguments)

    await this.triggerHooks(args)

    try {
      return this._invoke(args)
    } catch (error) {
      throw new ApiError(error.response.status, error.response.data.detail)
    }
  }

  /**
   * Signale le début du chargement à nuxt (si showProgress est true)
   * @param args
   */
  private static startLoading (args: UrlArgs) {
    if (args.showProgress) {
      const $nuxt = window.$nuxt
      $nuxt.$loading.start()
    }
  }

  /**
   * Send the request trough the Connection
   * @param url
   * @param method
   * @param args
   */
  protected static request (url: string, method: HTTP_METHOD, args: UrlArgs): Promise<any> {
    return Connection.invoke(method, url, args)
  }
}

export default BaseDataManager