"""
Serverseitiger SSH-Verbindungsaufbau (asyncssh).

Zentrales Sicherheitsprinzip (Konzept 4.2/4.4/6.4): der private Schluessel
wird pro Verbindung aus der DB geladen, entschluesselt, an asyncssh
uebergeben und danach nicht weiter referenziert -- er verlaesst den
Serverprozess nie und wird nicht geloggt. Strict Host Key Checking ist
Pflicht: ohne gepinnten Fingerprint wird die Verbindung abgelehnt.
"""
from __future__ import annotations

import logging

import asyncssh
import aiosqlite

from app.security.crypto import decrypt_secret

logger = logging.getLogger("jumphost.ssh_proxy")


class HostNotConfiguredError(Exception):
    pass


class HostKeyMismatchError(Exception):
    def __init__(self, expected: str | None, observed: str | None) -> None:
        self.expected = expected
        self.observed = observed
        super().__init__(f"Host-Key-Mismatch: erwartet={expected!r} beobachtet={observed!r}")


class HostKeyDiscoveryError(Exception):
    """Wird geworfen, wenn beim Host-Key-Discovery-Versuch (siehe
    discover_and_store_host_key) ueberhaupt KEIN Fingerprint beobachtet
    werden konnte (TCP/DNS/Timeout-Fehler VOR dem SSH-Key-Exchange) -- im
    Unterschied zu einem erwarteten Auth-Fehler NACH dem KEX (siehe dort).
    Der admin-only Endpunkt (admin/routes.py) faengt dies ab und liefert
    eine saubere 502 statt eines unbehandelten 500."""

    def __init__(self, host_id: int, reason: str) -> None:
        self.host_id = host_id
        self.reason = reason
        super().__init__(f"Host-Key-Ermittlung fuer Host {host_id} fehlgeschlagen: {reason}")


class HostKeyNotPinnedError(Exception):
    """Fuer den Host ist kein Host-Key hinterlegt.

    Bewusst ein harter Abbruch statt Trust-on-First-Use: ohne gepinnten
    Schluessel laesst sich nicht feststellen, ob am anderen Ende das
    erwartete System antwortet (Konzept 4.2/6.4).
    """

    def __init__(self, host_id: int) -> None:
        self.host_id = host_id
        super().__init__(
            "Fuer diesen Host ist kein SSH-Host-Key hinterlegt. Im Adminbereich unter "
            "'Server' -> Host-Key ermitteln einmalig uebernehmen (bewusste "
            "Vertrauensentscheidung), danach ist die Verbindung moeglich."
        )


class PrivateKeyUnusableError(Exception):
    """Der hinterlegte private Schluessel laesst sich nicht laden.

    Haeufigster Fall (und der Grund, warum es diese Klasse gibt): der
    Schluessel ist passphrasegeschuetzt, aber es ist keine -- oder die
    falsche -- Passphrase hinterlegt. asyncssh wirft dann
    KeyImportError("Passphrase must be specified to import encrypted
    private keys"), was ein ValueError und damit KEIN asyncssh.Error ist --
    es rauschte deshalb an saemtlichen Fehlerbehandlungen der WS-Routen
    vorbei und die Sitzung brach ohne verwertbare Meldung ab. Diese
    Exception traegt stattdessen einen fuer den Benutzer verstaendlichen
    deutschen Text, den die WS-Routen direkt an den Client durchreichen.
    """

    def __init__(self, message: str) -> None:
        super().__init__(message)


BCRYPT_MISSING_MESSAGE = (
    "Der private Schluessel ist passphrasegeschuetzt im OpenSSH-Format, auf dem "
    "Server fehlt aber das Python-Modul 'bcrypt' -- asyncssh kann die "
    "Schluesseldatei deshalb gar nicht erst entschluesseln. Weder der Schluessel "
    "noch die hinterlegte Passphrase sind schuld. Abhilfe: 'bcrypt' im "
    "Virtualenv der Anwendung nachinstallieren (pip install -r requirements.txt "
    "bzw. Ansible-Rolle python_runtime erneut ausrollen) und den Dienst "
    "jumphost-app neu starten."
)


