/**
 * Agenten — Aufnahme und Verwaltung.
 *
 * Die heikle Stelle ist das Aufnahme-Token: Es wird **genau einmal** angezeigt
 * und danach nur noch als Hash gespeichert. Die Oberfläche sagt das
 * ausdrücklich und lässt sich nicht mit Escape schließen, solange es zu
 * sehen ist — wer es wegklickt, muss ein neues erzeugen.
 *
 * Der Agent bestimmt seinen Namen nicht selbst: Er steht **im Token**. Sonst
 * könnte er sich als ein anderes System ausgeben.
 */

import { Ban, Copy, KeyRound, MonitorCog, Plus, RefreshCw, Terminal } from 'lucide-react';
import { useCallback, useState } from 'react';
import { useApiResource } from '@/api/useApiResource';
import { describeApiError, useMutation } from '@/api/useMutation';
import { PageHeader } from '@/components/layout/PageHeader';
import {
  Button,
  Callout,
  Card,
  ConfirmDialog,
  DataTable,
  DialogBody,
  DialogContent,
  DialogFooter,
  DialogHeader,
  DialogRoot,
  ErrorState,
  StatusBadge,
  TextInput,
  useToast,
  type TableColumn,
} from '@/components/ui';
import { formatDateTime, formatRelativeTime } from '@/lib/utils';
import {
  createEnrollmentToken,
  listAgents,
  revokeAgent,
  rotateAgentCredentials,
  type Agent,
  type EnrollmentToken,
} from './infrastructureApi';

