// ---------------------------------------------------------------------------
// Pure passthrough proxies — dispatched from the Worker entry, before Start.
// ---------------------------------------------------------------------------
//
// `/docs` and the PostHog proxy forward to an external origin and never touch
// the router, React, or the Effect app. They lived in Start's request
// middleware, which meant each one still paid Start's lazy `loadEntries`
// import of the whole server graph before it could forward a request.
//
// Measured on production (2026-08-18), splitting the two costs apart on a cold
// isolate: the graph import is p50 **3.1s** while the request's own work is
// p50 **33ms**. And essentially every request is cold — `worker.dispatch` ran
// 1,666 requests across 1,608 isolates (1.04 req/isolate), because `/mcp`
// dispatches before `fetchHandler` and so never warms the graph. A `/docs`
// page took 3-6s through the Worker against 0.098s straight from the upstream.
//
// So these move to the Worker entry, exactly as marketing did: classify and
// forward before anything imports Start. This module therefore must NOT import
// `@tanstack/react-start` or any app module — that import is the cost it
// exists to avoid.
//
// The middleware wrappers in `./docs` and `./posthog` stay registered. In the
// deployed Worker they become unreachable (server.ts answers first), but they
// keep the behavior identical on any host that reaches Start by another entry
// (local dev), and they source their matching from here so the two can't drift.
// ---------------------------------------------------------------------------

import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";

const DOCS_UPSTREAM_HOST = "executor.mintlify.dev";
const POSTHOG_INGEST_HOST = "us.i.posthog.com";
const POSTHOG_ASSETS_HOST = "us-assets.i.posthog.com";

export const POSTHOG_PROXY_PATH = `/api/${(
  import.meta.env.VITE_PUBLIC_ANALYTICS_PATH ?? "a"
).replace(/^\/+|\/+$/g, "")}`;

// The proxy fetch gets its own client span: `/docs` requests otherwise render
// as a single opaque server span, and during the Aug 2026 regression there
// was no way to tell upstream (Mintlify/Vercel) latency from worker-side
// dispatch cost. The noop tracer applies when no provider is installed
// (local dev without AXIOM_TOKEN), so this is free there.
const tracer = trace.getTracer("executor-cloud-docs-proxy");

export const isDocsPath = (pathname: string): boolean =>
  pathname === "/docs" || pathname.startsWith("/docs/");

export const isPosthogPath = (pathname: string): boolean =>
  pathname === POSTHOG_PROXY_PATH || pathname.startsWith(`${POSTHOG_PROXY_PATH}/`);

/**
 * Build the upstream request for an already-classified `/docs` path. Caller
 * guarantees `isDocsPath(pathname)` — we only swap the origin and fix up the
 * forwarding headers, preserving method, body, path, and query.
 */
export const buildDocsUpstream = (request: Request): Request => {
  const url = new URL(request.url);
  const forwardedHost = url.host;

  url.hostname = DOCS_UPSTREAM_HOST;
  url.protocol = "https:";
  url.port = "";

  const upstream = new Request(url, request);
  // Mintlify keys canonical links off the public host; tell it the real one.
  upstream.headers.set("X-Forwarded-Host", forwardedHost);
  upstream.headers.set("X-Forwarded-Proto", "https");
  // Never leak the executor.sh session cookie to the docs origin.
  upstream.headers.delete("cookie");
  return upstream;
};

/** Build the upstream request for an already-classified PostHog proxy path. */
export const buildPosthogUpstream = (request: Request, pathname: string): Request => {
  const url = new URL(request.url);
  url.hostname = pathname.startsWith(`${POSTHOG_PROXY_PATH}/static/`)
    ? POSTHOG_ASSETS_HOST
    : POSTHOG_INGEST_HOST;
  url.protocol = "https:";
  url.port = "";
  url.pathname = pathname.slice(POSTHOG_PROXY_PATH.length) || "/";

  const upstream = new Request(url, request);
  upstream.headers.delete("cookie");
  return upstream;
};

export const docsProxyResponse = (request: Request, pathname: string): Promise<Response> =>
  tracer.startActiveSpan(
    `http.client ${request.method}`,
    {
      kind: SpanKind.CLIENT,
      attributes: {
        "server.address": DOCS_UPSTREAM_HOST,
        "url.path": pathname,
        "http.request.method": request.method,
      },
    },
    async (span) => {
      // oxlint-disable-next-line executor/no-try-catch-or-throw -- adapter boundary; observe upstream response/error for span status, then pass both through unchanged
      try {
        const response = await fetch(buildDocsUpstream(request));
        span.setAttribute("http.response.status_code", response.status);
        if (response.status >= 500) {
          span.setStatus({ code: SpanStatusCode.ERROR, message: `HTTP ${response.status}` });
        }
        return response;
      } catch (err) {
        // oxlint-disable-next-line executor/no-instanceof-error, executor/no-unknown-error-message -- adapter boundary: fetch rejects untyped; normalized only for the OTel span record, the original error is rethrown below
        const cause = err instanceof Error ? err : String(err);
        span.recordException(cause);
        // oxlint-disable-next-line executor/no-unknown-error-message -- adapter boundary: same normalization as the recordException line above
        const message = typeof cause === "string" ? cause : cause.message;
        span.setStatus({ code: SpanStatusCode.ERROR, message });
        // oxlint-disable-next-line executor/no-try-catch-or-throw -- adapter boundary; preserve the original rejection for the platform handler
        throw err;
      } finally {
        span.end();
      }
    },
  );

/**
 * Answer a pure passthrough request without loading the Start server graph.
 * Returns `null` when the request belongs to the app, so the caller falls
 * through to normal dispatch.
 */
export const passthroughResponse = (
  request: Request,
  pathname: string,
): Promise<Response> | null => {
  if (isDocsPath(pathname)) return docsProxyResponse(request, pathname);
  if (isPosthogPath(pathname)) return fetch(buildPosthogUpstream(request, pathname));
  return null;
};