import axios from "axios";
import { getStore, setStore } from "./storage";
import { router  } from "../router/index";
import { Message } from "view-design";
import Cookies from "js-cookie";
import { handleRefreshToken } from "@/api/index";
import {v4 as uuidv4} from 'uuid';

// 统一请求路径前缀
export const baseUrl =
  (process.env.NODE_ENV === "development"
    ?  BASE.API_DEV.seller
    : BASE.API_PROD.seller) + BASE.PREFIX;
export const commonUrl =
  process.env.NODE_ENV === "development"
    ? BASE.API_DEV.common
    : BASE.API_PROD.common;
// 文件上传接口
export const uploadFile = commonUrl + "/common/common/upload/file";

export const uploadFile2 = commonUrl + "/common/lmk/file/upload";

// 使用状态标记替代计数器，避免竞态条件
let isRefreshing = false;
let failedQueue = [];

const processQueue = (error, token = null) => {
  failedQueue.forEach(prom => {
    if (error) {
      prom.reject(error);
    } else {
      prom.resolve(token);
    }
  });
  
  failedQueue = [];
};

// 改进的token刷新防抖机制
let refreshTokenPromise = null;
const refreshToken = () => {
  if (refreshTokenPromise) {
    return refreshTokenPromise;
  }
  
  refreshTokenPromise = new Promise((resolve, reject) => {
    let oldRefreshToken = getStore("refreshToken");
    handleRefreshToken(oldRefreshToken)
      .then(res => {
        if (res.success) {
          let { accessToken, refreshToken } = res.result;
          setStore("accessToken", accessToken);
          setStore("refreshToken", refreshToken);
          resolve("success");
        } else {
          reject("fail");
        }
      })
      .catch(err => {
        reject("fail");
      })
      .finally(() => {
        refreshTokenPromise = null;
      });
  });
  
  return refreshTokenPromise;
};

const service = axios.create({
  baseURL: baseUrl
});
axios.defaults.timeout = 100000
const recordCurrentPath = () => {
   return router.history.current.fullPath
}
// 跳转登录页
const redirectLogin = () => {
  router.push({path:'/login',query:{redirect: recordCurrentPath()}});
}

service.interceptors.request.use(
  config => {
    if (config.method == "get") {
      config.params = {
        _t: Date.parse(new Date()) / 1000,
        ...config.params
      };
    }
    let uuid = getStore("uuid");
    if (!uuid) {
      uuid = uuidv4();
      setStore('uuid', uuid);
    }

    // 动态获取并设置accessToken
    const accessToken = getStore("accessToken");
    if (accessToken) {
      config.headers["accessToken"] = accessToken;
    }
    
    config.headers["uuid"] = uuid;
    return config;
  },
  err => {  
    Message.error("请求超时");
    return Promise.resolve(err);
  }
);

// http response 拦截器
service.interceptors.response.use(
  response => {
    const data = response.data;
    // 根据返回的code值来做不同的处理(和后端约定)
    if (!data.success && data.message) {
      Message.error(data.message);
    }
    switch (data.code) {
      case 400:
        if (data.message !== null) {
          Message.error(data.message);
        } else {
          Message.error("系统异常");
        }
        break;
      case 401:
        // 未登录 清除已登录状态
        Cookies.set("userInfoSeller", "");
        setStore("accessToken", "");
        if (router.history.current.name != "login") {
          if (data.message !== null) {
            Message.error(data.message);
          } else {
            Message.error("未知错误，请重新登录");
          }
          redirectLogin();
        }
        break;
      case 500:
        // 系统异常
        if (data.message !== null) {
          Message.error(data.message);
        } else {
          Message.error("系统异常");
        }
        break;
      default:
        return data;
    }
  },
  async error => {
    // 返回状态码不为200时候的错误处理
    if (error.response) {
      if (error.response.status === 401) {
        // 这种情况一般调到登录页
      } else if (error.response.status === 404) {
        // 避免刷新token报错
      } else if (error.response.status === 403) {
        // 处理403错误，进行token刷新
        const originalRequest = error.config;
        
        if (!isRefreshing) {
          isRefreshing = true;
          
          try {
            const getTokenRes = await refreshToken();
            if (getTokenRes === "success") {
              processQueue(null, getStore("accessToken"));
              // 更新请求头中的token并重新发送请求
              originalRequest.headers["accessToken"] = getStore("accessToken");
              return service(originalRequest);
            } else {
              processQueue(new Error("Token refresh failed"), null);
              Cookies.set("userInfoSeller", "");
              setStore("accessToken", "");
              redirectLogin();
            }
          } catch (err) {
            processQueue(err, null);
            Cookies.set("userInfoSeller", "");
            setStore("accessToken", "");
            redirectLogin();
          } finally {
            isRefreshing = false;
          }
        }
        
        // 如果正在刷新token，则将请求加入队列
        return new Promise((resolve, reject) => {
          failedQueue.push({ resolve, reject });
        }).then(token => {
          originalRequest.headers["accessToken"] = token;
          return service(originalRequest);
        }).catch(err => {
          return Promise.reject(err);
        });
      } else {
        // 其他错误处理
        Message.error(error.response.data.message);
      }
    }

    /* router.push("/login") */
    return Promise.resolve(error);
  }
);

export const getRequest = (url, params, resBlob) => {
  let accessToken = getStore("accessToken");
  let data = {
    method: "get",
    url: `${url}`,
    params: params,
    headers: {
      accessToken: accessToken
    },
    responseType: "blob"
  };
  if (resBlob != "blob") {
    delete data.responseType;
  }


  return service(data);
};