def bcrypt_kdf_available() -> bool:
    """Ist das (formal optionale) bcrypt-Modul mit KDF-Unterstuetzung da?

    asyncssh und cryptography benoetigen es fuer die bcrypt_pbkdf-Ableitung,
    mit der OpenSSH verschluesselte Schluesseldateien schuetzt -- also fuer
    genau das Format, das 'ssh-keygen' standardmaessig erzeugt. Fehlt das
    Modul, scheitert JEDER passphrasegeschuetzte Schluessel mit
    "OpenSSH private key encryption requires bcrypt with KDF support", obwohl
    Schluessel und Passphrase korrekt sind. Es stand bis Phase 11 nicht in
    requirements.txt und fehlte deshalb im ausgerollten Virtualenv.
    """
    try:
        import bcrypt  # noqa: PLC0415 - bewusst lazy, das Modul ist optional
    except ImportError:
        return False
    return hasattr(bcrypt, "kdf")


def import_private_key_material(
    pem: bytes | str, passphrase: bytes | str | None = None
) -> asyncssh.SSHKey:
    """Importiert Schluesselmaterial und uebersetzt asyncssh-Importfehler in
    eine PrivateKeyUnusableError mit klarer Ursachenbeschreibung.

    Wird an ZWEI Stellen verwendet, bewusst mit identischer Semantik:
      * beim Verbindungsaufbau (load_private_key_for_host),
      * bereits beim Anlegen/Rotieren eines Schluessels im Adminbereich
        (app/admin/routes.py), damit ein unbrauchbarer Schluessel sofort
        mit HTTP 400 abgelehnt wird, statt erst beim ersten Verbindungs-
        versuch eines Benutzers aufzufallen.
    """
    if isinstance(pem, str):
        pem = pem.encode()
    if isinstance(passphrase, str):
        passphrase = passphrase.encode()
    if passphrase == b"":
        passphrase = None

    try:
        return asyncssh.import_private_key(pem, passphrase)
    except ValueError as exc:
        # Bewusst ValueError statt der konkreten asyncssh-Klassen:
        # KeyImportError, KeyEncryptionError und KeyGenerationError sind in
        # asyncssh allesamt ValueError-Unterklassen, ihre Namen und die
        # genaue Aufteilung unterscheiden sich aber zwischen asyncssh-
        # Versionen. Ein Zugriff auf einen in der installierten Version
        # nicht vorhandenen Klassennamen wuerde hier beim Import des Moduls
        # knallen -- diese Fassung ist gegen solche Versionsunterschiede
        # immun. asyncssh.Error (Protokollfehler) ist KEIN ValueError und
        # wird hier korrekterweise nicht mitgefangen.
        text = str(exc)

        if "bcrypt" in text.lower():
            # Umgebungsfehler, kein Benutzerfehler: ohne bcrypt kann asyncssh
            # OpenSSH-verschluesselte Schluessel grundsaetzlich nicht lesen.
            # Ohne diese Uebersetzung landete die englische asyncssh-Meldung
            # ungefiltert im Terminalfenster und sah nach einem kaputten
            # Schluessel aus.
            logger.error(
                "Import eines privaten Schluessels fehlgeschlagen: bcrypt fehlt im "
                "Virtualenv (asyncssh-Meldung: %s)", text,
            )
            raise PrivateKeyUnusableError(BCRYPT_MISSING_MESSAGE) from exc

        if "Passphrase must be specified" in text:
            raise PrivateKeyUnusableError(
                "Der private Schluessel ist passphrasegeschuetzt, es ist aber keine "
                "Passphrase hinterlegt. Die Passphrase im Adminbereich unter "
                "'SSH-Keys' nachtragen (Schluessel bearbeiten) oder einen "
                "unverschluesselten Schluessel hinterlegen."
            ) from exc

        if passphrase is not None:
            if "Incorrect passphrase" in text or "MAC" in text or "decrypt" in text.lower():
                raise PrivateKeyUnusableError(
                    "Die hinterlegte Passphrase passt nicht zum privaten Schluessel."
                ) from exc
            # Gegenprobe: manche asyncssh-Versionen quittieren eine Passphrase
            # zu einem UNverschluesselten Schluessel mit einem Importfehler.
            # In dem Fall ist nicht der Schluessel kaputt, sondern die
            # Passphrase ueberfluessig -- also ohne sie erneut versuchen.
            try:
                return asyncssh.import_private_key(pem, None)
            except ValueError:
                pass

        raise PrivateKeyUnusableError(
            f"Der private Schluessel konnte nicht gelesen werden: {text}"
        ) from exc


