import type { Metadata } from 'next';
import Link from 'next/link';
import { RailFilters } from '@/components/changes/rail-filters';
import { TerminalLayout } from '@/components/layout/terminal';
import { ActiveFilters } from '@/components/listing/filters';
import { BreadcrumbLd } from '@/components/meta/breadcrumb-ld';
import { Chip, EntityBadge } from '@/components/ui/badges';
import { DataTable, EmptyRow, Td, Th } from '@/components/ui/data-table';
import { EntityLink } from '@/components/ui/entity';
import { Hint } from '@/components/ui/hint';
import { Pagination, withParams } from '@/components/ui/pagination';
import { Container, Note, PageHeader } from '@/components/ui/section';
import { EmptyState, Unavailable } from '@/components/ui/unavailable';
import { api, safe } from '@/lib/api';
import { fmtDate, fmtInt } from '@/lib/format';
import { routes, SITE_NAME } from '@/lib/site';
import type { EntityDetail, EntitySummary } from '@/lib/types';

export const metadata: Metadata = { title: 'AI research papers — authors, models introduced, datasets, benchmarks', description: 'Research papers in the atlas with their authors, publication dates, arXiv categories and the models, datasets and benchmarks they are linked to — as stated by model cards and paper metadata.', alternates: { canonical: '/papers' } };
export const revalidate = 300;

type SP = Record<string, string | undefined>;
const LIMIT = 25;
const KEYS = ['q', 'category', 'org', 'since', 'until', 'sort', 'offset'] as const;
const SORTS = [
  { value: 'published', label: 'Recently published' },
  { value: 'updated', label: 'Recently updated' },
  { value: 'name', label: 'Title' },
];

function str(v: unknown): string | null {
  return typeof v === 'string' && v.trim() ? v : null;
}
function list(v: unknown): string[] {
  return Array.isArray(v) ? v.filter((x) => x !== null && x !== undefined).map(String) : [];
}
type Linked = { models: EntitySummary[]; datasets: EntitySummary[]; benchmarks: EntitySummary[]; code: EntitySummary[] };
function linked(d: EntityDetail | null): Linked {
  const out: Linked = { models: [], datasets: [], benchmarks: [], code: [] };
  if (!d) return out;
  const seen = new Set<string>();
  for (const g of d.relations ?? [])
    for (const it of g.items) {
      if (seen.has(it.id)) continue;
      seen.add(it.id);
      if (it.entity_type === 'model' || it.entity_type === 'artifact') out.models.push(it);
      else if (it.entity_type === 'dataset') out.datasets.push(it);
      else if (it.entity_type === 'benchmark') out.benchmarks.push(it);
      else if (['repository', 'framework', 'library'].includes(it.entity_type)) out.code.push(it);
    }
  return out;
}

