"""Eine Mietkarte fuer alle kode-Sitzungen: Zustand, Hochfahren, Loeschen, Kosten.

Der Zustand liegt in /var/lib/kode/zustand.json und wird nur unter einer
Dateisperre geaendert - CLI-Sitzungen und Waechter schreiben beide hinein.

Abgeschaltet wird zum spaeteren der beiden Zeitpunkte
`letzte_nutzung + leerlauf` und `halten_bis`. Das Loeschen prueft immer nach
(anbieter.loeschen), und ein Lauf gilt erst als beendet, wenn die Karte
nachweislich weg ist.
"""

import contextlib
import fcntl
import json
import signal
import sqlite3
import threading
import time
from typing import Any, Callable, Iterator

import httpx

from . import anbieter, katalog, konfig, protokoll

LEER = {"phase": "aus", "anbieter": None, "kennung": None, "karte": None,
        "preis": None, "modell": None, "basis": None, "seit": None,
        "puls": None, "letzte_nutzung": None, "halten_bis": None,
        "leerlauf_min": konfig.LEERLAUF_MIN, "lauf_id": None, "fehler": None,
        "fortschritt": None}

# melden(phase, text, prozent, rest_s=None): rest_s = gemessene Restzeit der Phase
Melder = Callable[..., None]

# Reihenfolge und Schaetzwerte der Startphasen (17.10.2026: "wann fertig
# geladen, geschaetzte Zeit?"). Gemessen am 16./17.10.: Vast-Instanz 46 s bis
# Ollama; RunPod noch ohne vollstaendigen Lauf. Die Gewichte schaetzt das
# Angebot (ladezeit_s - 100 s Grundaufwand), bis die echte Rate gemessen ist.
PHASEN = ("mieten", "dienst", "gewichte", "aufwaermen")
SCHAETZUNG_S = {"mieten": {"vast": 60, "runpod": 90}, "dienst": 20, "aufwaermen": 45}


# ------------------------------------------------------------ Zustand

@contextlib.contextmanager
def _gesperrt() -> Iterator[None]:
    konfig.verzeichnisse()
    with open(konfig.SPERRE, "a+") as f:
        fcntl.flock(f, fcntl.LOCK_EX)
        try:
            yield
        finally:
            fcntl.flock(f, fcntl.LOCK_UN)


def _roh_lesen() -> dict[str, Any]:
    try:
        d = json.loads(konfig.ZUSTAND.read_text(encoding="utf-8"))
    except (OSError, ValueError):
        d = {}
    return {**LEER, **d}


def _roh_schreiben(z: dict[str, Any]) -> None:
    tmp = konfig.ZUSTAND.with_suffix(".tmp")
    tmp.write_text(json.dumps(z, ensure_ascii=False, indent=1), encoding="utf-8")
    tmp.replace(konfig.ZUSTAND)


def lesen() -> dict[str, Any]:
    with _gesperrt():
        return _roh_lesen()


def aendern(**felder: Any) -> dict[str, Any]:
    with _gesperrt():
        z = _roh_lesen()
        z.update(felder)
        _roh_schreiben(z)
        return z


def frist(z: dict[str, Any] | None = None) -> float | None:
    """Zeitpunkt der Abschaltung (Unix-Sekunden) einer bereiten Karte."""
    z = z or lesen()
    if not z.get("kennung"):
        return None
    leer = 60 * (z.get("leerlauf_min") or konfig.LEERLAUF_MIN)
    nutzung = z.get("letzte_nutzung") or z.get("seit") or time.time()
    return max(nutzung + leer, z.get("halten_bis") or 0)


def kosten_bisher(z: dict[str, Any] | None = None) -> float | None:
    z = z or lesen()
    if not z.get("seit") or not z.get("preis"):
        return None
    return (time.time() - z["seit"]) / 3600 * float(z["preis"])


def genutzt() -> None:
    aendern(letzte_nutzung=time.time())


# ------------------------------------------------------------ Kosten

