"use client";

import { useState } from "react";
import { AlertTriangle, CheckCircle2, RefreshCw, RotateCcw, XCircle } from "lucide-react";
import { toast } from "sonner";
import { useRepositories } from "@/di/repository-provider";
import { useApiQuery } from "@/presentation/hooks/use-api-query";
import { useApiMutation } from "@/presentation/hooks/use-api-mutation";
import { useT } from "@/shared/i18n/client";
import { Badge } from "@/presentation/components/ui/badge";
import { Button } from "@/presentation/components/ui/button";
import { Input } from "@/presentation/components/ui/input";
import { Tabs, TabsList, TabsTrigger } from "@/presentation/components/ui/tabs";
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/presentation/components/ui/table";
import type { DonnaBindingProposal, DonnaBindingProposalStatus } from "@/domain/entities/donna";

type StatusFilter = DonnaBindingProposalStatus | "all";

const STATUS_STYLE: Record<DonnaBindingProposalStatus, string> = {
  pending: "bg-amber-100 text-amber-800 hover:bg-amber-100",
  confirmed: "bg-green-100 text-green-700 hover:bg-green-100",
  rejected: "bg-red-100 text-red-700 hover:bg-red-100",
};

/** The auditor's binding against the platform's data catalog: what it lacks, and the fields the auditor proposes.
 *  The admin confirms (after correcting the tool, field or rows key if need be), rejects or reopens each proposal. */
