#!/usr/bin/env python3
# ============================================================================
# ORBIT LTE-Guthaben-Fruehwarnung (MINIX / x86 — Plattform-Scope: NUR minix)
# Lumeon Media UG (haftungsbeschraenkt)
#
# ZWECK
#   Der Uplink-Watchdog (orbit-uplink-watchdog) reagiert, wenn der LTE-
#   Datenpfad bereits tot ist — zuverlaessig, aber eben erst danach. Dieser
#   Begleitdienst liest den SMS-Eingang des Teltonika RUT260 und meldet die
#   Vorboten, BEVOR der Carrier den Datenpfad zumacht.
#
#   Am 17.08.2026 lag die Warnung eine knappe halbe Stunde vor dem Ausfall im
#   Posteingang des Routers:
#     10:45:36  ALDI TALK: "Hinweis: Dein Guthaben ist unter 1 Euro gefallen."
#     ab 11:13  partielle, dann totale Datenstille bei stehender PDP-Session
#   Niemand hat sie gelesen, weil sie nur im Router lag.
#
#   Zusaetzlich relevant (Posteingang 18.08.2026): ALDI TALK aktiviert einen
#   "Kostenschutz", der nach Aufbrauch des Inklusivvolumens die kostenpflichtige
#   Datennutzung UNTERBINDET. Das ist exakt die Signatur "PDP steht, Daten tot".
#
# VERHALTEN
#   - Reiner Lesezugriff auf den Router. Es wird NICHTS geschaltet, kein USSD,
#     kein Modem-Neustart. Die Reaktion auf einen toten Pfad bleibt Sache des
#     Uplink-Watchdogs; hier geht es ausschliesslich um Sichtbarkeit.
#   - Treffer landen als WARN im Journal und in /run/orbit-lte-credit-warn/state.json.
#   - Jede SMS wird nur EINMAL gemeldet (Merkdatei), damit der Timer nicht alle
#     15 Minuten dieselbe Warnung wiederholt.
#
# ZUGANGSDATEN
#   Kommen aus /etc/orbit-lte-credit-warn.env (Modus 0600, root). Diese Datei
#   gehoert NICHT ins Repo. Vorlage: orbit-lte-credit-warn.env.example
#
# Plattform-Scope: MINIX (x86/i915). core/ und pi_player/ bleiben unberuehrt.
# ============================================================================

import hashlib
import json
import os
import re
import ssl
import sys
import time
import urllib.error
import urllib.request

VERSION = "1.0.0"
# Unter ProtectSystem=strict ist /run schreibgeschuetzt; das Verzeichnis
# legt systemd per RuntimeDirectory= an (RuntimeDirectoryPreserve=yes).
STATE_FILE = "/run/orbit-lte-credit-warn/state.json"
SEEN_FILE = "/var/lib/orbit-lte-credit-warn/seen.json"
ENV_FILE = "/etc/orbit-lte-credit-warn.env"

DEFAULTS = {
    "RUT_URL": "https://192.168.1.1",
    "RUT_USER": "admin",
    "RUT_PASS": "",
    "TIMEOUT": "15",
}

# Vorboten eines zumachenden Datenpfads. Bewusst breit gehalten und
# gross-/kleinschreibungsunabhaengig — ein Fehlalarm kostet eine Logzeile,
# eine verpasste Warnung kostet einen Ausfall.
PATTERNS = [
    (r"guthaben.{0,60}(unter|aufgebraucht|verbraucht|leer|niedrig|nur noch|reicht nicht)",
     "guthaben_niedrig"),
    (r"(kein|nicht)\s+(ausreichend|genug|mehr)\w*\s+guthaben", "guthaben_niedrig"),
    (r"(inklusiv|daten|highspeed)volumen.{0,60}(aufgebraucht|verbraucht|erreicht|zu ende|erschoepft|erschöpft)",
     "volumen_erschoepft"),
    (r"kostenschutz", "kostenschutz"),
    (r"(surf-ticket|option|paket|tarif).{0,60}(abgelaufen|endet|laeuft ab|läuft ab|verlaengert nicht|verlängert nicht)",
     "ticket_endet"),
    (r"bitte.{0,30}(aufladen|auflade|guthaben)", "aufladen_noetig"),
    (r"drossel|gedrosselt|throttl", "drosselung"),
    # Englische Fassungen — der Carrier kann bei Roaming/Fremdnetz umschalten.
    (r"(balance|credit).{0,40}(low|below|insufficient|empty)", "guthaben_niedrig"),
    (r"data.{0,20}(volume|allowance).{0,40}(used up|exhausted|depleted)",
     "volumen_erschoepft"),
]


def log(level, msg):
    print("%-5s %s" % (level, msg), flush=True)


