import type { Metadata } from 'next';
import Link from 'next/link';
import { DataStrip } from '@/components/layout/terminal';
import { BreadcrumbLd } from '@/components/meta/breadcrumb-ld';
import { TierBadge } from '@/components/ui/badges';
import { DataTable, EmptyRow, Td, Th } from '@/components/ui/data-table';
import { Hint } from '@/components/ui/hint';
import { Container, Note, PageHeader } from '@/components/ui/section';
import { Unavailable } from '@/components/ui/unavailable';
import { adminApi } from '@/lib/admin/admin-api';
import { getAdminToken } from '@/lib/admin/session';
import type { AdminConnector } from '@/lib/admin/types';
import { apiD3, safe } from '@/lib/api';
import { cn } from '@/lib/cn';
import { fmtAgo, fmtDateTime, fmtDuration, fmtInt, fmtPct, num, titleCase } from '@/lib/format';
import { routes, SITE_NAME } from '@/lib/site';
import type { SourceRow11 } from '@/lib/types';

export const metadata: Metadata = { title: 'Sources — health center: every site AI Atlas reads, tier, freshness and connector status', description: 'Transparency page: the sources AI Atlas crawls, their tier, last successful observation, documents and connector health. Operators see request-level health when signed in.', alternates: { canonical: '/sources' } };
/** Reads the admin cookie to decide whether to show operator columns → dynamic. API fetches stay ISR-cached. */
export const dynamic = 'force-dynamic';

const HEALTH: Record<string, string> = { ok: 'text-positive', healthy: 'text-positive', degraded: 'text-warning', failing: 'text-danger', broken: 'text-danger', disabled: 'text-ink-3', unknown: 'text-ink-3' };
const DOT: Record<string, string> = { ok: 'bg-positive', healthy: 'bg-positive', degraded: 'bg-warning', disabled: 'bg-ink-3', unknown: 'bg-ink-3' };

function statusOf(s: SourceRow11): string {
  if (!s.enabled) return 'disabled';
  const hs = (s.connectors ?? []).map((c) => c.health);
  if (!hs.length) return 'no connector';
  if (hs.some((h) => h === 'failing' || h === 'broken')) return 'failing';
  if (hs.some((h) => h === 'degraded')) return 'degraded';
  if (hs.every((h) => h === 'ok' || h === 'healthy')) return 'ok';
  return hs[0] ?? 'unknown';
}
function lastSuccess(s: SourceRow11): string | null {
  const ts = (s.connectors ?? []).map((c) => c.last_success_at).filter((x): x is string => !!x);
  return ts.length ? ts.sort().at(-1)! : s.last_crawled_at;
}

