import Link from "next/link";
import { requireAdmin } from "@/lib/session";
import { getRoutingAnalytics, parseRange, rangeLabel } from "@/lib/queries/admin";
import { formatBytes, formatMs, formatNumber, formatPercent, formatUsd } from "@/lib/format";
import { PageHeader } from "@/components/ui/page-header";
import { Table, TableBody, TableCell, TableEmpty, TableHead, TableHeader, TableRow } from "@/components/ui/table";
import { NetworkBadge, Panel, ProviderBadge, RangeTabs, numCell } from "@/components/admin/primitives";
import { ProviderSeriesChart } from "@/components/admin/charts";

export const dynamic = "force-dynamic";

/** Mirrors SCORE_WEIGHTS in packages/routing/src/engine.ts (kept in sync by hand; web does not depend on @fetcha/routing). */
const WEIGHTS: Array<{ key: string; weight: number; what: string; how: string }> = [
  { key: "success", weight: 35, what: "Historical success on this domain × route", how: "Bayesian-smoothed toward the network prior (datacenter 70 %, isp 85 %, residential 93 %, mobile 95 %) with 5 pseudo-observations, so new routes are not punished." },
  { key: "cost", weight: 20, what: "Cost efficiency", how: "1 − price_per_gb / $15. Cheaper networks score higher; the ceiling is the most expensive class." },
  { key: "latency", weight: 15, what: "Observed latency", how: "300 ms → 1.0, 5 s → 0, linear. Uses route stats when present, else 500 ms (datacenter) / 1 200 ms (others)." },
  { key: "health", weight: 15, what: "Provider health", how: "Circuit-breaker health factor for the route key (recent failure window)." },
  { key: "geo", weight: 10, what: "Geography match", how: "1 when the provider supports the requested country (or no country requested), 0 otherwise." },
  { key: "session", weight: 5, what: "Session stability", how: "1 unless a sticky session is required and the provider cannot honour it (direct)." },
];

