#!/usr/bin/env python3
# ============================================================================
# ORBIT Uplink-Watchdog (MINIX / x86 — Plattform-Scope: NUR minix)
# Lumeon Media UG (haftungsbeschraenkt)
#
# ZWECK
#   Aktiver, device-gepinnter Datenpfad-Waechter fuer den LTE->WLAN-Failover.
#   Er schliesst die Luecke, die NetworkManager nicht schliessen kann:
#
#     - NM-Connectivity-Check laeuft mit interval=300 (5 Minuten), kennt keine
#       Fehlerschwelle, keine Mindesthaltezeit und keine Hysterese.
#     - NM prueft "Konnektivitaet", nicht "Datenpfad ueber DIESEN Uplink" mit
#       Applikations-Antwort. Eine halbtote LTE-Session (PDP steht, IP+Routen
#       da, Guthaben leer -> 100% Paketverlust bzw. TCP-ESTAB ohne Datenfluss)
#       wird zu spaet oder gar nicht erkannt.
#     - Solange die LTE-Default-Route (Metrik 100) gewinnt, verlaesst AUCH
#       WLAN-gesourcter Traffic das Geraet ueber enp1s0 (nur 192.168.1.240 ist
#       per ip-rule 30100 gepinnt) -> bei totem LTE ist ALLES tot.
#
#   Vorfall 2026-08-17 (Prepaid-Guthaben leer, ALDI TALK/Telefonica):
#   Tunnel 13-16 min tot, Player-Sync/Heartbeat/Realtime ueber eine Stunde
#   in Timeout-Schleifen. Siehe .planning/debug/lte-wlan-fallback-haenger.md
#
# ENTWURFSPRINZIPIEN
#   1) MESSEN STATT RATEN: Jeder Uplink wird per SO_BINDTODEVICE einzeln
#      geprueft — unabhaengig davon, welche Default-Route gerade gewinnt.
#   2) APPLIKATIONS-ANTWORT PFLICHT: Ein TCP-Connect allein beweist nichts
#      (am 17.08. stand TCP ESTAB, waehrend 43 Byte SSH-Banner unbestaetigt
#      in der Send-Q haengen blieben). Der Probe verlangt echte Bytes zurueck.
#   3) UND-BEDINGUNG GEGEN FEHLALARME: Abgestuft wird NUR, wenn LTE faellt UND
#      WLAN gleichzeitig traegt. Faellt das Probe-Ziel (VPS) oder das ganze
#      Internet aus, scheitern BEIDE Proben -> keine Aktion. Damit ist ein
#      Ausfall der Mess-Infrastruktur systematisch harmlos.
#   4) HYSTERESE: Rueckschaltung erst nach N Erfolgen in Folge UND einer
#      Mindesthaltezeit. Kein Flapping.
#   5) LAUFZEIT-AENDERUNG, NICHT PERSISTENT: Die Metrik wird per
#      `nmcli device modify` nur an der APPLIED connection gedreht. Ein Reboot
#      stellt automatisch den Profil-Default (LTE primaer) wieder her.
#   6) SELBSTHEILUNG DES LTE-PINS: Tabelle 100 + Regel 30100 werden nach jeder
#      Umschaltung geprueft und bei Bedarf wiederhergestellt, damit der
#      LTE-gepinnte Zweit-Tunnel (Port 46002) erreichbar bleibt.
#
# BETRIEB
#   systemd-Service als root, Restart=always. Ausgabe geht ins Journal.
#   Zustand zusaetzlich als JSON unter /run/orbit-uplink-watchdog.json.
#
#   Diagnose ohne jede Aenderung:  orbit-uplink-watchdog --check
#   Trockenlauf (entscheidet, aendert aber nichts): --dry-run
#
# Plattform-Scope: MINIX (x86/i915). core/ und pi_player/ werden NICHT
# beruehrt — dies ist reine System-/Netzwerk-Ebene.
# ============================================================================

import argparse
import json
import os
import re
import shutil
import signal
import socket
import subprocess
import sys
import time

VERSION = "1.0.0"
STATE_FILE = "/run/orbit-uplink-watchdog.json"
CONF_FILE = "/etc/orbit-uplink-watchdog.conf"

