import type { Metadata } from 'next';
import Link from 'next/link';
import { TierBadge } from '@/components/ui/badges';
import { DataTable, Td, Th } from '@/components/ui/data-table';
import { Container, PageHeader, Section } from '@/components/ui/section';
import { Unavailable } from '@/components/ui/unavailable';
import { api, safe } from '@/lib/api';
import { fmtAgo, fmtInt, humanize } from '@/lib/format';
import { eventLabel, routes, TIER_LABELS } from '@/lib/site';
import type { Methodology } from '@/lib/types';

export const metadata: Metadata = { title: 'Methodology — provenance, tiers, confidence, quality score, events', description: 'How AI Atlas records facts: source tiers, confidence levels, temporal claims, conflict handling, the data-quality score, change events and estimates.', alternates: { canonical: '/methodology' } };
export const revalidate = 3600;

/** The API may return dicts or lists for these vocabularies; normalise to rows. */
function rows(v: unknown, keyName: string): { key: string; label?: string; description?: string; extra?: Record<string, unknown> }[] {
  if (!v) return [];
  if (Array.isArray(v)) return v.map((x) => (typeof x === 'string' ? { key: x } : { key: String((x as Record<string, unknown>)[keyName] ?? (x as Record<string, unknown>).key ?? (x as Record<string, unknown>).name ?? ''), label: (x as Record<string, unknown>).label as string | undefined, description: ((x as Record<string, unknown>).description ?? (x as Record<string, unknown>).text) as string | undefined, extra: x as Record<string, unknown> }));
  if (typeof v === 'object') return Object.entries(v as Record<string, unknown>).map(([k, d]) => (typeof d === 'string' ? { key: k, description: d } : { key: k, ...(d as Record<string, unknown>), extra: d as Record<string, unknown> }));
  return [];
}

