import { relogin } from "../core/auth/server/server-auth";
import { getCommonParams } from "../store/models/params.model";
import UserInfoModel from "../store/models/user.model";
import { decryptData, generateSign } from "./encrypted";

interface ApiOptions {
  url: string;
  data?: any;
  method?: 'GET' | 'POST'
}

interface ApiResponse {
  code: number;
  data: any;
  message: string;
}


const api = async <T>({url,data,method='GET'}:ApiOptions): Promise<T>=>{
  try {
    return await request<T>({url,data,method})
  } catch (error) {
    // 如果是401错误，尝试重新登录
      if (error.code === 401) {
        console.log("登录过期，尝试重新登录...");
        try {
          // 调用重新登录方法
          await relogin();
          console.log("重新登录成功，重新发起请求...");

          // 重新获取登录信息
          const newLoginInfo = UserInfoModel.getInstance().get();

          // 重新发起请求
          return new Promise((resolve, reject) => {
            wx.request({
              url: url,
              header: {
                "Content-Type": "application/x-www-form-urlencoded",
                Authorization: `Bearer ${newLoginInfo.token}`,
              },
              method: method,
              data,
              success: (res:any) => {
                if (res.statusCode === 200) {
                   const responseData = res.data as ApiResponse;
                  if (responseData.code === 200) {
                    // 解密响应数据
                    responseData.data = decryptData(responseData.data);
                    resolve(responseData.data);
                  } else {
                    reject({
                      code: responseData.code,
                      msg: responseData.message,
                    });
                  }
                } else {
                  reject({
                    code: -1,
                    msg: `网络请求失败 ${res.statusCode}`,
                  });
                }
              },
              fail: (error) => {
                reject({
                  code: -1,
                  msg: error.errMsg,
                });
              },
            });
          });
        } catch (loginError) {
          console.error("重新登录失败:", loginError);
          // 重新登录失败，返回原始错误
          throw error;
        }
      } else {
        // 其他错误直接抛出
        throw error;
      }
  }
 
}


const request = async <T>({url,data,method='GET'}:ApiOptions): Promise<T>=>{
 return new Promise<T>((resolve,reject)=>{
    const token = UserInfoModel.getInstance().getToken();
    const commonParams = getCommonParams()
    let  params = {
      ...commonParams,
      ...data
    }
     params = generateSign(params)
    // signParams.sign = sign

 
    wx.request({
    url,
    data: params,
    method,
    header: {
      "Content-Type": "application/x-www-form-urlencoded",
      Authorization:`Bearer ${token}`
    },
    success: (res: any) => {
      if(res.statusCode === 200) {
         const responseData = res.data as ApiResponse;
         if (responseData.code === 200) {
          responseData.data = decryptData(responseData.data);
           resolve(responseData.data);
         }else if(responseData.code === 401){
           reject({
                  code: 401,
                  msg: responseData.message,
                });
         }else {
          wx.showModal({
              title: "网络错误",
              icon:"none",
              showCancel:false,
              content: `${url}:${responseData.message}`,
            })
                reject({
                  code: responseData.code,
                  msg: responseData.message,
                });
              }
        return responseData;
      } else {
         
          reject({
            code: -1,
            msg: `network error ${res.message}`,
          });
        }
    },
    fail: (error) => {
      reject({
        code: -1,
        msg: `network error ${error.errMsg}`,
      });
    },
  });
  })
}



const get = <T>(url:string,data?:any): Promise<T>=>{
  return api<T>({url:`${import.meta.env.SDK_API_BASE}${url}`,data,method:'GET'})
}

const post = <T>(url:string,data?:any): Promise<T>=>{
  return api<T>({url:`${import.meta.env.SDK_API_BASE}${url}`,data,method:'POST'})
}

export default {
  get,
  post
}