import axios from "axios";
import crypto from "@/utils/crypto";
import Cookies from 'js-cookie';
import { ElMessage, ElLoading } from 'element-plus';
import router, { clearLoginState } from '@/router'; // 修正路由导入路径

// 获取基础 API 地址
const API_BASE_URL = import.meta.env.VITE_APP_API_BASE_URL;

// 获取内网 API 地址
const VITE_APP_API_INT_BASE_URL = import.meta.env.VITE_APP_API_INT_BASE_URL;

// 获取外网 API 地址
const VITE_APP_API_EXT_BASE_URL = import.meta.env.VITE_APP_API_EXT_BASE_URL;


if (!API_BASE_URL || !VITE_APP_API_INT_BASE_URL || !VITE_APP_API_EXT_BASE_URL) {
  console.warn('API基础地址未配置，请在环境变量中设置VITE_APP_API_BASE_URL');
}

// 设置基础 API 地址
const hostname = `${window.location.hostname}`;
var auth_api_url = ''
if(hostname == '192.168.6.104') {
    auth_api_url = API_BASE_URL
}else if (hostname == '8.134.12.216') {
    auth_api_url = VITE_APP_API_EXT_BASE_URL
}else if (hostname == '10.97.245.96') {
    auth_api_url = VITE_APP_API_INT_BASE_URL
}


// 创建axios实例
const api = axios.create({
  baseURL: auth_api_url,
  timeout: 15000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  }
});

// 加载状态管理
let loadingInstance = null;
let requestCount = 0;

// 显示加载状态
const showLoading = () => {
  if (requestCount === 0) {
    loadingInstance = ElLoading.service({
      lock: true,
      text: '加载中...',
      background: 'rgba(0, 0, 0, 0.1)'
    });
  }
  requestCount++;
};

// 隐藏加载状态
const hideLoading = () => {
  requestCount--;
  if (requestCount <= 0 && loadingInstance) {
    loadingInstance.close();
    loadingInstance = null;
    requestCount = 0;
  }
};

// 请求拦截器
api.interceptors.request.use(
  (config) => {
    // 如果需要显示加载状态
    if (config.showLoading !== false) {
      showLoading();
    }
    
    // 添加认证token
    const accessToken = Cookies.get('access_token');
    if (accessToken) {
      config.headers['Authorization'] = `Bearer ${accessToken}`;
    }
    
    // 处理POST请求加密（不加密请求会标记isEncrypted: true）
    if (config.method?.toLowerCase() === 'post' && !config.isEncrypted) {
      try {
        // 添加用户信息
        let requestData = { ...config.data };
        const storedUserInfo = localStorage.getItem('userInfo'); // 修正存储键名
        
        if (storedUserInfo) {
          const userInfo = JSON.parse(crypto.decrypt(storedUserInfo));
          requestData['user_id'] = userInfo.userId; // 匹配后端返回的userId字段
        }
        
        // 加密数据
        config.data = {
          postdata: crypto.encrypt(JSON.stringify(requestData))
        };
        
        // 标记为已加密
        config.isEncrypted = true;
      } catch (error) {
        console.error('请求数据加密失败:', error);
      }
    }
    
    return config;
  },
  (error) => {
    hideLoading();
    ElMessage.error('请求配置错误');
    return Promise.reject(error);
  }
);

// 响应拦截器
api.interceptors.response.use(
  (response) => {
    hideLoading();
    
    // 处理业务逻辑错误
    const { data } = response;
    // 根据实际后端规范调整（确保与后端code一致）
    if (data.code == null || ![0, 200].includes(data.code)) {
        ElMessage.error(data.message || '操作失败');
        return Promise.reject(new Error(data.message || '请求失败'));
    }
        
    return data;
  },
  async (error) => {
    hideLoading();
    
    // 处理网络错误
    if (!error.response) {
      ElMessage.error('网络连接异常，请检查网络');
      return Promise.reject(error);
    }
    
    const { status, data } = error.response;
    
    // 处理不同状态码
    switch (status) {
      case 401:
        // 未授权，处理token过期逻辑
        if (!router.currentRoute.value.path.includes('/auth')) {
          ElMessage.error('登录已过期，请重新登录');
          clearLoginState(); // 使用路由文件中的清除方法
          router.push('/auth');
        }
        break;
      case 403:
        ElMessage.error('没有权限执行此操作');
        break;
      case 404:
        ElMessage.error('请求的资源不存在');
        break;
      case 500:
        ElMessage.error('服务器内部错误，请稍后再试');
        break;
      default:
        ElMessage.error(data?.message || `请求错误 (${status})`);
    }
    
    return Promise.reject(error);
  }
);

// 封装请求方法
const request = {
  /**
   * GET请求
   * @param {string} url 请求地址
   * @param {object} params 请求参数
   * @param {object} config 额外配置
   * @returns {Promise}
   */
  get: (url, params = {}, config = {}) => {
    return api({
      url,
      method: 'get',
      params,
      ...config
    });
  },
  
  /**
   * POST请求
   * @param {string} url 请求地址
   * @param {object} data 请求数据
   * @param {object} config 额外配置
   * @returns {Promise}
   */
  post: (url, data = {}, config = {}) => {
    return api({
      url,
      method: 'post',
      data,
      ...config
    });
  },
  
  /**
   * PUT请求
   * @param {string} url 请求地址
   * @param {object} data 请求数据
   * @param {object} config 额外配置
   * @returns {Promise}
   */
  put: (url, data = {}, config = {}) => {
    return api({
      url,
      method: 'put',
      data,
      ...config
    });
  },
  
  /**
   * DELETE请求
   * @param {string} url 请求地址
   * @param {object} params 请求参数
   * @param {object} config 额外配置
   * @returns {Promise}
   */
  delete: (url, params = {}, config = {}) => {
    return api({
      url,
      method: 'delete',
      params,
      ...config
    });
  },
  
  /**
   * 不加密的POST请求（用于登录等不需要加密的场景）
   * @param {string} url 请求地址
   * @param {object} data 请求数据
   * @param {object} config 额外配置
   * @returns {Promise}
   */
  postWithoutEncryption: (url, data = {}, config = {}) => {
    return api({
      url,
      method: 'post',
      data,
      isEncrypted: true, // 标记为已加密，跳过加密处理
      showLoading: config.showLoading !== false, // 默认为显示加载状态
      ...config
    });
  }
};

// 暴露axios实例和请求方法
export { api, request };
export default request;
