"use client";
import Link from "next/link";
import { RefreshCw } from "lucide-react";
import { api } from "@/lib/api";
import { useAsync, useInterval } from "@/lib/hooks";
import { fmtBytes, fmtCompact, fmtGB, fmtInt, fmtRelative } from "@/lib/format";
import { Card, ErrorState, KpiTile, PageHeader, Skeleton, StatusBadge } from "@/components/ui";
import { DataTable } from "@/components/DataTable";

export interface PublicOverviewData {
  generated_at: string;
  status: string | null;
  totals: { files: number; rows: number; bytes: number; datasets_active: number; dataset_versions: number; raw_archives: number; raw_bytes: number };
  families: { family: string; datasets: number; rows: number; bytes: number }[];
  datasets: { id: string; name: string; kind: string; asset_class: string | null; interval: string | null; adjustment: string | null; status: string; current_version: number; row_count: number | null; bytes: number | null; file_count: number | null }[];
  coverage: { dataset_id: string; symbols: number; first_session: string | null; last_session: string | null; bars: number | null }[];
  options: { underlyings: number | null; first_day: string | null; last_day: string | null; rows: number | null };
  fundamentals: { entities: number; facts: number; first_period: string | null; last_period: string | null; earnings_events: number };
  instruments: { n: number; active: number; delisted: number };
  freshness: { vendor_last_update: string | null; last_successful_job: string | null; jobs_24h: Record<string, number> };
  storage: { hot_free_gb: number | null; cold_free_gb: number | null; curated_gb: number | null; raw_gb: number | null };
  backup: { last: string | null; verified: boolean | null };
  license: string;
}

const FAMILY_LABEL: Record<string, string> = {
  "market_bars.stock": "US stocks",
  "market_bars.etf": "US ETFs",
  "options.eod": "Options (EOD chains)",
  "market_bars.futures": "Futures (continuous)",
  "market_bars.futures_contracts": "Futures (contracts)",
  "market_bars.fx": "FX",
  "market_bars.crypto": "Crypto",
  "market_bars.index": "Indices",
};