export function AgentsPage({
  grantedPermissions,
}: {
  readonly grantedPermissions: readonly string[];
}) {
  const toast = useToast();
  const [isEnrollDialogOpen, setIsEnrollDialogOpen] = useState(false);
  const [issuedToken, setIssuedToken] = useState<EnrollmentToken | null>(null);
  const [agentPendingRevoke, setAgentPendingRevoke] = useState<Agent | null>(null);
  const [draftAgentName, setDraftAgentName] = useState('');

  const agentsResource = useApiResource(
    useCallback((abortSignal) => listAgents(abortSignal), []),
  );

  const mayEnroll =
    grantedPermissions.includes('*') || grantedPermissions.includes('agents.enroll');
  const mayWrite =
    grantedPermissions.includes('*') || grantedPermissions.includes('agents.write');

  const enrollMutation = useMutation(createEnrollmentToken, {
    onSuccess: (token) => {
      setIssuedToken(token);
      setIsEnrollDialogOpen(false);
      setDraftAgentName('');
      agentsResource.reload();
    },
    onError: (apiError) =>
      toast.showError(
        'Das Aufnahme-Token ließ sich nicht erzeugen',
        describeApiError(apiError),
        apiError.requestId,
      ),
  });

  const revokeMutation = useMutation(revokeAgent, {
    onSuccess: () => {
      toast.showSuccess(
        'Agent gesperrt',
        'Sein Betriebstoken gilt sofort nicht mehr — nicht erst nach Ablauf.',
      );
      setAgentPendingRevoke(null);
      agentsResource.reload();
    },
    onError: (apiError) =>
      toast.showError('Die Sperre schlug fehl', describeApiError(apiError), apiError.requestId),
  });

  const rotateMutation = useMutation(rotateAgentCredentials, {
    onSuccess: () => {
      toast.showSuccess(
        'Betriebstoken erneuert',
        'Der Agent muss mit dem neuen Token versorgt werden, sonst meldet er sich nicht mehr.',
      );
      agentsResource.reload();
    },
    onError: (apiError) =>
      toast.showError('Fehlgeschlagen', describeApiError(apiError), apiError.requestId),
  });

  const agents = agentsResource.data ?? [];

  const tableColumns: ReadonlyArray<TableColumn<Agent>> = [
    {
      key: 'name',
      header: 'Agent',
      render: (agent) => (
        <div className="min-w-0">
          <p className="truncate font-medium text-fg">{agent.name}</p>
          <p className="truncate text-xs text-fg-muted">
            {agent.hostname ?? '—'}
            {agent.platform ? ` · ${agent.platform}` : ''}
            {agent.architecture ? `/${agent.architecture}` : ''}
          </p>
        </div>
      ),
    },
    {
      key: 'status',
      header: 'Zustand',
      render: (agent) => <StatusBadge status={agent.status} />,
    },
    {
      key: 'version',
      header: 'Fassung',
      render: (agent) => (
        <span className="font-mono text-xs text-fg-muted">{agent.version ?? '—'}</span>
      ),
    },
    {
      key: 'heartbeat',
      header: 'Letzte Meldung',
      render: (agent) =>
        agent.last_heartbeat_at ? (
          <span className="text-sm text-fg-muted">
            {formatRelativeTime(agent.last_heartbeat_at)}
          </span>
        ) : (
          <span className="text-xs text-warning">Noch nie</span>
        ),
    },
    {
      key: 'actions',
      header: '',
      className: 'w-px',
      render: (agent) =>
        mayWrite ? (
          <div
            className="flex items-center justify-end gap-1"
            onClick={(clickEvent) => clickEvent.stopPropagation()}
            onKeyDown={(keyboardEvent) => keyboardEvent.stopPropagation()}
            role="presentation"
          >
            <Button
              variant="ghost"
              size="sm"
              onClick={() => void rotateMutation.run(agent.id)}
              title="Betriebstoken erneuern"
            >
              <RefreshCw />
            </Button>
            {agent.status !== 'revoked' ? (
              <Button
                variant="ghost"
                size="sm"
                onClick={() => setAgentPendingRevoke(agent)}
                title="Agent sperren"
              >
                <Ban />
              </Button>
            ) : null}
          </div>
        ) : null,
    },
  ];

  if (agentsResource.loadState === 'failed' && agentsResource.loadError) {
    return (
      <>
        <PageHeader title="Agenten" />
        <Card>
          <ErrorState
            message={describeApiError(agentsResource.loadError)}
            requestId={agentsResource.loadError.requestId}
            onRetry={agentsResource.reload}
          />
        </Card>
      </>
    );
  }

  return (
    <>
      <PageHeader
        title="Agenten"
        description="Systeme, die sich selbst sichern."
        actions={
          mayEnroll ? (
            <Button variant="primary" onClick={() => setIsEnrollDialogOpen(true)}>
              <Plus />
              Agent aufnehmen
            </Button>
          ) : null
        }
      />

      <Callout tone="info" className="mb-4">
        Der Agent holt seine Aufträge ab; der Server drückt sie nicht.
      </Callout>

      <Card>
        <DataTable
          columns={tableColumns}
          rows={agents}
          getRowKey={(agent) => agent.id}
          isLoading={agentsResource.loadState === 'loading'}
          emptyTitle="Kein Agent aufgenommen"
          emptyDescription="Registrierung über ein Aufnahme-Token, gültig eine Stunde."
          emptyAction={
            mayEnroll ? (
              <Button variant="primary" onClick={() => setIsEnrollDialogOpen(true)}>
                <Plus />
                Ersten Agenten aufnehmen
              </Button>
            ) : null
          }
        />
      </Card>

      {/* --- Aufnahme --- */}
      <DialogRoot open={isEnrollDialogOpen} onOpenChange={setIsEnrollDialogOpen}>
        <DialogContent>
          <DialogHeader
            title="Agent aufnehmen"
            description="Erzeugt ein einmalig gültiges Aufnahme-Token."
          />
          <DialogBody>
            <TextInput
              label="Name des Agenten"
              required
              value={draftAgentName}
              onChange={(changeEvent) => setDraftAgentName(changeEvent.target.value)}
              placeholder="dateiserver-01"
              hint="Der Name steht im Token, nicht in der Hand des Agenten — sonst könnte er sich als ein anderes System ausgeben."
            />
            <Callout tone="info">
              Gilt eine Stunde und nur zur Registrierung.
            </Callout>
          </DialogBody>
          <DialogFooter>
            <Button variant="ghost" onClick={() => setIsEnrollDialogOpen(false)}>
              Abbrechen
            </Button>
            <Button
              variant="primary"
              isLoading={enrollMutation.isRunning}
              disabled={!draftAgentName.trim()}
              onClick={() => void enrollMutation.run(draftAgentName.trim(), 60)}
            >
              Token erzeugen
            </Button>
          </DialogFooter>
        </DialogContent>
      </DialogRoot>

      {/* --- Einmalige Anzeige des Tokens --- */}
      {issuedToken ? (
        <IssuedTokenDialog token={issuedToken} onClose={() => setIssuedToken(null)} />
      ) : null}

      <ConfirmDialog
        open={agentPendingRevoke !== null}
        onOpenChange={(isOpen) => !isOpen && setAgentPendingRevoke(null)}
        title="Agent sperren"
        description={agentPendingRevoke?.name}
        confirmLabel="Sperren"
        isDestructive
        isLoading={revokeMutation.isRunning}
        onConfirm={() => {
          if (agentPendingRevoke) {
            void revokeMutation.run(agentPendingRevoke.id);
          }
        }}
      >
        <Callout tone="warning">
          Das Betriebstoken gilt sofort nicht mehr. Geplante Sicherungen fallen aus.
        </Callout>
      </ConfirmDialog>
    </>
  );
}

