import {
  RPC_IDENTITY_HEADER,
  RPC_INTERNAL_HEADER,
  RPC_PATH_PREFIX,
  type ServiceImplementation,
} from "@wrnexus/rpc";

export { RPC_INTERNAL_HEADER };
const EDGE_HEADERS = ["x-forwarded-for", "x-forwarded-host", "x-forwarded-proto", "forwarded"];

export function isRpcPath(pathname: string): boolean {
  return pathname === RPC_PATH_PREFIX || pathname.startsWith(`${RPC_PATH_PREFIX}/`);
}

export function isInternalCaller(req: Request): boolean {
  return (
    req.headers.get(RPC_INTERNAL_HEADER) === "1" &&
    !EDGE_HEADERS.some((name) => req.headers.has(name))
  );
}

function json(body: unknown, status = 200): Response {
  return Response.json(body, { status, headers: { "cache-control": "private, no-store" } });
}

export async function handleRpcRequest(
  req: Request,
  url: URL,
  services: Map<string, ServiceImplementation>,
): Promise<Response | null> {
  if (!isRpcPath(url.pathname)) return null;
  if (!isInternalCaller(req)) return new Response("Not found", { status: 404 });
  if (req.method !== "POST") return new Response("Method not allowed", { status: 405 });
  const segments = url.pathname.split("/");
  const SAFE_SEGMENT = /^[A-Za-z0-9_-]+$/;
  const serviceName = segments[3];
  const procedure = segments[4];
  const service =
    serviceName && SAFE_SEGMENT.test(serviceName) ? services.get(serviceName) : undefined;
  if (!service || !procedure || !SAFE_SEGMENT.test(procedure) || segments.length !== 5) {
    return json({ ok: false, code: "RPC_UNKNOWN", message: "Unknown procedure", retryable: false });
  }
  let payload: unknown;
  try {
    payload = await req.json();
  } catch {
    return json({ ok: false, code: "RPC_INVALID", message: "Invalid input", retryable: false });
  }
  return json(
    await service.invoke(procedure, payload, req.headers.get(RPC_IDENTITY_HEADER) ?? undefined),
  );
}