# ---------------------------------------------------------------------------
# Konfiguration (Defaults; ueberschreibbar via CONF_FILE oder Umgebung)
# ---------------------------------------------------------------------------
DEFAULTS = {
    # --- Uplinks ---
    "PRIMARY_IFACE": "enp1s0",           # LTE via RUT260 — gewuenschter Primaerpfad
    "PRIMARY_SRC_IP": "192.168.1.240",   # gepinnte Quell-IP (ip rule 30100)
    "PRIMARY_TABLE": "100",              # Policy-Routing-Tabelle des LTE-Pins
    "PRIMARY_RULE_PRIO": "30100",
    "PRIMARY_GATEWAY": "192.168.1.1",    # RUT260
    "FALLBACK_IFACE": "wlo1",
    "FALLBACK_CONN": "",                 # leer = automatisch ermitteln

    # --- Metriken ---
    # Normalzustand: LTE 100 (Ethernet-Default) schlaegt WLAN 600.
    # Abgestuft: 40100 — sicher oberhalb von WLAN 600 UND oberhalb eines
    # zusaetzlich NM-penalisierten WLAN (600 + 20000 = 20600).
    "METRIC_OK": "100",
    "METRIC_DEMOTED": "40100",

    # --- Probe ---
    "PROBE_TCP_HOST": "87.106.55.53",    # eigener VPS
    "PROBE_TCP_PORT": "22",
    "PROBE_TCP_EXPECT": "SSH-",          # Applikations-Antwort, portal-sicher
    "PROBE_TCP_TIMEOUT": "5",
    "PROBE_ICMP_HOSTS": "8.8.8.8,1.1.1.1",
    "PROBE_ICMP_TIMEOUT": "2",

    # --- Taktung / Schwellen ---
    "INTERVAL_OK": "30",       # Takt im gesunden Zustand
    "INTERVAL_FAST": "5",      # Takt sobald eine Probe gefallen ist
    # Blindfenster des Applikations-Probes. Solange ICMP durchgeht, wuerde ein
    # Pfad, der zwar Pakete an 8.8.8.8 zustellt aber keine Nutzdaten mehr traegt
    # (Portal, Drosselung, selektive Filterung), erst nach dieser Zeit auffallen.
    # 60 s haelt das Fenster innerhalb des 60-90-s-Ziels; der Preis sind rund
    # 2900 zusaetzliche "Connection closed"-Zeilen pro Tag im VPS-sshd-Log.
    "VERIFY_EVERY": "60",      # erzwungener Applikations-Probe (auch wenn ICMP ok)
    "FAIL_THRESHOLD": "3",     # Fehlschlaege in Folge bis Abstufung
    "OK_THRESHOLD": "4",       # Erfolge in Folge bis Rueckschaltung
    "MIN_HOLD_SEC": "180",     # Mindesthaltezeit nach jeder Umschaltung

    # --- Nebenwirkungen ---
    "KILL_STALE_SOCKETS": "1",       # verwaiste Sockets der alten Quell-IP zuruecksetzen
    "WLAN_REPAIR_AFTER": "90",       # Sekunden ohne IPv4 auf wlo1 bis Nudge
    "WLAN_REPAIR_COOLDOWN": "180",   # Mindestabstand zwischen zwei Nudges

    # --- Betriebsprotokoll ---
    "STATUS_EVERY": "600",           # periodische Lebenszeichen-Zeile im Journal
}


def load_config():
    cfg = dict(DEFAULTS)
    if os.path.exists(CONF_FILE):
        try:
            with open(CONF_FILE, "r", encoding="utf-8") as fh:
                for raw in fh:
                    line = raw.strip()
                    if not line or line.startswith("#") or "=" not in line:
                        continue
                    key, _, val = line.partition("=")
                    cfg[key.strip()] = val.strip().strip('"').strip("'")
        except OSError as exc:
            print("WARN  Config %s nicht lesbar: %s" % (CONF_FILE, exc), flush=True)
    for key in list(cfg):
        env = os.environ.get("ORBIT_UW_" + key)
        if env is not None:
            cfg[key] = env
    return cfg


def as_int(cfg, key):
    try:
        return int(str(cfg[key]).strip())
    except (KeyError, ValueError):
        return int(DEFAULTS[key])


def as_float(cfg, key):
    try:
        return float(str(cfg[key]).strip())
    except (KeyError, ValueError):
        return float(DEFAULTS[key])


# ---------------------------------------------------------------------------
# Logging (journald faengt stdout; Zeitstempel liefert systemd)
# ---------------------------------------------------------------------------
def log(level, msg):
    print("%-5s %s" % (level, msg), flush=True)


# ---------------------------------------------------------------------------
# Shell-Helfer
# ---------------------------------------------------------------------------
def run(cmd, timeout=15):
    """Fuehrt cmd (Liste) aus. Liefert (rc, stdout, stderr) — wirft nie."""
    try:
        proc = subprocess.run(
            cmd, capture_output=True, text=True, timeout=timeout, check=False
        )
        return proc.returncode, proc.stdout.strip(), proc.stderr.strip()
    except subprocess.TimeoutExpired:
        return 124, "", "timeout nach %ss: %s" % (timeout, " ".join(cmd))
    except OSError as exc:
        return 127, "", "%s: %s" % (type(exc).__name__, exc)


# ---------------------------------------------------------------------------
# Netzwerk-Zustand lesen
# ---------------------------------------------------------------------------
def ip_json(args):
    """`ip -j <args>` als Python-Struktur, oder None wenn nicht auswertbar.
    Strukturierte Auswertung statt Textsuche — ein Substring-Vergleich haelt
    eine Regel mit falscher Prioritaet oder eine Default-Route ueber das
    falsche Geraet faelschlich fuer korrekt (Codex-Review 2026-08-18)."""
    rc, out, _ = run(["ip", "-j"] + list(args), timeout=5)
    if rc != 0 or not out:
        return None
    try:
        data = json.loads(out)
    except ValueError:
        return None
    return data if isinstance(data, list) else None

