import axios, { AxiosInstance, AxiosError } from "axios";
// import { AxiosRequestConfig } from "axios";
import axiosRetry, { IAxiosRetryConfig } from "axios-retry";

const getToken = (): string | null => {
  return localStorage.getItem("jwtToken");
};

const useApiInterceptor = (): AxiosInstance => {
  // let isRefreshing = false;
  // let failedRequestsQueue: any[] = [];

  const apiInstance = axios.create({
    baseURL: process.env.NEXT_PUBLIC_API_BASE_URL,
    headers: {
      Accept: "application/json",
      "Content-Type": "application/json",
    },
  });

  // Retry logic with exponential backoff
  const retryOptions: IAxiosRetryConfig = {
    retries: 3,
    retryCondition: (err: AxiosError<any>) => {
      return (
        axiosRetry.isNetworkOrIdempotentRequestError(err) ||
        err.response?.status === 429
      );
    },
    retryDelay: (retryCount: number, err: AxiosError<any>) => {
      if (err.response) {
        const retry_after = err.response.headers["retry-after"];
        if (retry_after) {
          return parseInt(retry_after, 10) * 1000; // Convert to milliseconds
        }
      }
      return axiosRetry.exponentialDelay(retryCount);
    },
  };

  axiosRetry(apiInstance, retryOptions);

  // Interceptor to add Authorization header conditionally
  apiInstance.interceptors.request.use((config) => {
    const token = getToken();
    if (token) {
      config.headers["Authorization"] = `Bearer ${token}`;
    }
    return config;
  });

  // Response interceptor to handle 401 Unauthorized and refresh token
  // apiInstance.interceptors.response.use(
  //   (response) => response,
  //   async (error: AxiosError) => {
  //     const originalRequest = error.config as AxiosRequestConfig & {
  //       _retry?: boolean;
  //     };

  //     // If no error response or not 401, or already retried, reject
  //     if (
  //       !error.response ||
  //       error.response.status !== 401 ||
  //       originalRequest._retry
  //     ) {
  //       return Promise.reject(error);
  //     }

  //     originalRequest._retry = true;

  //     // Avoid multiple simultaneous refresh requests
  //     if (!isRefreshing) {
  //       isRefreshing = true;
  //       failedRequestsQueue = [];

  //       try {
  //         const newAccessToken = await useRefreshAccessToken();
  //         console.log("newAccessToken==>> ", newAccessToken);
  //         isRefreshing = false;

  //         // Retry all queued failed requests with new token
  //         failedRequestsQueue.forEach(({ config }) => {
  //           config.headers = {
  //             ...config.headers,
  //             Authorization: `Bearer ${newAccessToken}`,
  //           };
  //           apiInstance(config);
  //         });

  //         failedRequestsQueue = [];

  //         // Update the current request and retry it
  //         originalRequest.headers = {
  //           ...originalRequest.headers,
  //           Authorization: `Bearer ${newAccessToken}`,
  //         };

  //         return apiInstance(originalRequest);
  //       } catch (refreshError) {
  //         isRefreshing = false;
  //         failedRequestsQueue.forEach((req) => req.reject(refreshError));
  //         failedRequestsQueue = [];

  //         // Clear tokens and redirect to login
  //         localStorage.removeItem("jwtToken");
  //         window.location.href = "/login";

  //         return Promise.reject(refreshError);
  //       }
  //     } else {
  //       // Queue failed requests while waiting for new token
  //       return new Promise((resolve, reject) => {
  //         failedRequestsQueue.push({
  //           resolve,
  //           reject,
  //           config: originalRequest,
  //         });
  //       }).catch((err) => {
  //         return Promise.reject(err);
  //       });
  //     }
  //   }
  // );

  apiInstance.interceptors.response.use(
    (response) => response,
    (error: AxiosError) => {
      const isLoginPage = window.location.pathname === "/login";
      const isLogoutPage = window.location.pathname.startsWith("/logout");
      if (error.response?.status === 401) {
        // Clear all local auth keys for consistent session reset
        localStorage.removeItem("jwtToken");
        localStorage.removeItem("refreshToken");
        localStorage.removeItem("jobratorName");
        localStorage.removeItem("profileType");

        // Redirect to login page
        if (!isLoginPage && !isLogoutPage) {
          window.location.href = "/logout?unauthorized=true";
        }
      }
      return Promise.reject(error);
    }
  );

  return apiInstance;
};

export { useApiInterceptor };