def _db() -> sqlite3.Connection:
    konfig.verzeichnisse()
    c = sqlite3.connect(konfig.DATENBANK, timeout=30)
    c.execute("""CREATE TABLE IF NOT EXISTS laeufe (
        id INTEGER PRIMARY KEY, anbieter TEXT, kennung TEXT, karte TEXT,
        modell TEXT, preis REAL, beginn REAL, ende REAL, grund TEXT,
        kosten REAL, geloescht INTEGER)""")
    return c


def _lauf_anlegen(z: dict[str, Any]) -> int:
    with _db() as c:
        cur = c.execute("INSERT INTO laeufe (anbieter, kennung, karte, modell, preis, beginn)"
                        " VALUES (?,?,?,?,?,?)", (z["anbieter"], z["kennung"], z["karte"],
                                                  z["modell"], z["preis"], z["seit"]))
        return int(cur.lastrowid)


def _lauf_beenden(z: dict[str, Any], grund: str, geloescht: bool) -> None:
    if not z.get("lauf_id"):
        return
    ende = time.time()
    kosten = (ende - (z.get("seit") or ende)) / 3600 * float(z.get("preis") or 0)
    with _db() as c:
        c.execute("UPDATE laeufe SET ende=?, grund=?, kosten=?, geloescht=? WHERE id=?",
                  (ende, grund[:200], round(kosten, 5), int(geloescht), z["lauf_id"]))


def laeufe(anzahl: int = 15) -> list[dict[str, Any]]:
    with _db() as c:
        c.row_factory = sqlite3.Row
        return [dict(r) for r in c.execute(
            "SELECT * FROM laeufe ORDER BY id DESC LIMIT ?", (anzahl,))]


def kosten_summe(seit: float = 0) -> float:
    with _db() as c:
        r = c.execute("SELECT COALESCE(SUM(kosten),0) FROM laeufe WHERE beginn>=?",
                      (seit,)).fetchone()
        return float(r[0] or 0)


# ------------------------------------------------------------ Loeschen

@contextlib.contextmanager
def _ohne_strg_c() -> Iterator[None]:
    """Halb geloescht ist der schlechteste Zustand - waehrend des Loeschens
    wirkt Strg+C nicht (nur im Hauptfaden moeglich)."""
    if threading.current_thread() is not threading.main_thread():
        yield
        return
    alt = signal.signal(signal.SIGINT, signal.SIG_IGN)
    try:
        yield
    finally:
        signal.signal(signal.SIGINT, alt)


def herunterfahren(grund: str) -> tuple[bool, str]:
    """Loescht die Karte und prueft nach. Liefert (geloescht, Meldung)."""
    with _ohne_strg_c():
        return _herunterfahren(grund)


def _herunterfahren(grund: str) -> tuple[bool, str]:
    z = lesen()
    if not z.get("kennung"):
        aendern(**LEER)
        return True, "Es lief keine Karte."
    kosten = kosten_bisher(z) or 0
    t0 = time.monotonic()
    geloescht = anbieter.loeschen(z["anbieter"], z["kennung"])
    _lauf_beenden(z, grund, geloescht)
    protokoll.ereignis("karte_loeschen", grund=grund, geloescht=geloescht, anbieter=z["anbieter"],
                       kennung=z["kennung"], karte=z["karte"], modell=z["modell"],
                       kosten=round(kosten, 5), laufzeit_s=round(time.time() - (z.get("seit") or time.time())),
                       loeschdauer_s=round(time.monotonic() - t0, 1))
    if geloescht:
        aendern(**LEER)
        return True, f"Karte gelöscht ({grund}). Kosten dieses Laufs: {kosten:.4f} USD."
    aendern(fehler=f"Löschen nicht bestätigt ({grund})")
    konto = "Vast.ai" if z["anbieter"] == "vast" else "RunPod"
    return False, (f"Karte {z['kennung']} ließ sich nicht bestätigt löschen und läuft "
                   f"möglicherweise weiter ({z['preis']} USD/h). Bitte im {konto}-Konto "
                   f"nachsehen. Der Wächter versucht es weiter.")


