import type { AxiosRequestConfig, AxiosResponse, ResponseType } from 'axios'
import type { HeadersCustom } from './headers'
import type { LocaleCustom } from './locale'
import { formatResponseApi } from './serializer'
import setup from './setup'
import type { Interceptors, Locale, StorageClient } from './types'

export type AvailableServiceNames =
  | 'lc'
  | 'mindee'
  | 'ipLocation'
  | 'strapiAdmin'
  | 'sharegroop'
  | 'hubspot'
  | 'mapbox'

export type HttpType<ResT = unknown, ReqT = unknown> = {
  api: {
    name: AvailableServiceNames
    url: string
    source?: 'app' | 'stay' | 'website'
    getDeviceUniqueId?: () => Promise<string>
    interceptors?: Interceptors<ResT, ReqT>
  }
  locale?: Locale
  localeCustom?: LocaleCustom
  storageClient?: StorageClient
  headersCustom?: HeadersCustom
  unserialized?: boolean
}

export const http = ({
  api,
  locale,
  storageClient,
  unserialized = false,
}: HttpType<AxiosResponse, AxiosRequestConfig>) => {
  const config = {
    apiUrl: api.url,
    interceptors: api.interceptors,
    locale,
    storageClient,
    source: api.source,
    getDeviceUniqueId: api.getDeviceUniqueId,
  }

  return {
    get: async <Response>(
      endpoint: string,
      options?: Record<string, unknown>,
    ): Promise<Response> => {
      try {
        const response = await setup[api.name](config).get(endpoint, options)

        if (options?.responseType) {
          return Promise.resolve(response) as Promise<Response>
        }
        if (unserialized) {
          if (api.name === 'strapiAdmin') {
            return Promise.resolve(response.data) as Promise<Response>
          } else {
            return Promise.resolve(response) as Promise<Response>
          }
        } else {
          return Promise.resolve(
            formatResponseApi(response),
          ) as Promise<Response>
        }
      } catch (error: unknown) {
        return Promise.resolve({
          errors: error as Error,
        }) as unknown as Promise<Response>
      }
    },
    post: async <Response>(
      endpoint: string,
      params: Record<string, unknown> | BodyInit,
      options?: Record<string, unknown>,
    ): Promise<Response> => {
      try {
        const response = await setup[api.name](config).post(
          endpoint,
          params,
          options,
        )

        return unserialized
          ? (Promise.resolve(response) as Promise<Response>)
          : (Promise.resolve(formatResponseApi(response)) as Promise<Response>)
      } catch (error: unknown) {
        return Promise.resolve({
          errors: error as Error,
        }) as unknown as Promise<Response>
      }
    },
    put: async <Response>(
      endpoint: string,
      params: Record<string, unknown> | BodyInit,
      options?: Record<string, unknown>,
    ): Promise<Response> => {
      try {
        const response = await setup[api.name](config).put(
          endpoint,
          params,
          options,
        )

        return unserialized
          ? (Promise.resolve(response) as Promise<Response>)
          : (Promise.resolve(formatResponseApi(response)) as Promise<Response>)
      } catch (error: unknown) {
        return Promise.resolve({
          errors: error as Error,
        }) as unknown as Promise<Response>
      }
    },
    delete: async <Response>(endpoint: string): Promise<Response> => {
      try {
        const response = await setup[api.name](config).delete(endpoint)

        return unserialized
          ? (Promise.resolve(response) as Promise<Response>)
          : (Promise.resolve(formatResponseApi(response)) as Promise<Response>)
      } catch (error: unknown) {
        return Promise.resolve({
          errors: error as Error,
        }) as unknown as Promise<Response>
      }
    },
    raw: async <T extends Blob | ArrayBuffer | ReadableStream<Uint8Array>>(
      endpoint: string,
      options: Record<string, unknown> & {
        responseType: 'blob' | 'arrayBuffer' | 'stream'
      },
    ) => {
      const response = await setup[api.name](config).request<
        T,
        AxiosResponse<T>,
        AxiosResponse<T>
      >({
        url: endpoint,
        method: 'GET',
        ...options,
        responseType: options.responseType.toLowerCase() as ResponseType,
      })
      return {
        headers: new Headers(Object.entries(response.headers)),
        _data: response.data,
      }
    },
  }
}