import axios from "axios";
import { Message, Loading } from "element-ui";
import { debounce } from "lodash-es";
import store from "../store/index";
import { getToken } from "./getToken.js";

let axiosBaseURL;
let axiosTimeout;
if (
    import.meta.env.PROD) {
    //生产环境
    const ProjectConfig = window.ProjectConfig;

    axiosBaseURL = ProjectConfig.axiosBaseURL;
    axiosTimeout = ProjectConfig.axiosTimeout;
} else {
    //非生产环境
    axiosBaseURL = "/api";
    axiosTimeout = 1000 * 30;
}

export const http = axios.create({
    withCredentials: false,
    baseURL: axiosBaseURL,
    timeout: axiosTimeout
});




//处理响应的结果，返回统一结构
function handleTheResponse(response) {
    console.log(`axios包装过的响应${response.config.url}`, response);

    let responseData = response.data;
    if (response.status === 200) {
        if (/^\s*$/g.test("" + responseData)) {
            responseData = {
                code: 1,
                message: "无响应数据",
                data: null,
            };
        }
    } else {
        return {
            code: 1,
            message: responseData ? responseData.message : "服务异常",
            data: responseData,
        };
    }
    if (!responseData || responseData.code !== 0) {
        // Message.error({ message: responseData ? responseData.message : "服务异常", duration: 1000 * 3 });
    }
    return responseData;
}

//处理错误，返回统一结构
function handleTheError(error) {
    console.log(`axios包装过的错误${error.config.url}`, error);
    const responseData = { code: -999, data: null };
    if (error.response) {
        const { data, status, statusText } = error.response;
        if (status === 500 && /^\s*$/gi.test(data + "")) {
            responseData.message = "服务异常,无响应数据";
        } else {
            responseData.data = data;
            responseData.message = `${statusText ?? "服务异常,请稍后再试"}`;
        }
    } else if (error.request) {
        responseData.message = "未收到服务端响应,请稍后再试";
    } else {
        responseData.message = "未发送请求,请检查请求参数是否正确";
    }
    Message.error({ message: responseData.message, duration: 1000 * 3 });
    return responseData;
}

//添加请求拦截器
http.interceptors.request.use(
    (config) => {
        if (config.withToken !== false) {
            config.headers["token"] = getToken();
        }
        return config;
    },
    (error) => {
        // console.log("request-error", error);
        //todo 封装成固定结构 {code,data,message}
        return handleTheError(error);
    },
);

//响应拦截器
http.interceptors.response.use(
    (response) => {
        //todo 封装成固定结构 {code,data,message}
        return handleTheResponse(response);
    },
    (error) => {
        //todo 封装成固定结构 {code,data,message}
        return handleTheError(error);
    },
);
// 引擎接口
let modelaxiosUrl
const ProjectConfig = window.ProjectConfig;

modelaxiosUrl = ProjectConfig.modelUrl;
export const modelhttp = axios.create({
    withCredentials: false,
    baseURL: modelaxiosUrl,
    timeout: axiosTimeout
});

//添加请求拦截器
modelhttp.interceptors.request.use(
    (config) => {
        if (config.withProjectId !== false) {
            config.headers["projectId"] = store.getters["common/currentProjectId"];
        }
        if (config.withToken !== false) {
            config.headers["token"] = getToken();
        }
        return config;
    },
    (error) => {
        // console.log("request-error", error);
        //todo 封装成固定结构 {code,data,message}
        return handleTheError(error);
    },
);

//响应拦截器
modelhttp.interceptors.response.use(
    (response) => {
        //todo 封装成固定结构 {code,data,message}
        return handleTheResponse(response);
    },
    (error) => {
        //todo 封装成固定结构 {code,data,message}
        return handleTheError(error);
    },
);