"use client";

import { Play } from "lucide-react";
import { useState } from "react";
import { Button } from "@/components/ui";
import type { ConnectorHealthDTO } from "@/lib/admin-api";
import { Checkbox, Field, Input, Select } from "./primitives";
import { useToast } from "./toast";
import { useAdminMutation } from "./use-admin-query";

export type RunTask = "crawl" | "discover" | "full" | "reprocess";

/** Inline "run connector" form: task, group, limit, force → POST connectors/:id/run. */
export function RunForm({ connector, onDone, compact }: { connector: Pick<ConnectorHealthDTO, "id" | "schedule">; onDone?: () => void; compact?: boolean }) {
  const [task, setTask] = useState<RunTask>("crawl");
  const [group, setGroup] = useState("");
  const [limit, setLimit] = useState("");
  const [force, setForce] = useState(false);
  const { busy, run } = useAdminMutation();
  const toast = useToast();
  const groups = Object.keys(connector.schedule ?? {});
  const submit = async () => {
    const body: Record<string, unknown> = { task };
    if (group) body.group = group;
    if (limit && Number(limit) > 0) body.limit = Math.floor(Number(limit));
    if (force) body.force = true;
    const r = await run<{ enqueued: boolean; job?: { id?: string; name?: string } }>("run", `connectors/${encodeURIComponent(connector.id)}/run`, { body });
    if (r.ok) {
      toast({ tone: "ok", title: `Run enqueued · ${connector.id}`, description: `task ${task}${group ? ` · group ${group}` : ""}${r.data.job?.id ? ` · job ${r.data.job.id}` : ""}` });
      onDone?.();
    } else toast({ tone: "danger", title: "Run failed to enqueue", description: r.error });
  };
  return (
    <div className={compact ? "grid grid-cols-2 gap-2 sm:grid-cols-[140px_1fr_110px_auto_auto] sm:items-end" : "grid gap-2 sm:grid-cols-[160px_1fr_120px_auto_auto] sm:items-end"}>
      <Field label="Task">
        <Select value={task} onChange={(e) => setTask(e.target.value as RunTask)}>
          <option value="crawl">crawl — due pages</option>
          <option value="discover">discover — sitemap / RSS / seeds</option>
          <option value="full">full — discover + crawl</option>
          <option value="reprocess">reprocess — re-extract stored bodies</option>
        </Select>
      </Field>
      <Field label="Group" hint={groups.length ? `schedule groups: ${groups.join(", ")}` : undefined}>
        <Input list={`groups-${connector.id}`} value={group} onChange={(e) => setGroup(e.target.value)} placeholder="all groups" mono />
        {groups.length > 0 && (
          <datalist id={`groups-${connector.id}`}>
            {groups.map((g) => (
              <option key={g} value={g} />
            ))}
          </datalist>
        )}
      </Field>
      <Field label="Limit">
        <Input type="number" min={1} max={100000} value={limit} onChange={(e) => setLimit(e.target.value)} placeholder="∞" mono />
      </Field>
      <Checkbox label="force" checked={force} onChange={(e) => setForce(e.target.checked)} />
      <Button variant="accent" size="md" onClick={() => void submit()} disabled={busy === "run"}>
        <Play className="size-3.5" strokeWidth={2} />
        Run
      </Button>
    </div>
  );
}

