/**
 * @file 封装创建axios实例的方法
 */

import axios, { AxiosRequestConfig, Canceler } from "axios";
import qs from "qs";
import { message } from "ant-design-vue";
import router from "@/router";

interface CreateAxiosInstanceOptions {
  baseUrl: string;
  timeout: number;
}

const pending = new Map<string, Canceler>();

const addPending = (config: AxiosRequestConfig) => {
  const url = [config.method, config.url, qs.stringify(config.params), qs.stringify(config.data)].join("&");
  config.cancelToken =
    config.cancelToken ||
    new axios.CancelToken((cancel) => {
      if (!pending.has(url)) {
        pending.set(url, cancel);
      }
    });
};

const removePending = (config: AxiosRequestConfig) => {
  const url = [config.method, config.url].join("&");
  if (pending.has(url)) {
    const cancel = pending.get(url);
    cancel && cancel(url);
    pending.delete(url);
  }
};

export const clearPending = () => {
  for (const [url, cancel] of pending) {
    cancel(url);
    pending.clear();
  }
};

/**
 * 创建axios实例
 * @param options 创建实例时的配置
 * @param resolveRes 是否解析response，为false，则不对response作任何处理
 */
const createAxiosInstance = (options: CreateAxiosInstanceOptions, resolveRes = true) => {
  const instance = axios.create({
    baseURL: options.baseUrl,
    timeout: options.timeout,
  });

  // post请求头
  // instance.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded;charset=UTF-8";

  // 请求拦截器
  instance.interceptors.request.use((config) => {
    const token = localStorage.getItem("LUWANG_TOKEN");
    config.headers["X-Authorization"] = token;
    removePending(config);
    addPending(config);
    return config;
  });

  // 响应拦截器
  instance.interceptors.response.use(
    // status 2xx
    (response) => {
      removePending(response);
      if (resolveRes) {
        if (response.data && response.data?.constructor?.name == "Blob") {
          return Promise.resolve(response);
        } else if (response.data && (response.data?.code === "200" || response.data?.code === 200)) {
          return Promise.resolve(response.data.data);
        } else if (response.data) {
          return Promise.resolve(response.data);
        } else {
          console.error(response);

          return Promise.reject(response);
        }
      } else {
        return Promise.resolve(response);
      }
    },
    // status outside 2xx
    (error) => {
      if (error.response?.status) {
        switch (error.response?.status) {
          // 401 未登录
          case 401:
            // 清除token
            localStorage.removeItem("LUWANG_TOKEN");
            setTimeout(() => {
              router.replace({
                path: window.location.hostname == "hpaas.yucekj.com" ? "/login-ding" : "/login",
              });
            }, 1000);
            break;
          // // 403 token过期
          // case 403:
          //   break;
          // // 404 请求不存在
          // case 404:
          //   break;
          // // 500 服务端错误
          // case 500:
          //   break;
          // 其他错误，直接抛出错误提示
          default:
            message.error(error.response.data?.msg || "请求错误");
        }
      }
      // if (axios.isCancel(error)) {
      //   console.warn(`repeated request is cancelled: ${error.message}`);
      // } else {
      //   console.error(error);
      //   message.error(error.response?.data?.msg || "请求错误");
      // }
      return Promise.reject(error.response);
    }
  );
  /**
   * get方法，对应get请求
   * @param {String} url [请求的url地址]
   * @param {Object} params [请求时携带的参数]
   * @param {Boolean} ifNeedErrorMsg [请求错误时是否需要提示错误信息]
   */
  function get<T>(url: string, params?: any, ifNeedErrorMsg = false): Promise<T> {
    return new Promise((resolve, reject) => {
      instance
        .get(url, {
          params: params,
        })
        .then((res: any) => {
          resolve(res);
        })
        .catch((err: any) => {
          if (ifNeedErrorMsg) {
            message.error(err.data && err.data.msg ? err.data && err.data.msg : "请求错误");
          }
          reject(err);
        });
    });
  }
  /**
   * post方法，对应post请求
   * @param {String} url [请求的url地址]
   * @param {Object} params [请求时携带的参数]
   * @param {Boolean} ifNeedErrorMsg [请求错误时是否需要提示错误信息]
   */
  function post<T>(url: string, params: any, ifNeedErrorMsg = false): Promise<T> {
    return new Promise((resolve, reject) => {
      instance
        .post(url, params)
        .then((res: any) => {
          resolve(res);
        })
        .catch((err: any) => {
          if (ifNeedErrorMsg) {
            message.error(err.data && err.data.msg ? err.data && err.data.msg : "请求错误");
          }
          reject(err);
        });
    });
  }
  /**
   * delete方法，对应delete请求
   * @param {String} url [请求的url地址]
   * @param {Object} params [请求时携带的参数]
   * @param {Boolean} ifNeedErrorMsg [请求错误时是否需要提示错误信息]
   */
  function remove(url: string, params: any, ifNeedErrorMsg?: boolean) {
    return new Promise((resolve, reject) => {
      instance
        .delete(url, {
          params: params,
        })
        .then((res: any) => {
          resolve(res);
        })
        .catch((err: any) => {
          if (ifNeedErrorMsg) {
            message.error(err.data && err.data.msg ? err.data && err.data.msg : "请求错误");
          }
          reject(err);
        });
    });
  }
  /**
   * put方法，对应put请求
   * @param {String} url [请求的url地址]
   * @param {Object} params [请求时携带的参数]
   * @param {Boolean} ifNeedErrorMsg [请求错误时是否需要提示错误信息]
   */
  function put(url: string, params: any, ifNeedErrorMsg?: boolean) {
    return new Promise((resolve, reject) => {
      instance
        .put(url, params)
        .then((res: any) => {
          resolve(res);
        })
        .catch((err: any) => {
          if (ifNeedErrorMsg) {
            message.error(err.data && err.data.msg ? err.data && err.data.msg : "请求错误");
          }
          reject(err);
        });
    });
  }

  return {
    get,
    post,
    remove,
    put,
  };
};

export default createAxiosInstance;