export default async function PapersPage({ searchParams }: { searchParams: Promise<SP> }) {
  const sp = await searchParams;
  const current: Record<string, string | undefined> = {};
  for (const k of KEYS) if (sp[k]) current[k] = sp[k];
  const offset = Math.max(0, Number(current.offset) || 0);
  const sort = current.sort ?? 'published';
  const [page, orgs] = await Promise.all([safe(api.papers({ ...current, sort, limit: LIMIT, offset })), safe(api.companies({ limit: 40, sort: 'models' }))]);
  // "Introduces" needs each paper's relations: fetch the page's details in parallel (local API, ISR-cached).
  const details = page ? await Promise.all(page.items.map((p) => safe(api.entity(p.slug)))) : [];
  const href = (patch: Record<string, string | number | undefined | null>) => withParams('/papers', current, patch);
  const cats = new Map<string, number>();
  for (const p of page?.items ?? []) for (const c of list(p.attributes?.categories)) cats.set(c, (cats.get(c) ?? 0) + 1);
  const activeCount = Object.keys(current).filter((k) => !['sort', 'offset'].includes(k)).length;

  const filters = (
    <RailFilters
      action="/papers"
      resetHref={routes.papers()}
      testId="papers"
      fields={[
        { kind: 'text', name: 'q', label: 'Title contains', value: current.q, placeholder: 'e.g. mixture of experts' },
        { kind: 'text', name: 'category', label: 'arXiv category', value: current.category, placeholder: 'cs.CL, cs.LG…', list: [...cats.keys()].sort() },
        { kind: 'select', name: 'org', label: 'Organization', value: current.org, remote: 'companies', options: (orgs?.items ?? []).filter((o) => o.slug === current.org).map((o) => ({ value: o.slug, label: o.name })), note: 'Stated publisher only — arXiv metadata carries no affiliation.' },
        { kind: 'row', fields: [{ kind: 'date', name: 'since', label: 'Since', value: current.since }, { kind: 'date', name: 'until', label: 'Until', value: current.until }] },
        { kind: 'select', name: 'sort', label: 'Sort', value: sort, any: SORTS[0]!.label, options: SORTS.slice(1) },
      ]}
    />
  );
  const inspector = (
    <div className="space-y-4 text-sm">
      <div>
        <p className="eyebrow mb-1.5">Categories on this page</p>
        {cats.size === 0 ? (
          <p className="text-xs text-ink-3">—</p>
        ) : (
          <ul className="flex flex-wrap gap-1">
            {[...cats.entries()]
              .sort((a, b) => b[1] - a[1])
              .slice(0, 16)
              .map(([c, n]) => (
                <li key={c}>
                  <Link href={href({ category: c, offset: undefined })} className="inline-flex h-7 items-center gap-1 border border-rule px-1.5 text-xs text-ink-2 hover:border-rule-strong hover:text-ink">
                    <span className="mono">{c}</span> <span className="tnum text-ink-3">{n}</span>
                  </Link>
                </li>
              ))}
          </ul>
        )}
      </div>
      <p className="text-xs text-ink-3">
        “Introduces” lists the models whose cards cite the paper (<span className="mono">described_by</span>). Author names link to researcher pages when a record exists. <Link href={`/graph?mode=research`} className="link">Research graph →</Link>
      </p>
    </div>
  );

  return (
    <>
      <Container wide>
        <BreadcrumbLd items={[{ name: SITE_NAME, href: '/' }, { name: 'Research', href: '/papers' }]} />
        <PageHeader eyebrow="Research" title="Papers" lede="Publications linked to models, labs and benchmarks. Authors, venues and abstracts come from arXiv and publisher pages; model links come from model cards citing the paper." aside={page ? <p className="tnum text-sm text-ink-3">{fmtInt(page.total)} papers</p> : undefined} className="pb-3">
          <ActiveFilters current={current} labels={{ q: 'title', category: 'category', org: 'organization', since: 'since', until: 'until' }} makeHref={(p) => href(p)} className="mt-3" />
        </PageHeader>
      </Container>
      <div className="pb-16">
        <TerminalLayout filters={filters} inspector={inspector} filtersTitle="Filters" inspectorTitle="Context" storageKey="aia-papers-inspector" filterCount={activeCount}>
          {!page ? (
            <Unavailable what="Papers" />
          ) : page.items.length === 0 ? (
            <EmptyState title="No papers match">Try another title, category or organization.</EmptyState>
          ) : (
            <>
              <DataTable caption="Papers" compact scroll>
                <thead>
                  <tr>
                    <Th>Title</Th>
                    <Th>Authors</Th>
                    <Th>Organization</Th>
                    <Th>Published</Th>
                    <Th>
                      Introduces <Hint text="Models (and artifacts) whose model card or documentation cites this paper — inbound described_by relations." />
                    </Th>
                    <Th>Datasets</Th>
                    <Th>Benchmarks</Th>
                    <Th>Code</Th>
                  </tr>
                </thead>
                <tbody>
                  {page.items.length === 0 && <EmptyRow cols={8}>No rows.</EmptyRow>}
                  {page.items.map((e, i) => {
                    const a = e.attributes ?? {};
                    const authors = list(a.authors);
                    const l = linked(details[i] ?? null);
                    const code = str(a.code_url);
                    const primary = str(a.primary_category);
                    return (
                      <tr key={e.id}>
                        <Td primary>
                          <EntityLink e={e} />
                          <span className="mt-0.5 flex flex-wrap items-center gap-1">
                            {str(a.arxiv_id) && <span className="mono text-[11px] text-ink-3">arXiv:{str(a.arxiv_id)}</span>}
                            {primary && (
                              <Link href={href({ category: primary, offset: undefined })}>
                                <Chip tone="accent" className="mono">{primary}</Chip>
                              </Link>
                            )}
                          </span>
                        </Td>
                        <Td label="Authors" className="max-w-[18rem] text-sm text-ink-2">
                          {authors.length ? (
                            <>
                              {authors.slice(0, 3).join(', ')}
                              {authors.length > 3 && <span className="tnum text-ink-3"> +{authors.length - 3}</span>}
                            </>
                          ) : (
                            <span className="text-ink-3">—</span>
                          )}
                        </Td>
                        <Td label="Organization" className="text-ink-2">
                          {e.organization ? (
                            <Link href={routes.entity({ entity_type: 'company', slug: e.organization.slug })} className="hover:text-accent">
                              {e.organization.name}
                            </Link>
                          ) : str(a.venue) ? (
                            <span className="text-xs">{str(a.venue)}</span>
                          ) : (
                            <span className="text-ink-3">—</span>
                          )}
                        </Td>
                        <Td label="Published" className="tnum whitespace-nowrap text-ink-2">{str(a.published_at) ? fmtDate(str(a.published_at)) : <span className="text-ink-3">—</span>}</Td>
                        <Td label="Introduces">
                          {l.models.length ? (
                            <span className="flex flex-wrap gap-x-2 gap-y-0.5 text-sm">
                              {l.models.slice(0, 3).map((m) => (
                                <span key={m.id} className="inline-flex items-center gap-1">
                                  <EntityBadge type={m.entity_type} small />
                                  <EntityLink e={m} />
                                </span>
                              ))}
                              {l.models.length > 3 && <span className="tnum text-xs text-ink-3">+{l.models.length - 3}</span>}
                            </span>
                          ) : details[i] === null ? (
                            <span className="text-ink-3">unavailable</span>
                          ) : (
                            <span className="text-ink-3">—</span>
                          )}
                        </Td>
                        <Td label="Datasets" className="text-sm">{l.datasets.length ? l.datasets.slice(0, 2).map((x) => <EntityLink key={x.id} e={x} className="mr-2" />) : <span className="text-ink-3">—</span>}</Td>
                        <Td label="Benchmarks" className="text-sm">{l.benchmarks.length ? l.benchmarks.slice(0, 2).map((x) => <EntityLink key={x.id} e={x} className="mr-2" />) : <span className="text-ink-3">—</span>}</Td>
                        <Td label="Code" className="text-sm">
                          {l.code.length ? (
                            l.code.slice(0, 2).map((x) => <EntityLink key={x.id} e={x} className="mr-2" />)
                          ) : code ? (
                            <a href={code} target="_blank" rel="noopener noreferrer" className="link text-xs">
                              {code.replace(/^https?:\/\/(www\.)?/, '').slice(0, 32)}
                            </a>
                          ) : (
                            <span className="text-ink-3">—</span>
                          )}
                        </Td>
                      </tr>
                    );
                  })}
                </tbody>
              </DataTable>
              <Pagination total={page.total} limit={LIMIT} offset={offset} makeHref={(o) => href({ offset: o || undefined })} className="mt-4" />
              <Note className="mt-3">Author lists and categories are copied from the paper's own metadata (arXiv, publisher). Linked models, datasets, benchmarks and code come from stated relations only; a dash means no source stated one.</Note>
            </>
          )}
        </TerminalLayout>
      </div>
    </>
  );
}