import type { Metadata } from 'next';
import Link from 'next/link';
import { Sparkline } from '@/components/charts';
import { ChangeRow } from '@/components/changes/change-row';
import { Methodology, TrustChip } from '@/components/intelligence/bits';
import { DataStrip, type StripItem } from '@/components/layout/terminal';
import { PriceMovers } from '@/components/prices/movers';
import { ChipRow } from '@/components/timeline/chip-row';
import { DataTable, EmptyRow, Td, Th } from '@/components/ui/data-table';
import { EntityLink } from '@/components/ui/entity';
import { Container, Note, PageHeader, Section } from '@/components/ui/section';
import { EmptyState, Unavailable } from '@/components/ui/unavailable';
import { api, intel, safe } from '@/lib/api';
import { fmtDate, fmtDateTime, fmtInt, fmtScore, fmtTokens, num } from '@/lib/format';
import { routes, SITE_NAME, SITE_URL } from '@/lib/site';
import type { ChangeEvent, EntitySummary, PulseLeaderItem } from '@/lib/types';

export const revalidate = 120;

const WINDOWS = [7, 30, 90];
type SP = Record<string, string | undefined>;
const pickDays = (sp: SP) => (WINDOWS.includes(Number(sp.days)) ? Number(sp.days) : 7);

const LABELS: Record<string, string> = {
  new_models: 'New models',
  new_open_weight_models: 'New open-weight models',
  new_artifacts: 'New artifacts',
  new_papers: 'New papers',
  provider_listings: 'Provider listings',
  provider_delistings: 'Delistings',
  price_changes: 'Price changes',
  new_models_1m_context: 'New ≥ 1M-context models',
  new_benchmark_leaders: 'New benchmark leaders',
  documents_changed: 'Documents changed',
  sources_observed: 'Sources observed',
  events_total: 'Events total',
};
const HREF: Record<string, (days: number) => string> = {
  new_models: () => `${routes.changes()}?type=NEW_MODEL`,
  new_open_weight_models: () => `${routes.open()}`,
  new_papers: () => `${routes.papers()}?sort=published`,
  provider_listings: () => `${routes.changes()}?type=PROVIDER_LISTED`,
  provider_delistings: () => `${routes.changes()}?type=PROVIDER_DELISTED`,
  price_changes: () => `${routes.prices()}`,
  new_benchmark_leaders: () => routes.benchmarks(),
  documents_changed: () => `${routes.changes()}?type=DOCUMENT_CHANGED&include_documents=1`,
  sources_observed: () => routes.sources(),
  events_total: () => routes.changes(),
};
/** stats/history series key per counter (only where the history payload carries one). */
const HISTORY_KEY: Record<string, (c: Record<string, unknown>) => number | null> = {
  new_models: (c) => num((c.entities as Record<string, unknown> | undefined)?.model),
  new_papers: (c) => num((c.entities as Record<string, unknown> | undefined)?.paper),
  price_changes: (c) => num(c.prices_current),
  events_total: (c) => num(c.change_events),
  documents_changed: (c) => num(c.documents),
  sources_observed: (c) => num(c.sources),
};

const TITLE = 'Ecosystem Pulse — what happened in AI this week';
const DESC = 'Deterministic counters over events that occurred in the window (7, 30 or 90 days) and are not back-filled history: new models, open-weight releases, artifacts, papers, provider listings and delistings, price changes, new 1M-context models, new benchmark leaders, documents and sources observed — each with its definition.';
export async function generateMetadata({ searchParams }: { searchParams: Promise<SP> }): Promise<Metadata> {
  const days = pickDays(await searchParams);
  const title = days === 7 ? TITLE : `Ecosystem Pulse — the last ${days} days in AI`;
  return { title, description: DESC, alternates: { canonical: routes.pulse() }, openGraph: { title: `${title} | ${SITE_NAME}`, description: DESC, url: `${SITE_URL}${routes.pulse()}`, type: 'website', siteName: SITE_NAME }, twitter: { card: 'summary_large_image', title, description: DESC }, robots: days !== 7 ? { index: false, follow: true } : undefined };
}

const isLeader = (x: unknown): x is PulseLeaderItem => !!x && typeof x === 'object' && 'benchmark' in (x as object);
const isEvent = (x: unknown): x is ChangeEvent => !!x && typeof x === 'object' && 'event_type' in (x as object);
const isModel = (x: unknown): x is EntitySummary => !!x && typeof x === 'object' && 'entity_type' in (x as object) && 'slug' in (x as object);