# ------------------------------------------------------------ Hochfahren

def vorschlag(modell_id: str) -> list[dict[str, Any]]:
    t0 = time.monotonic()
    liste = anbieter.angebote(katalog.MODELLE[modell_id])
    protokoll.ereignis("karte_angebote", modell=modell_id, anzahl=len(liste),
                       dauer_s=round(time.monotonic() - t0, 2),
                       erste=[{k: x.get(k) for k in ("anbieter", "wolke", "name", "preis", "lage", "wert",
                                                     "ladezeit_s", "inet_down")} for x in liste[:10]])
    return liste


def _puls(phase: str, **mehr: Any) -> None:
    aendern(phase=phase, puls=time.time(), **mehr)


def _warte_dienst(basis: str, frist_s: int, melden: Melder, name: str) -> bool:
    t0 = time.monotonic()
    while time.monotonic() - t0 < frist_s:
        try:
            if httpx.get(f"{basis}/api/tags", timeout=15).status_code == 200:
                return True
        except httpx.HTTPError:
            pass
        _puls("dienst")
        melden("dienst", "warte, bis Ollama antwortet", None)
        time.sleep(5)
    return False


# Leitungsprobe beim automatischen Start (09.10.2026): ein Wirt
# mit angeblich 938 Mbit/s lieferte 27 MB/s und haette 12 Minuten gebraucht.
# Nach einer Minute Messung wird so eine Karte zurueckgegeben.
LEITUNG_PROBE_S = 60
LEITUNG_MIN_MB_S = 50
LEITUNG_MAX_REST_S = 300
LEITUNG_ZU_LANGSAM = "Leitung zu langsam"
RATE_FENSTER_S = 20


def _gewichte(basis: str, m: dict[str, Any], melden: Melder, probe: bool = False) -> str | None:
    """Zieht das Modell mit Strom (ohne Strom kappt der Proxy nach 100 s)."""
    schicht: dict[str, tuple[float, int]] = {}   # digest -> (Beginn, Bytes beim Beginn)
    fenster: list[tuple[float, int]] = []          # (Zeit, Bytes) der letzten RATE_FENSTER_S
    fenster_digest = ""
    letzter = ""
    t_start = time.monotonic()
    gesamt_b = 0
    for versuch in range(6):   # POST kommt spaeter durch als GET
        try:
            with httpx.stream("POST", f"{basis}/api/pull", timeout=httpx.Timeout(7200, connect=60),
                              json={"model": m["hf"], "stream": True}) as a:
                if a.status_code != 200:
                    a.read()
                    time.sleep(10)
                    continue
                letzter_puls = 0.0
                for zeile in a.iter_lines():
                    if not zeile.strip():
                        continue
                    try:
                        z = json.loads(zeile)
                    except ValueError:
                        continue
                    if z.get("error"):
                        protokoll.ereignis("gewichte_fehler", versuch=versuch, text=str(z["error"]))
                        return str(z["error"])[:200]
                    letzter = z.get("status", "")
                    gesamt, fertig = z.get("total"), z.get("completed")
                    if gesamt and gesamt > gesamt_b:
                        gesamt_b = gesamt
                    if probe and gesamt and fertig and gesamt > 1e9 and z.get("digest"):
                        t_s, b_s = schicht.setdefault(z["digest"], (time.monotonic(), fertig))
                        lauf = time.monotonic() - t_s
                        if lauf > LEITUNG_PROBE_S:
                            rate = (fertig - b_s) / lauf
                            rest = (gesamt - fertig) / rate if rate > 0 else 1e9
                            if rate / 1e6 < LEITUNG_MIN_MB_S and rest > LEITUNG_MAX_REST_S:
                                protokoll.ereignis("leitung_zu_langsam", mb_s=round(rate / 1e6, 1),
                                                   rest_s=round(rest))
                                return (f"{LEITUNG_ZU_LANGSAM}: {rate / 1e6:.0f} MB/s, noch rund "
                                        f"{rest / 60:.0f} min")
                    anteil = 100 * fertig / gesamt if gesamt and fertig else None
                    rest_s = None
                    if gesamt and fertig and gesamt > 1e8:
                        jetzt = time.monotonic()
                        if z.get("digest") != fenster_digest:
                            fenster_digest, fenster = z.get("digest", ""), []
                        fenster.append((jetzt, fertig))
                        while len(fenster) > 2 and jetzt - fenster[0][0] > RATE_FENSTER_S:
                            fenster.pop(0)
                        dt = jetzt - fenster[0][0]
                        rate = (fertig - fenster[0][1]) / dt if dt >= 3 else 0
                        rest_s = (gesamt - fertig) / rate if rate > 0 else None
                        text = (f"{fertig/1e9:.1f} / {gesamt/1e9:.1f} GB"
                                + (f" · {rate/1e6:.0f} MB/s" if rate > 0 else " · Rate wird gemessen"))
                    else:
                        text = letzter.replace("pulling manifest", "Manifest holen") or "Abruf beginnt"
                    melden("gewichte", text, anteil, rest_s=rest_s)
                    if time.time() - letzter_puls > 20:
                        _puls("gewichte")
                        letzter_puls = time.time()
                dauer = time.monotonic() - t_start
                protokoll.ereignis("gewichte_fertig", status=letzter, versuche=versuch + 1,
                                   dauer_s=round(dauer), gb=round(gesamt_b / 1e9, 2),
                                   mb_s=round(gesamt_b / 1e6 / dauer, 1) if dauer else None)
                return None if letzter == "success" else f"endete mit '{letzter}'"
        except httpx.HTTPError as f:
            protokoll.ereignis("gewichte_verbindung", versuch=versuch, typ=type(f).__name__, text=str(f))
            if versuch == 5:
                return f"{f.__class__.__name__}: {f}"
            time.sleep(10)
    return "kein Durchkommen zum Modellabruf"


