import type { Metadata } from 'next';
import Link from 'next/link';
import { SectionNav } from '@/components/layout/terminal';
import { BreadcrumbLd } from '@/components/meta/breadcrumb-ld';
import { Chip, Estimated, TierBadge } from '@/components/ui/badges';
import { DataTable, Td, Th } from '@/components/ui/data-table';
import { Container, Note, PageHeader, Section } from '@/components/ui/section';
import { Unavailable } from '@/components/ui/unavailable';
import { apiD3, safe } from '@/lib/api';
import { fmtAgo, fmtInt, humanize } from '@/lib/format';
import { eventLabel, routes, SITE_NAME, TIER_LABELS } from '@/lib/site';
import type { MethodologyD3 } from '@/lib/types';

export const metadata: Metadata = { title: 'Methodology — provenance, tiers, openness, trust, comparability, counters, events, anomalies, estimates', description: 'How AI Atlas records facts: source tiers, confidence, temporal claims and conflicts, openness definitions, benchmark trust levels and comparability rules, counter definitions, event semantics (occurred / observed / recorded), anomaly checks, hardware-fit assumptions and frontier composition.', 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 [];
}
function Defs({ obj, mono = true }: { obj: Record<string, unknown> | undefined | null; mono?: boolean }) {
  const entries = Object.entries(obj ?? {}).filter(([, v]) => typeof v === 'string');
  if (!entries.length) return <Unavailable what="Definitions" compact />;
  return (
    <dl className="kv max-w-4xl">
      {entries.map(([k, v]) => (
        <div key={k}>
          <dt className={mono ? 'mono' : undefined}>{k}</dt>
          <dd className="text-ink-2">{String(v)}</dd>
        </div>
      ))}
    </dl>
  );
}
function Keys({ items }: { items: unknown }) {
  if (!Array.isArray(items) || !items.length) return <span className="text-ink-3">—</span>;
  return (
    <span className="flex flex-wrap gap-1">
      {items.map((k) => (
        <Chip key={String(k)} className="mono">
          {String(k)}
        </Chip>
      ))}
    </span>
  );
}

const NAV = [
  { id: 'principles', label: 'Principles' },
  { id: 'tiers', label: 'Tiers' },
  { id: 'confidence', label: 'Confidence' },
  { id: 'openness', label: 'Openness' },
  { id: 'trust', label: 'Trust levels' },
  { id: 'comparability', label: 'Comparability' },
  { id: 'counters', label: 'Counters' },
  { id: 'events', label: 'Events' },
  { id: 'anomalies', label: 'Anomalies' },
  { id: 'estimates', label: 'Hardware fit' },
  { id: 'frontier', label: 'Frontier' },
  { id: 'quality', label: 'Quality' },
  { id: 'extractors', label: 'Extraction' },
];

