import axios from 'axios'
import { useUserStore } from '@/store/modules/user'
import { ApiStatus } from './status'
import { HttpError, handleError, showError, showSuccess } from './error'
import { $t } from '@/locales'
const REQUEST_TIMEOUT = 15e3
const LOGOUT_DELAY = 500
const MAX_RETRIES = 0
const RETRY_DELAY = 1e3
const UNAUTHORIZED_DEBOUNCE_TIME = 3e3
let isUnauthorizedErrorShown = false
let unauthorizedTimer = null
const { VITE_API_URL, VITE_WITH_CREDENTIALS } = import.meta.env
const axiosInstance = axios.create({
  timeout: REQUEST_TIMEOUT,
  baseURL: VITE_API_URL,
  withCredentials: VITE_WITH_CREDENTIALS === 'true',
  validateStatus: (status) => status >= 200 && status < 300,
  transformResponse: [
    (data, headers) => {
      const contentType = headers['content-type']
      if (contentType?.includes('application/json')) {
        try {
          return JSON.parse(data)
        } catch {
          return data
        }
      }
      return data
    }
  ]
})
axiosInstance.interceptors.request.use(
  (request2) => {
    const { accessToken } = useUserStore()
    if (accessToken) request2.headers.set('Authorization', accessToken)
    if (
      request2.data &&
      !(request2.data instanceof FormData) &&
      !request2.headers['Content-Type']
    ) {
      request2.headers.set('Content-Type', 'application/json')
      request2.data = JSON.stringify(request2.data)
    }
    return request2
  },
  (error) => {
    showError(createHttpError($t('httpMsg.requestConfigError'), ApiStatus.error))
    return Promise.reject(error)
  }
)
axiosInstance.interceptors.response.use(
  (response) => {
    const { code, msg } = response.data
    if (code === ApiStatus.success) return response
    if (code === ApiStatus.unauthorized) handleUnauthorizedError(msg)
    throw createHttpError(msg || $t('httpMsg.requestFailed'), code)
  },
  (error) => {
    if (error.response?.status === ApiStatus.unauthorized) handleUnauthorizedError()
    return Promise.reject(handleError(error))
  }
)
function createHttpError(message, code) {
  return new HttpError(message, code)
}
function handleUnauthorizedError(message) {
  const error = createHttpError(message || $t('httpMsg.unauthorized'), ApiStatus.unauthorized)
  if (!isUnauthorizedErrorShown) {
    isUnauthorizedErrorShown = true
    logOut()
    unauthorizedTimer = setTimeout(resetUnauthorizedError, UNAUTHORIZED_DEBOUNCE_TIME)
    showError(error, true)
    throw error
  }
  throw error
}
function resetUnauthorizedError() {
  isUnauthorizedErrorShown = false
  if (unauthorizedTimer) clearTimeout(unauthorizedTimer)
  unauthorizedTimer = null
}
function logOut() {
  setTimeout(() => {
    useUserStore().logOut()
  }, LOGOUT_DELAY)
}
function shouldRetry(statusCode) {
  return [
    ApiStatus.requestTimeout,
    ApiStatus.internalServerError,
    ApiStatus.badGateway,
    ApiStatus.serviceUnavailable,
    ApiStatus.gatewayTimeout
  ].includes(statusCode)
}
async function retryRequest(config, retries = MAX_RETRIES) {
  try {
    return await request(config)
  } catch (error) {
    if (retries > 0 && error instanceof HttpError && shouldRetry(error.code)) {
      await delay(RETRY_DELAY)
      return retryRequest(config, retries - 1)
    }
    throw error
  }
}
function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms))
}
async function request(config) {
  if (
    ['POST', 'PUT'].includes(config.method?.toUpperCase() || '') &&
    config.params &&
    !config.data
  ) {
    config.data = config.params
    config.params = void 0
  }
  try {
    const res = await axiosInstance.request(config)
    if (config.showSuccessMessage && res.data.msg) {
      showSuccess(res.data.msg)
    }
    return res.data.data
  } catch (error) {
    if (error instanceof HttpError && error.code !== ApiStatus.unauthorized) {
      const showMsg = config.showErrorMessage !== false
      showError(error, showMsg)
    }
    return Promise.reject(error)
  }
}
const api = {
  get(config) {
    return retryRequest({ ...config, method: 'GET' })
  },
  post(config) {
    return retryRequest({ ...config, method: 'POST' })
  },
  put(config) {
    return retryRequest({ ...config, method: 'PUT' })
  },
  del(config) {
    return retryRequest({ ...config, method: 'DELETE' })
  },
  request(config) {
    return retryRequest(config)
  }
}

export default api