def faehigkeiten(basis: str, m: dict[str, Any]) -> list[str]:
    try:
        a = httpx.post(f"{basis}/api/show", json={"model": m["hf"]}, timeout=60)
        return list(a.json().get("capabilities") or [])
    except (httpx.HTTPError, ValueError):
        return []


def _aufwaermen(basis: str, m: dict[str, Any]) -> tuple[bool | None, str]:
    """Laedt das Modell mit dem vollen Kontext und prueft den Grafikspeicher.

    Am 09.10.2026 lief Gemma 4 auf einer RTX 5090 komplett auf dem Prozessor
    (0,0 von 21,9 GB im Grafikspeicher, 2,6 Token/s). Ollama sagt das nicht.
    """
    try:
        httpx.post(f"{basis}/api/chat", timeout=900, json={
            "model": m["hf"], "stream": False, "keep_alive": -1,
            "options": {"num_ctx": m["kontext"], "num_predict": 1},
            "messages": [{"role": "user", "content": "Hallo"}]})
        ps = httpx.get(f"{basis}/api/ps", timeout=30).json().get("models") or []
    except (httpx.HTTPError, ValueError):
        return None, ""
    for e in ps:
        if m["hf"] in (e.get("name"), e.get("model")):
            gesamt, vram = e.get("size") or 0, e.get("size_vram") or 0
            if gesamt:
                return vram >= 0.9 * gesamt, f"{vram/1e9:.1f} von {gesamt/1e9:.1f} GB im Grafikspeicher"
    return None, ""


