"use client";
import { useMemo, useState, type FormEvent } from "react";
import { Plus, RefreshCw, RotateCcw, XCircle } from "lucide-react";
import { api, type Dataset, type HealthReport, type Job } from "@/lib/api";
import { useAsync, useInterval } from "@/lib/hooks";
import { useToast } from "@/lib/toast";
import { useAuth } from "@/lib/auth";
import { daysAgo, fmtDuration, fmtInt, fmtTs, splitList, today } from "@/lib/format";
import { Banner, Card, Empty, ErrorState, Field, PageHeader, StatusBadge } from "@/components/ui";
import { DataTable } from "@/components/DataTable";
import { JsonView } from "@/components/JsonView";
import { ConfirmDialog, Modal } from "@/components/ConfirmDialog";

const KINDS = ["incremental", "metadata", "backfill", "fundamentals", "derive", "compaction", "quality", "backup", "gc"] as const;
type Kind = (typeof KINDS)[number];
const STATUSES = ["", "queued", "running", "succeeded", "failed", "dead", "cancelled"];

const KIND_HELP: Record<Kind, string> = {
  incremental: "Fetch the vendor's latest day or week of bars and append (idempotent).",
  metadata: "Refresh the instrument master, corporate actions and vendor checkpoints.",
  backfill: "Full-history download for a ticker range (first letter). Heavy on disk and bandwidth.",
  fundamentals: "Ingest point-in-time fundamentals for the given tickers (or the tracked list).",
  derive: "Rebuild derived datasets (5m / 1d) from 1-minute bars.",
  compaction: "Merge delta files into base files and publish a new dataset version.",
  quality: "Run the quality checks and record anomalies.",
  backup: "pg_dump + rsync of the lake metadata to the backup target.",
  gc: "Garbage-collect retired files and expired exports.",
};