_RE_INET = re.compile(r"\binet (\d+\.\d+\.\d+\.\d+)/")
_RE_VIA = re.compile(r"\bvia (\d+\.\d+\.\d+\.\d+)")
_RE_METRIC = re.compile(r"\bmetric (\d+)")


def iface_ipv4(iface):
    rc, out, _ = run(["ip", "-4", "-o", "addr", "show", "dev", iface], timeout=5)
    if rc != 0:
        return None
    match = _RE_INET.search(out)
    return match.group(1) if match else None


def default_route(iface):
    """(gateway, metric) der IPv4-Default-Route ueber iface — oder (None, None)."""
    rc, out, _ = run(["ip", "-4", "route", "show", "default", "dev", iface], timeout=5)
    if rc != 0 or not out:
        return None, None
    line = out.splitlines()[0]
    gw = _RE_VIA.search(line)
    metric = _RE_METRIC.search(line)
    return (gw.group(1) if gw else None,
            int(metric.group(1)) if metric else None)


def winning_default_iface():
    """Interface der aktuell gewinnenden IPv4-Default-Route."""
    rc, out, _ = run(["ip", "-4", "route", "show", "default"], timeout=5)
    if rc != 0 or not out:
        return None
    best_iface, best_metric = None, None
    for line in out.splitlines():
        parts = line.split()
        if "dev" not in parts:
            continue
        iface = parts[parts.index("dev") + 1]
        metric_match = _RE_METRIC.search(line)
        metric = int(metric_match.group(1)) if metric_match else 0
        if best_metric is None or metric < best_metric:
            best_iface, best_metric = iface, metric
    return best_iface


# ---------------------------------------------------------------------------
# Proben — jede Messung ist an EIN Interface gebunden (SO_BINDTODEVICE),
# unabhaengig von der aktuell gewinnenden Default-Route.
# ---------------------------------------------------------------------------
def probe_icmp(iface, hosts, timeout):
    """Billige Vorstufe. True sobald EIN Ziel antwortet."""
    for host in hosts:
        rc, _, _ = run(
            ["ping", "-n", "-q", "-I", iface, "-c", "1", "-W", str(timeout), host],
            timeout=timeout + 3,
        )
        if rc == 0:
            return True
    return False


def probe_tcp(iface, host, port, expect, timeout):
    """
    Applikations-Autoritaet: TCP aufbauen UND echte Antwort-Bytes lesen.
    Ein blosser Connect wuerde die halbtote Session nicht entlarven
    (17.08.: TCP ESTAB, aber Banner blieb unbestaetigt in der Send-Q).
    """
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, iface.encode())
        sock.settimeout(timeout)
        sock.connect((host, port))
        data = sock.recv(64)
        return data.startswith(expect.encode())
    except (OSError, socket.timeout):
        return False
    finally:
        try:
            sock.close()
        except OSError:
            pass


class Prober:
    """Zweistufiger Probe mit erzwungener periodischer Applikations-Pruefung."""

    def __init__(self, cfg):
        self.icmp_hosts = [h.strip() for h in cfg["PROBE_ICMP_HOSTS"].split(",") if h.strip()]
        self.icmp_timeout = as_float(cfg, "PROBE_ICMP_TIMEOUT")
        self.tcp_host = cfg["PROBE_TCP_HOST"]
        self.tcp_port = as_int(cfg, "PROBE_TCP_PORT")
        self.tcp_expect = cfg["PROBE_TCP_EXPECT"]
        self.tcp_timeout = as_float(cfg, "PROBE_TCP_TIMEOUT")
        self.verify_every = as_int(cfg, "VERIFY_EVERY")
        self._last_verify = {}

    def probe(self, iface, force_app=False):
        """
        Liefert (ok, methode).
        Der Applikations-Probe entscheidet immer dann, wenn er laeuft:
        bei ICMP-Fehler, bei faelliger Validierung oder auf Anforderung.
        """
        now = time.monotonic()
        icmp_ok = probe_icmp(iface, self.icmp_hosts, self.icmp_timeout)
        verify_due = (now - self._last_verify.get(iface, -1e9)) >= self.verify_every
        if icmp_ok and not (verify_due or force_app):
            return True, "icmp"
        self._last_verify[iface] = now
        app_ok = probe_tcp(iface, self.tcp_host, self.tcp_port,
                           self.tcp_expect, self.tcp_timeout)
        if app_ok:
            return True, "app"
        return False, "app-fail(icmp=%s)" % ("ok" if icmp_ok else "fail")