def hochfahren(karte: dict[str, Any], modell_id: str, melden: Melder,
               probe: bool = False) -> tuple[bool, str, str]:
    """Mietet genau diese Karte und macht das Modell bereit.

    Liefert (bereit, Meldung, Art). Art sagt, ob eine andere Karte helfen
    kann: "karte" (ja - naechste versuchen), "modell" (nein - das Modell
    selbst geht nicht), "belegt" (es laeuft schon eine), "bereit".
    `probe`: zu langsame Leitung nach einer Minute abbrechen (automatischer Start).

    Jeder Fehlschlag loescht die Karte wieder (nachgeprueft). Auch Strg+C:
    KeyboardInterrupt wird abgefangen, die Karte geloescht und dann
    weitergereicht.
    """
    m = katalog.MODELLE[modell_id]
    with _gesperrt():
        z = _roh_lesen()
        if z.get("kennung"):
            return False, "Es läuft schon eine Karte - erst /stopp.", "belegt"
        z.update({**LEER, "phase": "mieten", "puls": time.time(), "modell": modell_id,
                  "leerlauf_min": z.get("leerlauf_min") or konfig.LEERLAUF_MIN})
        _roh_schreiben(z)

    name = karte["name"]
    karte_info = {k: karte.get(k) for k in ("anbieter", "id", "wolke", "name", "gb", "preis", "lage",
                                            "wert", "ladezeit_s", "inet_down")}
    protokoll.ereignis("karte_start", modell=modell_id, karte=karte_info, kontext=m["kontext"])
    melden_roh = melden
    phase_seit = {"phase": None, "t": time.monotonic(), "t0": time.monotonic(), "notiz": 0.0}

    gewichte_s = max(30, (karte.get("ladezeit_s") or 400) - 100)
    letzte_ablage = {"t": 0.0, "phase": None}

    def schaetzung(phase: str, rest_s: float | None) -> float:
        """Sekunden bis bereit: Rest der laufenden Phase + Schaetzwerte der folgenden."""
        def soll(ph: str) -> float:
            if ph == "gewichte":
                return gewichte_s
            w = SCHAETZUNG_S[ph]
            return w[karte["anbieter"]] if isinstance(w, dict) else w
        i = PHASEN.index(phase) if phase in PHASEN else 0
        lauf = time.monotonic() - phase_seit["t"] if phase == phase_seit["phase"] else 0
        jetzt_rest = rest_s if rest_s is not None else max(soll(PHASEN[i]) - lauf, 10)
        return jetzt_rest + sum(soll(ph) for ph in PHASEN[i + 1:])

    def melden(phase: str, text: str, prozent: float | None,  # noqa: F811
               rest_s: float | None = None) -> None:
        jetzt = time.monotonic()
        if phase != phase_seit["phase"]:
            protokoll.ereignis("karte_phase", phase=phase, text=text,
                               seit_start_s=round(jetzt - phase_seit["t0"], 1),
                               vorige_dauer_s=round(jetzt - phase_seit["t"], 1))
            phase_seit.update(phase=phase, t=jetzt, notiz=jetzt)
        elif jetzt - phase_seit["notiz"] >= 60:
            # Lange Phasen: einmal je Minute, damit sichtbar ist, wo es haengt
            protokoll.ereignis("karte_fortschritt", phase=phase, text=text, prozent=prozent,
                               seit_start_s=round(jetzt - phase_seit["t0"], 1))
            phase_seit["notiz"] = jetzt
        noch = schaetzung(phase, rest_s)
        # Fuer andere Sitzungen und die Statusleiste, hoechstens alle 3 s
        if phase != letzte_ablage["phase"] or jetzt - letzte_ablage["t"] >= 3:
            aendern(fortschritt={"phase": phase, "text": text, "prozent": prozent,
                                 "fertig_um": time.time() + noch,
                                 "seit": time.time() - (jetzt - phase_seit["t0"]),
                                 "phase_seit": time.time() - (jetzt - phase_seit["t"])})
            letzte_ablage.update(t=jetzt, phase=phase)
        melden_roh(phase, text, prozent, rest_s=rest_s, noch_s=noch)

    melden("mieten", "Mietvertrag anfragen", None)
    # RunPod: zwei Anlaeufe auf dieselbe Kartenart (gleicher Preis) - ein
    # zweiter Versuch trifft oft einen anderen Wirt. Vast-Angebote sind ein
    # bestimmter Rechner, ein zweiter Versuch bringt dort nichts.
    kennung, grund = None, None
    for versuch in ((1,) if karte["anbieter"] == "vast" else (1, 2)):
        if versuch > 1:
            melden("mieten", "zweiter Versuch", None)
            time.sleep(3)
        # Zweiter RunPod-Versuch mit geringstem Bedarf an RAM und Kernen.
        kennung, grund = (anbieter.vast_mieten(karte, m) if karte["anbieter"] == "vast"
                          else anbieter.runpod_mieten(karte, m, sparsam=versuch > 1))
        protokoll.ereignis("karte_mieten", versuch=versuch, kennung=kennung, grund=grund,
                           sparsam=versuch > 1)
        if kennung:
            break
    if not kennung:
        aendern(**LEER)
        return False, (f"{name} war gerade nicht mietbar - es wurde nichts berechnet."
                       + (f"\nGrund laut {'Vast' if karte['anbieter'] == 'vast' else 'RunPod'}: {grund}" if grund else "")), "karte"

    jetzt = time.time()
    z = aendern(anbieter=karte["anbieter"], kennung=kennung, karte=name,
                preis=karte["preis"], seit=jetzt, puls=jetzt, letzte_nutzung=jetzt)
    aendern(lauf_id=_lauf_anlegen(z))

    def scheitern(grund: str, art: str = "karte") -> tuple[bool, str, str]:
        # "fehlerart", nicht "art": art ist der Ereignisname von protokoll.ereignis
        # (am 17.10.2026 stuerzte daran jeder Fehlschlag nach dem Mieten ab).
        mehr: dict[str, Any] = {}
        if karte["anbieter"] == "vast":
            # Vorm Loeschen festhalten, wie Vast die Instanz sieht - danach ist sie weg.
            inst = anbieter.vast_instanz(kennung)
            if isinstance(inst, dict):
                mehr["vast"] = {k: inst.get(k) for k in ("actual_status", "cur_state", "intended_status",
                                                         "status_msg", "disk_usage", "disk_space",
                                                         "inet_down", "public_ipaddr")}
        protokoll.ereignis("karte_gescheitert", grund=grund, fehlerart=art, phase=lesen().get("phase"),
                           seit_start_s=round(time.monotonic() - phase_seit["t0"], 1), **mehr)
        ok, meldung = herunterfahren(grund)
        return False, f"{grund}. {meldung}", art

    try:
        t0 = time.monotonic()
        basis = None
        if karte["anbieter"] == "vast":
            while True:
                if time.monotonic() - t0 > konfig.VAST_BOOT_FRIST:
                    return scheitern(f"{name}: Instanz startete nicht")
                time.sleep(10)
                _puls("mieten")
                inst = anbieter.vast_instanz(kennung)
                # Vast sagt selbst, was es tut (z. B. loading = Abbild wird geladen)
                lage = (f"Vast meldet: {inst.get('actual_status') or 'wartet'}"
                        + (f" - {str(inst['status_msg']).strip()[:60]}" if inst.get("status_msg") else "")
                        if isinstance(inst, dict) else "Instanz startet")
                melden("mieten", lage, None)
                if isinstance(inst, dict) and inst.get("actual_status") == "running":
                    break
            t1 = time.monotonic()
            while time.monotonic() - t1 < konfig.DIENST_FRIST and not basis:
                inst = anbieter.vast_instanz(kennung)
                for b in (anbieter.vast_basen(inst) if isinstance(inst, dict) else []):
                    try:
                        if httpx.get(f"{b}/api/tags", timeout=10).status_code == 200:
                            basis = b
                            break
                    except httpx.HTTPError:
                        pass
                if not basis:
                    _puls("dienst")
                    melden("dienst", "Ollama-Port wird gesucht", None)
                    time.sleep(10)
            if not basis:
                return scheitern(f"{name}: Ollama war nicht erreichbar")
        else:
            basis = f"https://{kennung}-11434.proxy.runpod.net"
            while not anbieter.runpod_laeuft(kennung):
                if time.monotonic() - t0 > konfig.BOOT_FRIST:
                    return scheitern(f"{name}: Container kam nicht hoch")
                time.sleep(10)
                _puls("mieten")
                melden("mieten", "Container startet", None)
            if not _warte_dienst(basis, konfig.DIENST_FRIST, melden, name):
                return scheitern(f"{name}: Ollama antwortete nicht")

        _puls("gewichte", basis=basis)
        melden("gewichte", "Abruf beginnt", 0.0)
        fehler = _gewichte(basis, m, melden, probe=probe)
        if fehler:
            # Fehlt die Datei bei Hugging Face, hilft keine andere Karte.
            am_modell = any(w in fehler.lower() for w in ("manifest", "not found", "does not exist",
                                                          "unauthorized", "invalid model"))
            return scheitern(fehler if fehler.startswith(LEITUNG_ZU_LANGSAM) else f"Modellabruf: {fehler}",
                             "modell" if am_modell else "karte")

        faeh = faehigkeiten(basis, m)
        protokoll.ereignis("karte_faehigkeiten", modell=modell_id, faehigkeiten=faeh)
        if "tools" not in faeh:
            return scheitern(f"{m['name']}: Ollama erkennt keine Werkzeugfähigkeit", "modell")

        _puls("aufwaermen")
        melden("aufwaermen", f"Kontext {m['kontext']} Token, erster Aufruf", None)
        auf_gpu, wie = _aufwaermen(basis, m)
        if auf_gpu is False:
            return scheitern(f"Modell lief nicht vollständig auf der Grafikkarte ({wie})")
        aendern(phase="bereit", puls=time.time(), letzte_nutzung=time.time(), fortschritt=None)
        dauer = time.monotonic() - t0
        protokoll.ereignis("karte_bereit", modell=modell_id, karte=name, dauer_s=round(dauer),
                           grafikspeicher=wie, auf_gpu=auf_gpu, basis=basis)
        return True, (f"Bereit auf {name} ({karte['preis']} USD/h) nach {dauer/60:.1f} min"
                      + (f", {wie}" if wie else "") + "."), "bereit"
    except BaseException as f:
        protokoll.ereignis("karte_abbruch", typ=type(f).__name__, text=str(f),
                           phase=lesen().get("phase"))
        if not isinstance(f, KeyboardInterrupt):
            protokoll.fehler("hochfahren", f)
        herunterfahren("Start abgebrochen")
        raise


