import "./lib/error-capture";

import { consumeLastCapturedError } from "./lib/error-capture";
import { renderErrorPage } from "./lib/error-page";
import { getDb } from "./lib/db";
import { isAllowedEmbedUrl } from "./lib/embed/ad-guard";
import {
  fetchProxied,
  isAllowedAssetProxy,
  rewriteGameHtml,
} from "./lib/embed/proxy";

type ServerEntry = {
  fetch: (request: Request, env: unknown, ctx: unknown) => Promise<Response> | Response;
};

let dbReady = false;

function ensureDb() {
  if (dbReady) return;
  getDb();
  dbReady = true;
  console.log("[bootstrap] database ready");
}

try {
  ensureDb();
} catch (error) {
  console.error("[bootstrap] database failed:", error);
}

let serverEntryPromise: Promise<ServerEntry> | undefined;

async function getServerEntry(): Promise<ServerEntry> {
  if (!serverEntryPromise) {
    serverEntryPromise = import("@tanstack/react-start/server-entry").then(
      (m) => (m.default ?? m) as ServerEntry,
    );
  }
  return serverEntryPromise;
}

// h3 swallows in-handler throws into a normal 500 Response with body
// {"unhandled":true,"message":"HTTPError"} — try/catch alone never fires for those.
async function normalizeCatastrophicSsrResponse(response: Response): Promise<Response> {
  if (response.status < 500) return response;
  const contentType = response.headers.get("content-type") ?? "";
  if (!contentType.includes("application/json")) return response;

  const body = await response.clone().text();
  if (!body.includes('"unhandled":true') || !body.includes('"message":"HTTPError"')) {
    return response;
  }

  const captured = consumeLastCapturedError();
  console.error(captured ?? new Error(`h3 swallowed SSR error: ${body}`));
  const detail = captured ? formatError(captured) : `h3 swallowed SSR error: ${body}`;
  return new Response(renderErrorPage(detail), {
    status: 500,
    headers: { "content-type": "text/html; charset=utf-8" },
  });
}

function formatError(error: unknown): string {
  if (error instanceof Error) return `${error.name}: ${error.message}\n${error.stack ?? ""}`;
  return String(error);
}

async function handleGameFrame(url: URL): Promise<Response> {
  const embedUrl = url.searchParams.get("u");
  if (!embedUrl || !isAllowedEmbedUrl(embedUrl)) {
    return new Response("Invalid embed URL", { status: 400 });
  }

  try {
    const upstream = await fetchProxied(embedUrl);
    if (!upstream.ok) {
      return new Response(`Upstream ${upstream.status}`, { status: upstream.status });
    }
    const contentType = upstream.headers.get("content-type") ?? "";
    if (!contentType.includes("text/html") && !contentType.includes("application/xhtml")) {
      const buf = await upstream.arrayBuffer();
      return new Response(buf, {
        status: upstream.status,
        headers: { "content-type": contentType || "application/octet-stream", "cache-control": "public, max-age=3600" },
      });
    }
    const html = await upstream.text();
    const body = rewriteGameHtml(html, embedUrl, embedUrl);
    return new Response(body, {
      status: 200,
      headers: {
        "content-type": "text/html; charset=utf-8",
        "cache-control": "public, max-age=300",
      },
    });
  } catch (error) {
    return new Response(formatError(error), { status: 502 });
  }
}

async function handleAssetProxy(url: URL): Promise<Response> {
  const assetUrl = url.searchParams.get("u");
  const embedRef = url.searchParams.get("ref");
  if (!assetUrl || !isAllowedAssetProxy(assetUrl, embedRef)) {
    return new Response("Forbidden", { status: 403 });
  }

  try {
    const upstream = await fetchProxied(assetUrl);
    const buf = await upstream.arrayBuffer();
    const type = upstream.headers.get("content-type") ?? "application/octet-stream";
    return new Response(buf, {
      status: upstream.ok ? 200 : upstream.status,
      headers: {
        "content-type": type,
        "cache-control": "public, max-age=86400",
        "access-control-allow-origin": "*",
      },
    });
  } catch (error) {
    return new Response(formatError(error), { status: 502 });
  }
}

export default {
  async fetch(request: Request, env: unknown, ctx: unknown) {
    const url = new URL(request.url);

    if (url.pathname === "/api/health") {
      try {
        ensureDb();
        const db = getDb();
        const games = db.prepare("SELECT COUNT(*) AS c FROM games").get() as { c: number };
        const siteGames = db.prepare("SELECT COUNT(*) AS c FROM site_games").get() as { c: number };
        return Response.json({ ok: true, games: games.c, siteGames: siteGames.c });
      } catch (error) {
        return Response.json({ ok: false, error: formatError(error) }, { status: 500 });
      }
    }

    if (url.pathname === "/api/game-frame") {
      return handleGameFrame(url);
    }

    if (url.pathname === "/api/asset") {
      return handleAssetProxy(url);
    }

    try {
      ensureDb();
      const handler = await getServerEntry();
      const response = await handler.fetch(request, env, ctx);
      return await normalizeCatastrophicSsrResponse(response);
    } catch (error) {
      console.error(error);
      return new Response(renderErrorPage(formatError(error)), {
        status: 500,
        headers: { "content-type": "text/html; charset=utf-8" },
      });
    }
  },
};