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

export const metadata: Metadata = { title: 'AI agents — developer, kind, underlying models, platform, licence', description: 'Agents recorded in the atlas: developer, agent kind, the models they run on (relations), platform, repository, licence and release date — from official sources only.', alternates: { canonical: routes.agents() }, openGraph: { title: `AI agents | ${SITE_NAME}`, url: `${SITE_URL}${routes.agents()}`, siteName: SITE_NAME } };
export const revalidate = 300;

type Extra = { models: EntitySummary[]; total: number };
const AGENT_KINDS: Record<string, string> = { coding: 'Coding agent', browser: 'Browser agent', computer_use: 'Computer use', research: 'Research agent', assistant: 'Assistant', workflow: 'Workflow', voice: 'Voice agent', mcp_server: 'MCP server' };

export default async function AgentsPage({ searchParams }: { searchParams: Promise<Record<string, string | undefined>> }) {
  const sp = await searchParams;
  return (
    <IntelListing<Extra>
      title="Agents"
      eyebrow="Agents & tools"
      lede={<>Autonomous and semi-autonomous systems built on the models in the atlas: who develops them, what kind they are, which models they run on, where they run. Related software lives under <Link href={routes.frameworks()} className="link">Frameworks</Link>; developer tools under <Link href={routes.tools()} className="link">Tools</Link>.</>}
      basePath="/agents"
      searchParams={sp}
      fetch={(q) => api.explore('agent', q)}
      sorts={[
        { value: 'updated', label: 'Recently updated' },
        { value: 'release', label: 'Release date' },
        { value: 'stars', label: 'Stars' },
        { value: 'name', label: 'Name' },
      ]}
      filters={sp.org ? [{ kind: 'hidden', name: 'org', value: sp.org }] : []}
      connectors={['github (agent repositories)', 'official product pages', 'mcp registries']}
      emptyHint={<>The atlas declares the <span className="mono">agent</span> entity type but no connector has produced one yet. <Link href={routes.frameworks()} className="link">Agent frameworks</Link> (LangChain, CrewAI, …) are listed under Frameworks.</>}
      enrich={async (items) => {
        const details = await Promise.all(items.map((e) => safe(api.entity(e.slug))));
        const m = new Map<string, Extra>();
        details.forEach((d, i) => {
          if (!d) return;
          const rel = (d.relations ?? []).filter((g) => g.direction === 'out' && ['uses', 'runs_on', 'derived_from', 'integrates'].includes(g.predicate));
          const models = rel.flatMap((g) => g.items.filter((x) => x.entity_type === 'model'));
          m.set(items[i]!.slug, { models, total: rel.reduce((n, g) => n + g.total, 0) });
        });
        return m;
      }}
      columns={[
        {
          key: 'name',
          label: 'Agent',
          primary: true,
          render: (e) => (
            <>
              <span className="flex flex-wrap items-center gap-x-2 gap-y-0.5">
                <EntityLink e={e} />
                {e.entity_type !== 'agent' && <EntityBadge type={e.entity_type} small />}
              </span>
              {e.description && <span className="block max-w-md truncate text-xs text-ink-3">{e.description}</span>}
            </>
          ),
        },
        { key: 'developer', label: 'Developer', 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> : str(e.attributes?.developer) ?? <Dash />) },
        { key: 'kind', label: 'Agent kind', render: (e) => { const k = str(e.attributes?.agent_kind) ?? str(e.attributes?.kind) ?? str(e.attributes?.category); return k ? <Chip>{AGENT_KINDS[k] ?? k.replace(/_/g, ' ')}</Chip> : <Dash />; } },
        {
          key: 'models',
          label: 'Underlying models',
          render: (e, x) => {
            const fromAttr = list(e.attributes?.models ?? e.attributes?.underlying_models);
            if (x?.models.length) return <span className="flex flex-wrap gap-1">{x.models.slice(0, 4).map((m) => <EntityLink key={m.id} e={m} className="text-xs" />)}{x.models.length > 4 && <span className="text-xs text-ink-3">+{x.models.length - 4}</span>}</span>;
            return fromAttr.length ? <span className="text-xs text-ink-2">{fromAttr.join(', ')}</span> : <Dash />;
          },
        },
        { key: 'platform', label: 'Platform', className: 'text-ink-2 text-xs', render: (e) => { const p = list(e.attributes?.platforms ?? e.attributes?.platform); return p.length ? p.join(' · ') : <Dash />; } },
        { key: 'repo', label: 'Repository', className: 'text-xs', render: (e) => { const u = str(e.attributes?.repository_url) ?? str(e.attributes?.official_url); return u ? <a href={u} target="_blank" rel="noopener noreferrer" className="text-ink-2 hover:text-accent">{u.replace(/^https?:\/\/(www\.)?/, '').replace(/\/$/, '').slice(0, 40)}</a> : <Dash />; } },
        { key: 'license', label: 'Licence', className: 'max-w-[10rem] truncate text-ink-2', render: (e) => str(e.attributes?.license) ?? <Dash /> },
        { key: 'release', label: 'Release', className: 'tnum text-ink-2 whitespace-nowrap', render: (e) => (str(e.attributes?.release_date) ? fmtDate(str(e.attributes.release_date)) : <Dash />) },
        { key: 'quality', label: 'Quality', num: true, render: (e) => <QualityMark q={e.quality?.score} /> },
      ]}
      note="Underlying models come from graph relations (uses · runs_on · derived_from · integrates) on each agent, else from the agent's stated attributes; a dash means no source has stated it."
    />
  );
}