export const getRequestHasHeader = (url, params, headers) => {
  let accessToken = getStore("accessToken");
  let data = {
    method: "get",
    url: `${url}`,
    params: params,
    transformRequest: headers
      ? undefined
      : [
          function(data) {
            let ret = "";
            for (let it in data) {
              ret +=
                encodeURIComponent(it) +
                "=" +
                encodeURIComponent(data[it]) +
                "&";
            }
            ret = ret.substring(0, ret.length - 1);
            return ret;
          }
        ],
    headers: {
      "Content-Type": "application/x-www-form-urlencoded",
      accessToken: accessToken,
      ...headers
    },
    responseType: "blob"
  };
  return service(data);
};

export const postRequest2 = (url, params, headers) => {
  let accessToken = getStore("accessToken");
  return service({
    method: "post",
    url,
    data: params, // 直接传对象，不要用 [params] 包装
    headers: {
      "Content-Type": "application/json",
    },
  });
};

export const postRequest = (url, params, headers) => {
  let accessToken = getStore("accessToken");
  return service({
    method: "post",
    url: `${url}`,
    data: params,
    transformRequest: headers
      ? undefined
      : [
          function(data) {
            let ret = "";
            for (let it in data) {
              ret +=
                encodeURIComponent(it) +
                "=" +
                encodeURIComponent(data[it]) +
                "&";
            }
            ret = ret.substring(0, ret.length - 1);
            return ret;
          }
        ],
    headers: {
      "Content-Type": "application/x-www-form-urlencoded",
      accessToken: accessToken,
      ...headers
    }
  });
};

/** 不带form表单不带transformRequest */
export const postRequestWithNoForm = (url, params) => {
  let accessToken = getStore("accessToken");
  return service({
    method: "post",
    url: `${url}`,
    data: params,

    headers: {
      accessToken: accessToken
    }
  });
};

export const postRequestWithHeaders = (url, params) => {
  let accessToken = getStore("accessToken");
  return axios({
    method: "post",
    url: `${url}`,
    data: params,

    headers: {
      accessToken: accessToken,
      "Content-Type": "application/x-www-form-urlencoded"
    }
  });
};

export const putRequest = (url, params, headers) => {
  let accessToken = getStore("accessToken");
  return service({
    method: "put",
    url: `${url}`,
    data: params,
    transformRequest: headers
      ? undefined
      : [
          function(data) {
            let ret = "";
            for (let it in data) {
              ret +=
                encodeURIComponent(it) +
                "=" +
                encodeURIComponent(data[it]) +
                "&";
            }
            ret = ret.substring(0, ret.length - 1);
            return ret;
          }
        ],
    headers: {
      "Content-Type": "application/x-www-form-urlencoded",
      accessToken: accessToken,
      ...headers
    }
  });
};
export const putRequest2 = (url, params, headers) => {
  let accessToken = getStore("accessToken");
  return service({
    method: "put",
    url,
    data: params, // 直接传对象，不要用 [params] 包装
    headers: {
      "Content-Type": "application/json",
    },
  });
};

export const putRequestWithNoForm = (url, params) => {
  let accessToken = getStore("accessToken");
  return service({
    method: "put",
    url: `${url}`,
    data: params,

    headers: {
      accessToken: accessToken
    }
  });
};

export const deleteRequest = (url, params) => {
  let accessToken = getStore("accessToken");
  return service({
    method: "delete",
    url: `${url}`,
    params: params,
    headers: {
      accessToken: accessToken
    }
  });
};

export const importRequest = (url, params) => {
  let accessToken = getStore("accessToken");
  return service({
    method: "post",
    url: `${url}`,
    data: params,
    headers: {
      accessToken: accessToken
    }
  });
};
// 原始的axios暴露出去用即可
export default service
export const uploadFileRequest = (url, params) => {
  let accessToken = getStore("accessToken");
  return service({
    method: "post",
    url: `${url}`,
    data: params,
    headers: {
      accessToken: accessToken,
      'Content-Type': 'multipart/form-data'
    }
  });
};

export const uploadFileRequest2 = (url, params) => {
  let accessToken = getStore("accessToken");
  return axios({  // 直接使用 axios，而不是 service（避免 baseUrl 影响）
    method: "post",
    url: `${url}`,  // 直接传完整 URL，如 uploadFile
    data: params,
    headers: {
      accessToken: accessToken,
      'Content-Type': 'multipart/form-data'
    }
  });
};

export const delFileByFileKeyRequest = (url, params) => {
  let accessToken = getStore("accessToken");
  return axios({  // 直接使用 axios，而不是 service（避免 baseUrl 影响）
    method: "DELETE",
    url: `${url}` + '/'+params,  // 直接传完整 URL，如 uploadFile
    headers: {
      accessToken: accessToken,
    }
  });
};


/**
 * 无需token验证的请求 避免旧token过期导致请求失败
 * @param {*} url
 * @param {*} params
 */
export const getRequestWithNoToken = (url, params) => {
  return service({
    method: "get",
    url: `${url}`,
    params: params
  });
};

/**
 * 无需token验证的请求 避免旧token过期导致请求失败
 * @param {*} url
 * @param {*} params
 */
export const postRequestWithNoToken = (url, params) => {
  return service({
    method: "post",
    url: `${url}`,
    params: params
  });
};

/**
 * 无需token验证的请求 避免旧token过期导致请求失败
 * @param {*} url
 * @param {*} params
 */
 export const postRequestWithNoTokenData = (url, params) => {
  return service({
    method: "post",
    url: `${url}`,
    headers: {
      "Content-Type": "application/x-www-form-urlencoded"
    },
    data: params
  });
};