import axios from "axios";

import authStorage, { getData, getToken, getVendorToken, getUser } from "../storage";
import { routes } from "@/config/routes";
import { defaultBaseCountryCode, defaultBaseLanguage } from "@/constants/common";

import { getCountrySubDomainFromHostname, getLanguageValueFromSubdomain } from "@/server_api/utils/sub-domain";
import { localStorageValues } from "@/constants/local-storage-values";

const clearAuthSession = async () => {
    try {
        if (authStorage?.deleteUser) {
            await authStorage.deleteUser();
        }
        if (authStorage?.deleteVendorUser) {
            await authStorage.deleteVendorUser();
        }

        if (typeof window !== "undefined") {
            localStorage.removeItem("token");
            localStorage.removeItem("authToken");
            localStorage.removeItem("user_token");
            localStorage.removeItem("accessToken");
            localStorage.removeItem("menasale");
            localStorage.removeItem("menasale-vendor");
            localStorage.removeItem("dynatech_uuid");
            localStorage.removeItem("guestUser");
        }
    } catch (storageError) {
        console.error("Error clearing auth storage:", storageError);
    }
};

const navigateToLogin = () => {
    if (typeof window !== "undefined" && window.location.pathname !== routes.auth.login) {
        window.location.replace(routes.auth.login);
    }
};

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

// serverConnectAPI.interceptors.request.use(
//     async function (config: any) {
//         const authToken = await getToken();
//         const vendorToken = await getVendorToken();
//         const storedUser = await getUser();
//         const hostName = await authStorage.getData(localStorageValues.host);
//         const currency = await authStorage.getData(localStorageValues.currency);
//         const uuid = await getData("dynatech_uuid");

//         // Attach Authorization Token if skipAuth is not explicitly true
//         if (!config.skipAuth) {
//             if (authToken) {
//                 config.headers["Authorization"] = `Bearer ${authToken}`;
//             } else if (vendorToken) {
//                 config.headers["Authorization"] = `Bearer ${vendorToken}`;
//             }
//         }

//         // Attach User-Token / UUID if available
//         if (uuid) {
//             config.headers["User-Token"] = uuid;
//         }

//         // Manage Guest User and Logged User Section
//         const isGuest = Boolean(
//             !storedUser ||
//             storedUser?.isGuest ||
//             storedUser?.isGuestUser ||
//             storedUser?.userType === "guest"
//         );

//         // config.headers["Is-Guest"] = isGuest ? "true" : "false";
//         config.headers["User-Type"] = storedUser?.userType
//             ? storedUser.userType
//             : isGuest
//                 ? "guest"
//                 : "logged";

//         // Subdomain & Origin configuration
//         if (hostName) {
//             const testHost = await authStorage.getData("testHostName");
//             const effectiveHost = testHost || hostName;

//             if (effectiveHost) {
//                 config.headers["Origin"] = effectiveHost;
//                 const language =
//                     getLanguageValueFromSubdomain(effectiveHost) ||
//                     defaultBaseLanguage;
//                 const country =
//                     getCountrySubDomainFromHostname(effectiveHost) ||
//                     defaultBaseCountryCode;

//                 if (language !== defaultBaseLanguage) {
//                     config.headers["Language"] = language;
//                 }
//                 config.headers["Country"] = country;
//             }
//         }

//         // Currency configuration
//         config.headers["Currency"] = currency || "AED";