export default function IngestionPage() {
  const { isOwner } = useAuth();
  const toast = useToast();
  const [status, setStatus] = useState("");
  const [kind, setKind] = useState("");
  const jobs = useAsync((s) => api.get<{ data: Job[] }>("/admin/jobs", { status, kind, limit: 300 }, s), [status, kind], { enabled: isOwner });
  const dead = useAsync((s) => api.get<{ data: Job[] }>("/admin/jobs", { status: "dead", limit: 100 }, s), [], { enabled: isOwner });
  const failed = useAsync((s) => api.get<{ data: Job[] }>("/admin/jobs", { status: "failed", limit: 100 }, s), [], { enabled: isOwner });
  const datasets = useAsync((s) => api.get<{ data: Dataset[] }>("/catalog/datasets", undefined, s), []);
  const health = useAsync((s) => api.get<HealthReport>("/health", undefined, s), []);
  const [inspect, setInspect] = useState<Job | null>(null);
  const [showForm, setShowForm] = useState(false);

  const reloadAll = () => {
    jobs.reload();
    dead.reload();
    failed.reload();
  };
  const hasLive = (jobs.data?.data ?? []).some((j) => j.status === "queued" || j.status === "running");
  useInterval(reloadAll, hasLive ? 5000 : 30000);

  async function act(j: Job, action: "retry" | "cancel") {
    try {
      await api.post(`/admin/jobs/${j.id}/${action}`);
      toast.success(`Job ${action === "retry" ? "re-queued" : "cancelled"}`, j.id);
      reloadAll();
    } catch (e) {
      toast.error(e);
    }
  }

  const counts = useMemo(() => {
    const m: Record<string, number> = {};
    for (const j of jobs.data?.data ?? []) m[j.status] = (m[j.status] ?? 0) + 1;
    return m;
  }, [jobs.data]);

  if (!isOwner) return <Banner tone="warn">Ingestion controls require the owner role.</Banner>;

  const columns = [
    { key: "kind", header: "Kind", render: (j: Job) => <span className="font-medium">{j.kind}</span> },
    { key: "dataset_id", header: "Dataset", mono: true, hideSm: true, render: (j: Job) => <span className="font-mono text-xs">{j.dataset_id ?? "—"}</span> },
    { key: "status", header: "Status", render: (j: Job) => <StatusBadge status={j.status} /> },
    { key: "attempts", header: "Att.", num: true, hideSm: true, render: (j: Job) => `${j.attempts ?? 0}/${j.max_attempts ?? "—"}` },
    { key: "created_at", header: "Created", hideSm: true, render: (j: Job) => <span className="tnum text-xs">{fmtTs(j.created_at)}</span> },
    { key: "duration", header: "Duration", render: (j: Job) => <span className="tnum text-xs">{j.started_at ? fmtDuration(j.started_at, j.finished_at) : "—"}</span> },
    { key: "progress", header: "Progress", render: (j: Job) => (j.progress ? <JsonView value={j.progress} collapsed /> : <span className="text-ink-3">—</span>) },
    { key: "last_error", header: "Error", render: (j: Job) => (j.last_error ? <span className="line-clamp-2 text-xs text-crit-ink">{j.last_error}</span> : <span className="text-ink-3">—</span>) },
    {
      key: "actions",
      header: "",
      render: (j: Job) => (
        <div className="flex gap-1" onClick={(e) => e.stopPropagation()}>
          {(j.status === "failed" || j.status === "dead" || j.status === "cancelled") && (
            <button className="btn btn-sm" onClick={() => void act(j, "retry")} title="Retry">
              <RotateCcw className="h-3.5 w-3.5" /> Retry
            </button>
          )}
          {j.status === "queued" && (
            <button className="btn btn-sm" onClick={() => void act(j, "cancel")} title="Cancel">
              <XCircle className="h-3.5 w-3.5" /> Cancel
            </button>
          )}
        </div>
      ),
    },
  ];

  return (
    <>
      <PageHeader
        title="Ingestion"
        subtitle={<>Job queue · {Object.entries(counts).map(([k, v]) => `${k} ${v}`).join(" · ") || "no jobs"} · refresh every {hasLive ? 5 : 30} s</>}
        actions={
          <>
            <button className="btn btn-sm" onClick={reloadAll}>
              <RefreshCw className="h-3.5 w-3.5" /> Refresh
            </button>
            <button className="btn btn-sm btn-primary" onClick={() => setShowForm(true)}>
              <Plus className="h-3.5 w-3.5" /> Enqueue job
            </button>
          </>
        }
      />

      {health.data?.components.ingest_worker && health.data.components.ingest_worker !== "running" && (
        <Banner tone="crit" className="mb-4">
          The ingest worker is <strong>{health.data.components.ingest_worker}</strong> — queued jobs will not start until it holds the lake lock.
        </Banner>
      )}

      {(dead.data?.data.length ?? 0) + (failed.data?.data.length ?? 0) > 0 && (
        <Card title={`Dead-letter & failed (${(dead.data?.data.length ?? 0) + (failed.data?.data.length ?? 0)})`} className="mb-4 border-crit/40">
          <DataTable rows={[...(dead.data?.data ?? []), ...(failed.data?.data ?? [])]} rowKey={(j) => j.id} mobile="scroll" columns={columns} onRowClick={setInspect} />
        </Card>
      )}

      <Card
        title="Jobs"
        actions={
          <div className="flex gap-2">
            <select className="input w-auto py-1 text-xs" value={status} onChange={(e) => setStatus(e.target.value)} aria-label="Status filter">
              {STATUSES.map((s) => (
                <option key={s} value={s}>
                  {s || "any status"}
                </option>
              ))}
            </select>
            <select className="input w-auto py-1 text-xs" value={kind} onChange={(e) => setKind(e.target.value)} aria-label="Kind filter">
              <option value="">any kind</option>
              {KINDS.map((k) => (
                <option key={k} value={k}>
                  {k}
                </option>
              ))}
            </select>
          </div>
        }
      >
        {jobs.error && <ErrorState error={jobs.error} retry={jobs.reload} />}
        <DataTable rows={jobs.data?.data} loading={jobs.loading} rowKey={(j) => j.id} mobile="scroll" columns={columns} onRowClick={setInspect} empty="No jobs match." footer={<span>{fmtInt(jobs.data?.data.length ?? 0)} jobs (max 300)</span>} />
      </Card>

      <Modal open={!!inspect} title={inspect ? `${inspect.kind} · ${inspect.id}` : ""} onClose={() => setInspect(null)} wide>
        {inspect && (
          <div className="grid gap-3 md:grid-cols-2">
            <div className="md:col-span-2 flex flex-wrap items-center gap-2 text-sm">
              <StatusBadge status={inspect.status} />
              <span className="font-mono text-xs">{inspect.dataset_id}</span>
              <span className="text-xs text-ink-3">priority {inspect.priority} · attempts {inspect.attempts}/{inspect.max_attempts} · by {inspect.created_by ?? "—"}</span>
            </div>
            <div className="text-xs">
              <div className="text-ink-3">created</div>
              {fmtTs(inspect.created_at)}
              <div className="mt-1 text-ink-3">started</div>
              {fmtTs(inspect.started_at)}
              <div className="mt-1 text-ink-3">finished</div>
              {fmtTs(inspect.finished_at)}
              <div className="mt-1 text-ink-3">next run</div>
              {fmtTs(inspect.next_run_at)}
            </div>
            <div>
              <div className="mb-1 text-xs text-ink-3">params</div>
              <JsonView value={inspect.params ?? {}} />
            </div>
            <div>
              <div className="mb-1 text-xs text-ink-3">progress</div>
              <JsonView value={inspect.progress ?? {}} />
            </div>
            <div>
              <div className="mb-1 text-xs text-ink-3">result</div>
              <JsonView value={inspect.result ?? {}} />
            </div>
            {inspect.last_error && (
              <div className="md:col-span-2">
                <div className="mb-1 text-xs text-ink-3">last_error</div>
                <pre className="overflow-auto rounded-md border border-crit/40 bg-crit-soft p-2 text-xs text-crit-ink whitespace-pre-wrap">{inspect.last_error}</pre>
              </div>
            )}
          </div>
        )}
      </Modal>

      <Modal open={showForm} title="Enqueue a job" onClose={() => setShowForm(false)}>
        <EnqueueForm
          datasets={datasets.data?.data ?? []}
          lake={health.data?.components.lake}
          onDone={() => {
            setShowForm(false);
            reloadAll();
          }}
        />
      </Modal>
    </>
  );
}