#: Fehler, die den Aufbau einer SSH-Sitzung verhindern und dem angemeldeten
#: Benutzer im Klartext gezeigt werden duerfen (keine Geheimnisse, nur
#: Konfigurations-/Erreichbarkeitsaussagen). Wird von terminal_ws.py und
#: sftp.py gemeinsam benutzt, damit beide Wege dieselbe Meldung zeigen.
SSH_SETUP_ERRORS: tuple[type[Exception], ...] = (
    HostNotConfiguredError,
    HostKeyNotPinnedError,
    HostKeyMismatchError,
    HostKeyDiscoveryError,
    PrivateKeyUnusableError,
)


def describe_connection_error(exc: Exception) -> str:
    """Deutsche Klartextmeldung zu einem Verbindungsfehler."""
    if isinstance(exc, HostKeyMismatchError):
        return (
            "Der SSH-Host-Key des Ziels weicht vom hinterlegten ab -- die Verbindung wurde "
            "abgebrochen, bevor Zugangsdaten gesendet wurden. "
            f"Erwartet: {exc.expected}; angeboten: {exc.observed}. Wurde das Zielsystem neu "
            "aufgesetzt, den Host-Key im Adminbereich erneut ermitteln."
        )
    if isinstance(exc, HostKeyDiscoveryError):
        return f"Das Ziel ist nicht erreichbar: {exc.reason}"
    return str(exc)


class _PinnedHostKeyClient(asyncssh.SSHClient):
    """Zweite Verteidigungslinie fuer Strict Host Key Checking.

    ACHTUNG: asyncssh ruft validate_host_public_key() nur auf, wenn
    known_hosts NICHT None ist -- diese Klasse allein hat das Pinning also
    nicht durchgesetzt (siehe _verified_host_key(), das die eigentliche
    Pruefung vor der Anmeldung uebernimmt). Sie bleibt erhalten, weil sie in
    Konfigurationen mit gesetztem known_hosts greift und nie schadet."""

    def __init__(self, expected_fingerprint: str | None, *, discovery_mode: bool = False) -> None:
        self.expected_fingerprint = expected_fingerprint
        self.discovery_mode = discovery_mode
        self.observed_fingerprint: str | None = None

    def validate_host_public_key(self, host, addr, port, key) -> bool:  # noqa: D102
        self.observed_fingerprint = key.get_fingerprint("sha256")
        if self.discovery_mode:
            # Nur ueber den expliziten Admin-Discovery-Endpunkt erreichbar,
            # niemals im regulaeren Verbindungspfad (siehe admin/routes.py).
            return True
        if not self.expected_fingerprint:
            return False
        return self.observed_fingerprint == self.expected_fingerprint