# ---------------------------------------------------------------------------
# Stellglieder
# ---------------------------------------------------------------------------
def set_route_metric(iface, metric):
    """
    Laufzeit-Aenderung an der APPLIED connection (nicht persistent!).
    Reboot stellt automatisch den Profil-Default wieder her.
    """
    rc, out, err = run(
        ["nmcli", "device", "modify", iface,
         "ipv4.route-metric", str(metric),
         "ipv6.route-metric", str(metric)],
        timeout=30,
    )
    if rc != 0:
        log("WARN", "nmcli device modify %s route-metric %s fehlgeschlagen (rc=%s): %s"
            % (iface, metric, rc, err or out))
    return rc == 0


def force_route_metric(iface, gateway, metric):
    """Notnagel, falls nmcli die Kernel-Metrik nicht durchsetzt."""
    rc, _, err = run(
        ["ip", "route", "replace", "default", "via", gateway,
         "dev", iface, "metric", str(metric)],
        timeout=10,
    )
    if rc != 0:
        log("WARN", "ip route replace (%s metric %s) fehlgeschlagen: %s"
            % (iface, metric, err))
    return rc == 0


def ensure_lte_pin(cfg):
    """
    Tabelle 100 + Regel 30100 wiederherstellen, falls ein Reapply sie
    abgeraeumt hat. Ohne den Pin ist der LTE-Zweit-Tunnel (46002) tot —
    also genau der Rueckweg, der bei kaputtem Default-Pfad zaehlt.
    """
    table = cfg["PRIMARY_TABLE"]
    prio = cfg["PRIMARY_RULE_PRIO"]
    src = cfg["PRIMARY_SRC_IP"]
    iface = cfg["PRIMARY_IFACE"]
    gateway = cfg["PRIMARY_GATEWAY"]
    healed = []

    # --- Regel: exakt Prioritaet + Quelle + Zieltabelle ---
    rules = ip_json(["rule", "show"])
    if rules is None:
        rc, out, _ = run(["ip", "rule", "show"], timeout=5)
        rule_ok = rc == 0 and ("from %s lookup %s" % (src, table)) in out
    else:
        rule_ok = any(
            str(r.get("src")) == src
            and str(r.get("table")) == str(table)
            and str(r.get("priority")) == str(prio)
            for r in rules
        )
    if not rule_ok:
        # Eine Regel mit derselben Prioritaet, aber falschem Inhalt wuerde sonst
        # stehen bleiben und die neue ueberlagern.
        run(["ip", "rule", "del", "priority", prio], timeout=5)
        rc2, _, err = run(["ip", "rule", "add", "priority", prio,
                           "from", src, "table", table], timeout=5)
        healed.append("rule %s %s" % (prio, "ok" if rc2 == 0 else "FEHLER: " + err))

    # --- Default-Route der Tabelle: exakt Gateway + Geraet ---
    routes = ip_json(["route", "show", "table", table])
    if routes is None:
        rc, out, _ = run(["ip", "route", "show", "table", table], timeout=5)
        route_ok = rc == 0 and "default" in out
    else:
        route_ok = any(
            r.get("dst") == "default"
            and r.get("gateway") == gateway
            and r.get("dev") == iface
            for r in routes
        )
    if not route_ok:
        rc2, _, err = run(["ip", "route", "replace", "default", "via", gateway,
                           "dev", iface, "table", table], timeout=5)
        healed.append("table %s default %s" % (table, "ok" if rc2 == 0 else "FEHLER: " + err))

    if healed:
        log("WARN", "LTE-Pin war unvollstaendig, wiederhergestellt: %s" % "; ".join(healed))
    return healed


def kill_stale_sockets(src_ip):
    """
    Sockets mit der alten Quell-IP hart zuruecksetzen. Ohne das haengen
    langlebige Verbindungen am Kernel-TCP-Timeout (am 17.08. war der
    Reverse-Tunnel deshalb 13-16 Minuten tot), obwohl der neue Pfad laengst
    traegt. Betroffene Dienste (Tunnel, Player) bauen sofort neu auf.
    """
    if not src_ip or not shutil.which("ss"):
        return False
    # Vor dem Reset protokollieren, WAS getroffen wird — der Eingriff ist breit
    # (alle TCP-Sockets dieser Quell-IP: Tunnel, Player-Downloads, Heartbeat,
    # Wartungs-SSH) und war bisher im Nachhinein nicht nachvollziehbar.
    rc0, out0, _ = run(["ss", "-tn", "src", src_ip], timeout=10)
    if rc0 == 0 and out0:
        rows = [ln for ln in out0.splitlines()[1:] if ln.strip()]
        peers = []
        for ln in rows[:8]:
            parts = ln.split()
            if len(parts) >= 5:
                peers.append(parts[4])
        log("INFO", "Setze %d Socket(s) mit Quell-IP %s zurueck%s"
            % (len(rows), src_ip,
               (" -> " + ", ".join(peers)) if peers else ""))
    rc, _, err = run(["ss", "-K", "src", src_ip], timeout=10)
    if rc != 0:
        log("WARN", "ss -K src %s fehlgeschlagen (rc=%s): %s" % (src_ip, rc, err))
        return False
    log("INFO", "Verwaiste Sockets mit Quell-IP %s zurueckgesetzt" % src_ip)
    return True


