import { type ActionFunctionArgs, type LoaderFunctionArgs, data } from "react-router";
import { safeFetch } from "../../lib/safeFetch";

async function proxyRequest(request: Request, path: string | undefined) {
    if (!path) {
        return data({ message: "No path provided" }, { status: 400 });
    }

    const getEnv = (key: string) => {
        // @ts-ignore
        if (typeof import.meta !== "undefined" && import.meta.env?.[key]) return import.meta.env[key];
        if (process.env[key]) return process.env[key];
        return undefined;
    };

    const baseUrl = getEnv("CORE_API_URL") || getEnv("VITE_CORE_API_URL") || getEnv("VITE_CORE_API");
    const apiKey = getEnv("CORE_API_KEY") || getEnv("VITE_CORE_API_KEY");

    if (!baseUrl) {
        console.error("Core API URL is not set in environment variables");
        return data({ message: "Server configuration error" }, { status: 500 });
    }

    const url = new URL(request.url);
    const cleanPath = path.startsWith("/") ? path.slice(1) : path;
    const targetUrl = `${baseUrl}/${cleanPath}${url.search}`;

    const headers = new Headers(request.headers);
    headers.delete("host");
    headers.delete("origin");
    headers.delete("referer");
    headers.delete("connection");
    headers.delete("content-length");
    // Cookies are forwarded intentionally

    // Inject API Key from server environment
    if (apiKey) {
        headers.set("x-api-key", apiKey);
    }


    try {
        const isGetOrHead = ["GET", "HEAD"].includes(request.method.toUpperCase());
        const response = await safeFetch(targetUrl, {
            method: request.method,
            headers,
            body: isGetOrHead ? undefined : request.body,
            // @ts-ignore - duplex is needed for streaming body in Node fetch
            duplex: isGetOrHead ? undefined : "half",
        });

        const newHeaders = new Headers(response.headers);
        newHeaders.delete("content-encoding");
        newHeaders.delete("content-length");
        
        const setCookieStr = response.headers.getSetCookie();
        if (setCookieStr && setCookieStr.length > 0) {
            newHeaders.delete("set-cookie");
            setCookieStr.forEach((cookie) => {
                newHeaders.append("Set-Cookie", cookie);
            });
        }

        return new Response(response.body, {
            status: response.status,
            headers: newHeaders,
        });
    } catch (error) {
        console.error("Proxy error:", error);
        return data({ message: "Proxy error", details: (error as Error).message }, { status: 502 });
    }
}
export async function action({ request, params }: ActionFunctionArgs) {
    return proxyRequest(request, params["*"]);
}

export async function loader({ request, params }: LoaderFunctionArgs) {
    return proxyRequest(request, params["*"]);
}