import type { Metadata } from 'next';
import Link from 'next/link';
import { CompareTrayBar } from '@/components/compare/compare-tray-bar';
import { type Current, MODEL_PARAM_KEYS, MODEL_SORTS, ModelsFilterRail, modelsHref, UnderstoodChips } from '@/components/models/models-filters';
import { ModelsTable, ModelsTerminal } from '@/components/models/models-terminal';
import { parseScale } from '@/components/models/shared';
import { Hint } from '@/components/ui/hint';
import { Pagination } from '@/components/ui/pagination';
import { Container, Note } from '@/components/ui/section';
import { Unavailable } from '@/components/ui/unavailable';
import { api, apiD1, safe } from '@/lib/api';
import { fmtInt } from '@/lib/format';
import { routes, SITE_NAME, SITE_URL } from '@/lib/site';

export const metadata: Metadata = {
  title: 'AI models — parameters, context, openness, licences & pricing',
  description: 'Every canonical AI model release in the atlas: parameters, context window, openness, canonical licence, release date and data quality — filterable, sortable and shareable, with provenance on every value.',
  alternates: { canonical: '/models' },
  openGraph: { title: `AI models — parameters, context, openness, licences & pricing | ${SITE_NAME}`, url: `${SITE_URL}/models`, type: 'website' },
};
export const revalidate = 120;

type SP = Record<string, string | undefined>;
const LIMIT = 50;

export default async function ModelsPage({ searchParams }: { searchParams: Promise<SP> }) {
  const sp = await searchParams;
  const current: Current = {};
  for (const k of MODEL_PARAM_KEYS) if (sp[k]) current[k] = sp[k];
  const offset = Math.max(0, Number(current.offset) || 0);
  const sort = current.sort ?? 'updated';
  const order = current.order;
  const [page, stats] = await Promise.all([
    safe(
      apiD1.models({
        q: current.q,
        org: current.org,
        family: current.family,
        openness: current.openness,
        modality: current.modality,
        status: current.status,
        license: current.license,
        trust: current.trust,
        reasoning: current.reasoning,
        include: current.include,
        min_params: parseScale(current.min_params),
        max_params: parseScale(current.max_params),
        min_context: parseScale(current.min_context),
        year_from: current.year_from,
        year_to: current.year_to,
        sort,
        order,
        limit: LIMIT,
        offset,
        facets: 1,
      }),
    ),
    safe(api.stats()),
  ]);
  const href = (patch: Record<string, string | number | undefined | null>) => modelsHref(current, patch);
  const sortHref: Record<string, string> = {};
  for (const s of [...MODEL_SORTS.map((x) => x.value)]) sortHref[s] = href({ sort: s, order: sort === s && order !== 'asc' ? 'asc' : undefined, offset: undefined });
  const filterCount = Object.keys(current).filter((k) => !['sort', 'order', 'offset'].includes(k)).length;
  const artifacts = current.include === 'artifacts';
  const definition = stats?.definitions?.models ?? page?.facets?.definitions?.models ?? 'Canonical model releases; artifacts, quantisations, conversions and folded evaluation variants are excluded.';
  const artifactsDef = stats?.definitions?.artifacts;
  const ld = { '@context': 'https://schema.org', '@type': 'CollectionPage', name: 'AI models', url: `${SITE_URL}/models`, description: metadata.description, isPartOf: { '@type': 'WebSite', name: SITE_NAME, url: SITE_URL }, ...(page ? { mainEntity: { '@type': 'ItemList', numberOfItems: page.total, itemListElement: page.items.slice(0, 10).map((m, i) => ({ '@type': 'ListItem', position: offset + i + 1, url: `${SITE_URL}${routes.entity(m)}`, name: m.name })) } } : {}) };

  return (
    <>
      <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(ld) }} />
      <Container wide>
        <header className="flex flex-col gap-3 pb-4 pt-6 md:flex-row md:items-end md:justify-between md:pt-8">
          <div className="min-w-0">
            <p className="eyebrow">Models</p>
            <h1 className="display mt-1 text-[26px] md:text-[34px]">AI models</h1>
            <p className="mt-2 max-w-2xl text-sm text-ink-2">Canonical model releases across every lab and modality. Parameters, context, openness and licences exactly as their sources state them — one row per real model, artifacts folded under their canonical release.</p>
          </div>
          {page && (
            <p className="tnum flex items-center gap-1 text-sm text-ink-2" data-models-count>
              <span className="font-semibold text-ink">{fmtInt(page.total)}</span> {artifacts ? 'models + artifacts' : 'canonical models'} <span className="text-ink-3">{artifacts ? '(artifacts included)' : '(artifacts excluded)'}</span>
              <Hint text={artifacts ? (artifactsDef ? `${definition} Artifacts: ${artifactsDef}` : definition) : definition} align="right" />
            </p>
          )}
        </header>
        <UnderstoodChips current={current} facets={page?.facets} className="pb-3" />
      </Container>

      <ModelsTerminal filters={<ModelsFilterRail current={current} facets={page?.facets} universeNote={artifactsDef} />} filterCount={filterCount} items={page?.items ?? []}>
        {!page ? (
          <Unavailable what="Models" reason="The API did not answer. Try again in a moment." />
        ) : (
          <>
            <div className="flex flex-wrap items-center justify-between gap-2 pb-1 text-xs text-ink-3">
              <p>
                Sort:{' '}
                {MODEL_SORTS.map((s, i) => (
                  <span key={s.value}>
                    {i > 0 && ' · '}
                    <Link href={sortHref[s.value] ?? '#'} className={sort === s.value ? 'font-medium text-ink' : 'hover:text-ink'} aria-current={sort === s.value ? 'true' : undefined}>
                      {s.label}
                    </Link>
                  </span>
                ))}
              </p>
              <p className="tnum">
                {page.items.length ? `${fmtInt(offset + 1)}–${fmtInt(offset + page.items.length)} of ${fmtInt(page.total)}` : '0 rows'} · {page.universe ?? 'canonical models'}
              </p>
            </div>
            <ModelsTable items={page.items} sort={sort} order={order} sortHref={sortHref} orgHrefTemplate={href({ org: '__ORG__', offset: undefined })} offset={offset} />
            <Pagination total={page.total} limit={LIMIT} offset={offset} makeHref={(o) => href({ offset: o || undefined })} className="mt-4" />
            <Note className="mt-3">
              Best price = cheapest current offer across providers when the listing carries one (USD per 1M tokens); otherwise open the model for its provider deployments. Data quality is how well AI Atlas knows the entity, not how good the model is. Rows focus with the keyboard: ↑ ↓ move, Enter inspects. <Link href="/methodology" className="link">Methodology →</Link>
            </Note>
          </>
        )}
      </ModelsTerminal>
      <CompareTrayBar />
    </>
  );
}