export default async function PulsePage({ searchParams }: { searchParams: Promise<SP> }) {
  const days = pickDays(await searchParams);
  const since = new Date(Date.now() - days * 86400000).toISOString().slice(0, 10);
  const [pulse, history, priceFallback, ctxFallback] = await Promise.all([safe(intel.pulse(days)), safe(api.statsHistory(Math.max(days, 14))), safe(api.changes({ type: 'PRICE_CHANGED', since, limit: 30 })), safe(api.models({ min_context: 1_000_000, sort: 'release', limit: 12 }))]);
  const href = (d: number) => (d === 7 ? routes.pulse() : `${routes.pulse()}?days=${d}`);

  if (!pulse) {
    return (
      <Container wide>
        <PageHeader eyebrow="Ecosystem pulse" title="Pulse" lede="Deterministic counters over what occurred in the window." />
        <Unavailable what="Pulse" reason="GET /pulse did not answer. Counters are never cached or hardcoded." />
      </Container>
    );
  }
  const counters = pulse.counters ?? {};
  const hist = history?.items ?? [];
  const spark = (key: string): number[] => {
    const f = HISTORY_KEY[key];
    if (!f) return [];
    return hist.map((h) => f(h.counts as Record<string, unknown>)).filter((v): v is number => v !== null);
  };
  const strip: StripItem[] = Object.entries(counters).map(([key, c]) => {
    const vals = spark(key);
    return {
      label: LABELS[key] ?? key.replace(/_/g, ' '),
      value: fmtInt(c.value),
      definition: c.definition,
      href: HREF[key]?.(days),
      hint: vals.length >= 2 ? <Sparkline values={vals} width={64} height={16} stroke="var(--accent)" title={`${LABELS[key] ?? key} · daily stats history`} /> : num(c.median_percent) !== null ? `median ${fmtScore(c.median_percent)} %` : undefined,
    };
  });
  const leaders = (counters.new_benchmark_leaders?.items ?? []).filter(isLeader);
  const priceItems = (counters.price_changes?.items ?? []).filter(isEvent);
  const priceRows = priceItems.length ? priceItems : (priceFallback?.items ?? []);
  const ctxItems = (counters.new_models_1m_context?.items ?? []);
  const ctxModels: EntitySummary[] = ctxItems.filter(isModel);
  const ctxEvents: ChangeEvent[] = ctxItems.filter(isEvent);
  const historyDays = hist.length;
  const ld = { '@context': 'https://schema.org', '@type': 'Dataset', name: `AI Atlas Pulse · ${days} days`, description: DESC, url: `${SITE_URL}${routes.pulse()}`, temporalCoverage: `${pulse.since}/${pulse.until}`, creator: { '@type': 'Organization', name: SITE_NAME, url: SITE_URL } };

  return (
    <Container wide>
      <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(ld) }} />
      <PageHeader eyebrow="Ecosystem pulse" title={`The last ${days} days in AI`} lede="Deterministic counters over events that occurred in the window — historical backfill excluded, so a re-crawl of old pages never inflates them. Hover a label for how each one is counted." aside={<p className="tnum text-sm text-ink-3" title={`${pulse.since} → ${pulse.until}`}>{fmtDate(pulse.since)} → {fmtDateTime(pulse.until)}</p>}>
        <div className="mt-6">
          <p className="eyebrow mb-1.5">Window</p>
          <ChipRow label="Window" items={WINDOWS.map((d) => ({ href: href(d), label: `${d} days`, active: days === d }))} />
        </div>
      </PageHeader>

      <DataStrip items={strip} />
      <p className="tnum mt-2 text-xs text-ink-3">
        All counters use <span className="mono">is_backfill = false</span> and <span className="mono">occurred_at</span> inside the window. Sparklines show the daily stats history where a series exists ({historyDays} day{historyDays === 1 ? '' : 's'} recorded so far{historyDays < 2 ? ' — a line needs two' : ''}).
      </p>
      <Methodology text={pulse.note} className="mt-1" />

      {/* --------------------------------------------------------------------------------------------- leaders */}
      <Section eyebrow="Benchmark leadership" title={`New benchmark leaders · ${fmtInt(counters.new_benchmark_leaders?.value)}`} lede={counters.new_benchmark_leaders?.definition} action={{ href: routes.benchmarks(), label: 'All leaderboards' }}>
        {leaders.length === 0 ? (
          <EmptyState title="No leadership change in the window">The primary-group leader of every benchmark is unchanged over these {days} days.</EmptyState>
        ) : (
          <div className="md:overflow-x-auto">
          <DataTable caption="New benchmark leaders">
            <thead>
              <tr>
                <Th>Benchmark</Th>
                <Th>Current leader</Th>
                <Th num>Score</Th>
                <Th>Previous leader</Th>
                <Th>Group</Th>
                <Th>Trust</Th>
              </tr>
            </thead>
            <tbody>
              {leaders.map((l) => (
                <tr key={l.benchmark.id}>
                  <Td primary>
                    <Link href={routes.benchmark(l.benchmark.slug)} className="text-ink hover:text-accent hover:underline">
                      {l.benchmark.name}
                    </Link>
                  </Td>
                  <Td label="Current leader">
                    {l.current ? (
                      <>
                        <Link href={routes.entity({ entity_type: l.current.model.entity_type ?? 'model', slug: l.current.model.slug })} className="font-medium text-ink hover:text-accent hover:underline">
                          {l.current.model.name}
                        </Link>
                        {l.current.model.organization && <span className="ml-1.5 text-xs text-ink-3">{l.current.model.organization.name}</span>}
                      </>
                    ) : (
                      '—'
                    )}
                  </Td>
                  <Td num label="Score" className="tnum font-medium">{l.current ? `${fmtScore(l.current.score)}${l.current.metric ? ` ${l.current.metric}` : ''}` : '—'}</Td>
                  <Td label="Previous leader" className="text-ink-2">
                    {l.previous ? (
                      <>
                        <Link href={routes.entity({ entity_type: l.previous.model.entity_type ?? 'model', slug: l.previous.model.slug })} className="hover:text-accent">
                          {l.previous.model.name}
                        </Link>{' '}
                        <span className="tnum text-xs text-ink-3">{fmtScore(l.previous.score)}</span>
                      </>
                    ) : (
                      <span className="text-ink-3">first leader recorded</span>
                    )}
                  </Td>
                  <Td label="Group" className="mono text-[11px] text-ink-3">
                    {l.current?.group_label ?? '—'}
                    {num(l.current?.n_models) !== null && <span> · n={fmtInt(l.current?.n_models)}</span>}
                  </Td>
                  <Td label="Trust"><TrustChip level={l.current?.trust_level} /></Td>
                </tr>
              ))}
            </tbody>
          </DataTable>
          </div>
        )}
      </Section>

      {/* ---------------------------------------------------------------------------------------------- prices */}
      <Section eyebrow="Prices" title={`Price changes · ${fmtInt(counters.price_changes?.value)}${num(counters.price_changes?.median_percent) !== null ? ` · median ${fmtScore(counters.price_changes?.median_percent)} %` : ''}`} lede={counters.price_changes?.definition} action={{ href: routes.prices(), label: 'Price terminal' }}>
        {!priceItems.length && priceRows.length > 0 && <Note className="mb-2">The pulse returns the count only; the rows below are PRICE_CHANGED events since {fmtDate(since)} from the change feed (same window, same backfill rule).</Note>}
        <PriceMovers movers={priceRows} limit={30} />
      </Section>

      {/* --------------------------------------------------------------------------------------------- context */}
      <Section eyebrow="Long context" title={`New ≥ 1M-context models · ${fmtInt(counters.new_models_1m_context?.value)}`} lede={counters.new_models_1m_context?.definition}>
        {ctxModels.length > 0 ? (
          <ul className="border-t border-rule">
            {ctxModels.map((m) => (
              <li key={m.id} className="flex flex-wrap items-baseline gap-x-3 border-b border-rule py-2.5 text-sm">
                <EntityLink e={m} className="font-medium" />
                {m.organization && <span className="text-xs text-ink-3">{m.organization.name}</span>}
                <span className="tnum ml-auto text-xs text-ink-2">{fmtTokens(m.attributes?.context_length)} · {typeof m.attributes?.release_date === 'string' ? fmtDate(m.attributes.release_date) : '—'}</span>
              </li>
            ))}
          </ul>
        ) : ctxEvents.length > 0 ? (
          <ul className="border-t border-rule">{ctxEvents.map((e) => <ChangeRow key={e.id} e={e} showDate live={false} />)}</ul>
        ) : num(counters.new_models_1m_context?.value) === 0 ? (
          <>
            <EmptyState title={`No new model with a ≥ 1M-token context in the last ${days} days`}>
              {ctxFallback?.items.length ? <>For reference, the most recently released models with a sourced context of at least 1M tokens (any date):</> : null}
            </EmptyState>
            {ctxFallback?.items.length ? (
              <ul className="border-b border-rule">
                {ctxFallback.items.slice(0, 8).map((m) => (
                  <li key={m.id} className="flex flex-wrap items-baseline gap-x-3 border-b border-rule py-2 text-sm last:border-b-0">
                    <EntityLink e={m} />
                    {m.organization && <span className="text-xs text-ink-3">{m.organization.name}</span>}
                    <span className="tnum ml-auto text-xs text-ink-2">{fmtTokens(m.attributes?.context_length)} · {typeof m.attributes?.release_date === 'string' ? fmtDate(m.attributes.release_date) : 'release date unavailable'}</span>
                  </li>
                ))}
              </ul>
            ) : null}
          </>
        ) : (
          <EmptyState title={`${fmtInt(counters.new_models_1m_context?.value)} new ≥ 1M-context models`}>The pulse returns the count only; the list is not part of the API response yet.</EmptyState>
        )}
      </Section>

      <Section eyebrow="Reading the pulse" title="Definitions" hairline>
        <dl className="grid gap-x-8 gap-y-3 md:grid-cols-2">
          {Object.entries(counters).map(([k, c]) => (
            <div key={k} className="border-b border-rule pb-2">
              <dt className="flex items-baseline justify-between gap-3 text-sm font-medium text-ink">
                {LABELS[k] ?? k.replace(/_/g, ' ')} <span className="tnum text-ink-2">{fmtInt(c.value)}</span>
              </dt>
              <dd className="mt-0.5 text-xs leading-relaxed text-ink-3">{c.definition}</dd>
            </div>
          ))}
        </dl>
        <Note className="mt-3">
          Source: <Link href="/developers" className="link">GET /pulse?days={days}</Link>. Nothing on this page is a projection.
        </Note>
      </Section>
    </Container>
  );
}