def nm_recheck_connectivity():
    """NMs eigene Sicht anstossen, damit sein Penalty nicht gegen uns arbeitet."""
    run(["nmcli", "networking", "connectivity", "check"], timeout=20)


def resolve_fallback_conn(cfg):
    """Profilname der WLAN-Verbindung ermitteln (konfiguriert oder autoconnect)."""
    if cfg["FALLBACK_CONN"]:
        return cfg["FALLBACK_CONN"]
    iface = cfg["FALLBACK_IFACE"]
    rc, out, _ = run(["nmcli", "-t", "-f", "NAME,DEVICE", "connection", "show"], timeout=10)
    if rc != 0:
        return ""
    for line in out.splitlines():
        parts = line.split(":")
        if len(parts) >= 2 and parts[-1] == iface:
            return ":".join(parts[:-1])
    return ""


# ---------------------------------------------------------------------------
# Watchdog
# ---------------------------------------------------------------------------
class Watchdog:
    STATE_PRIMARY = "primary"
    STATE_FALLBACK = "fallback"

    def __init__(self, cfg, dry_run=False):
        self.cfg = cfg
        self.dry_run = dry_run
        self.prober = Prober(cfg)

        self.primary = cfg["PRIMARY_IFACE"]
        self.fallback = cfg["FALLBACK_IFACE"]
        self.metric_ok = as_int(cfg, "METRIC_OK")
        self.metric_demoted = as_int(cfg, "METRIC_DEMOTED")
        self.interval_ok = as_float(cfg, "INTERVAL_OK")
        self.interval_fast = as_float(cfg, "INTERVAL_FAST")
        self.fail_threshold = as_int(cfg, "FAIL_THRESHOLD")
        self.ok_threshold = as_int(cfg, "OK_THRESHOLD")
        self.min_hold = as_float(cfg, "MIN_HOLD_SEC")
        self.kill_sockets = cfg["KILL_STALE_SOCKETS"] not in ("0", "no", "false", "")
        self.wlan_repair_after = as_float(cfg, "WLAN_REPAIR_AFTER")
        self.wlan_repair_cooldown = as_float(cfg, "WLAN_REPAIR_COOLDOWN")

        self.fail_count = 0
        self.ok_count = 0
        self.last_switch = 0.0
        self.wlan_down_since = None
        self.last_wlan_repair = 0.0
        self.wlan_repair_attempts = 0
        self.both_dead_logged = False
        self.status_every = as_float(cfg, "STATUS_EVERY")
        self.last_status = 0.0
        self.running = True

        self.state = self._detect_state()

    # -- Zustandserkennung beim Start: eine Rest-Abstufung aus einem
    #    frueheren Lauf wird uebernommen, nicht blind ueberschrieben.
    def _detect_state(self):
        _, metric = default_route(self.primary)
        if metric is not None and metric >= self.metric_demoted:
            self.last_switch = time.monotonic()
            log("INFO", "Startzustand: %s traegt bereits Metrik %s -> FALLBACK uebernommen"
                % (self.primary, metric))
            return self.STATE_FALLBACK
        return self.STATE_PRIMARY

    # -- Umschalten ---------------------------------------------------------
    def _demote(self, reason):
        old_src = iface_ipv4(self.primary)
        log("WARN", "UMSCHALTUNG auf Fallback (%s -> %s): %s"
            % (self.primary, self.fallback, reason))
        if self.dry_run:
            log("INFO", "[dry-run] keine Aenderung durchgefuehrt")
            self.state = self.STATE_FALLBACK
            self.last_switch = time.monotonic()
            return

        # REIHENFOLGE IST ENTSCHEIDEND (on-device gemessen 2026-08-18):
        # `ss -K` sendet RST ueber den Pfad, der im Moment des Kills GEWINNT.
        # Laeuft der Kill erst nach dem Metrik-Wechsel, verlaesst das RST das
        # Geraet mit der ALTEN Quell-IP ueber den NEUEN Uplink und wird
        # unterwegs verworfen. Die Gegenstelle bleibt dann auf ESTAB mit
        # Send-Q>0 haengen und gibt den Reverse-Tunnel-Port erst nach dem
        # Kernel-TCP-Timeout frei — gemessen: Rueckschaltung 10:06:43,
        # Port 46001 noch um 10:13:25 blockiert (>6,5 min). In der
        # Gegenrichtung fiel das nicht auf, weil ip-rule 30100 die LTE-Quell-IP
        # ohnehin auf den alten Pfad zwingt und das RST deshalb ankam.
        #
        # GRENZE DIESER MASSNAHME (Codex-Review 2026-08-18): Sie hilft nur,
        # solange der ALTE Pfad das RST noch transportieren kann. Beim realen
        # Guthaben-leer-Fall ist er tot — dann kommt auch das vorgezogene RST
        # nicht an und die Gegenstelle muss VPS-seitig abgeraeumt werden
        # (siehe infra/vps/orbit-tunnel-reaper).
        if self.kill_sockets:
            kill_stale_sockets(old_src)

        if not set_route_metric(self.primary, self.metric_demoted):
            gateway, _ = default_route(self.primary)
            force_route_metric(self.primary, gateway or self.cfg["PRIMARY_GATEWAY"],
                               self.metric_demoted)
        self._verify_metric(self.metric_demoted)
        ensure_lte_pin(self.cfg)
        if self.kill_sockets:
            # Zweiter Durchgang: was sich zwischen Kill und Metrik-Wechsel
            # erneut ueber den alten Pfad aufgebaut hat, faellt hier weg.
            kill_stale_sockets(old_src)
        nm_recheck_connectivity()

        self.state = self.STATE_FALLBACK
        self.last_switch = time.monotonic()
        self.fail_count = 0
        self.ok_count = 0
        log("INFO", "Fallback aktiv — gewinnende Default-Route: %s"
            % (winning_default_iface() or "unbekannt"))

    def _promote(self, reason):
        old_src = iface_ipv4(self.fallback)
        log("INFO", "RUECKSCHALTUNG auf Primaerpfad (%s): %s" % (self.primary, reason))
        if self.dry_run:
            log("INFO", "[dry-run] keine Aenderung durchgefuehrt")
            self.state = self.STATE_PRIMARY
            self.last_switch = time.monotonic()
            return

        # REIHENFOLGE IST ENTSCHEIDEND (on-device gemessen 2026-08-18):
        # `ss -K` sendet RST ueber den Pfad, der im Moment des Kills GEWINNT.
        # Laeuft der Kill erst nach dem Metrik-Wechsel, verlaesst das RST das
        # Geraet mit der ALTEN Quell-IP ueber den NEUEN Uplink und wird
        # unterwegs verworfen. Die Gegenstelle bleibt dann auf ESTAB mit
        # Send-Q>0 haengen und gibt den Reverse-Tunnel-Port erst nach dem
        # Kernel-TCP-Timeout frei — gemessen: Rueckschaltung 10:06:43,
        # Port 46001 noch um 10:13:25 blockiert (>6,5 min). In der
        # Gegenrichtung fiel das nicht auf, weil ip-rule 30100 die LTE-Quell-IP
        # ohnehin auf den alten Pfad zwingt und das RST deshalb ankam.
        #
        # GRENZE DIESER MASSNAHME (Codex-Review 2026-08-18): Sie hilft nur,
        # solange der ALTE Pfad das RST noch transportieren kann. Beim realen
        # Guthaben-leer-Fall ist er tot — dann kommt auch das vorgezogene RST
        # nicht an und die Gegenstelle muss VPS-seitig abgeraeumt werden
        # (siehe infra/vps/orbit-tunnel-reaper).
        if self.kill_sockets:
            kill_stale_sockets(old_src)

        if not set_route_metric(self.primary, self.metric_ok):
            gateway, _ = default_route(self.primary)
            force_route_metric(self.primary, gateway or self.cfg["PRIMARY_GATEWAY"],
                               self.metric_ok)
        self._verify_metric(self.metric_ok)
        ensure_lte_pin(self.cfg)
        if self.kill_sockets:
            # Zweiter Durchgang: was sich zwischen Kill und Metrik-Wechsel
            # erneut ueber den alten Pfad aufgebaut hat, faellt hier weg.
            kill_stale_sockets(old_src)
        nm_recheck_connectivity()

        self.state = self.STATE_PRIMARY
        self.last_switch = time.monotonic()
        self.fail_count = 0
        self.ok_count = 0
        log("INFO", "Primaerpfad aktiv — gewinnende Default-Route: %s"
            % (winning_default_iface() or "unbekannt"))

    def _verify_metric(self, expected):
        """Beweis statt Annahme: hat die Kernel-Route die Metrik wirklich?"""
        for _ in range(10):
            _, metric = default_route(self.primary)
            if metric == expected:
                return True
            time.sleep(0.5)
        _, metric = default_route(self.primary)
        log("WARN", "Metrik von %s ist %s, erwartet %s — Notnagel greift"
            % (self.primary, metric, expected))
        gateway, _ = default_route(self.primary)
        return force_route_metric(self.primary,
                                  gateway or self.cfg["PRIMARY_GATEWAY"], expected)

    # -- WLAN-Reparatur -----------------------------------------------------
    def _maybe_repair_wlan(self, now):
        """
        Am 17.08. hing wlo1 nach einem AP-Roaming 41 Minuten ohne DHCP-Lease
        (neuer AP antwortete nicht), waehrend NMs eigener Retry-Backoff
        immer laengere Pausen machte. Ein beschraenkter Nudge verkuerzt das.
        """
        if iface_ipv4(self.fallback):
            if self.wlan_down_since is not None:
                log("INFO", "%s hat wieder eine IPv4-Adresse" % self.fallback)
            self.wlan_down_since = None
            self.wlan_repair_attempts = 0
            return
        if self.wlan_down_since is None:
            self.wlan_down_since = now
            log("WARN", "%s ohne IPv4-Adresse — Fallback derzeit nicht verfuegbar"
                % self.fallback)
            return
        if now - self.wlan_down_since < self.wlan_repair_after:
            return
        # Wachsender Abstand: ein Gastnetz, das dauerhaft kein DHCP liefert,
        # soll nicht endlos angestossen werden (stoert Roaming, flutet das Log).
        backoff = self.wlan_repair_cooldown * (2 ** min(self.wlan_repair_attempts, 4))
        if now - self.last_wlan_repair < backoff:
            return
        conn = resolve_fallback_conn(self.cfg)
        self.last_wlan_repair = now
        self.wlan_repair_attempts += 1
        if not conn:
            log("WARN", "Kein WLAN-Profil ermittelbar — kein Reparaturversuch moeglich")
            return
        log("WARN", "WLAN seit %.0fs ohne IPv4 — erzwinge Neuaufbau von '%s'"
            % (now - self.wlan_down_since, conn))
        if self.dry_run:
            return
        run(["nmcli", "connection", "up", conn], timeout=60)

    # -- Stellzustand gegen Drift absichern ---------------------------------
    def _enforce_desired_metric(self):
        """
        NetworkManager setzt die APPLIED-Metrik bei Reapply, DHCP-Renew oder
        eigenem Neustart auf den Profilwert zurueck. Ohne Nachfuehrung stuende
        der Watchdog weiter auf 'fallback', waehrend die Default-Route laengst
        wieder ueber den toten Primaerpfad gewinnt — genau das oszillierende
        Verhalten, das am 17.08. beobachtet wurde (Codex-Review 2026-08-18).
        """
        if self.dry_run:
            return
        want = (self.metric_demoted if self.state == self.STATE_FALLBACK
                else self.metric_ok)
        _, metric = default_route(self.primary)
        if metric is None or metric == want:
            return
        log("WARN", "Metrik-Drift auf %s: ist %s, soll %s (Zustand=%s) — wird nachgefuehrt"
            % (self.primary, metric, want, self.state))
        if not set_route_metric(self.primary, want):
            gateway, _ = default_route(self.primary)
            force_route_metric(self.primary,
                               gateway or self.cfg["PRIMARY_GATEWAY"], want)
        ensure_lte_pin(self.cfg)

    # -- Zustand veroeffentlichen -------------------------------------------
    def _write_state(self, snapshot):
        try:
            tmp = STATE_FILE + ".tmp"
            with open(tmp, "w", encoding="utf-8") as fh:
                json.dump(snapshot, fh, indent=2)
            os.replace(tmp, STATE_FILE)
        except OSError:
            pass

    # -- Hauptschleife ------------------------------------------------------
    def stop(self, *_):
        self.running = False

    def run_forever(self):
        log("INFO", "orbit-uplink-watchdog %s gestartet (primaer=%s, fallback=%s, "
                    "Takt %ss/%ss, Schwelle %s/%s, Haltezeit %ss, dry_run=%s)"
            % (VERSION, self.primary, self.fallback, self.interval_ok,
               self.interval_fast, self.fail_threshold, self.ok_threshold,
               self.min_hold, self.dry_run))

        while self.running:
            now = time.monotonic()
            primary_ok, primary_how = self.prober.probe(self.primary)

            # WLAN nur messen, wenn es entscheidungsrelevant ist oder wir
            # ohnehin darauf stehen — spart Takt und Rauschen.
            need_fallback_probe = (not primary_ok) or self.state == self.STATE_FALLBACK
            if need_fallback_probe:
                fallback_ok, fallback_how = self.prober.probe(self.fallback)
            else:
                fallback_ok, fallback_how = None, "uebersprungen"

            self._maybe_repair_wlan(now)
            self._enforce_desired_metric()

            if self.state == self.STATE_PRIMARY:
                if primary_ok:
                    if self.fail_count:
                        log("INFO", "%s wieder erreichbar (%s) nach %d Fehlversuch(en)"
                            % (self.primary, primary_how, self.fail_count))
                    self.fail_count = 0
                    self.both_dead_logged = False
                else:
                    self.fail_count += 1
                    log("WARN", "%s Datenpfad-Probe fehlgeschlagen (%d/%d, %s); %s=%s"
                        % (self.primary, self.fail_count, self.fail_threshold,
                           primary_how, self.fallback,
                           "ok" if fallback_ok else "fehlgeschlagen"))
                    if self.fail_count >= self.fail_threshold:
                        if fallback_ok:
                            self._demote("%s seit %d Proben ohne Datenpfad, %s traegt"
                                         % (self.primary, self.fail_count, self.fallback))
                        elif not self.both_dead_logged:
                            log("WARN", "BEIDE Uplinks ohne Datenpfad — keine Umschaltung "
                                        "(Umschalten wuerde nichts verbessern)")
                            self.both_dead_logged = True
            else:  # FALLBACK
                if primary_ok:
                    self.ok_count += 1
                    held = now - self.last_switch
                    if self.ok_count >= self.ok_threshold and held >= self.min_hold:
                        self._promote("%s seit %d Proben (%s) stabil, Haltezeit %.0fs erfuellt"
                                      % (self.primary, self.ok_count, primary_how, held))
                    else:
                        log("INFO", "%s wieder erreichbar (%d/%d Proben, Haltezeit %.0f/%.0fs)"
                            % (self.primary, self.ok_count, self.ok_threshold,
                               held, self.min_hold))
                else:
                    if self.ok_count:
                        log("INFO", "%s wieder ausgefallen — Erfolgszaehler zurueckgesetzt"
                            % self.primary)
                    self.ok_count = 0

            if self.status_every > 0 and (now - self.last_status) >= self.status_every:
                self.last_status = now
                log("INFO", "Status: zustand=%s default=%s %s=%s(metrik %s) %s=%s(metrik %s)"
                    % (self.state, winning_default_iface() or "?",
                       self.primary, "ok" if primary_ok else "TOT",
                       default_route(self.primary)[1],
                       self.fallback,
                       {True: "ok", False: "TOT", None: "-"}[fallback_ok],
                       default_route(self.fallback)[1]))

            self._write_state({
                "version": VERSION,
                "updated": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
                "state": self.state,
                "primary": {
                    "iface": self.primary,
                    "ok": primary_ok,
                    "method": primary_how,
                    "ipv4": iface_ipv4(self.primary),
                    "metric": default_route(self.primary)[1],
                    "fail_count": self.fail_count,
                },
                "fallback": {
                    "iface": self.fallback,
                    "ok": fallback_ok,
                    "method": fallback_how,
                    "ipv4": iface_ipv4(self.fallback),
                    "metric": default_route(self.fallback)[1],
                },
                "winning_default_iface": winning_default_iface(),
                "ok_count": self.ok_count,
                "seconds_since_switch": round(now - self.last_switch, 1) if self.last_switch else None,
                "dry_run": self.dry_run,
            })

            healthy = primary_ok if self.state == self.STATE_PRIMARY else True
            delay = self.interval_ok if healthy and not self.fail_count else self.interval_fast
            deadline = time.monotonic() + delay
            while self.running and time.monotonic() < deadline:
                time.sleep(0.25)

        log("INFO", "orbit-uplink-watchdog beendet (Zustand bleibt unveraendert: %s)"
            % self.state)


