import config from './config.js'

// 创建请求实例
const service = {
  // 默认配置
  defaults: {
    headers: {
      'Content-Type': 'application/json;charset=utf-8',
      // 'token':uni.getStorageSync('token')
    },
    timeout: 100000
  },

  // 基础URL
  baseURL: config.apiBaseUrl || ''
}

// 请求拦截器
const requestInterceptors = []

// 响应拦截器
const responseInterceptors = []

addRequestInterceptor(async (cfg) => {
  const needToken = !(cfg.headers && cfg.headers.isToken === false)
  if (needToken) {
    const token = uni.getStorageSync('token')
    if (!token) {
      try { uni.reLaunch({ url: '/subpackage/login/login' }) } catch (e) { }
      return Promise.reject({ message: 'NO_TOKEN' })
    }
      cfg.headers = { 
      ...(cfg.headers || {}), 
      'Authorization': `Bearer ${token}` 
    }
  } else {
    const headers = { ...(cfg.headers || {}) }
    if ('Authorization' in headers) {
      delete headers.Authorization
    }
    cfg.headers = headers
  }

  return cfg
})
let isRedirecting = false;
addResponseInterceptor(async (res) => {
  // 1. 判断HTTP状态码是否为401（核心判断）
  const is401 = (res.statusCode === 200 && res.data.code === 401 );
  // 2. 可选：判断业务码是否为401（根据你的后端返回格式调整，比如 res.data.code === 401）
  // const isBiz401 = res.data && res.data.code === 401;
  
  if (is401) {
    // 防重复跳转：如果正在跳转，直接拒绝Promise
    if (isRedirecting) {
      return Promise.reject({ message: '已在跳转登录页', statusCode: 401 });
    }
    
    isRedirecting = true;
    
    try {
      // 清除本地无效Token
      uni.removeStorageSync('token');
      // 跳转到登录页（使用reLaunch关闭所有页面，避免返回原页面）
      await uni.reLaunch({ url: '/subpackage/login/login' });
    } catch (e) {
      console.error('401跳转登录失败：', e);
    } finally {
      // 重置跳转标识
      isRedirecting = false;
    }
    
    // 拒绝Promise，阻止后续业务逻辑执行
    return Promise.reject({ message: 'Token无效或已过期，请重新登录', statusCode: 401 });
  }
  
  // 非401响应，直接返回原响应
  return res;
})

/**
 * 添加请求拦截器
 * @param {Function} fn 拦截器函数
 */
function addRequestInterceptor(fn) {
  requestInterceptors.push(fn)
}

/**
 * 添加响应拦截器
 * @param {Function} fn 拦截器函数
 */
function addResponseInterceptor(fn) {
  responseInterceptors.push(fn)
}

/**
 * 处理请求拦截
 * @param {Object} config 请求配置
 * @returns {Object} 处理后的配置
 */
async function handleRequestInterceptors(config) {
  let handledConfig = { ...config }

  for (const interceptor of requestInterceptors) {
    handledConfig = await interceptor(handledConfig)
  }

  return handledConfig
}

/**
 * 处理响应拦截
 * @param {Object} response 响应数据
 * @returns {Object} 处理后的响应
 */
async function handleResponseInterceptors(response) {
  let handledResponse = { ...response }

  for (const interceptor of responseInterceptors) {
    handledResponse = await interceptor(handledResponse)
  }

  return handledResponse
}

/**
 * 转换请求参数为查询字符串
 * @param {Object} params 参数对象
 * @returns {String} 查询字符串
 */
function tansParams(params) {
  let result = ''
  for (const propName of Object.keys(params)) {
    const value = params[propName]
    var part = encodeURIComponent(propName) + "="
    if (value !== null && value !== "" && typeof (value) !== "undefined") {
      if (typeof value === 'object') {
        for (const key of Object.keys(value)) {
          if (value[key] !== null && value[key] !== "" && typeof (value[key]) !== "undefined") {
            let params = propName + "[" + key + "]"
            var subPart = encodeURIComponent(params) + "="
            result += subPart + encodeURIComponent(value[key]) + "&"
          }
        }
      } else {
        result += part + encodeURIComponent(value) + "&"
      }
    }
  }
  return result
}