function EnqueueForm({ datasets, lake, onDone }: { datasets: Dataset[]; lake?: HealthReport["components"]["lake"]; onDone: () => void }) {
  const toast = useToast();
  const [kind, setKind] = useState<Kind>("incremental");
  const [datasetId, setDatasetId] = useState("market_bars.stock.1m.raw");
  const [period, setPeriod] = useState<"day" | "week">("day");
  const [letter, setLetter] = useState("A");
  const [tickers, setTickers] = useState("");
  const [start, setStart] = useState(daysAgo(30));
  const [end, setEnd] = useState(today());
  const [priority, setPriority] = useState(50);
  const [extra, setExtra] = useState("{}");
  const [confirm, setConfirm] = useState(false);
  const [busy, setBusy] = useState(false);

  const needsDataset = ["incremental", "backfill", "derive", "compaction", "quality"].includes(kind);

  function buildParams(): Record<string, unknown> {
    let base: Record<string, unknown> = {};
    try {
      base = extra.trim() ? (JSON.parse(extra) as Record<string, unknown>) : {};
    } catch {
      throw new Error("Extra params must be valid JSON");
    }
    if (kind === "incremental") base = { period, ...base };
    if (kind === "backfill") base = { ticker_range: letter.toUpperCase(), ...base };
    if (kind === "fundamentals") {
      const t = splitList(tickers);
      if (t.length) base = { tickers: t, ...base };
    }
    if (kind === "quality" || kind === "derive") base = { start, end, ...base };
    return base;
  }

  async function submit(e?: FormEvent) {
    e?.preventDefault();
    if (kind === "backfill" && !confirm) {
      setConfirm(true);
      return;
    }
    setBusy(true);
    try {
      const params = buildParams();
      const out = await api.post<{ id: string }>("/admin/jobs", { kind, dataset_id: needsDataset || kind === "fundamentals" ? datasetId || null : null, params, priority });
      toast.success("Job enqueued", `${kind} · ${out.id}`);
      onDone();
    } catch (err) {
      toast.error(err);
    } finally {
      setBusy(false);
      setConfirm(false);
    }
  }

  return (
    <form onSubmit={submit} className="flex flex-col gap-3">
      <Field label="Kind">
        <select className="input" value={kind} onChange={(e) => setKind(e.target.value as Kind)}>
          {KINDS.map((k) => (
            <option key={k} value={k}>
              {k}
            </option>
          ))}
        </select>
      </Field>
      <p className="text-xs text-ink-2">{KIND_HELP[kind]}</p>
      {needsDataset && (
        <Field label="Dataset">
          <select className="input font-mono text-xs" value={datasetId} onChange={(e) => setDatasetId(e.target.value)}>
            {!datasets.some((d) => d.id === datasetId) && <option value={datasetId}>{datasetId}</option>}
            {datasets.map((d) => (
              <option key={d.id} value={d.id}>
                {d.id}
              </option>
            ))}
          </select>
        </Field>
      )}
      {kind === "incremental" && (
        <Field label="Period">
          <select className="input" value={period} onChange={(e) => setPeriod(e.target.value as "day" | "week")}>
            <option value="day">latest day</option>
            <option value="week">latest week</option>
          </select>
        </Field>
      )}
      {kind === "backfill" && (
        <Field label="Ticker range (first letter)" hint="One letter A–Z or 0 (numeric tickers). One backfill per letter.">
          <select className="input" value={letter} onChange={(e) => setLetter(e.target.value)}>
            {"ABCDEFGHIJKLMNOPQRSTUVWXYZ0".split("").map((l) => (
              <option key={l} value={l}>
                {l}
              </option>
            ))}
          </select>
        </Field>
      )}
      {kind === "fundamentals" && (
        <Field label="Tickers" hint="Comma / newline separated. Leave empty to use the tracked list from Settings.">
          <textarea className="input min-h-20 font-mono uppercase" value={tickers} onChange={(e) => setTickers(e.target.value)} placeholder="AAPL, MSFT" />
        </Field>
      )}
      {(kind === "quality" || kind === "derive") && (
        <div className="grid grid-cols-2 gap-2">
          <Field label="Start">
            <input type="date" className="input" value={start} onChange={(e) => setStart(e.target.value)} />
          </Field>
          <Field label="End">
            <input type="date" className="input" value={end} onChange={(e) => setEnd(e.target.value)} />
          </Field>
        </div>
      )}
      <div className="grid grid-cols-2 gap-2">
        <Field label="Priority" hint="lower runs first (default 50)">
          <input type="number" className="input" min={1} max={100} value={priority} onChange={(e) => setPriority(Number(e.target.value) || 50)} />
        </Field>
        <Field label="Extra params (JSON)">
          <input className="input font-mono text-xs" value={extra} onChange={(e) => setExtra(e.target.value)} />
        </Field>
      </div>
      <div className="flex justify-end gap-2 pt-1">
        <button className="btn btn-primary" disabled={busy}>
          {busy ? "Enqueuing…" : kind === "backfill" ? "Review & enqueue" : "Enqueue"}
        </button>
      </div>
      <ConfirmDialog
        open={confirm}
        title={`Start backfill for tickers “${letter.toUpperCase()}…”?`}
        confirmLabel="Start backfill"
        danger
        busy={busy}
        onCancel={() => setConfirm(false)}
        onConfirm={() => void submit()}
      >
        <p>A backfill downloads the full 1-minute history for every ticker starting with <strong>{letter.toUpperCase()}</strong>. This can take hours and add tens of GB.</p>
        {lake && (
          <p className="mt-2 rounded-md border border-warn/50 bg-warn-soft p-2 text-xs text-warn-ink">
            Disk budget: <strong>{lake.free_gb} GB free</strong> · curated {lake.curated_gb} GB of a {lake.soft_limit_gb} GB soft limit · hard minimum {lake.hard_min_free_gb} GB free. The API refuses backfills under {(lake.hard_min_free_gb * 1.5).toFixed(0)} GB free.
          </p>
        )}
      </ConfirmDialog>
    </form>
  );
}