import { useUserStore } from "@/store"
import { getToken } from "@/utils/auth"
import storage from "@/utils/storage"
import { showMessage } from "./status"

// 重试队列，每一项将是一个待执行的函数形式
let requestQueue = []

// 防止重复提交
const repeatSubmit = config => {
  const requestObj = {
    url: config.url,
    data:
      typeof config.data === "object"
        ? JSON.stringify(config.data)
        : config.data,
    time: new Date().getTime()
  }
  const sessionObj = storage.getJSON("sessionObj")
  if (!sessionObj) {
    storage.setJSON("sessionObj", requestObj)
  } else {
    const s_url = sessionObj.url // 请求地址
    const s_data = sessionObj.data // 请求数据
    const s_time = sessionObj.time // 请求时间
    const interval = 1000 // 间隔时间(ms)，小于此时间视为重复提交
    if (
      s_data === requestObj.data &&
      requestObj.time - s_time < interval &&
      s_url === requestObj.url
    ) {
      const message = "数据正在处理，请勿重复提交"
      console.warn(`[${s_url}]: ${message}`)
      return Promise.reject(new Error(message))
    } else {
      storage.setJSON("sessionObj", requestObj)
    }
  }
}

// 是否正在刷新token的标记
let isRefreshing = false

// 刷新token
const refreshToken = async (http, config) => {
  // 是否在获取token中,防止重复获取
  if (!isRefreshing) {
    // 修改登录状态为true
    isRefreshing = true
    // 等待登录完成
    await useUserStore().authLogin()
    // 登录完成之后，开始执行队列请求
    requestQueue.forEach(cb => cb())
    // 重试完了清空这个队列
    requestQueue = []
    isRefreshing = false
    // 重新执行本次请求
    return http.request(config)
  }

  return new Promise(resolve => {
    // 将resolve放进队列，用一个函数形式来保存，等登录后直接执行
    requestQueue.push(() => {
      resolve(http.request(config))
    })
  })
}

function requestInterceptors(http) {
  /**
   * 请求拦截
   * @param {object} http
   */
  http.interceptors.request.use(
    config => {
      // 可使用async await 做异步操作
      // 初始化请求拦截器时，会执行此方法，此时data为undefined，赋予默认{}
      config.data = config.data || {}
      // 自定义参数
      const custom = config?.custom

      // 是否需要设置 token
      const isToken = custom?.auth === false
      if (getToken() && !isToken && config.header) {
        // token设置
        config.header.token = getToken()
      }

      // 是否显示 loading
      if (custom?.loading) {
        uni.showLoading({
          title: "加载中",
          mask: true
        })
      }

      // 是否需要防止数据重复提交
      const isRepeatSubmit = custom?.repeatSubmit === false
      if (
        !isRepeatSubmit &&
        (config.method === "POST" || config.method === "UPLOAD")
      ) {
        repeatSubmit(config)
      }
      return config
    },
    (
      config // 可使用async await 做异步操作
    ) => Promise.reject(config)
  )
}
function responseInterceptors(http) {
  /**
   * 响应拦截
   * @param {object} http
   */
  http.interceptors.response.use(
    response => {
      /* 对响应成功做点什么 可使用async await 做异步操作 */
      const data = response.data
      // 配置参数
      const config = response.config
      // 自定义参数
      const custom = config?.custom

      // 登录状态失效，重新登录
      if (data.code === 401) {
        return refreshToken(http, config)
      }

      // 隐藏loading
      if (custom?.loading) {
        uni.hideLoading()
      }

      // 请求成功则返回结果
      if (data.code === 200) {
        return response || {}
      }

      // 如果没有显式定义custom的toast参数为false的话，默认对报错进行toast弹出提示
      if (custom?.toast !== false) {
        uni.$u.toast(data.message)
      }

      // 请求失败则抛出错误
      return Promise.reject(data)
    },
    response => {
      // 自定义参数
      const custom = response.config?.custom

      // 隐藏loading
      if (custom?.loading !== false) {
        uni.hideLoading()
      }

      // 如果没有显式定义custom的toast参数为false的话，默认对报错进行toast弹出提示
      if (custom?.toast !== false) {
        const message = response.statusCode
          ? showMessage(response.statusCode)
          : "网络连接异常,请稍后再试!"
        uni.$u.toast(message)
      }

      return Promise.reject(response)
    }
  )
}

export { requestInterceptors, responseInterceptors }