# ---------------------------------------------------------------------------
# Einmal-Diagnose
# ---------------------------------------------------------------------------
def do_check(cfg):
    prober = Prober(cfg)
    primary = cfg["PRIMARY_IFACE"]
    fallback = cfg["FALLBACK_IFACE"]
    report = {"version": VERSION, "mode": "check"}
    for iface in (primary, fallback):
        t0 = time.monotonic()
        ok, how = prober.probe(iface, force_app=True)
        gw, metric = default_route(iface)
        report[iface] = {
            "ok": ok,
            "method": how,
            "seconds": round(time.monotonic() - t0, 3),
            "ipv4": iface_ipv4(iface),
            "gateway": gw,
            "metric": metric,
        }
    rc, rules, _ = run(["ip", "rule", "show"], timeout=5)
    report["lte_pin_rule"] = ("from %s lookup %s"
                              % (cfg["PRIMARY_SRC_IP"], cfg["PRIMARY_TABLE"])) in (rules or "")
    rc, tbl, _ = run(["ip", "route", "show", "table", cfg["PRIMARY_TABLE"]], timeout=5)
    report["lte_pin_route"] = "default" in (tbl or "")
    report["winning_default_iface"] = winning_default_iface()
    print(json.dumps(report, indent=2))
    return 0


def main():
    parser = argparse.ArgumentParser(
        description="ORBIT Uplink-Watchdog — aktiver LTE->WLAN-Failover (MINIX)")
    parser.add_argument("--check", action="store_true",
                        help="Einmalige Diagnose als JSON, aendert nichts")
    parser.add_argument("--dry-run", action="store_true",
                        help="Vollstaendige Regelschleife, aber ohne Stellglieder")
    parser.add_argument("--version", action="store_true")
    args = parser.parse_args()

    cfg = load_config()
    if args.version:
        print(VERSION)
        return 0
    if args.check:
        return do_check(cfg)

    watchdog = Watchdog(cfg, dry_run=args.dry_run)
    signal.signal(signal.SIGTERM, watchdog.stop)
    signal.signal(signal.SIGINT, watchdog.stop)
    watchdog.run_forever()
    return 0


if __name__ == "__main__":
    sys.exit(main())