export default async function MethodologyPage() {
  const m: MethodologyD3 | null = await safe(apiD3.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');
  const comp = (m?.comparability ?? {}) as Record<string, unknown>;
  const hf = (m?.hardware_fit ?? {}) as { assumptions?: string[]; bytes_per_param?: Record<string, number>; reserved_gb?: number };
  return (
    <Container>
      <BreadcrumbLd items={[{ name: SITE_NAME, href: '/' }, { name: 'Methodology', href: '/methodology' }]} />
      <PageHeader eyebrow="Methodology 2.0" 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. Everything on this page is read from GET /methodology; nothing is hardcoded." aside={m?.quality_version ? <p className="mono text-xs text-ink-3">quality v{m.quality_version}</p> : undefined} />
      <SectionNav items={NAV} />
      {!m && <Unavailable what="Methodology" className="my-8" />}

      <Section id="principles" eyebrow="Principles" title="Non-negotiables" hairline={false}>
        {m?.principles?.length ? (
          <ol className="max-w-3xl list-decimal space-y-1.5 pl-5 text-[15px] leading-relaxed text-ink-2">
            {m.principles.map((p) => (
              <li key={p}>{p}</li>
            ))}
          </ol>
        ) : (
          <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. Every document is snapshotted and archived; every fact points back to a snapshot. Facts are temporal claims — a property, a value, a source, a tier, a confidence, an extractor and a validity interval. Missing means missing.</p>
          </div>
        )}
      </Section>

      <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>
        ) : (
          <Unavailable what="Tier vocabulary" compact />
        )}
        <p className="mt-3 max-w-3xl text-sm text-ink-2">A higher tier can supersede a lower one; the reverse produces a flagged conflict. Both claims are kept.</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 />
        )}
        {m?.status_vocabulary?.length ? (
          <p className="mt-3 text-sm text-ink-2">
            Status vocabulary: <Keys items={m.status_vocabulary} />
          </p>
        ) : null}
      </Section>

      <Section id="openness" eyebrow="Openness" title="Openness is derived from measurable dimensions" lede={m?.openness?.note}>
        {m?.openness ? (
          <>
            <DataTable caption="Openness categories" compact>
              <thead>
                <tr>
                  <Th>Category</Th>
                  <Th>Label</Th>
                  <Th>Definition</Th>
                </tr>
              </thead>
              <tbody>
                {m.openness.categories.map((c) => (
                  <tr key={c}>
                    <Td primary className="mono text-xs">{c}</Td>
                    <Td label="Label" className="text-ink">{m.openness?.labels?.[c] ?? humanize(c)}</Td>
                    <Td label="Definition" wide className="text-ink-2">{m.openness?.definitions?.[c] ?? '—'}</Td>
                  </tr>
                ))}
              </tbody>
            </DataTable>
            <p className="mt-3 text-sm text-ink-2">
              Dimensions: <Keys items={m.openness.dimensions} />
            </p>
            {m.licence_categories?.length ? (
              <p className="mt-2 text-sm text-ink-2">
                Licence categories: <Keys items={m.licence_categories} />
              </p>
            ) : null}
          </>
        ) : (
          <Unavailable what="Openness definitions" compact />
        )}
      </Section>

      <Section id="trust" eyebrow="Benchmarks" title="Trust levels of a result">
        {m?.trust_levels?.length ? (
          <dl className="kv max-w-3xl">
            {(m.trust_levels as { key: string; label: string; description?: string }[]).map((t) => (
              <div key={t.key}>
                <dt className="mono">{t.key}</dt>
                <dd className="text-ink-2">{t.label}{t.description ? ` — ${t.description}` : ''}</dd>
              </div>
            ))}
          </dl>
        ) : (
          <Unavailable what="Trust levels" compact />
        )}
      </Section>

      <Section id="comparability" eyebrow="Benchmarks" title="Results are never compared blindly" lede={typeof comp.group === 'string' ? comp.group : undefined}>
        {Object.keys(comp).length ? (
          <>
            <dl className="kv max-w-4xl">
              {(['comparable', 'partially-comparable', 'not-comparable'] as const).filter((k) => typeof comp[k] === 'string').map((k) => (
                <div key={k}>
                  <dt className="mono">{k}</dt>
                  <dd className="text-ink-2">{String(comp[k])}</dd>
                </div>
              ))}
              {typeof comp.leaderboard === 'string' && (
                <div>
                  <dt>Leaderboards</dt>
                  <dd className="text-ink-2">{comp.leaderboard}</dd>
                </div>
              )}
            </dl>
            <div className="mt-4 grid gap-4 md:grid-cols-3">
              <div>
                <p className="eyebrow mb-1.5">Task-defining keys</p>
                <Keys items={comp.task_keys} />
              </div>
              <div>
                <p className="eyebrow mb-1.5">Condition keys</p>
                <Keys items={comp.condition_keys} />
              </div>
              <div>
                <p className="eyebrow mb-1.5">Ignored keys</p>
                <Keys items={comp.ignored_keys} />
              </div>
            </div>
          </>
        ) : (
          <Unavailable what="Comparability rules" compact />
        )}
      </Section>

      <Section id="counters" eyebrow="Counters" title="How every number is counted">
        <Defs obj={m?.counters} />
      </Section>

      <Section id="events" eyebrow="History" title="Change events: occurred, observed, recorded">
        <Defs obj={m?.event_semantics} />
        {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>Importance</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="Importance" className="tnum text-ink-2">{e.extra?.importance !== undefined ? String(e.extra.importance) : '—'}</Td>
                  <Td num label="Recorded" className="tnum text-ink-2">{e.extra?.count !== undefined ? fmtInt(e.extra.count) : '—'}</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="anomalies" eyebrow="Data health" title="Anomaly checks" lede="Impossible or suspicious values are flagged, never deleted; each flag points at a review action.">
        {m?.anomaly_checks?.length ? (
          <DataTable caption="Anomaly checks" compact>
            <thead>
              <tr>
                <Th>Check</Th>
                <Th>Severity</Th>
                <Th>Description</Th>
              </tr>
            </thead>
            <tbody>
              {m.anomaly_checks.map((c) => (
                <tr key={c.check}>
                  <Td primary className="mono text-xs">{c.check}</Td>
                  <Td label="Severity">
                    <span className={c.severity === 'critical' ? 'text-danger' : c.severity === 'warning' ? 'text-warning' : 'text-ink-2'}>{c.severity}</span>
                  </Td>
                  <Td label="Description" wide className="text-ink-2">{c.description}</Td>
                </tr>
              ))}
            </tbody>
          </DataTable>
        ) : (
          <Unavailable what="Anomaly checks" compact />
        )}
      </Section>

      <Section id="estimates" eyebrow="Estimates" title={<>Hardware fit is an estimate <Estimated className="ml-2 align-middle" /></>}>
        {hf.assumptions?.length ? (
          <ul className="max-w-3xl list-disc space-y-1 pl-5 text-sm leading-relaxed text-ink-2">
            {hf.assumptions.map((a) => (
              <li key={a}>{a}</li>
            ))}
          </ul>
        ) : (
          <Unavailable what="Hardware-fit assumptions" compact />
        )}
        {hf.bytes_per_param && (
          <p className="mt-3 text-sm text-ink-2">
            Bytes per parameter:{' '}
            {Object.entries(hf.bytes_per_param).map(([k, v], i) => (
              <span key={k} className="tnum">
                {i > 0 && ' · '}
                <span className="mono">{k}</span> {v}
              </span>
            ))}
            {hf.reserved_gb !== undefined && <> · reserved {hf.reserved_gb} GB</>}
          </p>
        )}
      </Section>

      <Section id="frontier" eyebrow="Frontier" title="Frontier composition">
        {typeof m?.frontier === 'string' ? <p className="max-w-3xl text-sm leading-relaxed text-ink-2">{m.frontier}</p> : m?.frontier ? <Defs obj={m.frontier as Record<string, unknown>} mono={false} /> : <Unavailable what="Frontier definition" compact />}
        {m?.find_a_model && (
          <>
            <p className="eyebrow mb-1.5 mt-5">Find-a-model rules</p>
            <Defs obj={m.find_a_model} />
          </>
        )}
      </Section>

      <Section id="quality" eyebrow="Data quality" title="The quality score measures our knowledge, not the entity">
        {m && m.metrics?.length > 0 ? (
          <DataTable caption="Metric definitions">
            <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>
        ) : (
          <Unavailable what="Metric definitions" compact />
        )}
        {m?.expected_fields && (
          <>
            <p className="eyebrow mb-1.5 mt-5">Expected fields per type (completeness)</p>
            <dl className="kv max-w-4xl">
              {Object.entries(m.expected_fields).map(([t, fields]) => (
                <div key={t}>
                  <dt className="mono">{t}</dt>
                  <dd>
                    <Keys items={fields} />
                  </dd>
                </div>
              ))}
            </dl>
          </>
        )}
      </Section>

      <Section id="extractors" eyebrow="Extraction" title="Deterministic before LLM">
        {m && extractors.length > 0 ? (
          <dl className="kv 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>
        ) : (
          <Unavailable what="Extractor vocabulary" compact />
        )}
        <Note className="mt-4">
          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. Sources and connector health: <Link href={routes.sources()} className="link">/sources</Link>.
        </Note>
      </Section>
    </Container>
  );
}