export default async function MethodologyPage() {
  const m: Methodology | null = await safe(api.methodology());
  const tiers = rows(m?.tiers, 'tier');
  const conf = rows(m?.confidence_levels, 'key');
  const events = rows(m?.event_types, 'event_type');
  const extractors = rows(m?.extractors, 'key');
  return (
    <Container>
      <PageHeader eyebrow="Methodology" title="How AI Atlas records facts" lede="The dataset is the product. These are the rules every connector, extractor and page follows — and the vocabularies the API exposes." />
      <div className="prose-atlas max-w-3xl text-[15px] leading-relaxed text-ink-2">
        <p>AI Atlas is built from first-party connectors that read public documents directly: official documentation, pricing pages, model cards, release notes, papers, feeds, sitemaps and repositories. Nothing depends on a third-party data API. Every document is snapshotted and archived; every fact points back to a snapshot.</p>
        <p>Facts are <strong className="text-ink">temporal claims</strong>: a property, a value, a source, a tier, a confidence, an extractor and a validity interval. When a better-or-equal source states a new value, the old claim is superseded (its interval closes) and the new one becomes current. When a worse source disagrees, the value is stored as <em>conflicting</em> and flagged for review — it is never averaged or silently overwritten. Missing means missing: the site shows “Unavailable” rather than a guess.</p>
      </div>

      <Section id="tiers" eyebrow="Source tiers" title="Primary sources first">
        {m && tiers.length ? (
          <DataTable caption="Source tiers">
            <thead><tr><Th>Tier</Th><Th>Meaning</Th><Th>Description</Th></tr></thead>
            <tbody>
              {tiers.map((t, i) => (
                <tr key={`${t.key}-${i}`}>
                  <Td primary><TierBadge tier={Number(t.key)} /></Td>
                  <Td label="Meaning" className="text-ink">{t.label ?? TIER_LABELS[Number(t.key)] ?? humanize(t.key)}</Td>
                  <Td label="Description" wide className="text-ink-2">{t.description ?? '—'}</Td>
                </tr>
              ))}
            </tbody>
          </DataTable>
        ) : m ? (
          <ul className="space-y-1 text-sm text-ink-2">{[1, 2, 3, 4].map((t) => <li key={t} className="flex items-center gap-2"><TierBadge tier={t} /> {TIER_LABELS[t]}</li>)}</ul>
        ) : (
          <Unavailable what="Tier vocabulary" compact />
        )}
        <p className="mt-3 max-w-3xl text-sm text-ink-2">A tier 1 source is the entity's own publisher (a lab's documentation, a provider's pricing page, an arXiv listing for a paper). Tier 2 are quality secondary sources, tier 3 community sources, tier 4 unverified. A higher tier can supersede a lower one; the reverse produces a flagged conflict.</p>
      </Section>

      <Section id="confidence" eyebrow="Confidence" title="Confidence levels">
        {m && conf.length ? (
          <dl className="kv max-w-3xl">
            {conf.map((c, i) => (
              <div key={`${c.key}-${i}`}>
                <dt className="mono">{c.key}</dt>
                <dd className="text-ink-2">{c.description ?? c.label ?? '—'}</dd>
              </div>
            ))}
          </dl>
        ) : (
          <Unavailable what="Confidence vocabulary" compact />
        )}
        <p className="mt-3 max-w-3xl text-sm text-ink-2">Default confidence follows the tier (tier 1 → high, tier 2 → medium, tiers 3–4 → low). A claim becomes <em>conflicted</em> when a current value is contradicted by another source. Extractors can raise confidence to <em>verified</em> when a value is confirmed by several independent tier 1–2 sources.</p>
      </Section>

      <Section id="quality" eyebrow="Data quality" title="The quality score measures our knowledge, not the entity">
        <p className="max-w-3xl text-sm leading-relaxed text-ink-2">
          <span className="mono text-ink">quality.score = 100 × (0.25 completeness + 0.25 primary-source ratio + 0.20 freshness + 0.15 agreement + 0.15 source diversity)</span>. It says how well AI Atlas knows an entity — how many expected attributes are filled, how much comes from tier 1, how recently it was re-observed, how few conflicts remain and how many independent sources agree. It says nothing about whether a model is good.
        </p>
        {m && m.metrics?.length > 0 && (
          <DataTable caption="Metric definitions" className="mt-5">
            <thead><tr><Th>Metric</Th><Th>Definition</Th><Th>Version</Th></tr></thead>
            <tbody>
              {m.metrics.map((x, i) => (
                <tr key={String(x.key ?? x.name ?? i)}>
                  <Td primary className="mono text-xs">{String(x.key ?? x.name ?? '—')}</Td>
                  <Td label="Definition" wide className="text-ink-2">{String(x.description ?? x.formula ?? x.label ?? '—')}{x.unit ? <span className="text-ink-3"> · {String(x.unit)}</span> : null}</Td>
                  <Td label="Version" className="mono text-xs text-ink-3">{x.version !== undefined ? String(x.version) : '—'}</Td>
                </tr>
              ))}
            </tbody>
          </DataTable>
        )}
      </Section>

      <Section id="events" eyebrow="History" title="Change events">
        <p className="max-w-3xl text-sm leading-relaxed text-ink-2">Material properties — context length, status, license, openness, parameters, release date, deprecation and retirement dates, versions, prices — emit events when they change. Noisy metrics (downloads, likes, stars) are stored as time series and never generate events. Descriptions and other soft text follow their own source without events. Each event has a category and an importance from 0 (minor) to 3 (major), and links to the source document that triggered it.</p>
        {m && events.length ? (
          <DataTable caption="Event types" className="mt-5" compact>
            <thead><tr><Th>Event type</Th><Th>Label</Th><Th>Category</Th><Th num>Recorded</Th><Th>Last seen</Th></tr></thead>
            <tbody>
              {events.map((e, i) => (
                <tr key={`${e.key}-${String(e.extra?.category ?? '')}-${i}`}>
                  <Td primary className="mono text-xs">{e.key}</Td>
                  <Td label="Label" className="text-ink-2">{e.label ?? e.description ?? eventLabel(e.key)}</Td>
                  <Td label="Category" className="text-ink-2">{String(e.extra?.category ?? '—')}</Td>
                  <Td num label="Recorded" className="tnum text-ink-2">{e.extra?.count !== undefined ? fmtInt(e.extra.count) : e.extra?.importance !== undefined ? `importance ${String(e.extra.importance)}` : '—'}</Td>
                  <Td label="Last seen" className="text-ink-2">{typeof e.extra?.last_seen_at === 'string' ? fmtAgo(e.extra.last_seen_at) : '—'}</Td>
                </tr>
              ))}
            </tbody>
          </DataTable>
        ) : (
          <Unavailable what="Event vocabulary" compact className="mt-4" />
        )}
      </Section>

      <Section id="extractors" eyebrow="Extraction" title="Deterministic before LLM">
        <p className="max-w-3xl text-sm leading-relaxed text-ink-2">Stage 1 runs on every document: DOM selectors, JSON-LD, tables, Markdown, feeds. Only documents flagged as needing it go to the local LLM factory (MacLustr, OpenAI-compatible), through versioned schemas with full token accounting. LLM-extracted values are marked as such in provenance. Improving a parser bumps its version and reprocesses archived snapshots — never a re-crawl.</p>
        {m && extractors.length > 0 && (
          <dl className="kv mt-5 max-w-3xl">
            {extractors.map((x, i) => (
              <div key={`${x.key}-${i}`}>
                <dt className="mono">{x.key}</dt>
                <dd className="text-ink-2">{x.description ?? x.label ?? '—'}</dd>
              </div>
            ))}
          </dl>
        )}
      </Section>

      <Section id="benchmarks" eyebrow="Benchmarks" title="Results are never compared blindly">
        <p className="max-w-3xl text-sm leading-relaxed text-ink-2">Benchmark results are append-only and carry their configuration (harness, prompting, number of shots, judge). Leaderboards rank current rows under the benchmark's own direction; results with different configurations are shown with their config so the reader can judge comparability. We do not compute composite indices.</p>
      </Section>

      <Section id="estimates" eyebrow="Estimates" title="Hardware fit is an estimate">
        <p className="max-w-3xl text-sm leading-relaxed text-ink-2">The only derived figures on AI Atlas are hardware-fit estimates: memory need ≈ parameters × bytes per parameter (4-bit 0.5 × 1.15 overhead, 8-bit 1.0, fp16 2.0) plus a KV-cache allowance for the chosen context. They are labelled <span className="border border-dashed border-warning/60 px-1 text-[11px] uppercase text-warning">Estimated</span> everywhere and never mixed with observed facts.</p>
      </Section>

      <Section eyebrow="Crawling" title="Respectful by design">
        <p className="max-w-3xl text-sm leading-relaxed text-ink-2">
          Connectors honour robots.txt, use per-domain rate limits and conditional requests, identify as <Link href={routes.bot()} className="link mono">AIAtlasBot</Link>, never bypass access controls and never collect private data. The list of sources and connector health is public on <Link href={routes.sources()} className="link">/sources</Link>.
        </p>
      </Section>
    </Container>
  );
}