//         return config;
//     },
//     function (error) {
//         return Promise.reject(error);
//     }
// );
serverConnectAPI.interceptors.request.use(
    async function (config: any) {
        const authToken = await getToken();
        const vendorToken = await getVendorToken();
        const hostName = await authStorage.getData(localStorageValues.host);
        const uuid = await getData("dynatech_uuid");

        // Attach Authorization Token if skipAuth is not explicitly true
        if (!config.skipAuth) {
            if (authToken) {
                config.headers["Authorization"] = `Bearer ${authToken}`;
            } else if (vendorToken) {
                config.headers["Authorization"] = `Bearer ${vendorToken}`;
            }
        }

        // Attach User-Token / UUID if available
        if (uuid) {
            config.headers["User-Token"] = uuid;
        }

        // Subdomain & Origin configuration
        let effectiveHost = hostName;

        if (hostName) {
            const testHost = await authStorage.getData("testHostName");
            effectiveHost = testHost || hostName;

            if (effectiveHost) {
                config.headers["Origin"] = effectiveHost;

                const language =
                    getLanguageValueFromSubdomain(effectiveHost) ||
                    defaultBaseLanguage;

                if (language !== defaultBaseLanguage) {
                    config.headers["Language"] = language;
                }
            }
        }

        // Always pass Country
        const country =
            getCountrySubDomainFromHostname(effectiveHost) ||
            defaultBaseCountryCode;

        config.headers["Country"] = country;

        return config;
    },
    function (error) {
        return Promise.reject(error);
    }
);
serverConnectAPI.interceptors.response.use(
    async function (response: any) {
        const authToken = await getToken();
        const vendorToken = await getVendorToken();
        const hasAuthToken = Boolean(authToken || vendorToken);

        if (response && response.status === 200) {
            if (response.data) {
                // Check if reLogin flag is returned for an authenticated session
                if (response.data.reLogin === true && hasAuthToken) {
                    await clearAuthSession();
                    navigateToLogin();
                    return Promise.reject("Session expired. Please login again.");
                }

                if (response.data.status === false) {
                    const errorMsg = String(response.data.message || "").toLowerCase();
                    if (
                        hasAuthToken &&
                        (errorMsg.includes("invalid token") ||
                            errorMsg.includes("token expired") ||
                            errorMsg.includes("unauthorized"))
                    ) {
                        await clearAuthSession();
                        navigateToLogin();
                        return Promise.reject("Session expired. Please login again.");
                    }

                    if (response.data.validation) {
                        return Promise.reject(response.data.validation);
                    } else if (response.data.message !== "") {
                        return Promise.reject(response.data.message);
                    }
                }

                return response.data;
            }
            return response;
        } else if (response.status === 201) {
            if (!response?.data?.status && response?.data?.reLogin && hasAuthToken) {
                await clearAuthSession();
                navigateToLogin();
                return Promise.reject("Session expired. Please login again.");
            }
            return response.data || response;
        } else if (response.status === 403) {
            if (typeof window !== "undefined") {
                alert("You do not have permission for this action!");
            }
            return Promise.reject("You do not have permission for this action!");
        } else if (response.status === 204) {
            return Promise.reject("No content found");
        } else {
            return Promise.reject("Unknown database error (code:2)");
        }
    },
    async function (error: any) {
        const authToken = await getToken();
        const vendorToken = await getVendorToken();
        const hasAuthToken = Boolean(authToken || vendorToken);

        if (error && error.response) {
            const { data, status } = error.response;

            const errorMessage = String(
                data?.message || data?.errorMsg || data?.error || ""
            ).toLowerCase();

            const isInvalidToken =
                hasAuthToken &&
                (status === 401 ||
                    data?.reLogin === true ||
                    errorMessage.includes("invalid token") ||
                    errorMessage.includes("token expired") ||
                    errorMessage.includes("session expired"));

            if (isInvalidToken) {
                await clearAuthSession();
                navigateToLogin();
                return Promise.reject("Session expired. Please login again.");
            }

            if (status === 403) {
                return Promise.reject(
                    data?.message || "You do not have permission for this action!"
                );
            }

            if (status === 500 && data) {
                return Promise.reject(data?.message || "Internal server error");
            }

            if (data?.errorMsg) {
                return Promise.reject(data.errorMsg);
            }

            if (data?.message) {
                return Promise.reject(data.message);
            }

            return Promise.reject(error?.message || "Something went wrong");
        }

        return Promise.reject(error?.message || "Network error");
    }
);

export default serverConnectAPI;