import { env } from "cloudflare:workers";
import type { ReactNode } from "react";
import { featurePage } from "~/lib/marketing/features";
import { accountCardVersion, featureCardVersion, OG_PREFIX, repoCardVersion, siteCardVersion } from "~/lib/og";
import { enforceRateLimit, requestIp } from "../limits";
import { loadRepo } from "../repos";
import { AccountCard, FeatureCard, RepoCard, SiteCard } from "./cards";
import { accountCardData, avatarDataUri, repoCardData, repoCardVisible } from "./data";

/** Versioned URLs change whenever the card would, so they can sit in caches for two weeks. */
export const OG_VERSIONED_CACHE = "public, max-age=1209600";
/** Unversioned or stale URLs, and the generic card every hidden target gets, revalidate hourly. */
export const OG_FALLBACK_CACHE = "public, max-age=3600";
const CACHE_NAME = "og-cards";

type Card = { key: string; version: string; render: () => Promise<ReactNode> };

function host(): string {
  return new URL(env.PUBLIC_URL).host;
}

function siteCard(): Card {
  return { key: "site", version: siteCardVersion(), render: async () => <SiteCard host={host()} /> };
}

function decode(segment: string): string | null {
  try {
    return decodeURIComponent(segment);
  } catch {
    return null;
  }
}

/**
 * Resolves the card for a path, or null for the generic card. Every lookup reads only public data and never the
 * session, and every refusal (private, hidden, taken down, missing, malformed) collapses to the same null.
 */
async function resolveCard(pathname: string): Promise<Card | null> {
  const rest = pathname.slice(OG_PREFIX.length);
  if (!rest.endsWith(".png")) return null;
  const parts = rest.slice(0, -".png".length).split("/").map(decode);
  if (parts.some((part) => !part)) return null;
  const segments = parts as string[];
  if (segments.length === 1 && segments[0] === "site") return siteCard();
  if (segments.length === 2 && segments[0] === "feature") {
    const page = featurePage(segments[1]);
    if (!page) return null;
    return {
      key: `feature/${page.slug}`,
      version: featureCardVersion(page.slug, page.title, page.lede),
      render: async () => <FeatureCard title={page.title} lede={page.lede} slug={page.slug} host={host()} />,
    };
  }
  if (segments.length === 1) {
    const account = await accountCardData(segments[0]);
    if (!account) return null;
    return {
      key: `account/${account.name.toLowerCase()}`,
      version: accountCardVersion(account),
      render: async () => (
        <AccountCard account={account} avatar={await avatarDataUri(account.avatarKey)} host={host()} />
      ),
    };
  }
  if (segments.length === 2) {
    const row = await loadRepo(segments[0], segments[1]);
    if (!row || !repoCardVisible(row)) return null;
    const repo = await repoCardData(row);
    return {
      key: `repo/${row.id}`,
      version: repoCardVersion(repo),
      render: async () => <RepoCard repo={repo} avatar={await avatarDataUri(repo.avatarKey)} host={host()} />,
    };
  }
  return null;
}

/** Cached by content version per colo; only misses render, and misses are rate limited per client. */
async function cardBytes(request: Request, url: URL, card: Card, ctx: ExecutionContext): Promise<ArrayBuffer> {
  const cache = await caches.open(CACHE_NAME);
  const cacheKey = new Request(`${url.origin}/og/__cache/${card.key}/${card.version}.png`);
  const hit = await cache.match(cacheKey);
  if (hit) return hit.arrayBuffer();
  await enforceRateLimit("HEAVY_LIMITER", `og:${requestIp(request)}`);
  // Loaded on first miss so satori and the wasm modules stay out of every other request's startup.
  const [{ renderPng }, { loadRuntime }] = await Promise.all([import("./render"), import("./runtime")]);
  const png = await renderPng(await card.render(), loadRuntime());
  const bytes = png.buffer.slice(png.byteOffset, png.byteOffset + png.byteLength) as ArrayBuffer;
  const stored = new Response(bytes.slice(0), {
    headers: { "content-type": "image/png", "cache-control": OG_VERSIONED_CACHE },
  });
  ctx.waitUntil(cache.put(cacheKey, stored));
  return bytes;
}

export async function handleOgRoutes(request: Request, url: URL, ctx: ExecutionContext): Promise<Response | null> {
  if (!url.pathname.startsWith(OG_PREFIX)) return null;
  if (request.method !== "GET" && request.method !== "HEAD") {
    return new Response("Method not allowed\n", { status: 405, headers: { allow: "GET, HEAD" } });
  }
  const resolved = await resolveCard(url.pathname);
  const card = resolved ?? siteCard();
  const versioned = resolved !== null && url.searchParams.get("v") === card.version;
  const bytes = await cardBytes(request, url, card, ctx);
  return new Response(request.method === "HEAD" ? null : bytes, {
    headers: {
      "content-type": "image/png",
      "content-length": String(bytes.byteLength),
      "cache-control": versioned ? OG_VERSIONED_CACHE : OG_FALLBACK_CACHE,
      "x-content-type-options": "nosniff",
    },
  });
}