/** Inline schedule editor: one interval per group → PATCH connectors/:id/schedule. */
export function ScheduleEditor({ connector, onSaved }: { connector: Pick<ConnectorHealthDTO, "id" | "schedule">; onSaved?: (schedule: Record<string, string>) => void }) {
  const [rows, setRows] = useState<Array<{ group: string; interval: string }>>(() => Object.entries(connector.schedule ?? {}).map(([group, interval]) => ({ group, interval })));
  const [error, setError] = useState<string | null>(null);
  const { busy, run } = useAdminMutation();
  const toast = useToast();
  const save = async () => {
    const body: Record<string, string> = {};
    for (const r of rows) {
      if (!r.group.trim()) continue;
      if (!/^[a-z0-9_*-]+$/i.test(r.group.trim())) return setError(`bad group name "${r.group}"`);
      if (!/^(hourly|daily|weekly|biweekly|monthly|quarterly|never|\d+\s*(m|min|h|d|w))$/i.test(r.interval.trim())) return setError(`bad interval for ${r.group}: "${r.interval}" (daily, weekly, 12h, 30m…)`);
      body[r.group.trim()] = r.interval.trim().toLowerCase();
    }
    if (!Object.keys(body).length) return setError("nothing to save");
    setError(null);
    const r = await run<{ id: string; schedule: Record<string, string>; file: { updated: boolean; error?: string; backup: string | null } }>("schedule", `connectors/${encodeURIComponent(connector.id)}/schedule`, { method: "PATCH", body });
    if (r.ok) {
      toast({ tone: r.data.file.updated ? "ok" : "warn", title: "Schedule saved", description: r.data.file.updated ? `YAML updated${r.data.file.backup ? " (backup kept)" : ""}` : `DB updated; YAML not updated: ${r.data.file.error ?? "unknown"}` });
      onSaved?.(r.data.schedule);
    } else {
      setError(r.error);
      toast({ tone: "danger", title: "Schedule not saved", description: r.error });
    }
  };
  return (
    <div className="space-y-2">
      <div className="grid gap-2 sm:grid-cols-2 lg:grid-cols-3">
        {rows.map((r, i) => (
          <div key={i} className="flex items-end gap-2">
            <Field label="Group" className="flex-1">
              <Input value={r.group} onChange={(e) => setRows((p) => p.map((x, j) => (j === i ? { ...x, group: e.target.value } : x)))} mono />
            </Field>
            <Field label="Interval" className="w-[120px]">
              <Input list="dci-intervals" value={r.interval} onChange={(e) => setRows((p) => p.map((x, j) => (j === i ? { ...x, interval: e.target.value } : x)))} mono />
            </Field>
            <Button size="md" variant="ghost" aria-label="Remove group" onClick={() => setRows((p) => p.filter((_, j) => j !== i))}>
              ×
            </Button>
          </div>
        ))}
      </div>
      <datalist id="dci-intervals">
        {["hourly", "3h", "6h", "12h", "daily", "weekly", "biweekly", "monthly", "quarterly", "never"].map((v) => (
          <option key={v} value={v} />
        ))}
      </datalist>
      {error && <p className="text-[12px] text-danger">{error}</p>}
      <div className="flex flex-wrap gap-2">
        <Button size="sm" variant="ghost" onClick={() => setRows((p) => [...p, { group: "", interval: "weekly" }])}>
          + group
        </Button>
        <Button size="sm" variant="primary" onClick={() => void save()} disabled={busy === "schedule"}>
          Save schedule
        </Button>
        <span className="self-center text-[11.5px] text-ink-4">Intervals: hourly, daily, weekly, biweekly, monthly, quarterly, never, or 30m / 12h / 3d / 2w. Writes the DB row and the YAML file (backup kept).</span>
      </div>
    </div>
  );
}

/** Pause / resume toggle → POST connectors/:id/pause|resume. */
export function PauseResumeButton({ connector, onChanged, size = "xs" }: { connector: Pick<ConnectorHealthDTO, "id" | "health">; onChanged?: (paused: boolean) => void; size?: "xs" | "sm" }) {
  const { busy, run } = useAdminMutation();
  const toast = useToast();
  const paused = connector.health === "paused";
  const toggle = async () => {
    const action = paused ? "resume" : "pause";
    const r = await run<{ id: string; paused: boolean; health: string }>(action, `connectors/${encodeURIComponent(connector.id)}/${action}`, { body: {} });
    if (r.ok) {
      toast({ tone: "ok", title: `${connector.id} ${r.data.paused ? "paused" : "resumed"}` });
      onChanged?.(r.data.paused);
    } else toast({ tone: "danger", title: `Could not ${action}`, description: r.error });
  };
  return (
    <Button size={size} variant={paused ? "secondary" : "ghost"} onClick={() => void toggle()} disabled={busy !== null}>
      {paused ? "Resume" : "Pause"}
    </Button>
  );
}