import axios from 'axios'
import { ElMessage, ElMessageBox } from 'element-plus'
import { useUserStore } from '../stores/user'
import qs from 'qs';

// 创建 axios 实例
const service = axios.create({
 // baseURL: import.meta.env.VITE_API_BASE_URL || '/api', // 从环境变量获取 API 基础 URL
  //baseURL: 'http://localhost:8101', // 从环境变量获取 API 基础 URL
  baseURL: 'http://localhost:8084', // 从环境变量获取 API 基础 URL
  timeout: 15000, // 请求超时时间
})

// 请求拦截器
service.interceptors.request.use(
  config => {
    // 在发送请求之前做些什么
    const userStore = useUserStore()

    // 如果有 token，添加到请求头
    if (userStore.isLoggedIn && userStore.token) {
      config.headers['Authorization'] = `Bearer ${userStore.token}`
    }



      config.headers['token'] = `eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3NDI0NzI5MzUsInVzZXJuYW1lIjoiYWRtaW4ifQ.-4e5HlHyM9gYlfkaraNdIcPDAeegiPoe3KPRaID9fRY`


    // 根据请求方法和数据类型动态设置 Content-Type
    if (config.method.toUpperCase() === 'POST' || config.method.toUpperCase() === 'PUT') {
      // 如果数据是 FormData 类型，不设置 Content-Type，让浏览器自动设置
      if (config.data instanceof FormData) {
        // axios 会自动设置正确的 Content-Type，包括 boundary
      }
      // 如果数据是普通对象，设置为 application/json
      else if (typeof config.data === 'object') {
        config.headers['Content-Type'] = 'application/json;charset=utf-8'
      }
    }

    return config
  },
  error => {
    // 对请求错误做些什么
    console.error('Request error:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
service.interceptors.response.use(
  response => {
    const res = response.data

    // 根据实际后端返回的状态码和数据结构调整这里的逻辑
    // 这里假设后端返回的数据结构是 { code: number, data: any, message: string }
    if (res.code && res.code !== 200) {
      ElMessage({
        message: res.message || 'Error',
        type: 'error',
        duration: 5 * 1000
      })

      // 401: 未登录或 token 过期
      if (res.code === 401) {
        // 重新登录
        ElMessageBox.confirm(
          '您已登出，可以取消继续留在该页面，或者重新登录',
          '确认登出',
          {
            confirmButtonText: '重新登录',
            cancelButtonText: '取消',
            type: 'warning'
          }
        ).then(() => {
          const userStore = useUserStore()
          userStore.logout()
          window.location.reload()
        })
      }

      return Promise.reject(new Error(res.message || 'Error'))
    } else {
      return res
    }
  },
  error => {
    console.error('Response error:', error)

    // 处理网络错误
    let message = '网络错误，请稍后重试'

    if (error.response) {
      // 服务器返回了错误状态码
      switch (error.response.status) {
        case 400:
          message = '请求错误'
          break
        case 401:
          message = '未授权，请登录'
          // 处理登出逻辑
          ElMessageBox.confirm(
            '您的登录已过期，请重新登录',
            '登录过期',
            {
              confirmButtonText: '重新登录',
              cancelButtonText: '取消',
              type: 'warning'
            }
          ).then(() => {
            const userStore = useUserStore()
            userStore.logout()
            window.location.href = '/login'
          })
          break
        case 403:
          message = '拒绝访问'
          break
        case 404:
          message = '请求的资源不存在'
          break
        case 408:
          message = '请求超时'
          break
        case 500:
          message = '服务器内部错误'
          break
        case 501:
          message = '服务未实现'
          break
        case 502:
          message = '网关错误'
          break
        case 503:
          message = '服务不可用'
          break
        case 504:
          message = '网关超时'
          break
        case 505:
          message = 'HTTP版本不受支持'
          break
        default:
          message = `未知错误: ${error.response.status}`
      }

      // 如果响应中有详细错误信息，使用它
      if (error.response.data) {
        if (typeof error.response.data === 'string') {
          message = error.response.data
        } else if (error.response.data.message) {
          message = error.response.data.message
        }
      }
    } else if (error.request) {
      // 请求已发送但没有收到响应
      message = '服务器无响应，请稍后重试'
    } else {
      // 请求设置有问题
      message = error.message
    }

    ElMessage({
      message: message,
      type: 'error',
      duration: 5 * 1000
    })

    return Promise.reject(error)
  }
)

// 封装 GET 请求
export function get(url, params) {
  return service({
    url,
    method: 'get',
    params
  })
}

// 封装 POST 请求
export function post(url, data) {
  return service({
    url,
    method: 'post',
    data
  })
}

// 封装 PUT 请求
export function put(url, data) {
  return service({
    url,
    method: 'put',
    data
  })
}

// 封装 DELETE 请求
export function del(url, params) {
  return service({
    url,
    method: 'delete',
    params
  })
}

// 封装 `@RequestParam` 方式的 POST 请求
export function postRequest(url, params) {
  const formData = new FormData();
  for (const key in params) {
    console.log(params[key]);
    formData.append(key, params[key]);
  }
  for (let pair of formData.entries()) {
    console.log(pair[0] + ': ' + pair[1]);
  }
  return service({
    url,
    method: 'post',
    data: formData,
  });
}


export function getRequest(url, params) {
  const searchParams = new URLSearchParams();
  for (const key in params) {
    if (Array.isArray(params[key])) {
      params[key].forEach(item => {
        searchParams.append(key, item); // 注意这里直接使用 key，不加 []
      });
    } else {
      searchParams.append(key, params[key]);
    }
  }
  return service({
    url: `${url}?${searchParams.toString()}`,
    method: 'get'
  });
}


export function getRequestWithqs(url, params) {
  return service({
    url,
    method: 'get',
    params,
    paramsSerializer: params => {
      // 设置 arrayFormat 为 'repeat' 表示 ids=1&ids=2&ids=3
      // 设置 arrayFormat 为 'comma' 表示 ds=1%2C2%2C3
      return qs.stringify(params, { arrayFormat: 'repeat' });
    }
  });
}


export function postRequestJSON(url, params) {
  return service({
    url,
    method: 'post',
    data: JSON.stringify(params), // 发送 JSON
    headers: { 'Content-Type': 'application/json' }
  });
}

// 封装上传文件的请求
export function upload(url, file, onUploadProgress) {
  const formData = new FormData()

  // 如果 file 是文件数组，则添加多个文件
  if (Array.isArray(file)) {
    file.forEach((f, index) => {
      formData.append('files', f)
    })
  } else {
    // 单个文件上传
    formData.append('file', file)
  }

  return service({
    url,
    method: 'post',
    data: formData,
    // 上传进度回调
    onUploadProgress: onUploadProgress ? progressEvent => {
      const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total)
      onUploadProgress(percentCompleted)
    } : undefined
  })
}

// 封装下载文件的请求
export function download(url, params, filename) {
  return service({
    url,
    method: 'get',
    params,
    responseType: 'blob'
  }).then(response => {
    // 创建 blob 链接并下载
    const blob = new Blob([response])
    const link = document.createElement('a')
    link.href = URL.createObjectURL(blob)
    link.download = filename || getFilenameFromResponse(response)
    link.click()
    URL.revokeObjectURL(link.href)
    return response
  })
}

// 从响应头中获取文件名
function getFilenameFromResponse(response) {
  const contentDisposition = response.headers['content-disposition']
  if (contentDisposition) {
    const filenameMatch = contentDisposition.match(/filename="(.+)"/)
    if (filenameMatch) {
      return filenameMatch[1]
    }
  }
  return 'downloaded-file'
}

// 导出 axios 实例
export default service