export default async function SourcesPage() {
  const token = await getAdminToken();
  const [res, admin] = await Promise.all([
    safe(apiD3.sources()),
    token
      ? adminApi.connectors().catch(() => null)
      : Promise.resolve(null),
  ]);
  const items = ((res?.items ?? []) as SourceRow11[]).slice().sort((a, b) => a.tier - b.tier || (num(b.documents) ?? 0) - (num(a.documents) ?? 0));
  const byConnector = new Map<string, AdminConnector>((admin?.items ?? []).map((c) => [c.name, c]));
  const isAdmin = !!admin;
  const connectors = items.flatMap((s) => s.connectors ?? []);
  const count = (pred: (h: string) => boolean) => connectors.filter((c) => pred(c.health)).length;
  const docs = items.reduce((n, s) => n + (num(s.documents) ?? 0), 0);
  const snaps = items.reduce((n, s) => n + (num(s.snapshots) ?? 0), 0);
  const claims = items.reduce((n, s) => n + (num(s.claims) ?? 0), 0);
  const stale = items.filter((s) => {
    const t = lastSuccess(s);
    return s.enabled && t && Date.now() - new Date(t).getTime() > 3 * 86400000;
  }).length;

  return (
    <Container wide>
      <BreadcrumbLd items={[{ name: SITE_NAME, href: '/' }, { name: 'Sources', href: '/sources' }]} />
      <PageHeader eyebrow="Sources · health center" title="What AI Atlas reads" lede="Every source is crawled directly and archived. Tier grades reliability (1 official → 4 unverified); status is the live health of the connectors reading it. Signed-in operators see request-level health." aside={res ? <p className="tnum text-sm text-ink-3">{fmtInt(res.total ?? items.length)} sources · {fmtInt(connectors.length)} connectors</p> : undefined} />
      <div className="pb-16">
        {!res ? (
          <Unavailable what="Sources" />
        ) : (
          <>
            <DataStrip
              dense
              items={[
                { label: 'Sources', value: fmtInt(res.total ?? items.length), definition: 'Registered sources (registry/sources.yaml), enabled or not.' },
                { label: 'Documents', value: fmtInt(docs), definition: 'Distinct documents discovered across all sources.' },
                { label: 'Snapshots', value: snaps ? fmtInt(snaps) : '—', definition: 'Archived fetches (raw + text) across all sources.' },
                { label: 'Claims', value: claims ? fmtInt(claims) : '—', definition: 'Claims whose source is this registry entry.' },
                { label: 'Connectors OK', value: fmtInt(count((h) => h === 'ok' || h === 'healthy')), definition: 'Connectors whose last run succeeded within their interval.' },
                { label: 'Degraded', value: fmtInt(count((h) => h === 'degraded')), definition: 'Connectors with recent failures or a breakage suspicion.', delta: count((h) => h === 'degraded') ? { value: 'attention', tone: 'neutral' } : undefined },
                { label: 'Failing', value: fmtInt(count((h) => h === 'failing' || h === 'broken')), definition: 'Connectors whose circuit breaker is open or whose last runs failed.' },
                { label: 'Stale > 3 d', value: fmtInt(stale), definition: 'Enabled sources with no successful observation in the last 3 days.' },
              ]}
            />
            <div className="mt-4 flex flex-wrap items-center gap-x-4 gap-y-1 text-xs text-ink-3">
              <span>
                Tiers:{' '}
                {Object.entries(res.tiers ?? {}).map(([t, l], i) => (
                  <span key={t}>
                    {i > 0 && ' · '}
                    <TierBadge tier={Number(t)} /> {l}
                  </span>
                ))}
              </span>
              {isAdmin && <span className="rounded-[3px] bg-accent-soft px-1.5 text-[10px] uppercase tracking-wide text-accent">operator columns on</span>}
            </div>
            <DataTable caption="Sources" scroll compact className="mt-4">
              <thead>
                <tr>
                  <Th>Source</Th>
                  <Th>Category</Th>
                  <Th>Tier</Th>
                  <Th>Last successful observation</Th>
                  <Th num>Documents</Th>
                  <Th>Status</Th>
                  <Th>Connectors</Th>
                  {isAdmin && (
                    <>
                      <Th>Last request</Th>
                      <Th>
                        HTTP <Hint text="Not exposed per connector by /admin/connectors (documents carry last_status individually) — shown as —." />
                      </Th>
                      <Th num>
                        Unchanged share <Hint text="docs_unchanged / docs_fetched of the last run — a proxy for the conditional-request hit rate, which the API does not report directly." />
                      </Th>
                      <Th num>Docs changed</Th>
                      <Th num>Claims</Th>
                      <Th num>Errors 7 d</Th>
                      <Th>Parser</Th>
                      <Th>
                        LLM <Hint text="needs_llm flag from the connector registry; the LLM fallback *rate* is not exposed by the API." />
                      </Th>
                      <Th num>Latency</Th>
                    </>
                  )}
                </tr>
              </thead>
              <tbody>
                {items.length === 0 && <EmptyRow cols={isAdmin ? 16 : 7}>No sources registered.</EmptyRow>}
                {items.map((s) => {
                  const st = statusOf(s);
                  const ls = lastSuccess(s);
                  const conns = (s.connectors ?? []).map((c) => byConnector.get(c.name)).filter((c): c is AdminConnector => !!c);
                  const run = conns.map((c) => c.last_run).find((r) => r) ?? null;
                  const fetched = num(run?.docs_fetched);
                  const unchanged = num(run?.docs_unchanged);
                  return (
                    <tr key={s.key} className={!s.enabled ? 'opacity-60' : undefined}>
                      <Td primary>
                        <a href={s.base_url ?? `https://${s.domain}`} target="_blank" rel="noopener noreferrer" className="hover:text-accent">
                          {s.name}
                        </a>
                        <span className="mono block text-[11px] text-ink-3">
                          {s.domain}
                          {s.organization ? ` · ${s.organization.name}` : ''}
                        </span>
                      </Td>
                      <Td label="Category" className="text-ink-2">{titleCase(s.category)}<span className="block text-[11px] text-ink-3">{titleCase(s.kind)}</span></Td>
                      <Td label="Tier">
                        <TierBadge tier={s.tier} />
                      </Td>
                      <Td label="Last observation" className="text-ink-2" title={ls ? fmtDateTime(ls) : undefined}>{ls ? fmtAgo(ls) : <span className="text-ink-3">never</span>}</Td>
                      <Td num label="Documents" className="tnum">{fmtInt(s.documents)}</Td>
                      <Td label="Status">
                        <span className={cn('inline-flex items-center gap-1.5 text-xs', HEALTH[st] ?? 'text-ink-3')}>
                          <span className={cn('inline-block size-1.5 rounded-full', DOT[st] ?? (st === 'no connector' ? 'bg-ink-3' : 'bg-danger'))} aria-hidden />
                          {st}
                        </span>
                      </Td>
                      <Td label="Connectors">
                        {s.connectors?.length ? (
                          <ul className="space-y-0.5 text-xs">
                            {s.connectors.map((c) => (
                              <li key={c.name} className="flex flex-wrap items-center gap-x-2">
                                <span className="mono text-ink-2">{c.name}</span>
                                <span className={HEALTH[c.health] ?? 'text-ink-3'}>{c.health}</span>
                                <span className="text-ink-3">every {fmtDuration(c.interval_seconds)}</span>
                              </li>
                            ))}
                          </ul>
                        ) : (
                          <span className="text-ink-3">—</span>
                        )}
                      </Td>
                      {isAdmin && (
                        <>
                          <Td label="Last request" className="text-xs text-ink-2">{conns[0]?.last_attempt_at ? fmtAgo(conns[0].last_attempt_at) : '—'}</Td>
                          <Td label="HTTP" className="text-xs text-ink-3">—</Td>
                          <Td num label="Unchanged share" className="tnum text-xs">{fetched && unchanged !== null ? fmtPct((unchanged / fetched) * 100, 0) : '—'}</Td>
                          <Td num label="Docs changed" className="tnum text-xs">{run ? fmtInt(run.docs_changed) : '—'}</Td>
                          <Td num label="Claims" className="tnum text-xs">{run ? fmtInt(run.claims_written) : '—'}</Td>
                          <Td num label="Errors 7 d" className={cn('tnum text-xs', conns.some((c) => (num((c as unknown as { errors_7d?: unknown }).errors_7d) ?? 0) > 0) && 'text-danger')}>{conns.length ? fmtInt(conns.reduce((n, c) => n + (num((c as unknown as { errors_7d?: unknown }).errors_7d) ?? 0), 0)) : '—'}</Td>
                          <Td label="Parser" className="mono text-xs text-ink-2">{conns[0]?.parser_version ?? '—'}</Td>
                          <Td label="LLM" className="text-xs text-ink-2">{conns.length ? (conns.some((c) => (c.meta as { needs_llm?: boolean } | undefined)?.needs_llm) ? 'fallback on' : 'deterministic') : '—'}</Td>
                          <Td num label="Latency" className="tnum text-xs">{num(run?.duration_ms) === null ? '—' : fmtDuration(Math.round((num(run?.duration_ms) ?? 0) / 1000))}</Td>
                        </>
                      )}
                    </tr>
                  );
                })}
              </tbody>
            </DataTable>
            <Note className="mt-4">
              Crawling policy: robots.txt honoured, per-domain rate limits, conditional requests, identified user agent (<Link href={routes.bot()} className="link mono">AIAtlasBot</Link>). Tiers and confidence are explained in the <Link href={routes.methodology()} className="link">methodology</Link>.
              {isAdmin ? <> Operator columns come from <span className="mono">/admin/connectors</span> (last run); HTTP status, conditional-hit rate and LLM fallback rate are not exposed per connector by the API and show “—”. Full console: <Link href={routes.admin('connectors')} className="link">Connectors →</Link></> : token ? ' Operator columns unavailable (admin API did not answer).' : null}
            </Note>
          </>
        )}
      </div>
    </Container>
  );
}