def load_env():
    cfg = dict(DEFAULTS)
    try:
        with open(ENV_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:
        log("WARN", "%s nicht lesbar: %s" % (ENV_FILE, exc))
    for key in list(cfg):
        env = os.environ.get(key)
        if env is not None:
            cfg[key] = env
    return cfg


def _ctx():
    # Der Router traegt ein selbstsigniertes Zertifikat auf einer festen
    # LAN-Adresse. Zertifikatspruefung waere hier reine Symbolik.
    ctx = ssl.create_default_context()
    ctx.check_hostname = False
    ctx.verify_mode = ssl.CERT_NONE
    return ctx


def _post_json(url, payload, timeout, token=None):
    data = json.dumps(payload).encode("utf-8")
    req = urllib.request.Request(url, data=data, method="POST")
    req.add_header("Content-Type", "application/json")
    if token:
        req.add_header("Authorization", "Bearer " + token)
    with urllib.request.urlopen(req, timeout=timeout, context=_ctx()) as resp:
        return json.loads(resp.read().decode("utf-8", "replace"))


def _get_json(url, timeout, token):
    req = urllib.request.Request(url, method="GET")
    req.add_header("Authorization", "Bearer " + token)
    with urllib.request.urlopen(req, timeout=timeout, context=_ctx()) as resp:
        return json.loads(resp.read().decode("utf-8", "replace"))


def login(cfg):
    if not cfg["RUT_PASS"]:
        log("WARN", "Kein RUT_PASS in %s gesetzt — Fruehwarnung inaktiv" % ENV_FILE)
        return None
    try:
        res = _post_json(cfg["RUT_URL"] + "/api/login",
                         {"username": cfg["RUT_USER"], "password": cfg["RUT_PASS"]},
                         float(cfg["TIMEOUT"]))
    except (urllib.error.URLError, OSError, ValueError) as exc:
        log("WARN", "Router-Login fehlgeschlagen: %s: %s" % (type(exc).__name__, exc))
        return None
    token = (res.get("data") or {}).get("token")
    if not token:
        log("WARN", "Router-Login ohne Token (Antwort: %s)" % str(res)[:120])
    return token


def fetch_messages(cfg, token):
    try:
        res = _get_json(cfg["RUT_URL"] + "/api/messages/status",
                        float(cfg["TIMEOUT"]), token)
    except (urllib.error.URLError, OSError, ValueError) as exc:
        log("WARN", "SMS-Abruf fehlgeschlagen: %s: %s" % (type(exc).__name__, exc))
        return []
    data = res.get("data")
    return data if isinstance(data, list) else []


def load_seen():
    try:
        with open(SEEN_FILE, "r", encoding="utf-8") as fh:
            seen = json.load(fh)
        return set(seen) if isinstance(seen, list) else set()
    except (OSError, ValueError):
        return set()


def save_seen(seen):
    try:
        os.makedirs(os.path.dirname(SEEN_FILE), exist_ok=True)
        tmp = SEEN_FILE + ".tmp"
        with open(tmp, "w", encoding="utf-8") as fh:
            # Gedeckelt, damit die Datei nicht unbegrenzt waechst.
            json.dump(sorted(seen)[-200:], fh)
        os.replace(tmp, SEEN_FILE)
    except OSError as exc:
        log("WARN", "Merkdatei nicht schreibbar: %s" % exc)


def classify(text):
    low = text.lower()
    return [tag for rx, tag in PATTERNS if re.search(rx, low)]


def write_state(snapshot):
    try:
        tmp = STATE_FILE + ".tmp"
        with open(tmp, "w", encoding="utf-8") as fh:
            json.dump(snapshot, fh, indent=2, ensure_ascii=False)
        os.replace(tmp, STATE_FILE)
    except OSError:
        pass


def main():
    show = "--show" in sys.argv
    cfg = load_env()

    if show:
        try:
            with open(STATE_FILE, "r", encoding="utf-8") as fh:
                print(fh.read())
        except OSError:
            print("{}")
        return 0

    token = login(cfg)
    if not token:
        write_state({"version": VERSION, "updated": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
                     "ok": False, "reason": "kein Router-Token"})
        return 0  # Timer-Dienst: kein Fehlerrauschen in systemd

    messages = fetch_messages(cfg, token)
    seen = load_seen()
    hits, fresh = [], []

    for msg in messages:
        if not isinstance(msg, dict):
            continue
        text = str(msg.get("message", ""))
        date = str(msg.get("date", "?"))
        sender = str(msg.get("sender", "?"))
        tags = classify(text)
        if not tags:
            continue
        # Schluessel ueber den VOLLSTAENDIGEN Text: ein Praefix-Vergleich
        # verschluckt zwei SMS mit gleichem Anfang (Carrier-Serienbriefe
        # sehen sich sehr aehnlich) — Codex-Review 2026-08-18.
        key = hashlib.sha256(
            ("%s|%s|%s" % (date, sender, text)).encode("utf-8")).hexdigest()[:32]
        entry = {"date": date, "sender": sender, "tags": tags, "text": text[:200]}
        hits.append(entry)
        if key not in seen:
            fresh.append(entry)
            seen.add(key)

    for entry in fresh:
        log("WARN", "LTE-VORWARNUNG [%s] von %s (%s): %s"
            % (entry["date"], entry["sender"], ",".join(entry["tags"]),
               entry["text"][:140]))
    if fresh:
        log("WARN", "Der LTE-Datenpfad kann demnaechst schliessen, obwohl die "
                    "PDP-Session steht. orbit-uplink-watchdog schwenkt dann binnen "
                    "~45 s auf WLAN — SIM aufladen bzw. Volumen pruefen.")
        save_seen(seen)
    elif hits:
        log("INFO", "%d bekannte Vorwarnung(en) im Router-Posteingang, nichts Neues"
            % len(hits))
    else:
        log("INFO", "Keine Guthaben-/Volumen-Warnung im Router-Posteingang (%d SMS)"
            % len(messages))

    write_state({
        "version": VERSION,
        "updated": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
        "ok": True,
        "messages_total": len(messages),
        "warnings": hits,
        "new_warnings": len(fresh),
    })
    return 0


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