export default async function AdminRoutingPage({ searchParams }: { searchParams: Promise<Record<string, string | string[] | undefined>> }) {
  await requireAdmin();
  const sp = await searchParams;
  const range = parseRange(sp.range);
  const a = await getRoutingAnalytics(range);
  const totals = a.matrix.reduce((acc, r) => ({ requests: acc.requests + r.requests, successes: acc.successes + r.successes, cost: acc.cost + r.cost }), { requests: 0, successes: 0, cost: 0 });

  return (
    <>
      <PageHeader eyebrow="Intelligence" title="Routing" description={`${rangeLabel(range)} · hourly routing_metrics aggregated by provider × network.`} actions={<RangeTabs current={range} basePath="/admin/routing" />} />

      <Panel title="Provider × network" description={`${formatNumber(totals.requests)} routed attempts · ${formatPercent(totals.requests ? (totals.successes / totals.requests) * 100 : null)} success · ${formatUsd(totals.cost, true)} upstream`} flush>
        <Table>
          <TableHeader>
            <TableRow>
              <TableHead>Provider</TableHead>
              <TableHead>Network</TableHead>
              <TableHead className="text-right">Requests</TableHead>
              <TableHead className="text-right">Successes</TableHead>
              <TableHead className="text-right">Success</TableHead>
              <TableHead className="text-right">Blocked</TableHead>
              <TableHead className="text-right">Errors</TableHead>
              <TableHead className="text-right">Avg latency</TableHead>
              <TableHead className="text-right">GB</TableHead>
              <TableHead className="text-right">Cost</TableHead>
              <TableHead className="text-right">Cost / success</TableHead>
            </TableRow>
          </TableHeader>
          <TableBody>
            {a.matrix.length === 0 ? (
              <TableEmpty colSpan={11}>No routing metrics in this range. Metrics are written hourly by the API as attempts complete.</TableEmpty>
            ) : (
              a.matrix.map((r) => (
                <TableRow key={`${r.provider}:${r.network}`}>
                  <TableCell>
                    <ProviderBadge id={r.provider} />
                  </TableCell>
                  <TableCell>
                    <NetworkBadge network={r.network} />
                  </TableCell>
                  <TableCell className={numCell}>{formatNumber(r.requests)}</TableCell>
                  <TableCell className={numCell}>{formatNumber(r.successes)}</TableCell>
                  <TableCell className={numCell}>{formatPercent(r.successRate)}</TableCell>
                  <TableCell className={numCell}>{formatNumber(r.blocked)}</TableCell>
                  <TableCell className={numCell}>{formatNumber(r.errors)}</TableCell>
                  <TableCell className={numCell}>{formatMs(r.avgLatency)}</TableCell>
                  <TableCell className={numCell}>{formatBytes(r.bytes)}</TableCell>
                  <TableCell className={numCell}>{formatUsd(r.cost, true)}</TableCell>
                  <TableCell className={`${numCell} font-semibold`}>{formatUsd(r.costPerSuccess, true)}</TableCell>
                </TableRow>
              ))
            )}
          </TableBody>
        </Table>
      </Panel>

      <div className="mt-6 grid gap-6 xl:grid-cols-2">
        <Panel title="Requests over time per provider" bodyClassName="p-2 pt-3">
          <ProviderSeriesChart data={a.series} providers={a.providers} unit={a.unit as "hour" | "day"} metric="requests" />
        </Panel>
        <Panel title="Upstream cost over time per provider" bodyClassName="p-2 pt-3">
          <ProviderSeriesChart data={a.series} providers={a.providers} unit={a.unit as "hour" | "day"} metric="cost" />
        </Panel>
      </div>

      <Panel title="How the routing score works" description="Each candidate route (provider × network) gets a weighted score in [0, 1]. Weights mirror packages/routing/src/engine.ts." flush className="mt-6">
        <Table>
          <TableHeader>
            <TableRow>
              <TableHead>Factor</TableHead>
              <TableHead className="text-right">Weight</TableHead>
              <TableHead>Measures</TableHead>
              <TableHead>Computation</TableHead>
            </TableRow>
          </TableHeader>
          <TableBody>
            {WEIGHTS.map((w) => (
              <TableRow key={w.key}>
                <TableCell className="font-mono text-[12.5px]">{w.key}</TableCell>
                <TableCell className={numCell}>{w.weight} %</TableCell>
                <TableCell>{w.what}</TableCell>
                <TableCell className="max-w-[520px] text-[12.5px] text-fg-muted">{w.how}</TableCell>
              </TableRow>
            ))}
          </TableBody>
        </Table>
        <div className="grid gap-4 border-t border-border p-4 text-[13px] leading-relaxed text-fg-muted lg:grid-cols-3">
          <div>
            <h3 className="mb-1 font-semibold text-fg">Auto escalation</h3>
            <p>
              For <code className="font-mono text-[12px]">network: &quot;auto&quot;</code> candidates are grouped by class in the order datacenter → isp → residential → mobile (limited to the plan&apos;s networks), then sorted by score inside each class. A class is skipped
              entirely for a domain once its route stats show ≥ 5 attempts with &gt; 60 % blocks (residential is never skipped). Providers are de-duplicated so retries alternate upstreams before repeating one.
            </p>
          </div>
          <div>
            <h3 className="mb-1 font-semibold text-fg">Domain profiles</h3>
            <p>
              <Link href="/admin/domains" className="text-accent hover:underline">
                domain_profiles.route_stats
              </Link>{" "}
              feed the success and latency factors per route key. The admin <em>policy</em> can pin an explicit route order (wins over score, still bounded by circuit state) or force a network for auto requests. Explicit customer network choices are never overridden.
            </p>
          </div>
          <div>
            <h3 className="mb-1 font-semibold text-fg">Circuit breakers</h3>
            <p>
              Each route key has a breaker. An open circuit removes the route from the candidate list entirely; a half-open one lets a trickle through. The breaker&apos;s recent failure ratio is also the 15 % health factor, so a degrading route loses score before it is cut off.
              Reset circuits from <Link href="/admin/providers" className="text-accent hover:underline">Providers</Link>.
            </p>
          </div>
        </div>
      </Panel>
    </>
  );
}