import axios, { AxiosResponse } from 'axios'
// import 'nprogress/nprogress.css'
import envConfig from '../../config/envConfig'
import WebLog from '../../utils/weblogs'
import errorCode from './errorCode'
import { login } from './login'
import commonData from '../../store/data'

// interface TypeRes {
//   status: number
//   // code: number
//   // msg: string
//   data: TypeResData
// }
// interface TypeResData {
//   code: number
//   msg: string
//   data: unknown
// }

const axiosInstance = axios.create({
  baseURL: envConfig.urlENV.WEB_BASE,
  timeout: 60000,
  withCredentials: true,
  validateStatus: function (status): boolean {
    return status >= 200 && status <= 500 // 默认的
  }
})

let refreshPromise: Promise<string> | null = null
let requests: Array<(token: string) => void> = []

// 刷新token并执行队列中的请求
const refreshTokenAndRetry = (): Promise<string> => {
  if (refreshPromise) {
    return refreshPromise
  }

  // 创建新的Promise
  refreshPromise = new Promise((resolve, reject) => {
    login()
      .then(() => {
        const newToken = commonData.get('access_token') as string
        console.log('获取新token成功', newToken)

        // 执行队列中的请求
        requests.forEach((callback) => callback(newToken))
        requests = []

        resolve(newToken)
      })
      .catch((error) => {
        requests = [] // 清空队列以防止重复调用
        reject(error)
      })
      .finally(() => {
        refreshPromise = null
      })
  })

  return refreshPromise
}

// HTTPrequest拦截
axiosInstance.interceptors.request.use(
  (config) => {
    const isToken = (config.headers || {}).isToken === false
    // const token = localStorage.getItem('access_token')
    const token = commonData.get('access_token')

    if (token && !isToken) {
      // console.log('token', 'Bearer ' + token)
      config.headers['Authorization'] = 'Bearer ' + token // token
    }

    // if (config.method === 'get') {
    //   config.paramsSerializer = function (params) {
    //     return qs.stringify(params, { arrayFormat: 'repeat' })
    //   }
    // }

    return config
  },
  (error) => {
    return Promise.reject(error)
  }
)

// HTTPresponse拦截
axiosInstance.interceptors.response.use(
  async (res: AxiosResponse) => {
    // console.log('http-res:', res.status)
    const status = Number(res.status) || 200
    const message = res.data.msg || errorCode[status] || errorCode['default']

    if (status === 424 || status === 401) {
      console.log('token过期，准备刷新', message)

      const retryOriginalRequest = new Promise<AxiosResponse>((resolve) => {
        requests.push((token: string) => {
          res.config.headers['Authorization'] = 'Bearer ' + token
          resolve(axios(res.config))
        })
      })

      try {
        await refreshTokenAndRetry()
        return retryOriginalRequest
      } catch (error) {
        return Promise.reject(error)
      }
    }

    if (status !== 200 || res.data.code === 1) {
      // const { params, data, url, method } = res.config;
      // console.log('请求参数：', { params, data });
      // console.log('请求地址和方法：', { url, method });
      console.error(
        'http-error-code1:',
        res.request.path,
        res.request.method,
        'data:',
        res.config.data,
        ',params:',
        res.config.params
      )
      console.log('error-msg:', message)
      WebLog.set({
        type: 'Error',
        content: `${message}`
      })
      return Promise.reject(new Error(message))
    }

    return res
  },
  (error) => {
    // 处理 503 网络异常
    console.log(
      'http-error: ',
      error.config.url,
      error.message,
      error.response && error.response.status
    )
    if (error.response && error.response.status === 503) {
      WebLog.set({
        type: 'Error',
        content: `${error.response.data.msg}`
      })
    } else if (error.message.includes('ETIMEDOUT')) {
      WebLog.set({
        type: 'Error',
        content: `请求超时`
      })
    }
    return Promise.reject(new Error(error))
  }
)

export default axiosInstance