import type { Metadata } from 'next';
import Link from 'next/link';
import { ResolutionPair } from '@/components/admin/resolution-pair';
import { AdminFilters, AdminTitle, Mono, Notice } from '@/components/admin/ui';
import { DataTable, EmptyRow, Td, Th } from '@/components/ui/data-table';
import { Pagination, withParams } from '@/components/ui/pagination';
import { Note } from '@/components/ui/section';
import { EmptyState, Unavailable } from '@/components/ui/unavailable';
import { adminApi, load, requireAdmin } from '@/lib/admin/admin-api';
import { fmtDateTime, fmtInt, fmtPct, num } from '@/lib/format';
import { routes } from '@/lib/site';

export const metadata: Metadata = { title: 'Entity resolution', robots: { index: false, follow: false } };
export const dynamic = 'force-dynamic';

const LIMIT = 20;
const TYPES = ['model', 'company', 'organization', 'lab', 'paper', 'benchmark', 'provider', 'hardware', 'framework', 'dataset'];

export default async function EntityResolutionPage({ searchParams }: { searchParams: Promise<Record<string, string | undefined>> }) {
  await requireAdmin();
  const sp = await searchParams;
  const current: Record<string, string | undefined> = { type: sp.type ?? 'model', status: sp.status ?? 'pending' };
  if (sp.threshold) current.threshold = sp.threshold;
  if (sp.offset) current.offset = sp.offset;
  const offset = Math.max(0, Number(current.offset) || 0);
  const href = (patch: Record<string, string | number | undefined | null>) => withParams('/admin/entity-resolution', current, patch);
  const ret = href({});
  const [res, decided] = await Promise.all([load(adminApi.entityResolution({ type: current.type, status: current.status, threshold: current.threshold, limit: LIMIT, offset })), current.status === 'decided' ? Promise.resolve(null) : load(adminApi.entityResolution({ type: current.type, status: 'decided', limit: 10 }))]);
  return (
    <>
      <AdminTitle title="Entity resolution" count={res.ok ? fmtInt(res.data.total) : undefined} lede="Candidate pairs side by side. Nothing is merged until you decide; decisions persist (resolution_decisions) and are applied by the API: merge, alias, variant-of, family member — or keep separate / defer.">
        <Link href="/admin/quality" className="text-xs text-ink-3 hover:text-ink">
          Data quality →
        </Link>
      </AdminTitle>
      <Notice notice={sp.notice} level={sp.level} />
      <AdminFilters
        action="/admin/entity-resolution"
        className="mb-4"
        fields={[
          { kind: 'select', name: 'type', label: 'Entity type', value: current.type, any: 'model', options: TYPES.map((t) => ({ value: t, label: t })) },
          { kind: 'select', name: 'status', label: 'Status', value: current.status, any: 'pending', options: ['pending', 'decided', 'all'].map((s) => ({ value: s, label: s })) },
          { kind: 'select', name: 'threshold', label: 'Similarity ≥', value: current.threshold, any: '0.8 (default)', options: ['0.6', '0.7', '0.8', '0.9', '0.95'].map((v) => ({ value: v, label: v })) },
        ]}
      />
      {!res.ok ? (
        <Unavailable what="Entity resolution" reason={res.error} />
      ) : res.data.items.length === 0 ? (
        <EmptyState title="No candidate pairs">{current.status === 'pending' ? 'Nothing above the similarity threshold awaits a decision for this type.' : 'No decided pairs for this type yet.'}</EmptyState>
      ) : (
        <>
          <p className="mb-3 text-xs text-ink-3">
            Threshold {fmtPct((num(res.data.threshold) ?? 0) * 100, 0)} · signals: review queue, trigram similarity, shared variant key. {res.data.note}
          </p>
          <ul className="space-y-6" data-resolution-list>
            {res.data.items.map((it) => (
              <li key={`${it.a.id}-${it.b.id}`}>
                <ResolutionPair item={it} decisions={res.data.decisions} returnTo={ret} />
              </li>
            ))}
          </ul>
          <Pagination total={res.data.total} limit={LIMIT} offset={offset} makeHref={(o) => href({ offset: o || undefined })} className="mt-4" />
        </>
      )}
      {decided && decided.ok && (
        <section className="mt-10">
          <h2 className="text-base font-semibold tracking-tight">
            Decision history <span className="tnum text-sm font-normal text-ink-3">{fmtInt(decided.data.total)}</span>
          </h2>
          <Note className="mb-3 mt-1">Latest decided pairs for this type (persisted in resolution_decisions; every POST is also in the audit log).</Note>
          <DataTable compact scroll caption="Decision history">
            <thead>
              <tr>
                <Th>A</Th>
                <Th>B</Th>
                <Th>Decision</Th>
                <Th>Note</Th>
                <Th>Decided</Th>
              </tr>
            </thead>
            <tbody>
              {decided.data.items.length === 0 && <EmptyRow cols={5}>No decision recorded yet.</EmptyRow>}
              {decided.data.items.map((it) => {
                const d = (typeof it.decision === 'string' ? { decision: it.decision } : it.decision) as { decision: string; note?: string | null; decided_at?: string | null; applied?: boolean } | null;
                return (
                  <tr key={`${it.a.id}-${it.b.id}`}>
                    <Td primary>
                      <Link href={routes.entity(it.a)} className="text-ink hover:text-accent">
                        {it.a.name}
                      </Link>{' '}
                      <Mono>{it.a.slug}</Mono>
                    </Td>
                    <Td>
                      <Link href={routes.entity(it.b)} className="text-ink hover:text-accent">
                        {it.b.name}
                      </Link>{' '}
                      <Mono>{it.b.slug}</Mono>
                    </Td>
                    <Td>
                      <Mono>{d?.decision ?? '—'}</Mono>
                      {d && 'applied' in d && d.applied !== undefined && <span className="ml-1 text-[11px] text-ink-3">{d.applied ? 'applied' : 'recorded'}</span>}
                    </Td>
                    <Td className="text-xs text-ink-2">{d && typeof d.note === 'string' ? d.note : '—'}</Td>
                    <Td className="tnum text-xs text-ink-3">{d && typeof d.decided_at === 'string' ? fmtDateTime(d.decided_at) : '—'}</Td>
                  </tr>
                );
              })}
            </tbody>
          </DataTable>
          <p className="mt-2 text-xs">
            <Link href={href({ status: 'decided', offset: undefined })} className="link">
              All decided pairs →
            </Link>{' '}
            · <Link href="/admin/audit?action=entity-resolution" className="link">Audit log →</Link>
          </p>
        </section>
      )}
    </>
  );
}