async def load_host(conn: aiosqlite.Connection, host_id: int) -> dict:
    cursor = await conn.execute(
        "SELECT id, hostname, address, port, os_type, protocol, ssh_host_key_fingerprint, "
        "ssh_username, file_transfer_enabled, host_group_id, "
        "rdp_username, rdp_domain, rdp_require_nla, clipboard_enabled, rdp_ignore_cert, "
        "ssh_host_key "
        "FROM hosts WHERE id = ? AND is_active = 1",
        (host_id,),
    )
    row = await cursor.fetchone()
    if row is None:
        raise HostNotConfiguredError(f"Host {host_id} nicht gefunden oder inaktiv")
    keys = (
        "id", "hostname", "address", "port", "os_type", "protocol",
        "ssh_host_key_fingerprint", "ssh_username", "file_transfer_enabled", "host_group_id",
        # Bugfix: die folgenden fuenf Spalten wurden bisher NICHT geladen,
        # obwohl build_rdp_params() (app/rdp_proxy/guacd_client.py) sie per
        # host.get(...) ausliest. Ergebnis war eine RDP-connect-Instruktion
        # ohne Benutzernamen und ohne Domaene -- das Zielsystem lehnt die
        # Anmeldung dann ab bzw. der Client haengt in "Warte auf Server ...".
        # Zusaetzlich war clipboard_enabled dadurch immer None (= Clipboard
        # dauerhaft gesperrt, unabhaengig von der Hostkonfiguration).
        "rdp_username", "rdp_domain", "rdp_require_nla", "clipboard_enabled",
        "rdp_ignore_cert",
        # Vollstaendiger Host-Key (Migration 0010): erlaubt es, den vom Ziel
        # angebotenen Schluessel VOR der Anmeldung byteweise zu vergleichen --
        # mit einem Fingerprint allein geht das nicht, den sieht man erst,
        # wenn der Server seinen Schluessel bereits praesentiert hat.
        "ssh_host_key",
    )
    host = dict(zip(keys, row))
    for flag in ("file_transfer_enabled", "rdp_require_nla", "clipboard_enabled", "rdp_ignore_cert"):
        host[flag] = bool(host[flag])
    return host


async def load_ssh_credential_for_host(
    conn: aiosqlite.Connection, host_id: int
) -> tuple[asyncssh.SSHKey, str | None]:
    """Laedt den dem Host zugeordneten Schluessel, entschluesselt ihn und gibt
    ihn zusammen mit dem am Schluessel hinterlegten Benutzernamen zurueck.

    Der Benutzername gehoert seit Migration 0010 zu den Zugangsdaten
    (ssh_keys.username) und nicht mehr zum Host: er ist Teil der Anmeldung,
    nicht der Beschreibung des Zielsystems. Ist zu dem Schluessel eine
    Passphrase hinterlegt (ssh_keys.passphrase_enc, Migration 0009), wird sie
    ebenfalls entschluesselt und an asyncssh uebergeben.
    """
    cursor = await conn.execute(
        "SELECT sk.private_key_enc, sk.passphrase_enc, sk.username FROM ssh_keys sk "
        "JOIN host_ssh_key_map m ON m.ssh_key_id = sk.id "
        "WHERE m.host_id = ? LIMIT 1",
        (host_id,),
    )
    row = await cursor.fetchone()
    if row is None:
        raise HostNotConfiguredError(f"Kein SSH-Schluessel fuer Host {host_id} hinterlegt")
    pem = decrypt_secret(row[0], associated_data=b"ssh_private_key")
    passphrase = (
        decrypt_secret(row[1], associated_data=b"ssh_key_passphrase") if row[1] else None
    )
    username = (row[2] or "").strip() or None
    try:
        return import_private_key_material(pem, passphrase), username
    finally:
        # Bestpraxis: Referenzen auf das Klartextmaterial so schnell wie
        # moeglich loslassen (Konzept 6.4).
        del pem
        del passphrase


async def load_private_key_for_host(conn: aiosqlite.Connection, host_id: int) -> asyncssh.SSHKey:
    """Rueckwaertskompatible Fassung ohne Benutzername (siehe
    load_ssh_credential_for_host)."""
    key, _username = await load_ssh_credential_for_host(conn, host_id)
    return key


def resolve_ssh_username(host: dict, credential_username: str | None) -> str:
    """Ermittelt den Anmeldenamen fuer eine SSH-Sitzung.

    Vorrang hat der Benutzername der Zugangsdaten (ssh_keys.username). Der
    alte Wert am Host (hosts.ssh_username) wird nur noch als Fallback fuer
    Datensaetze gelesen, die vor Migration 0010 angelegt wurden -- neue
    Schreibpfade und die Oberflaeche pflegen ihn nicht mehr.
    """
    username = (credential_username or "").strip() or (host.get("ssh_username") or "").strip()
    if not username:
        raise HostNotConfiguredError(
            "Fuer diesen Host ist kein SSH-Benutzername hinterlegt. Der Benutzername "
            "gehoert zum SSH-Key (Adminbereich -> Zugangsdaten -> SSH-Key bearbeiten)."
        )
    return username