/**
 * 通用请求方法
 * @param {Object} options 请求配置
 * @returns {Promise}
 */
function request(options) {
  // 合并默认配置
  const config = {
    method: 'GET',
    headers: { ...service.defaults.headers },
    timeout: service.defaults.timeout,
    baseURL: service.baseURL,
    ...options
  }

  // 执行请求拦截器
  return handleRequestInterceptors(config)
    .then(processedConfig => {
      // 构建完整URL
      let url = processedConfig.baseURL + processedConfig.url

      // 处理GET请求参数
      if (processedConfig.method.toUpperCase() === 'GET' && processedConfig.params) {
        const paramsStr = tansParams(processedConfig.params)
        if (paramsStr) {
          url += (url.includes('?') ? '&' : '?') + paramsStr.slice(0, -1)
        }
      }

      // 构建uni.request参数
      const requestOptions = {
        url: url,
        method: processedConfig.method.toUpperCase(),
        header: processedConfig.headers,
        timeout: processedConfig.timeout
      }

      // 添加请求体（非GET请求）
      if (processedConfig.method.toUpperCase() !== 'GET' && processedConfig.data) {
        requestOptions.data = processedConfig.data
      }

      // 发起请求
      return new Promise((resolve, reject) => {
        uni.request({
          ...requestOptions,
          success: (res) => {
            // 处理响应拦截器
            handleResponseInterceptors(res)
              .then(processedRes => {
                resolve(processedRes)
              })
              .catch(error => {
                reject(error)
              })
          },
          fail: (err) => {
            reject(err)
          }
        })
      })
    })
    .catch(error => {
      console.error('Request interceptor error:', error)
      return Promise.reject(error)
    })
}

/**
 * GET请求
 * @param {String} url 请求地址
 * @param {Object} params 请求参数
 * @param {Object} config 请求配置
 * @returns {Promise}
 */
function get(url, params = {}, config = {}) {
  return request({
    method: 'GET',
    url,
    params,
    ...config
  })
}

/**
 * POST请求
 * @param {String} url 请求地址
 * @param {Object} data 请求数据
 * @param {Object} config 请求配置
 * @returns {Promise}
 */
function post(url, data = {}, config = {}) {
  return request({
    method: 'POST',
    url,
    data,
    ...config
  })
}

/**
 * PUT请求
 * @param {String} url 请求地址
 * @param {Object} data 请求数据
 * @param {Object} config 请求配置
 * @returns {Promise}
 */
function put(url, data = {}, config = {}) {
  return request({
    method: 'PUT',
    url,
    data,
    ...config
  })
}

/**
 * DELETE请求
 * @param {String} url 请求地址
 * @param {Object} params 请求参数
 * @param {Object} config 请求配置
 * @returns {Promise}
 */
function del(url, params = {}, config = {}) {
  return request({
    method: 'DELETE',
    url,
    params,
    ...config
  })
}

/**
 * 通用上传文件方法
 * @param {Object} options 上传配置
 * @returns {Promise}
 */
function uploadFile(options) {
  const config = {
    headers: { ...service.defaults.headers },
    timeout: service.defaults.timeout,
    baseURL: service.baseURL,
    ...options
  }

  return handleRequestInterceptors(config)
    .then(processedConfig => {
      return new Promise((resolve, reject) => {
        uni.uploadFile({
          url: processedConfig.baseURL + processedConfig.url,
          filePath: processedConfig.filePath,
          name: processedConfig.name || 'file',
          header: processedConfig.headers,
          formData: processedConfig.formData,
          success: (res) => {
            // uni.uploadFile 的 data 是字符串，尝试解析为对象
            if (typeof res.data === 'string') {
              try {
                res.data = JSON.parse(res.data)
              } catch (e) {
                // 解析失败则保持原样
              }
            }
            handleResponseInterceptors(res)
              .then(processedRes => {
                resolve(processedRes)
              })
              .catch(error => {
                reject(error)
              })
          },
          fail: (err) => {
            reject(err)
          }
        })
      })
    })
}

// 导出方法
export default {
  request,
  uploadFile,
  get,
  post,
  put,
  delete: del,
  addRequestInterceptor,
  addResponseInterceptor,
  service
}