/* eslint-disable @typescript-eslint/no-require-imports */
/* eslint-disable @typescript-eslint/naming-convention */
import config from '@src/config';
import session from '@utils/auth/session';

// 是否刷新token
let isRefreshingToken = false;

// 滞留请求队列
let subscribersQueue: any[] = [];

// 发送滞留的请求
const onRequestFetched = (token: string) => {
  subscribersQueue = subscribersQueue.filter(callback => callback(token));
};

// 订阅滞留的请求
const addSubscriberQueue = (callback: Function) => subscribersQueue.push(callback);

// 处理因token失效而滞留的请求
const handleWaitRequest = (config: FlyRequestConfig) => {
  if (!isRefreshingToken) {
    isRefreshingToken = true;

    // 刷新登录态
    session.refreshLogin().then(() => {
      const token = session.getAuthTokenSync();
      isRefreshingToken = false;
      onRequestFetched(token);
    });
  }

  return new Promise((resolve) => {
    addSubscriberQueue((token: string) => {
      // set new access token
      // eslint-disable-next-line no-param-reassign
      config.headers.Authorization = token;
      resolve(fly.request(config));
    });
  });
};

// flyio lib
const Fly = require('@lib/fly');

// fly instance
const fly: Fly = new Fly();

// merge config
Object.assign(fly.config, {
  baseURL: config.API_URL,
  timeout: 10 * 1000,
  withCredentials: true,
  cache: true,
  retry: 0,
  autoRetry: true,
  headers: { 'Content-Type': 'application/json' },
});

// request interceptors
fly.interceptors.request.use((request: FlyRequestConfig) => {
  // 设置 Authorization 请求头
  const token = session.getAuthTokenSync();

  if (token) request.headers.Authorization = token;

  // 是否防止缓存，添加时间戳
  if (request?.cache) {
    const method = request.method?.toLocaleUpperCase();
    const timestamp = new Date().getTime();

    if (method === 'GET') {
      request.params = { ...request.params, timestamp };
    } else if (method === 'POST') {
      request.body = { ...request.body, timestamp };
    }
  }

  return request;
});

// response interceptors
fly.interceptors.response.use(
  (response) => {
    const code = response?.status;

    if ((code >= 200 && code < 300) || code === 304) {
      return Promise.resolve(response?.data);
    }

    return Promise.reject(response?.data);
  },
  async (error) => {
    const config = error.request;

    // 登录态过期或失效
    if (error?.status === 403) {
      // 检查是否自动重试
      if (config?.autoRetry) {
        // 然后重新发起请求
        return handleWaitRequest(config as FlyRequestConfig);
      }
      // 刷新登录态
      await session.refreshLogin();
    }

    // 是否执行重试机制
    if (config?.retry && config.autoRetry) {
      config.retryCount = config.retryCount || 0;

      // 检查重试次数是否达到总数
      if (config.retryCount >= config.retry) {
        return Promise.reject(error);
      }

      // 重试次数自增
      config.retryCount += 1;

      // 使用promise函数-延时处理
      const backOff = new Promise((resolve) => {
        setTimeout(() => resolve(config), config.retryDelay || 1000);
      });

      // 重新发起request请求
      return backOff.then(() => fly.request(config));
    }

    return Promise.reject(error);
  },
);

export default fly;