def warten_auf_fremden_start(melden: Melder, frist_s: int = 1800) -> dict[str, Any]:
    """Eine andere Sitzung faehrt gerade hoch - warten statt doppelt mieten."""
    t0 = time.monotonic()
    while time.monotonic() - t0 < frist_s:
        z = lesen()
        if z["phase"] in ("aus", "bereit"):
            return z
        if z.get("puls") and time.time() - z["puls"] > konfig.PULS_FRIST:
            return z
        f = z.get("fortschritt") or {}
        melden(z["phase"], f.get("text") or "…", f.get("prozent"), fremd=True,
               noch_s=(f["fertig_um"] - time.time()) if f.get("fertig_um") else None,
               seit=f.get("seit"), phase_seit=f.get("phase_seit"))
        time.sleep(2)
    return lesen()


def bereit() -> dict[str, Any] | None:
    """Zustand, wenn eine Karte bereit ist (oder eine feste Basis gesetzt ist)."""
    if konfig.FESTE_BASIS:
        return {"phase": "bereit", "basis": konfig.FESTE_BASIS, "modell": None,
                "karte": "fest", "preis": 0}
    z = lesen()
    return z if z["phase"] == "bereit" and z.get("basis") else None


def guthaben() -> dict[str, float | None]:
    return {"runpod": anbieter.runpod_guthaben() if konfig.RUNPOD_API_KEY else None,
            "vast": anbieter.vast_guthaben() if konfig.VAST_API_KEY else None}