import type { Method } from "alova";
import type { AxiosError } from "axios";
import { axiosRequestAdapter } from "@alova/adapter-axios";
import { createAlova } from "alova";
import { toast } from "sonner-native";
import { useUserStore } from "@/store/user";

enum HttpCode {
  Success = 1000,
  Unauthorized = 1001,
  Fail = 500,
  BusinessError = 2000,
  SystemError = 3000,
}

// 仅保留「无需登录」接口
const WhiteList = ["/auth/login/**"];

function isWhiteListed(url: string) {
  return WhiteList.some((pattern) => {
    if (pattern.endsWith("/**")) {
      const base = pattern.slice(0, -3);
      return url.startsWith(base);
    }
    return url === pattern;
  });
}

const alovaInstance = createAlova({
  baseURL: process.env.EXPO_PUBLIC_API_URL,
  requestAdapter: axiosRequestAdapter(),
  timeout: 5000,
  cacheFor: null,

  responded: {
    onSuccess: async (response, _method: Method) => {
      const resData = response.data as ResponseData<any>;

      const result = {
        ...resData,
        isSuccess: resData.code === HttpCode.Success,
      };

      if (resData.code === HttpCode.Unauthorized) {
        toast.error("登录状态已过期，请重新登录");
        useUserStore.getState().setAuthExpired(true);
        return result;
      } else if (resData.code === HttpCode.BusinessError) {
        toast.error(resData.message || "业务异常，请稍后再试");
        return result;
      } else if (resData.code === HttpCode.SystemError) {
        toast.error(resData.message || "系统异常，请稍后再试");
        return result;
      }

      return result;
    },

    onError: (error: AxiosError) => {
      return Promise.reject(error);
    },
  },

  beforeRequest(method) {
    // 白名单接口直接放行
    if (isWhiteListed(method.url)) return;

    const userStore = useUserStore.getState();

    // 未登录直接拦截
    if (!userStore.isLogged()) {
      userStore.setAuthExpired(true);
      return Promise.reject(new Error("未登录"));
    }

    // 注入 JWT
    method.config.headers.Token = userStore.userInfo!.token;
  },
});

export default alovaInstance;