async def _verified_host_key(
    conn: aiosqlite.Connection, host: dict
) -> asyncssh.SSHKey:
    """Holt den Host-Key des Ziels OHNE Anmeldung und prueft ihn gegen den
    hinterlegten Schluessel bzw. Fingerprint.

    Warum ueberhaupt ein eigener Schritt: asyncssh ruft
    SSHClient.validate_host_public_key() NUR auf, wenn known_hosts nicht None
    ist -- mit known_hosts=None ist die Host-Key-Pruefung komplett abgeschaltet
    und der Callback wird nie erreicht. Genau diese Kombination war hier im
    Einsatz, das Pinning also faktisch wirkungslos (aufgefallen, weil aus dem
    gleichen Grund auch die Host-Key-Ermittlung keinen Fingerprint mehr sah).
    asyncssh.get_server_host_key() fuehrt nur den Key-Exchange durch und
    liefert den Schluessel zurueck -- damit laesst sich VOR jeder Anmeldung
    entscheiden, ob das Gegenueber das erwartete System ist.
    """
    expected_fingerprint = (host.get("ssh_host_key_fingerprint") or "").strip()
    if not expected_fingerprint:
        raise HostKeyNotPinnedError(host["id"])

    try:
        observed_key = await asyncssh.get_server_host_key(
            host["address"], port=host["port"], connect_timeout=10
        )
    except (asyncssh.Error, OSError) as exc:
        raise HostKeyDiscoveryError(host["id"], str(exc)) from exc
    if observed_key is None:
        raise HostKeyDiscoveryError(host["id"], "Das Ziel hat keinen Host-Key gesendet")

    observed_fingerprint = observed_key.get_fingerprint("sha256")
    if observed_fingerprint != expected_fingerprint:
        raise HostKeyMismatchError(expected_fingerprint, observed_fingerprint)

    stored = (host.get("ssh_host_key") or "").strip()
    observed_pub = observed_key.export_public_key("openssh").decode().strip()
    if stored:
        # Schaerfer als der Fingerprintvergleich: byteweise Gleichheit des
        # gesamten Schluessels.
        if _public_key_body(stored) != _public_key_body(observed_pub):
            raise HostKeyMismatchError(expected_fingerprint, observed_fingerprint)
    else:
        # Altbestand (vor Migration 0010 ermittelt): Schluessel nachtragen,
        # nachdem er gegen den gepinnten Fingerprint geprueft wurde.
        await conn.execute(
            "UPDATE hosts SET ssh_host_key = ? WHERE id = ?", (observed_pub, host["id"])
        )
        await conn.commit()
    return observed_key


def _public_key_body(openssh_line: str) -> tuple[str, str]:
    """(Algorithmus, Base64-Material) einer OpenSSH-Zeile -- ohne Kommentar,
    der sich zwischen Exporten unterscheiden darf."""
    parts = openssh_line.split()
    if len(parts) < 2:
        return ("", openssh_line.strip())
    return (parts[0], parts[1])