export function PublicOverview({ signedIn }: { signedIn: boolean }) {
  const { data, error, loading, reload } = useAsync((signal) => api.get<PublicOverviewData>("/public/overview", undefined, signal), []);
  useInterval(reload, 120_000);
  const stocks = data?.coverage.find((c) => c.dataset_id === "market_bars.stock.1m.raw");
  const etfs = data?.coverage.find((c) => c.dataset_id === "market_bars.etf.1m.raw");
  const indices = data?.coverage.find((c) => c.dataset_id === "market_bars.index.1m.raw");
  const jobs = data?.freshness.jobs_24h ?? {};

  return (
    <>
      <PageHeader
        title="FinData OS — the lake at a glance"
        subtitle={data ? <>Catalog figures refreshed {fmtRelative(data.generated_at)} · public metrics only, data access requires sign-in</> : "Research-grade market data lakehouse (FirstRate Data, private use)"}
        actions={
          <>
            {data?.status && <StatusBadge status={data.status} label={data.status === "ok" ? "all systems ok" : data.status} />}
            <button className="btn btn-sm" onClick={reload} disabled={loading}>
              <RefreshCw className={loading ? "h-3.5 w-3.5 animate-spin" : "h-3.5 w-3.5"} /> Refresh
            </button>
            {!signedIn && (
              <Link href="/login/" className="btn btn-primary btn-sm">
                Sign in
              </Link>
            )}
          </>
        }
      />

      {error && <ErrorState error={error} retry={reload} />}
      {!data && !error && <Skeleton rows={6} />}

      {data && (
        <>
          <div className="mb-4 grid grid-cols-2 gap-3 md:grid-cols-3 xl:grid-cols-6">
            <KpiTile label="Rows in the lake" value={fmtCompact(data.totals.rows)} sub={fmtInt(data.totals.rows)} />
            <KpiTile label="Curated Parquet" value={fmtBytes(data.totals.bytes, 0)} sub={`${fmtInt(data.totals.files)} files · ${fmtInt(data.totals.datasets_active)} active datasets`} href={signedIn ? "/datasets/" : undefined} />
            <KpiTile label="Stocks (1-min)" value={fmtInt(stocks?.symbols)} sub={stocks ? `${stocks.first_session} → ${stocks.last_session}` : "—"} href={signedIn ? "/symbols/" : undefined} />
            <KpiTile label="ETFs (1-min)" value={fmtInt(etfs?.symbols)} sub={etfs ? `${etfs.first_session} → ${etfs.last_session}` : "—"} />
            <KpiTile label="Option underlyings" value={fmtInt(data.options.underlyings)} sub={data.options.first_day ? `${fmtCompact(data.options.rows)} rows · ${data.options.first_day} → ${data.options.last_day}` : "—"} />
            <KpiTile label="Fundamentals" value={fmtInt(data.fundamentals.entities)} sub={`${fmtCompact(data.fundamentals.facts)} PIT facts · ${fmtCompact(data.fundamentals.earnings_events)} earnings`} href={signedIn ? "/fundamentals/" : undefined} />
            <KpiTile label="Indices (1-min)" value={fmtInt(indices?.symbols)} sub={indices ? `${indices.first_session} → ${indices.last_session}` : "—"} />
            <KpiTile label="Instruments" value={fmtInt(data.instruments.n)} sub={`${fmtInt(data.instruments.active)} active · ${fmtInt(data.instruments.delisted)} delisted`} />
            <KpiTile label="Vendor last update" value={data.freshness.vendor_last_update ?? "—"} sub={data.freshness.last_successful_job ? `last job ${fmtRelative(data.freshness.last_successful_job)}` : undefined} />
            <KpiTile label="Jobs (24 h)" value={`${fmtInt(jobs.succeeded ?? 0)} ok`} sub={`${fmtInt(jobs.queued ?? 0)} queued · ${fmtInt(jobs.running ?? 0)} running · ${fmtInt(jobs.dead ?? 0)} dead`} tone={jobs.dead ? "crit" : undefined} />
            <KpiTile label="Raw archives kept" value={fmtBytes(data.totals.raw_bytes, 0)} sub={`${fmtInt(data.totals.raw_archives)} vendor archives (sha256 recorded)`} />
            <KpiTile
              label="Free space"
              value={data.storage.hot_free_gb !== null ? fmtGB(data.storage.hot_free_gb, 0) : "—"}
              sub={data.storage.cold_free_gb !== null ? `internal · external ${fmtGB(data.storage.cold_free_gb, 0)}` : "internal SSD"}
            />
          </div>

          <div className="grid gap-4 lg:grid-cols-[1fr_minmax(280px,0.7fr)]">
            <Card title="Data families">
              <DataTable
                rows={data.families}
                rowKey={(r) => r.family}
                mobile="scroll"
                columns={[
                  { key: "family", header: "Family", render: (r) => <span className="font-medium">{FAMILY_LABEL[r.family] ?? r.family}</span> },
                  { key: "datasets", header: "Datasets", render: (r) => <span className="tnum">{fmtInt(r.datasets)}</span> },
                  { key: "rows", header: "Rows", render: (r) => <span className="tnum">{fmtInt(r.rows)}</span> },
                  { key: "bytes", header: "Size", render: (r) => <span className="tnum">{fmtBytes(r.bytes, 1)}</span> },
                ]}
              />
            </Card>
            <Card title="Platform">
              <ul className="flex flex-col gap-2 text-sm">
                <li className="flex items-center justify-between gap-2">
                  <span>Status</span>
                  <StatusBadge status={data.status} label={data.status ?? "unknown"} />
                </li>
                <li className="flex items-center justify-between gap-2">
                  <span>Dataset versions published</span>
                  <span className="tnum">{fmtInt(data.totals.dataset_versions)}</span>
                </li>
                <li className="flex items-center justify-between gap-2">
                  <span>Fundamentals periods</span>
                  <span className="tnum text-xs">{data.fundamentals.first_period ?? "—"} → {data.fundamentals.last_period ?? "—"}</span>
                </li>
                <li className="flex items-center justify-between gap-2">
                  <span>Last backup</span>
                  <span className="text-right text-xs">
                    {data.backup.last ? (
                      <>
                        <StatusBadge status={data.backup.verified ? "verified" : "warning"} label={data.backup.verified ? "verified" : "unverified"} />{" "}
                        <span className="text-ink-2">{fmtRelative(data.backup.last)}</span>
                      </>
                    ) : (
                      <StatusBadge status="warning" label="none yet" />
                    )}
                  </span>
                </li>
              </ul>
              <p className="mt-4 text-xs text-ink-2">{data.license}</p>
              <p className="mt-2 text-xs text-ink-2">
                API reference: <a className="text-accent-ink hover:underline" href="/api/docs">/api/docs</a> · <Link className="text-accent-ink hover:underline" href="/docs/">Documentation</Link>
              </p>
            </Card>
          </div>

          <Card title="Datasets" className="mt-4">
            <DataTable
              rows={data.datasets.filter((d) => d.status === "active" && (d.row_count ?? 0) > 0)}
              rowKey={(r) => r.id}
              mobile="scroll"
              columns={[
                { key: "id", header: "Dataset", mono: true, render: (r) => (signedIn ? <Link href={`/datasets/detail/?id=${encodeURIComponent(r.id)}`} className="text-accent-ink hover:underline">{r.id}</Link> : r.id) },
                { key: "asset_class", header: "Asset", hideSm: true, render: (r) => r.asset_class ?? "—" },
                { key: "interval", header: "Interval", hideSm: true, render: (r) => r.interval ?? "—" },
                { key: "adjustment", header: "Adjustment", hideSm: true, render: (r) => r.adjustment ?? "—" },
                { key: "row_count", header: "Rows", render: (r) => <span className="tnum">{fmtInt(r.row_count)}</span> },
                { key: "bytes", header: "Size", render: (r) => <span className="tnum">{fmtBytes(r.bytes, 1)}</span> },
                { key: "current_version", header: "Version", hideSm: true, render: (r) => <span className="tnum">v{r.current_version}</span> },
              ]}
            />
          </Card>
        </>
      )}
    </>
  );
}