import type { Metadata } from 'next';
import Link from 'next/link';
import { Sparkline } from '@/components/charts';
import { Dash, IntelListing, str } from '@/components/intelligence/listing-table';
import { Chip } from '@/components/ui/badges';
import { EntityLink, QualityMark } from '@/components/ui/entity';
import { api, safe } from '@/lib/api';
import { fmtDate, fmtInt, num } from '@/lib/format';
import { routes, SITE_NAME, SITE_URL } from '@/lib/site';

export const metadata: Metadata = { title: 'AI frameworks, inference engines, libraries and runtimes — versions, licences, stars', description: 'Training frameworks, inference engines, serving stacks, libraries, runtimes, agent frameworks, orchestration and eval harnesses with latest version, release date, licence and repository stars read from PyPI, GitHub and release pages.', alternates: { canonical: routes.frameworks() }, openGraph: { title: `AI frameworks | ${SITE_NAME}`, url: `${SITE_URL}${routes.frameworks()}`, siteName: SITE_NAME } };
export const revalidate = 300;

type Extra = { stars: number[] };
/** Canonical kind vocabulary → label; entity_type is the fallback when no `kind` attribute is stated. */
const KIND_LABELS: Record<string, string> = {
  training_framework: 'Training framework',
  training: 'Training framework',
  inference_engine: 'Inference engine',
  inference: 'Inference engine',
  serving: 'Serving',
  library: 'Library',
  runtime: 'Runtime',
  agent_framework: 'Agent framework',
  agent: 'Agent framework',
  orchestration: 'Orchestration',
  eval_harness: 'Eval harness',
  evaluation: 'Eval harness',
  framework: 'Framework',
};
const kindOf = (e: { entity_type: string; attributes: Record<string, unknown> }) => {
  const k = str(e.attributes?.kind) ?? str(e.attributes?.category);
  if (k) return KIND_LABELS[k.toLowerCase().replace(/[\s-]+/g, '_')] ?? k;
  return KIND_LABELS[e.entity_type] ?? e.entity_type;
};

export default async function FrameworksPage({ searchParams }: { searchParams: Promise<Record<string, string | undefined>> }) {
  const sp = await searchParams;
  return (
    <IntelListing<Extra>
      title="Frameworks & runtimes"
      eyebrow="Frameworks"
      lede="Training frameworks, inference engines, serving stacks, libraries, runtimes, agent frameworks, orchestration and eval harnesses. Versions and stars are read from PyPI, GitHub and release pages — never estimated."
      basePath="/frameworks"
      searchParams={sp}
      fetch={(q) => api.explore('framework', q)}
      sorts={[
        { value: 'updated', label: 'Recently updated' },
        { value: 'stars', label: 'Stars' },
        { value: 'release', label: 'Latest release' },
        { value: 'name', label: 'Name' },
        { value: 'quality', label: 'Data quality' },
      ]}
      filters={sp.org ? [{ kind: 'hidden', name: 'org', value: sp.org }] : []}
      connectors={['github (repositories)', 'pypi', 'release feeds']}
      compare
      enrich={async (items) => {
        const hist = await Promise.all(items.map((e) => safe(api.entityHistory(e.slug, 'metric.stars'))));
        const m = new Map<string, Extra>();
        hist.forEach((h, i) => {
          const vals = (h?.items ?? []).slice().sort((a, b) => a.observed_at.localeCompare(b.observed_at)).map((c) => num(c.value)).filter((v): v is number => v !== null);
          m.set(items[i]!.slug, { stars: vals });
        });
        return m;
      }}
      columns={[
        {
          key: 'name',
          label: 'Framework',
          primary: true,
          render: (e) => (
            <>
              <EntityLink e={e} />
              {e.description && <span className="block max-w-md truncate text-xs text-ink-3">{e.description}</span>}
            </>
          ),
        },
        { key: 'kind', label: 'Kind', render: (e) => <Chip>{kindOf(e)}</Chip> },
        { key: 'version', label: 'Latest release', className: 'mono text-xs text-ink', render: (e) => (str(e.attributes?.latest_version) ? <>{(str(e.attributes.latest_version) as string).slice(0, 24)}{str(e.attributes?.latest_release_at) && <span className="tnum block font-sans text-[11px] text-ink-3">{fmtDate(str(e.attributes.latest_release_at))}</span>}</> : <Dash />) },
        { key: 'license', label: 'Licence', className: 'max-w-[10rem] truncate text-ink-2', render: (e) => str(e.attributes?.license) ?? <Dash /> },
        {
          key: 'stars',
          label: 'Stars',
          num: true,
          className: 'tnum',
          render: (e, x) => {
            const v = num(e.attributes?.['metric.stars']);
            if (v === null) return <Dash />;
            const distinct = new Set(x?.stars ?? []).size;
            return (
              <span className="inline-flex items-center justify-end gap-2">
                {x && x.stars.length >= 2 && distinct >= 2 && <Sparkline values={x.stars} width={64} height={18} stroke="var(--type-framework)" title={`Stars history · ${x.stars.length} observations`} />}
                <span>{fmtInt(v)}</span>
              </span>
            );
          },
        },
        { key: 'language', label: 'Language', className: 'text-ink-2', render: (e) => str(e.attributes?.language) ?? <Dash /> },
        { key: 'org', label: 'Organization', className: 'text-ink-2', render: (e) => (e.organization ? <Link href={routes.entity({ entity_type: 'company', slug: e.organization.slug })} className="hover:text-accent">{e.organization.name}</Link> : <Dash />) },
        { key: 'quality', label: 'Quality', num: true, render: (e) => <QualityMark q={e.quality?.score} /> },
      ]}
      note="Stars are a GitHub metric observed at crawl time; the sparkline appears once the claim history holds two distinct values (see each framework's History tab). Kind falls back to the entity type (framework · library · runtime) when no source states a finer category."
    />
  );
}