async def connect_to_host(conn: aiosqlite.Connection, host_id: int) -> asyncssh.SSHClientConnection:
    host = await load_host(conn, host_id)
    if host["protocol"] != "ssh":
        raise HostNotConfiguredError("Host ist kein SSH-Ziel")

    # Reihenfolge mit Absicht: erst das Ziel identifizieren, dann erst
    # Schluesselmaterial entschluesseln und eine Anmeldung versuchen.
    trusted_key = await _verified_host_key(conn, host)
    private_key, credential_username = await load_ssh_credential_for_host(conn, host_id)
    username = resolve_ssh_username(host, credential_username)
    client_factory = lambda: _PinnedHostKeyClient(host["ssh_host_key_fingerprint"])

    try:
        connection = await asyncssh.connect(
            host["address"],
            port=host["port"],
            username=username,
            client_keys=[private_key],
            known_hosts=None,
            client_factory=client_factory,
            connect_timeout=10,
        )
    except asyncssh.Error as exc:
        logger.warning("SSH-Verbindungsfehler zu Host %s: %s", host_id, exc)
        raise

    # Zweite Haelfte des Pinnings: der Schluessel dieser Sitzung muss derselbe
    # sein wie der eben gepruefte. Faengt den (sehr schmalen) Fall ab, dass
    # zwischen Pruefung und Sitzungsaufbau ein anderes System antwortet.
    session_key = connection.get_server_host_key()
    session_fingerprint = session_key.get_fingerprint("sha256") if session_key else None
    if session_fingerprint != trusted_key.get_fingerprint("sha256"):
        connection.abort()
        logger.error(
            "Host-Key-Wechsel zwischen Pruefung und Sitzungsaufbau bei Host %s", host_id
        )
        raise HostKeyMismatchError(host["ssh_host_key_fingerprint"], session_fingerprint)
    return connection


async def discover_and_store_host_key(
    conn: aiosqlite.Connection, host_id: int, *, admin_user_id: int
) -> str:
    """Holt den Host-Key des Ziels EINMALIG und hinterlegt ihn (Fingerprint und
    vollstaendigen Schluessel) in der DB. Nur ueber einen dedizierten,
    admin-only Endpunkt aufrufbar -- jeder Aufruf ist eine bewusste
    Vertrauensentscheidung und wird im Audit-Log als solche vermerkt (siehe
    admin/routes.py).

    Bugfix (Meldung "Ziel nicht erreichbar: Permission denied for user ..."):
    Die Ermittlung lief bisher ueber einen vollstaendigen
    asyncssh.connect()-Versuch und las den Fingerprint aus dem Callback
    SSHClient.validate_host_public_key(). Diesen Callback ruft asyncssh aber
    NUR auf, wenn known_hosts nicht None ist -- mit known_hosts=None ist die
    Host-Key-Pruefung abgeschaltet und der Callback wird nie erreicht. Der
    Fingerprint blieb deshalb leer, und der voellig erwartbare Auth-Fehler der
    anschliessenden Anmeldung ("Permission denied") wurde als "Ziel nicht
    erreichbar" gemeldet, obwohl der Key-Exchange laengst erfolgreich war.
    Jetzt wird asyncssh.get_server_host_key() verwendet: das fuehrt nur den
    Key-Exchange durch, versucht gar keine Anmeldung und liefert den
    Schluessel direkt zurueck. Ein Auth-Fehler kann die Ermittlung damit
    nicht mehr verhindern."""
    host = await load_host(conn, host_id)
    if host["protocol"] != "ssh":
        raise HostNotConfiguredError("Host-Key-Ermittlung ist nur fuer SSH-Ziele moeglich")

    try:
        key = await asyncssh.get_server_host_key(
            host["address"], port=host["port"], connect_timeout=10
        )
    except (asyncssh.Error, OSError) as exc:
        logger.warning("Host-Key-Ermittlung fuer Host %s fehlgeschlagen: %s", host_id, exc)
        raise HostKeyDiscoveryError(host_id, str(exc)) from exc
    if key is None:
        raise HostKeyDiscoveryError(host_id, "Das Ziel hat keinen Host-Key gesendet")

    fingerprint = key.get_fingerprint("sha256")
    public_key = key.export_public_key("openssh").decode().strip()
    await conn.execute(
        "UPDATE hosts SET ssh_host_key_fingerprint = ?, ssh_host_key = ? WHERE id = ?",
        (fingerprint, public_key, host_id),
    )
    await conn.commit()
    logger.info(
        "Host-Key fuer Host %s durch Admin %s uebernommen: %s", host_id, admin_user_id, fingerprint
    )
    return fingerprint