export default function DonnaBindingsTab() {
  const t = useT();
  const b = t.donnaBindings;
  const repo = useRepositories().donnaRepository;
  const [status, setStatus] = useState<StatusFilter>("pending");
  const [edits, setEdits] = useState<Record<number, { tool: string; field: string; rows_key: string }>>({});

  const { data, loading, refetch } = useApiQuery(() => repo.getBindings(status === "all" ? undefined : status), { deps: [status] });
  const refresh = useApiMutation(() => repo.refreshBindings(), { onSuccess: () => { toast.success(b.toasts.refreshed); void refetch(); } });
  const decide = useApiMutation(
    (input: { id: number; decision: "confirm" | "reject" | "pending" }) => {
      const edit = edits[input.id];
      return repo.decideBindingProposal(input.id, { decision: input.decision, ...(edit ? { tool: edit.tool, field: edit.field, rows_key: edit.rows_key } : {}) });
    },
    { onSuccess: () => void refetch() }
  );

  const edited = (proposal: DonnaBindingProposal) => edits[proposal.id] ?? { tool: proposal.tool, field: proposal.field, rows_key: proposal.rows_key ?? "" };
  const change = (proposal: DonnaBindingProposal, key: "tool" | "field" | "rows_key", value: string) => setEdits((all) => ({ ...all, [proposal.id]: { ...edited(proposal), [key]: value } }));
  const act = async (proposal: DonnaBindingProposal, decision: "confirm" | "reject" | "pending") => {
    const saved = await decide.mutate({ id: proposal.id, decision });
    if (saved) toast.success(b.toasts[decision]);
  };

  const proposals = data?.proposals ?? [];
  const problems = data?.validation.problems ?? [];

  return (
    <div className="space-y-4">
      <div className="flex flex-wrap items-center gap-3">
        <Tabs value={status} onValueChange={(value) => setStatus(value as StatusFilter)}>
          <TabsList>
            {(["pending", "confirmed", "rejected", "all"] as const).map((value) => (
              <TabsTrigger key={value} value={value}>
                {b.status[value]}
                {value === "pending" && (data?.counts.pending ?? 0) > 0 && <span className="ml-1.5 rounded-full bg-amber-500 px-1.5 text-xs font-semibold text-white">{data?.counts.pending}</span>}
              </TabsTrigger>
            ))}
          </TabsList>
        </Tabs>
        <div className="flex-1" />
        {data && <span className="text-sm text-muted-foreground">{b.platform} {data.platform} · {b.catalogVersion} {data.catalog_version ?? "—"}</span>}
        <Button size="sm" variant="outline" disabled={refresh.loading} onClick={() => void refresh.mutate(undefined)}>
          <RefreshCw className="mr-1 h-4 w-4" />{b.actions.refresh}
        </Button>
      </div>

      {data && (
        <div className="grid gap-3 md:grid-cols-3">
          <Summary title={b.summary.unboundGroups} items={data.unbound_groups} empty={b.summary.none} />
          <Summary title={b.summary.unavailable} items={data.validation.unavailable} empty={b.summary.none} />
          <Summary title={b.summary.unverified} items={data.validation.unverified} empty={b.summary.none} muted />
        </div>
      )}

      {problems.length > 0 && (
        <div className="rounded-md border">
          <p className="flex items-center gap-2 px-4 py-2 text-sm font-semibold"><AlertTriangle className="h-4 w-4 text-amber-600" />{b.problems.title}</p>
          <Table>
            <TableHeader>
              <TableRow>
                <TableHead>{b.problems.group}</TableHead>
                <TableHead>{b.problems.concept}</TableHead>
                <TableHead>{b.problems.kind}</TableHead>
                <TableHead>{b.problems.detail}</TableHead>
              </TableRow>
            </TableHeader>
            <TableBody>
              {problems.map((problem, index) => (
                <TableRow key={index}>
                  <TableCell className="font-mono text-xs">{problem.group}</TableCell>
                  <TableCell className="font-mono text-xs">{problem.concept ?? "—"}</TableCell>
                  <TableCell className="text-xs">{(b.problemKinds as Record<string, string>)[problem.kind] ?? problem.kind}</TableCell>
                  <TableCell className="text-xs text-muted-foreground">{problem.detail}</TableCell>
                </TableRow>
              ))}
            </TableBody>
          </Table>
        </div>
      )}

      <div className="rounded-md border">
        <Table>
          <TableHeader>
            <TableRow>
              <TableHead>{b.columns.concept}</TableHead>
              <TableHead>{b.columns.tool}</TableHead>
              <TableHead>{b.columns.field}</TableHead>
              <TableHead>{b.columns.rowsKey}</TableHead>
              <TableHead>{b.columns.confidence}</TableHead>
              <TableHead>{b.columns.reason}</TableHead>
              <TableHead>{b.columns.status}</TableHead>
              <TableHead />
            </TableRow>
          </TableHeader>
          <TableBody>
            {loading && proposals.length === 0 ? (
              <TableRow><TableCell colSpan={8} className="py-10 text-center text-muted-foreground">…</TableCell></TableRow>
            ) : proposals.length === 0 ? (
              <TableRow><TableCell colSpan={8} className="py-10 text-center text-muted-foreground">{b.empty}</TableCell></TableRow>
            ) : (
              proposals.map((proposal) => {
                const value = edited(proposal);
                const editable = proposal.status === "pending";
                return (
                  <TableRow key={proposal.id}>
                    <TableCell className="font-mono text-xs">{proposal.concept}</TableCell>
                    <TableCell>{editable ? <Input className="h-8 font-mono text-xs" value={value.tool} onChange={(e) => change(proposal, "tool", e.target.value)} /> : <span className="font-mono text-xs">{proposal.tool}</span>}</TableCell>
                    <TableCell>{editable ? <Input className="h-8 font-mono text-xs" value={value.field} onChange={(e) => change(proposal, "field", e.target.value)} /> : <span className="font-mono text-xs">{proposal.field}</span>}</TableCell>
                    <TableCell>{editable ? <Input className="h-8 font-mono text-xs" placeholder={b.columns.rowsKeyHint} value={value.rows_key} onChange={(e) => change(proposal, "rows_key", e.target.value)} /> : <span className="font-mono text-xs">{proposal.rows_key ?? "—"}</span>}</TableCell>
                    <TableCell><Badge variant={proposal.confidence >= 0.85 ? "default" : "secondary"}>{Math.round(proposal.confidence * 100)} %</Badge></TableCell>
                    <TableCell><p className="line-clamp-2 max-w-xs text-xs text-muted-foreground">{proposal.reason}</p></TableCell>
                    <TableCell><Badge className={STATUS_STYLE[proposal.status]}>{b.statusOne[proposal.status]}</Badge></TableCell>
                    <TableCell>
                      <div className="flex gap-1">
                        {proposal.status !== "confirmed" && (
                          <Button size="sm" className="bg-green-600 hover:bg-green-700" disabled={decide.loading || !value.tool.trim() || !value.field.trim()} onClick={() => act(proposal, "confirm")} title={b.actions.confirm}>
                            <CheckCircle2 className="h-4 w-4" />
                          </Button>
                        )}
                        {proposal.status !== "rejected" && (
                          <Button size="sm" variant="outline" className="text-red-600" disabled={decide.loading} onClick={() => act(proposal, "reject")} title={b.actions.reject}>
                            <XCircle className="h-4 w-4" />
                          </Button>
                        )}
                        {proposal.status !== "pending" && (
                          <Button size="sm" variant="outline" disabled={decide.loading} onClick={() => act(proposal, "pending")} title={b.actions.reopen}>
                            <RotateCcw className="h-4 w-4" />
                          </Button>
                        )}
                      </div>
                    </TableCell>
                  </TableRow>
                );
              })
            )}
          </TableBody>
        </Table>
      </div>
      <p className="text-xs text-muted-foreground">{b.hint}</p>
    </div>
  );
}

function Summary({ title, items, empty, muted }: { title: string; items: string[]; empty: string; muted?: boolean }) {
  return (
    <div className="rounded-md border p-3">
      <p className="text-sm font-semibold">{title} <span className="text-muted-foreground">({items.length})</span></p>
      <p className={`mt-1 line-clamp-3 font-mono text-xs ${muted ? "text-muted-foreground" : ""}`}>{items.length ? items.join(", ") : empty}</p>
    </div>
  );
}