/**
 * Zeigt das Aufnahme-Token einmalig.
 *
 * Der Dialog lässt sich nicht versehentlich schließen: Es gibt nur eine
 * Schaltfläche, und sie sagt, was sie bewirkt.
 */
/**
 * Zeigt das Aufnahme-Token einmalig — samt Anleitung für beide Systeme.
 *
 * Der Dialog lässt sich nicht versehentlich schließen: Es gibt nur eine
 * Schaltfläche, und sie sagt, was sie bewirkt.
 *
 * Die Befehle stehen **fertig ausgefüllt** da, mit Serveradresse und Token
 * eingesetzt. Eine Anleitung mit Platzhaltern führt zuverlässig dazu, dass
 * jemand `<token>` wörtlich einsetzt — und dann eine Fehlermeldung sucht, die
 * nichts mit seinem Problem zu tun hat.
 */
function IssuedTokenDialog({
  token,
  onClose,
}: {
  readonly token: EnrollmentToken;
  readonly onClose: () => void;
}) {
  const toast = useToast();
  const [copiedKey, setCopiedKey] = useState<string | null>(null);
  const [platform, setPlatform] = useState<'linux' | 'windows'>('linux');

  // Die Adresse, unter der die Konsole gerade läuft, ist auch die, unter der
  // der Agent den Server erreicht — jedenfalls im Normalfall hinter nginx.
  const serverAddress = window.location.origin;

  const copyText = async (textToCopy: string, entryKey: string) => {
    try {
      await navigator.clipboard.writeText(textToCopy);
      setCopiedKey(entryKey);
      window.setTimeout(() => setCopiedKey(null), 2000);
    } catch {
      toast.showInfo('Kopieren nicht möglich', 'Markieren Sie den Text und kopieren Sie von Hand.');
    }
  };

  const linuxSteps = [
    {
      key: 'linux-paket',
      title: '1. Paket auspacken',
      command: `sudo mkdir -p /opt/syncova-agent
sudo tar -xzf syncova-*-linux-amd64.tar.gz -C /tmp
sudo cp /tmp/syncova-*/bin/syncova-agent /opt/syncova-agent/`,
    },
    {
      key: 'linux-konto',
      title: '2. Dienstkonto und Verzeichnisse',
      command: `sudo useradd --system --no-create-home --shell /usr/sbin/nologin syncova-agent
sudo install -d -o syncova-agent -g syncova-agent /var/lib/syncova-agent`,
    },
    {
      key: 'linux-enroll',
      title: '3. Aufnehmen',
      command: `sudo -u syncova-agent /opt/syncova-agent/syncova-agent enroll \\
  --server ${serverAddress} \\
  --token ${token.token} \\
  --state /var/lib/syncova-agent/state.json`,
    },
    {
      key: 'linux-dienst',
      title: '4. Als Dienst einrichten',
      command: `sudo tee /etc/systemd/system/syncova-agent.service >/dev/null <<'EOF'
[Unit]
Description=Syncova Agent
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=syncova-agent
ExecStart=/opt/syncova-agent/syncova-agent run --state /var/lib/syncova-agent/state.json
Restart=on-failure
RestartSec=10
NoNewPrivileges=yes
ProtectSystem=strict
ReadWritePaths=/var/lib/syncova-agent
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now syncova-agent`,
    },
  ];

  const windowsSteps = [
    {
      key: 'win-paket',
      title: '1. Paket auspacken',
      command: `New-Item -ItemType Directory -Force "C:\\Program Files\\Syncova Agent"
Expand-Archive syncova-*-windows-amd64.zip -DestinationPath $env:TEMP\\syncova
Copy-Item $env:TEMP\\syncova\\*\\bin\\syncova-agent.exe "C:\\Program Files\\Syncova Agent\\"`,
    },
    {
      key: 'win-enroll',
      title: '2. Aufnehmen',
      command: `New-Item -ItemType Directory -Force "C:\\ProgramData\\Syncova"
& "C:\\Program Files\\Syncova Agent\\syncova-agent.exe" enroll \`
  --server ${serverAddress} \`
  --token ${token.token} \`
  --state "C:\\ProgramData\\Syncova\\state.json"`,
    },
    {
      key: 'win-dienst',
      title: '3. Als Dienst einrichten',
      command: `New-Service -Name SyncovaAgent \`
  -DisplayName "Syncova Agent" \`
  -BinaryPathName '"C:\\Program Files\\Syncova Agent\\syncova-agent.exe" run --state "C:\\ProgramData\\Syncova\\state.json"' \`
  -StartupType Automatic
Start-Service SyncovaAgent`,
    },
  ];

  const activeSteps = platform === 'linux' ? linuxSteps : windowsSteps;

  return (
    <DialogRoot open onOpenChange={() => undefined}>
      <DialogContent size="xl">
        <DialogHeader
          title="Agent aufnehmen"
          description={`Für „${token.agent_name}"`}
        />
        <DialogBody>
          <Callout tone="warning" title="Dieses Token erscheint genau einmal">
            Es wird nur als Hash gespeichert. Schließen Sie das Fenster erst,
            wenn der Agent aufgenommen ist.
          </Callout>

          <div className="border border-line bg-sunken p-3">
            <div className="flex items-start justify-between gap-3">
              <code className="min-w-0 break-all font-mono text-sm text-fg">
                {token.token}
              </code>
              <Button
                size="sm"
                className="shrink-0"
                onClick={() => void copyText(token.token, 'token')}
              >
                {copiedKey === 'token' ? <KeyRound /> : <Copy />}
                {copiedKey === 'token' ? 'Kopiert' : 'Kopieren'}
              </Button>
            </div>
            {token.expires_at ? (
              <p className="mt-2 text-xs text-fg-muted">
                Gültig bis {formatDateTime(token.expires_at)} — danach ein neues erzeugen.
              </p>
            ) : null}
          </div>

          {/* Systemwahl */}
          <div className="flex gap-2 border-b border-line pb-3">
            <Button
              size="sm"
              variant={platform === 'linux' ? 'primary' : 'ghost'}
              onClick={() => setPlatform('linux')}
            >
              <Terminal />
              Linux
            </Button>
            <Button
              size="sm"
              variant={platform === 'windows' ? 'primary' : 'ghost'}
              onClick={() => setPlatform('windows')}
            >
              <MonitorCog />
              Windows (PowerShell)
            </Button>
          </div>

          {platform === 'windows' ? (
            <Callout tone="warning">
              Der Windows-Dienst ist gebaut und übersetzt, aber{' '}
              <strong>nie auf echter Hardware gefahren</strong>. Der
              Kommandozeilenweg ist nachgewiesen.
            </Callout>
          ) : null}

          {activeSteps.map((step) => (
            <div key={step.key}>
              <div className="mb-1.5 flex items-center justify-between gap-2">
                <p className="text-sm font-medium text-fg">{step.title}</p>
                <Button
                  size="sm"
                  variant="ghost"
                  onClick={() => void copyText(step.command, step.key)}
                >
                  {copiedKey === step.key ? <KeyRound /> : <Copy />}
                  {copiedKey === step.key ? 'Kopiert' : 'Kopieren'}
                </Button>
              </div>
              <pre className="overflow-x-auto border border-line bg-sunken p-2.5 font-mono text-xs text-fg">
                {step.command}
              </pre>
            </div>
          ))}

          <Callout tone="info" title="Zwei Stolperstellen">
            <ul className="mt-1 space-y-1 text-xs">
              <li>
                <code className="font-mono">--state</code> erwartet eine{' '}
                <strong>Datei</strong>, kein Verzeichnis. Mit einem Verzeichnis
                hält sich der Agent für registriert und läuft ohne Token.
              </li>
              <li>
                Der Agent braucht <strong>Schreibzugriff auf das Repository</strong>.
                Auf einem gemeinsamen Server ist das der lokale Pfad, bei
                getrennten Maschinen eine Freigabe.
              </li>
            </ul>
          </Callout>
        </DialogBody>
        <DialogFooter>
          <Button variant="primary" onClick={onClose}>
            Der Agent ist aufgenommen
          </Button>
        </DialogFooter>
      </DialogContent>
    </DialogRoot>
  );
}