#!/usr/bin/env python3
"""
RegioBahn.eu - Telemetrie-Client (Fenster-Programm)
---------------------------------------------------
Richtiges Desktop-Programm mit Oberflaeche: Einstellungen eintragen,
auf "Verbindung starten" klicken - fertig. Kein Terminal noetig.

Liest die Telemetrie aus Train Sim World (eingebaute Schnittstelle unter
http://localhost:31270) und sendet sie an RegioBahn.eu.

Start: Doppelklick (Windows oeffnet .pyw ohne Konsolenfenster).
Benoetigtes Paket:  py -m pip install requests
"""

import base64
import json
import math
import os
import queue
import threading
import time
import tkinter as tk
from datetime import datetime
from tkinter import messagebox, ttk

try:
    import requests
except ImportError:  # pragma: no cover
    requests = None

try:
    import winsound
except ImportError:  # pragma: no cover
    winsound = None

from tkinter import simpledialog

# Eine gemeinsame HTTP-Sitzung: spart pro Anfrage den Verbindungsaufbau.
if requests is not None:
    HTTP = requests.Session()
    try:
        _adapter = requests.adapters.HTTPAdapter(
            pool_connections=4, pool_maxsize=8, max_retries=0
        )
        HTTP.mount("http://", _adapter)
        HTTP.mount("https://", _adapter)
    except Exception:  # pragma: no cover
        pass
    # Eigene Sitzung nur fuer Train Sim World auf diesem PC: ignoriert
    # System-Proxys/VPNs, damit lokale Abfragen nie ueber das Internet laufen
    # und Internet-Aussetzer die Spielverbindung nicht stoeren.
    LOCAL = requests.Session()
    LOCAL.trust_env = False
    try:
        LOCAL.mount("http://", requests.adapters.HTTPAdapter(pool_connections=2, pool_maxsize=4, max_retries=0))
    except Exception:  # pragma: no cover
        pass
else:  # pragma: no cover
    HTTP = None
    LOCAL = None

ENDPOINT = "https://regiobahn.eu/api/public/telemetry"
ORDERS_ENDPOINT = "https://regiobahn.eu/api/public/assignments"
REPORT_ENDPOINT = "https://regiobahn.eu/api/public/trip-report"
HISTORY_ENDPOINT = "https://regiobahn.eu/api/public/trip-history"
CHAT_ENDPOINT = "https://regiobahn.eu/api/public/chat"
EVENTS_ENDPOINT = "https://regiobahn.eu/api/public/ops-events"

# Vorgefertigte Funksprueche fuer die Multiplayer-Karte
QUICK_RADIO = (
    ("Am Bahnsteig", "Stehe am Bahnsteig, Fahrgastwechsel laeuft."),
    ("Signal Halt", "Achtung: Halt zeigendes Signal vor mir."),
    ("Bitte vorbei", "Fahre langsam – du kannst gern vorbeiziehen."),
    ("Verspaetung", "Ich habe Verspaetung, bitte Anschluss beachten."),
    ("Stoerung", "Stoerung am Zug, bitte Abstand halten."),
)
TSW_API = "http://127.0.0.1:31270"  # IPv4: "localhost" loest bei vielen PCs auf ::1 auf
CONFIG_DIR = os.path.join(os.environ.get("LOCALAPPDATA", os.path.expanduser("~")), "RegioBahn")
CONFIG_FILE = os.path.join(CONFIG_DIR, "client-config.json")

# Wetter (Open-Meteo, Frankfurt a. M. - wie auf der Webseite)
WEATHER_URL = (
    "https://api.open-meteo.com/v1/forecast?latitude=50.11&longitude=8.66"
    "&current=temperature_2m,weather_code,wind_speed_10m"
    "&hourly=temperature_2m,precipitation_probability&forecast_days=1"
    "&timezone=Europe%2FBerlin"
)
WMO_TEXT = {
    0: "Klar", 1: "Überwiegend klar", 2: "Teils bewölkt", 3: "Bedeckt",
    45: "Nebel", 48: "Nebel", 51: "Nieselregen", 53: "Nieselregen",
    55: "Nieselregen", 61: "Regen", 63: "Regen", 65: "Starkregen",
    66: "Eisregen", 67: "Eisregen", 71: "Schnee", 73: "Schnee",
    75: "Schnee", 77: "Schneegriesel", 80: "Schauer", 81: "Schauer",
    82: "Starkregen-Schauer", 85: "Schneeschauer", 86: "Schneeschauer",
    95: "Gewitter", 96: "Gewitter", 99: "Gewitter",
}

# Begrüßungsbild (eingebettet, damit keine Extra-Datei nötig ist)
SPLASH_PNG = base64.b64decode(
    "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"
)

BG = "#0B1220"
CARD = "#141d31"
PANEL = "#0f1930"
ENTRY_BG = "#0c1526"
BORDER = "#22304c"
FG = "#eef3ff"
MUTED = "#8fa0bf"
RED = "#E2001A"
RED_HOVER = "#ff2a41"
GHOST = "#1d2a44"
GHOST_HOVER = "#26365a"
GREEN = "#36b37e"
BLUE = "#4c8dff"

# --------------------------------------------------------------------------
# Streckennetz fuer die Ingame-Karte (S8 / S9 und Frankfurt - Fulda)
# --------------------------------------------------------------------------
STATIONS = {
    "Frankfurt Hbf": (50.1071, 8.6638),
    "Niederrad": (50.0846, 8.6289),
    "Frankfurt Stadion": (50.0687, 8.6395),
    "Frankfurt Flughafen Regionalbahnhof": (50.0512, 8.5702),
    "Frankfurt Flughafen Fernbahnhof": (50.0532, 8.5706),
    "Kelsterbach": (50.0648, 8.5300),
    "Raunheim": (50.0122, 8.4480),
    "Rüsselsheim Opelwerk": (50.0060, 8.4210),
    "Rüsselsheim": (49.9906, 8.4104),
    "Frankfurt-Griesheim": (50.0970, 8.5970),
    "Frankfurt-Nied": (50.1010, 8.5720),
    "Frankfurt-Höchst": (50.1010, 8.5450),
    "Frankfurt-Höchst Farbwerke": (50.0960, 8.5290),
    "Frankfurt-Sindlingen": (50.0880, 8.5130),
    "Hattersheim (Main)": (50.0720, 8.4820),
    "Eddersheim": (50.0530, 8.4530),
    "Flörsheim (Main)": (50.0250, 8.4320),
    "Hochheim (Main)": (50.0130, 8.3550),
    "Mainz-Kastel": (50.0080, 8.2800),
    "Wiesbaden Ost": (50.0300, 8.2620),
    "Wiesbaden Hbf": (50.0709, 8.2437),
    "Frankfurt Stresemannallee": (50.0949, 8.6660),
    "Frankfurt (Main) Süd": (50.0989, 8.6862),
    "Offenbach (Main) Hbf": (50.0995, 8.7607),
    "Offenbach (Main) Ost": (50.1120, 8.7810),
    "Mühlheim (Main)": (50.1155, 8.8330),
    "Mühlheim (Main) Dietesheim": (50.1160, 8.8620),
    "Steinheim (Main)": (50.1210, 8.9130),
    "Hanau Hbf": (50.1206, 8.9290),
    "Hanau Wilhelmsbad": (50.1385, 8.8875),
    "Wolfgang": (50.1281, 8.9761),
    "Langenselbold": (50.1789, 9.0417),
    "Hailer-Meerholz": (50.1889, 9.1236),
    "Gelnhausen": (50.1990, 9.1900),
    "Haitz-Höchst": (50.2078, 9.2314),
    "Wirtheim": (50.2194, 9.2694),
    "Bad Soden-Salmünster": (50.2764, 9.3667),
    "Steinau an der Straße": (50.3156, 9.4619),
    "Schlüchtern": (50.3490, 9.5230),
    "Elm": (50.3444, 9.5931),
    "Flieden": (50.4230, 9.5570),
    "Neuhof": (50.4531, 9.6144),
    "Fulda": (50.5545, 9.6835),
    "Kassel-Wilhelmshöhe": (51.3128, 9.4468),
    "Würzburg Hbf": (49.8017, 9.9360),
    "Rottendorf": (49.7936, 10.0281),
    "Buchbrunn-Mainstockheim": (49.7539, 10.1281),
    "Dettelbach": (49.7642, 10.1622),
    "Kitzingen": (49.7381, 10.1592),
    "Iphofen": (49.7017, 10.2611),
    "Markt Bibart": (49.6461, 10.4025),
    "Neustadt (Aisch)": (49.5808, 10.6083),
    "Neustadt (Aisch) Mitte": (49.5789, 10.6175),
    "Emskirchen": (49.5528, 10.7103),
    "Hagenbüchach": (49.5333, 10.7761),
    "Puschendorf": (49.5225, 10.8264),
    "Siegelsdorf": (49.5069, 10.8697),
    "Fürth-Burgfarrnbach": (49.4864, 10.9308),
    "Fürth-Unterfürberg": (49.4783, 10.9581),
    "Fürth (Bay) Hbf": (49.4744, 10.9906),
    "Nürnberg Rothenburger Straße": (49.4494, 11.0489),
    "Nürnberg-Steinbühl": (49.4419, 11.0672),
    "Nürnberg Hbf": (49.4455, 11.0821),
}

# Schematische Streckenpositionen nach der originalen TSW-Kartenansicht.
MAP_POINTS = {
    "Frankfurt Hbf": (910, 58, "above", "center"),
    "Frankfurt-Griesheim": (828, 74, "above", "e"),
    "Frankfurt-Nied": (750, 72, "below", "e"),
    "Frankfurt-Höchst": (680, 92, "above", "e"),
    "Frankfurt-Höchst Farbwerke": (622, 154, "below", "e"),
    "Frankfurt-Sindlingen": (560, 238, "above", "e"),
    "Hattersheim (Main)": (496, 322, "below", "e"),
    "Eddersheim": (430, 398, "above", "e"),
    "Flörsheim (Main)": (350, 432, "below", "e"),
    "Hochheim (Main)": (278, 418, "above", "e"),
    "Niederrad": (872, 98, "below", "w"),
    "Frankfurt Stadion": (846, 150, "above", "w"),
    "Frankfurt Flughafen Regionalbahnhof": (866, 205, "below", "w"),
    "Frankfurt Flughafen Fernbahnhof": (816, 232, "below", "w"),
    "Kelsterbach": (748, 225, "below", "w"),
    "Raunheim": (684, 286, "above", "w"),
    "Rüsselsheim Opelwerk": (592, 370, "below", "w"),
    "Rüsselsheim": (430, 474, "above", "w"),
    "Mainz-Kastel": (208, 404, "below", "center"),
    "Wiesbaden Ost": (142, 366, "above", "center"),
    "Wiesbaden Hbf": (92, 142, "below", "center"),
    "Frankfurt Stresemannallee": (980, 150, "below", "w"),
    "Frankfurt (Main) Süd": (1035, 205, "above", "w"),
    "Offenbach (Main) Hbf": (1085, 255, "below", "w"),
    "Offenbach (Main) Ost": (1130, 298, "above", "w"),
    "Mühlheim (Main)": (1175, 340, "below", "w"),
    "Mühlheim (Main) Dietesheim": (1215, 378, "above", "w"),
    "Steinheim (Main)": (1250, 408, "below", "w"),
    "Hanau Hbf": (1285, 435, "above", "w"),
    "Hanau Wilhelmsbad": (1297, 447, "below", "e"),
    "Wolfgang": (1310, 459, "above", "w"),
    "Langenselbold": (1322, 470, "below", "e"),
    "Hailer-Meerholz": (1335, 482, "above", "w"),
    "Gelnhausen": (1347, 494, "below", "e"),
    "Haitz-Höchst": (1360, 506, "above", "w"),
    "Wirtheim": (1372, 518, "below", "e"),
    "Bad Soden-Salmünster": (1385, 529, "above", "w"),
    "Steinau an der Straße": (1397, 541, "below", "e"),
    "Schlüchtern": (1410, 553, "above", "w"),
    "Elm": (1422, 565, "below", "e"),
    "Flieden": (1435, 576, "above", "w"),
    "Neuhof": (1447, 588, "below", "e"),
    "Fulda": (1460, 600, "above", "e"),
    "Kassel-Wilhelmshöhe": (1520, 300, "above", "e"),
    "Würzburg Hbf": (1520, 620, "below", "e"),
    "Rottendorf": (1528, 650, "above", "e"),
    "Buchbrunn-Mainstockheim": (1538, 676, "below", "e"),
    "Dettelbach": (1552, 698, "above", "e"),
    "Kitzingen": (1570, 720, "below", "e"),
    "Iphofen": (1592, 742, "above", "e"),
    "Markt Bibart": (1616, 762, "below", "e"),
    "Neustadt (Aisch)": (1644, 782, "above", "e"),
    "Neustadt (Aisch) Mitte": (1672, 800, "below", "e"),
    "Emskirchen": (1702, 816, "above", "e"),
    "Hagenbüchach": (1734, 830, "below", "e"),
    "Puschendorf": (1766, 842, "above", "e"),
    "Siegelsdorf": (1800, 853, "below", "e"),
    "Fürth-Burgfarrnbach": (1838, 862, "above", "e"),
    "Fürth-Unterfürberg": (1876, 868, "below", "e"),
    "Fürth (Bay) Hbf": (1916, 870, "above", "e"),
    "Nürnberg Rothenburger Straße": (1958, 866, "below", "e"),
    "Nürnberg-Steinbühl": (2000, 858, "above", "e"),
    "Nürnberg Hbf": (2040, 845, "below", "e"),
}
MAP_LABELS = {
    "Frankfurt-Höchst Farbwerke": "Frankfurt-Höchst\nFarbwerke",
    "Frankfurt Flughafen Regionalbahnhof": "Frankfurt Flughafen\nRegionalbahnhof",
    "Frankfurt Flughafen Fernbahnhof": "Frankfurt Flughafen\nFernbahnhof",
    "Frankfurt Stresemannallee": "Frankfurt\nStresemannallee",
    "Frankfurt (Main) Süd": "Frankfurt (Main)\nSüd",
    "Offenbach (Main) Hbf": "Offenbach (Main)\nHbf",
    "Offenbach (Main) Ost": "Offenbach (Main)\nOst",
    "Mühlheim (Main) Dietesheim": "Mühlheim (Main)\nDietesheim",
    "Hanau Wilhelmsbad": "Hanau\nWilhelmsbad",
    "Hailer-Meerholz": "Hailer-\nMeerholz",
    "Bad Soden-Salmünster": "Bad Soden-\nSalmünster",
    "Steinau an der Straße": "Steinau an\nder Straße",
    "Kassel-Wilhelmshöhe": "Kassel-\nWilhelmshöhe",
    "Buchbrunn-Mainstockheim": "Buchbrunn-\nMainstockheim",
    "Neustadt (Aisch) Mitte": "Neustadt (Aisch)\nMitte",
    "Fürth-Burgfarrnbach": "Fürth-\nBurgfarrnbach",
    "Fürth-Unterfürberg": "Fürth-\nUnterfürberg",
    "Fürth (Bay) Hbf": "Fürth (Bay)\nHbf",
    "Nürnberg Rothenburger Straße": "Nürnberg\nRothenburger Str.",
    "Nürnberg-Steinbühl": "Nürnberg-\nSteinbühl",
}

ROUTE_SUED = [
    "Frankfurt Hbf", "Niederrad", "Frankfurt Stadion",
    "Frankfurt Flughafen Regionalbahnhof", "Frankfurt Flughafen Fernbahnhof",
    "Kelsterbach", "Raunheim", "Rüsselsheim Opelwerk", "Rüsselsheim",
    "Mainz-Kastel", "Wiesbaden Ost", "Wiesbaden Hbf",
]

ROUTE_NORD = [
    "Frankfurt Hbf", "Frankfurt-Griesheim", "Frankfurt-Nied", "Frankfurt-Höchst",
    "Frankfurt-Höchst Farbwerke", "Frankfurt-Sindlingen", "Hattersheim (Main)",
    "Eddersheim", "Flörsheim (Main)", "Hochheim (Main)",
    "Mainz-Kastel", "Wiesbaden Ost", "Wiesbaden Hbf",
]

ROUTE_FULDA = [
    "Frankfurt Hbf", "Frankfurt Stresemannallee", "Frankfurt (Main) Süd",
    "Offenbach (Main) Hbf", "Offenbach (Main) Ost", "Mühlheim (Main)",
    "Mühlheim (Main) Dietesheim", "Steinheim (Main)", "Hanau Hbf",
    "Hanau Wilhelmsbad", "Wolfgang", "Langenselbold", "Hailer-Meerholz",
    "Gelnhausen", "Haitz-Höchst", "Wirtheim", "Bad Soden-Salmünster",
    "Steinau an der Straße", "Schlüchtern", "Elm", "Flieden", "Neuhof", "Fulda",
]

ROUTE_KASSEL = ["Kassel-Wilhelmshöhe", "Fulda", "Würzburg Hbf"]

ROUTE_NUERNBERG = [
    "Nürnberg Hbf", "Nürnberg-Steinbühl", "Nürnberg Rothenburger Straße",
    "Fürth (Bay) Hbf", "Fürth-Unterfürberg", "Fürth-Burgfarrnbach",
    "Siegelsdorf", "Puschendorf", "Hagenbüchach", "Emskirchen",
    "Neustadt (Aisch) Mitte", "Neustadt (Aisch)", "Markt Bibart", "Iphofen",
    "Kitzingen", "Dettelbach", "Buchbrunn-Mainstockheim", "Rottendorf",
    "Würzburg Hbf",
]

ALL_ROUTES = (ROUTE_SUED, ROUTE_NORD, ROUTE_FULDA, ROUTE_KASSEL, ROUTE_NUERNBERG)
MAP_WIDTH = 2120
MAP_HEIGHT = 920
MAP_REGIONS = (
    ("Wiesbaden", 150, 265, 3),
    ("Main-Taunus", 430, 350, 7),
    ("Frankfurt", 835, 130, 8),
    ("Offenbach · Hanau", 1190, 345, 7),
    ("Kinzigtal · Fulda", 1130, 470, 4),
    ("Kassel · Würzburg", 1470, 175, 3),
    ("Steigerwald · Kitzingen", 1540, 770, 8),
    ("Nürnberg · Fürth", 1830, 760, 11),

)
MAP_HUBS = {"Frankfurt Hbf", "Wiesbaden Hbf", "Hanau Hbf", "Fulda",
            "Kassel-Wilhelmshöhe", "Würzburg Hbf", "Nürnberg Hbf",
            "Fürth (Bay) Hbf"}

MIN_LAT = min(v[0] for v in STATIONS.values())
MAX_LAT = max(v[0] for v in STATIONS.values())
MIN_LNG = min(v[1] for v in STATIONS.values())
MAX_LNG = max(v[1] for v in STATIONS.values())


# --------------------------------------------------------------------------
# Telemetrie-Quelle
# --------------------------------------------------------------------------
def _documents_dirs():
    """Alle moeglichen Dokumente-Ordner (auch OneDrive-/umgeleitete Ordner)."""
    dirs = []
    try:
        import ctypes
        from ctypes import wintypes

        class GUID(ctypes.Structure):
            _fields_ = [("a", wintypes.DWORD), ("b", wintypes.WORD), ("c", wintypes.WORD), ("d", ctypes.c_ubyte * 8)]

        fid = GUID(0xFDD39AD0, 0x238F, 0x46AF, (ctypes.c_ubyte * 8)(0xAD, 0xB4, 0x6C, 0x85, 0x48, 0x03, 0x69, 0xC7))
        ptr = ctypes.c_wchar_p()
        if ctypes.windll.shell32.SHGetKnownFolderPath(ctypes.byref(fid), 0, None, ctypes.byref(ptr)) == 0:
            dirs.append(ptr.value)
            ctypes.windll.ole32.CoTaskMemFree(ptr)
    except Exception:
        pass
    home = os.path.expanduser("~")
    for env in ("OneDrive", "OneDriveConsumer", "OneDriveCommercial"):
        base = os.environ.get(env)
        if base:
            dirs += [os.path.join(base, "Documents"), os.path.join(base, "Dokumente")]
    dirs += [os.path.join(home, "Documents"), os.path.join(home, "Dokumente"),
             os.path.join(home, "OneDrive", "Documents"), os.path.join(home, "OneDrive", "Dokumente")]
    seen, out = set(), []
    for d in dirs:
        k = os.path.normcase(os.path.abspath(d))
        if k not in seen and os.path.isdir(d):
            seen.add(k)
            out.append(d)
    return out


def find_comm_key_path():
    """Sucht CommAPIKey.txt in allen TSW-Ordnern (Steam, Epic, alle Versionen) - neueste Datei gewinnt."""
    found = []
    for docs in _documents_dirs():
        games = os.path.join(docs, "My Games")
        try:
            names = os.listdir(games)
        except Exception:
            continue
        for name in names:
            if not name.lower().startswith("trainsimworld"):
                continue
            path = os.path.join(games, name, "Saved", "Config", "CommAPIKey.txt")
            if os.path.isfile(path):
                try:
                    found.append((os.path.getmtime(path), path))
                except Exception:
                    pass
    found.sort(reverse=True)
    return found[0][1] if found else ""


def find_comm_key():
    """Liest den API-Schluessel, den Train Sim World beim Start mit -HTTPAPI anlegt."""
    path = find_comm_key_path()
    if not path:
        return ""
    try:
        return open(path, "r", encoding="utf-8-sig").read().strip()
    except Exception:
        return ""


class TswApi:
    """Zugriff auf die offizielle Train-Sim-World-Schnittstelle (-HTTPAPI)."""

    def __init__(self, base=TSW_API, timeout=5, comm_key=None):
        self.base = base.rstrip("/")
        self.timeout = timeout
        self.comm_key = (comm_key or find_comm_key() or "").strip()
        self.nodes = None
        self.controls = {}

    @property
    def headers(self):
        return {"DTGCommKey": self.comm_key} if self.comm_key else {}

    def available(self):
        try:
            r = LOCAL.get(f"{self.base}/info", headers=self.headers, timeout=self.timeout)
            if r.status_code in (401, 403):
                fresh = find_comm_key()
                if fresh and fresh != self.comm_key:
                    self.comm_key = fresh
                    r = LOCAL.get(f"{self.base}/info", headers=self.headers, timeout=self.timeout)
            if not r.ok:
                return False
            data = r.json()
            return isinstance(data, dict) and "Meta" in data
        except Exception:
            return False

    def get(self, path):
        """Liefert das Values-Objekt (oder den Rohwert) eines Endpunkts."""
        try:
            # Kurzes Timeout: ein haengender Einzelwert darf den Takt nicht bremsen.
            r = LOCAL.get(f"{self.base}/get/{path}", headers=self.headers, timeout=min(self.timeout, 1.5))
            if not r.ok:
                return None
            data = r.json()
        except Exception:
            return None
        if not isinstance(data, dict):
            return None
        if isinstance(data.get("Values"), dict):
            return data["Values"]
        # Manche Endpunkte antworten flach, z. B. {"Speed (ms)": 23.4}
        return {k: v for k, v in data.items() if k not in ("Result", "NodePath", "NodeName")}

    def value(self, path, default=None):
        values = self.get(path)
        if not isinstance(values, dict):
            return default
        if "Value" in values:
            return values["Value"]
        for v in values.values():
            if isinstance(v, (int, float, bool)):
                return v
        return default

    def node_names(self):
        if self.nodes is not None:
            return self.nodes
        self.nodes = []
        try:
            r = LOCAL.get(
                f"{self.base}/list/CurrentDrivableActor", headers=self.headers, timeout=self.timeout
            )
            if r.ok:
                data = r.json()
                self.nodes = [
                    n.get("Name", "") for n in data.get("Nodes", []) if isinstance(n, dict)
                ]
        except Exception:
            pass
        return self.nodes

    def find_node(self, keywords, avoid=()):
        """Sucht den passenden Bedienhebel der aktuellen Lok (Namen variieren je Zug)."""
        cache_key = keywords[0]
        if cache_key in self.controls:
            return self.controls[cache_key]
        found = None
        for name in self.node_names():
            low = name.lower()
            if any(bad in low for bad in avoid):
                continue
            if any(word in low for word in keywords):
                found = name
                break
        self.controls[cache_key] = found
        return found


def _num(value, default=0.0):
    try:
        f = float(value)
    except (TypeError, ValueError):
        return default
    if not math.isfinite(f) or abs(f) > 1e6:
        return default
    return f


_TSW_POOL = None


def _tsw_pool():
    """Kleiner Thread-Pool: alle Spielwerte werden gleichzeitig abgefragt."""
    global _TSW_POOL
    if _TSW_POOL is None:
        from concurrent.futures import ThreadPoolExecutor
        _TSW_POOL = ThreadPoolExecutor(max_workers=6, thread_name_prefix="tsw")
    return _TSW_POOL


def read_tsw(api):
    """Liest alle Werte parallel. Gibt None zurueck, wenn das Spiel nicht antwortet."""
    names = api.node_names()  # einmalig gecacht
    def node(keywords, avoid=()):
        n = api.find_node(keywords, avoid)
        return f"CurrentDrivableActor/{n}.Value" if n else None
    paths = {
        "speed": "CurrentDrivableActor.Function.HUD_GetSpeed",
        "aid": "DriverAid.Data",
        "info": "DriverAid.PlayerInfo",
        "throttle": node(("throttle", "regulator", "powerhandle"), avoid=("cutoff",)),
        "brake": node(("trainbrake", "brakehandle", "automaticbrake"), avoid=("dynamic", "park")),
        "brake_hud": "CurrentDrivableActor.Function.HUD_GetTrainBrakeHandle",
        "doors": node(("door",), avoid=("light", "lock", "window")),
    }
    pool = _tsw_pool()
    futures = {k: pool.submit(api.get, v) for k, v in paths.items() if v}
    raw = {}
    for k, f in futures.items():
        try:
            raw[k] = f.result(timeout=3)
        except Exception:
            raw[k] = None
    del names

    def val(k):
        values = raw.get(k)
        if not isinstance(values, dict):
            return None
        if "Value" in values:
            return values["Value"]
        for v in values.values():
            if isinstance(v, (int, float, bool)):
                return v
        return None

    if raw.get("speed") is None:
        return None  # Spiel antwortet gerade nicht

    speed = abs(_num(val("speed"), 0.0)) * 3.6

    limit = 0.0
    aid = raw.get("aid")
    if isinstance(aid, dict):
        raw_limit = aid.get("speedLimit")
        if isinstance(raw_limit, dict):
            limit = _num(raw_limit.get("value"), 0.0) * 3.6
        else:
            limit = _num(raw_limit, 0.0) * 3.6

    lat = lng = None
    info = raw.get("info")
    if isinstance(info, dict):
        geo = info.get("geoLocation")
        if isinstance(geo, dict):
            lat = _num(geo.get("latitude"), 999.0)
            lng = _num(geo.get("longitude"), 999.0)
            if abs(lat) > 90 or abs(lng) > 180:
                lat = lng = None

    throttle = _num(val("throttle"), 0.0)
    brake = _num(val("brake"), 0.0)
    if brake == 0.0:
        brake = _num(val("brake_hud"), 0.0)
    doors = _num(val("doors"), 0.0)

    result = {
        "speed_kmh": round(min(speed, 500.0), 1),
        "speed_limit_kmh": round(min(max(limit, 0.0), 500.0), 1),
        "throttle": round(min(max(throttle, 0.0), 1.0), 2),
        "brake": round(min(max(brake, 0.0), 1.0), 2),
        "doors_open": doors > 0.5,
    }
    if lat is not None and lng is not None:
        result["latitude"] = round(lat, 6)
        result["longitude"] = round(lng, 6)
    return result



def demo_values(tick):
    speed = round(60 + 50 * abs(math.sin(tick / 25)), 1)
    return {
        "speed_kmh": speed,
        "speed_limit_kmh": 120.0,
        "throttle": round(min(speed / 140, 1.0), 2),
        "brake": 0.0,
        "doors_open": speed < 2,
    }


# --------------------------------------------------------------------------
# Hintergrund-Sender
# --------------------------------------------------------------------------
class Sender(threading.Thread):
    def __init__(self, cfg, out):
        super().__init__(daemon=True)
        self.cfg = cfg
        self.out = out
        self.stop_event = threading.Event()

    _post_busy = False

    def log(self, text):
        self.out.put(("log", text))

    def _post(self, payload, values, live):
        try:
            r = HTTP.post(
                self.cfg.get("endpoint", ENDPOINT),
                json=payload,
                headers={"x-telemetry-key": self.cfg.get("key", "")},
                timeout=6,
            )
            ok = r.ok
            if r.status_code == 503:
                try:
                    status = r.json().get("error", "Wartungsmodus aktiv")
                except Exception:
                    status = "Wartungsmodus aktiv - bitte spaeter erneut verbinden"
            else:
                status = "gesendet" if ok else f"Fehler {r.status_code}: {r.text[:100]}"
        except Exception as exc:
            ok = False
            status = f"Netzwerkfehler: {exc}"
        finally:
            self._post_busy = False
        self.out.put(("data", {"ok": ok, "status": status, "live": live, "values": values}))

    def run(self):
        interval = max(float(self.cfg.get("intervall", 2.0)), 1.0)
        section = max(float(self.cfg.get("abschnitt", 180.0)), 1.0)
        demo_only = bool(self.cfg.get("demo"))
        api = None
        tick = 0
        fahrzeit = 0.0
        standzeit = 0.0
        # Fahrtende-Erkennung: merkt sich, ob eine Fahrt lief, und wie lange
        # Train Sim World schon nicht mehr antwortet (Szenario beendet).
        fahrt_lief = False
        ende_gemeldet = False
        last_sig = None
        last_sent = 0.0

        if not demo_only:
            api = TswApi()
            if not api.comm_key:
                self.log(
                    "Kein Spiel-Schluessel gefunden. Train Sim World bitte mit dem "
                    "Startparameter -HTTPAPI starten (Steam: Eigenschaften > Startoptionen)."
                )
            if api.available():
                self.log(
                    f"Train Sim World gefunden - Live-Telemetrie aktiv ({len(api.node_names())} Bedienelemente erkannt)."
                )
            else:
                api = None
                kp = find_comm_key_path()
                self.log(
                    "Train Sim World antwortet nicht - die Übertragung pausiert. "
                    "Pruefen: 1) Startoption -HTTPAPI gesetzt, 2) Spiel komplett neu gestartet, "
                    "3) Firewall/Antivirus blockiert Port 31270 nicht. "
                    + (f"Schluessel gefunden: {kp}" if kp else "Kein CommAPIKey.txt gefunden (auch nicht in OneDrive).")
                )
        else:
            self.log("Demo-Modus: es werden Testwerte gesendet.")


        # Kurze Aussetzer von Train Sim World (Ladepausen, Menü, Lags) duerfen die
        # Verbindung nicht sofort trennen. Erst nach mehreren Fehlversuchen in Folge
        # gilt das Spiel als geschlossen.
        misses = 0
        MAX_MISSES = 5          # ~10 Sekunden Toleranz bei 2 s Intervall
        OFFLINE_DELETE_AFTER = 45.0  # erst danach den Zug von der Karte nehmen
        offline_since = None
        removed = False

        while not self.stop_event.is_set():
            tick += 1
            if api is None and not demo_only:
                probe = TswApi()
                if probe.available():
                    api = probe
                    misses = 0
                    offline_since = None
                    removed = False
                    self.log("Train Sim World gefunden - Live-Telemetrie aktiv.")

            if api is not None and tick % 60 == 0:
                # Lok gewechselt? Bedienelemente neu einlesen.
                api.nodes = None
                api.controls = {}

            values = None
            if api is not None:
                values = read_tsw(api)
            if api is not None and values is None and not api.available():
                misses += 1
                if misses < MAX_MISSES:
                    # Nur ein kurzer Aussetzer: Verbindung halten, nichts loeschen.
                    self.stop_event.wait(interval)
                    continue
                # Spiel/Szenario wurde beendet oder geschlossen.
                api = None
                misses = 0
                offline_since = time.time()
                self.out.put(("waiting", None))
                self.log("Train Sim World antwortet nicht mehr - die Übertragung pausiert.")
                if fahrt_lief and not ende_gemeldet:
                    ende_gemeldet = True
                    self.log("Fahrtende erkannt - Train Sim World meldet keine Fahrt mehr.")
                    self.out.put(("trip_end", None))
            elif api is not None:
                misses = 0
                if values is None:
                    self.stop_event.wait(0.3)
                    continue

            if api is None and not demo_only:
                if (
                    not removed
                    and offline_since is not None
                    and time.time() - offline_since > OFFLINE_DELETE_AFTER
                ):
                    removed = True
                    try:
                        HTTP.delete(
                            self.cfg.get("endpoint", ENDPOINT),
                            headers={"x-telemetry-key": self.cfg.get("key", "")},
                            timeout=6,
                        )
                    except Exception:
                        pass
                self.out.put(("waiting", None))
                self.stop_event.wait(interval)
                continue

            if values is None:
                values = demo_values(tick)

            if values["speed_kmh"] > 1.0:
                fahrzeit += interval
                standzeit = 0.0
                if api is not None:
                    fahrt_lief = True
                    ende_gemeldet = False
            else:
                standzeit += interval
                if standzeit > 15.0:
                    fahrzeit = 0.0
            progress = min(fahrzeit / section, 1.0)

            payload = {
                "telemetry_mode": "demo" if demo_only else "live",
                "train_number": self.cfg.get("zug", ""),
                "line": self.cfg.get("linie", ""),
                "loco": self.cfg.get("lok", ""),
                "last_station": self.cfg.get("letzter_halt", ""),
                "next_station": self.cfg.get("halt", ""),
                "destination": self.cfg.get("ziel", ""),
                "progress": round(progress, 3),
                "delay_minutes": int(self.cfg.get("verspaetung", 0) or 0),
                **values,
            }

            signature = (
                round(values["speed_kmh"], 1), values["throttle"], values["brake"],
                values["doors_open"], payload["next_station"], payload["delay_minutes"],
            )
            now = time.time()
            if signature == last_sig and now - last_sent < 10.0:
                # Nichts veraendert (z. B. Halt im Bahnhof): Netz und Server schonen.
                self.out.put((
                    "data",
                    {"ok": True, "status": "unveraendert", "live": api is not None,
                     "values": values},
                ))
                self.stop_event.wait(interval)
                continue
            last_sig = signature
            last_sent = now

            # Senden laeuft im Hintergrund: eine langsame Internetverbindung
            # verzoegert das Auslesen des Spiels nicht mehr.
            if self._post_busy:
                self.out.put(("data", {"ok": True, "status": "sende noch ...",
                                       "live": api is not None, "values": values}))
            else:
                self._post_busy = True
                threading.Thread(
                    target=self._post, args=(payload, values, api is not None), daemon=True
                ).start()
            self.stop_event.wait(interval)

        try:
            HTTP.delete(
                self.cfg.get("endpoint", ENDPOINT),
                headers={"x-telemetry-key": self.cfg.get("key", "")},
                timeout=6,
            )
        except Exception:
            pass
        self.log("Verbindung beendet.")
        self.out.put(("stopped", None))


# --------------------------------------------------------------------------
# Oberflaeche
# --------------------------------------------------------------------------
FIELDS = [
    ("key", "Telemetrie-Schlüssel", "tsw_…"),
    ("zug", "Zugnummer", "34712"),
    ("linie", "Linie", "S8"),
    ("ziel", "Zielbahnhof", "Wiesbaden Hbf"),
    ("letzter_halt", "Zuletzt verlassener Halt", "Frankfurt Hbf"),
    ("halt", "Nächster Halt", "Niederrad"),
    ("lok", "Baureihe / Lok", "BR 430"),
    ("verspaetung", "Verspätung (Minuten)", "0"),
    ("intervall", "Sendeabstand (Sekunden)", "2"),
    ("abschnitt", "Fahrzeit je Abschnitt (Sek.)", "180"),
]
class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("RegioBahn.eu – Telemetrie-Client")
        self.configure(bg=BG)
        self.geometry("980x900")
        self.minsize(720, 780)
        self.withdraw()

        self.queue = queue.Queue()
        self.sender = None
        self.vars = {}
        self.trains = []
        self.orders = []
        self.events = []
        self.seen_event_ids = None
        self.chat_messages = []
        self.chat_last_id = None
        self.entries = {}
        self.overlay = None
        self.overlay_canvas = None
        self.overlay_status = None
        self._overlay_keepalive = None
        self._overlay_animation = None
        self._overlay_last_frame = None
        self._overlay_motion = {}
        self._overlay_heading = None
        self._map_fetching = False
        self.demo_var = tk.BooleanVar(value=False)
        self._list_trains = []
        self._near_last = set()
        self._stats = {"max": 0.0, "km": 0.0, "start": None, "last": None}
        self._last_overspeed = 0.0

        self._build()
        self._load_config()
        self.after(200, self._poll)
        self.after(1200, self._map_tick)
        self.after(1600, self._orders_tick)
        self.after(2400, self._chat_tick)
        self.after(3200, self._history_tick)
        self.after(2600, self._events_tick)
        self._tick_clock()
        self.after(2000, self._weather_tick)
        self.protocol("WM_DELETE_WINDOW", self._on_close)

        if requests is None:
            messagebox.showerror(
                "Paket fehlt",
                "Das Paket 'requests' fehlt.\n\nBitte in der Eingabeaufforderung ausführen:\n"
                "py -m pip install requests",
            )

        self._show_splash()

    # ---- Bausteine -------------------------------------------------------
    def _button(self, parent, text, command, kind="ghost"):
        bg, hover, fg = (
            (RED, RED_HOVER, "#ffffff") if kind == "primary" else (GHOST, GHOST_HOVER, FG)
        )
        btn = tk.Button(
            parent, text=text, command=command, bg=bg, fg=fg,
            activebackground=hover, activeforeground=fg, disabledforeground=MUTED,
            relief="flat", bd=0, highlightthickness=0, cursor="hand2",
            font=("Segoe UI", 10, "bold" if kind == "primary" else "normal"),
            padx=18, pady=9,
        )
        btn.bind("<Enter>", lambda _e: btn.configure(bg=hover) if btn["state"] != "disabled" else None)
        btn.bind("<Leave>", lambda _e: btn.configure(bg=bg))
        return btn

    def _card(self, parent):
        return tk.Frame(parent, bg=CARD, highlightbackground=BORDER, highlightthickness=1)

    def _meter(self, parent, label, color):
        row = tk.Frame(parent, bg=CARD)
        row.pack(fill="x", pady=5)
        tk.Label(
            row, text=label, bg=CARD, fg=MUTED, font=("Segoe UI", 9), width=8, anchor="w"
        ).pack(side="left")
        canvas = tk.Canvas(row, height=8, bg=ENTRY_BG, highlightthickness=0)
        canvas.pack(side="left", fill="x", expand=True, padx=(6, 10))
        rect = canvas.create_rectangle(0, 0, 0, 8, fill=color, width=0)
        value = tk.Label(row, text="0 %", bg=CARD, fg=FG, font=("Segoe UI", 9, "bold"), width=5, anchor="e")
        value.pack(side="left")
        return canvas, rect, value

    def _set_meter(self, meter, frac):
        canvas, rect, value = meter
        frac = min(max(float(frac or 0.0), 0.0), 1.0)
        width = max(canvas.winfo_width(), 10)
        canvas.coords(rect, 0, 0, int(width * frac), 8)
        value.configure(text=f"{int(round(frac * 100))} %")

    # ---- Aufbau ----------------------------------------------------------
    def _build(self):
        tk.Frame(self, bg=RED, height=3).pack(fill="x")

        head = tk.Frame(self, bg=BG)
        head.pack(fill="x", padx=24, pady=(18, 10))
        title_row = tk.Frame(head, bg=BG)
        title_row.pack(fill="x")
        tk.Label(
            title_row, text="RegioBahn", bg=BG, fg=FG, font=("Segoe UI Semibold", 20)
        ).pack(side="left")
        tk.Label(
            title_row, text=".eu", bg=BG, fg=RED, font=("Segoe UI Semibold", 20)
        ).pack(side="left")
        tk.Label(
            title_row, text="  Telemetrie-Client", bg=BG, fg=MUTED, font=("Segoe UI", 11)
        ).pack(side="left", pady=(6, 0))
        tk.Label(
            title_row, text="TRAIN SIM WORLD", bg=PANEL, fg=MUTED,
            font=("Segoe UI", 8, "bold"), padx=10, pady=4,
        ).pack(side="right")
        tk.Label(
            head, text="Sendet deine Fahrdaten live an die Leitstelle und die Netzkarte.",
            bg=BG, fg=MUTED, font=("Segoe UI", 9),
        ).pack(anchor="w", pady=(3, 0))

        # Uhrzeit + Wetter (Frankfurt a. M.)
        info_row = tk.Frame(head, bg=CARD, highlightthickness=1,
                            highlightbackground=BORDER)
        info_row.pack(fill="x", pady=(10, 0))
        self.clock_label = tk.Label(
            info_row, text="--:--:--", bg=CARD, fg=FG,
            font=("Segoe UI Semibold", 12), padx=14, pady=8,
        )
        self.clock_label.pack(side="left")
        self.weather_label = tk.Label(
            info_row, text="Wetter wird geladen …", bg=CARD, fg=MUTED,
            font=("Segoe UI", 10), padx=14, pady=8,
        )
        self.weather_label.pack(side="right")

        style = ttk.Style(self)
        try:
            style.theme_use("clam")
        except Exception:
            pass
        style.configure("TNotebook", background=BG, borderwidth=0)
        style.configure(
            "TNotebook.Tab", background=BG, foreground=MUTED,
            padding=(20, 10), font=("Segoe UI", 10), borderwidth=0,
        )
        style.map(
            "TNotebook.Tab",
            background=[("selected", CARD)],
            foreground=[("selected", FG)],
        )

        nb = ttk.Notebook(self)
        nb.pack(fill="both", expand=True, padx=20, pady=(6, 18))

        page = tk.Frame(nb, bg=BG)
        orders_page = tk.Frame(nb, bg=BG)
        map_page = tk.Frame(nb, bg=BG)
        chat_page = tk.Frame(nb, bg=BG)
        history_page = tk.Frame(nb, bg=BG)
        nb.add(page, text="  Fahrt & Telemetrie  ")
        nb.add(orders_page, text="  Fahraufträge  ")
        nb.add(map_page, text="  Multiplayer-Karte  ")
        nb.add(history_page, text="  Fahrtenverlauf  ")
        nb.add(chat_page, text="  Leitstellen-Chat  ")
        self._orders_page = orders_page
        self.nb = nb
        self._tab_widgets = {
            "orders": orders_page, "map": map_page,
            "history": history_page, "chat": chat_page,
        }

        # -- Einstellungen (zwei Spalten) ----------------------------------
        card = self._card(page)
        card.pack(fill="x", padx=2, pady=(12, 4))
        card.columnconfigure(0, weight=1, uniform="f")
        card.columnconfigure(1, weight=1, uniform="f")

        tk.Label(
            card, text="FAHRT-EINSTELLUNGEN", bg=CARD, fg=MUTED,
            font=("Segoe UI", 8, "bold"),
        ).grid(row=0, column=0, columnspan=2, sticky="w", padx=16, pady=(14, 2))

        for index, (key, label, placeholder) in enumerate(FIELDS):
            cell = tk.Frame(card, bg=CARD)
            cell.grid(row=index // 2 + 1, column=index % 2, sticky="ew", padx=16, pady=5)
            tk.Label(
                cell, text=label, bg=CARD, fg=MUTED, font=("Segoe UI", 9)
            ).pack(anchor="w")
            var = tk.StringVar()
            entry = tk.Entry(
                cell, textvariable=var, bg=ENTRY_BG, fg=FG, insertbackground=FG,
                relief="flat", bd=0, font=("Segoe UI", 10),
                highlightthickness=1, highlightbackground=BORDER, highlightcolor=RED,
                show="•" if key == "key" else "",
            )
            if key in ("ziel", "letzter_halt", "halt"):
                row = tk.Frame(cell, bg=CARD)
                row.pack(fill="x", pady=(3, 0))
                entry.pack(in_=row, side="left", fill="x", expand=True, ipady=6)
                pick = tk.Button(
                    row, text="▾", bg=ENTRY_BG, fg=FG, relief="flat", bd=0,
                    activebackground=BORDER, activeforeground=FG, cursor="hand2",
                    font=("Segoe UI", 10, "bold"), width=3,
                )
                pick.configure(command=lambda b=pick, v=var, e=entry: self._station_menu(b, v, e))
                pick.pack(side="left", fill="y", padx=(2, 0))
            else:
                entry.pack(fill="x", ipady=6, pady=(3, 0))
            self.vars[key] = var
            self.entries[key] = entry
            self._placeholder(entry, var, placeholder)

        tk.Checkbutton(
            card, text="Demo-Modus (Testwerte ohne laufendes Spiel)",
            variable=self.demo_var, bg=CARD, fg=FG, selectcolor=ENTRY_BG,
            activebackground=CARD, activeforeground=FG, font=("Segoe UI", 9),
        ).grid(row=len(FIELDS) // 2 + 1, column=0, columnspan=2, sticky="w", padx=14, pady=(8, 14))

        # -- Aktionen --------------------------------------------------------
        actions = tk.Frame(page, bg=BG)
        actions.pack(fill="x", padx=2, pady=(10, 0))
        self.start_btn = self._button(actions, "▶  Verbindung starten", self._start, "primary")
        self.start_btn.pack(side="left")
        self.stop_btn = self._button(actions, "■  Stoppen", self._stop)
        self.stop_btn.pack(side="left", padx=10)
        self.stop_btn.configure(state="disabled")
        self._button(actions, "Einstellungen speichern", self._save_config).pack(side="right")

        # -- Live-Anzeige ----------------------------------------------------
        status = self._card(page)
        status.pack(fill="x", padx=2, pady=(12, 4))

        left = tk.Frame(status, bg=CARD)
        left.pack(side="left", fill="y", padx=20, pady=16)
        self.state_label = tk.Label(
            left, text="●  Getrennt", bg=CARD, fg=MUTED, font=("Segoe UI", 10, "bold")
        )
        self.state_label.pack(anchor="w")
        speed_row = tk.Frame(left, bg=CARD)
        speed_row.pack(anchor="w", pady=(6, 0))
        self.speed_label = tk.Label(
            speed_row, text="—", bg=CARD, fg=FG, font=("Segoe UI Semibold", 38)
        )
        self.speed_label.pack(side="left")
        tk.Label(
            speed_row, text=" km/h", bg=CARD, fg=MUTED, font=("Segoe UI", 12)
        ).pack(side="left", pady=(12, 0))
        self.detail_label = tk.Label(
            left, text="Türen —", bg=CARD, fg=MUTED, font=("Segoe UI", 9)
        )
        self.detail_label.pack(anchor="w", pady=(4, 0))

        right = tk.Frame(status, bg=CARD)
        right.pack(side="left", fill="both", expand=True, padx=20, pady=18)
        self.throttle_meter = self._meter(right, "Schub", GREEN)
        self.brake_meter = self._meter(right, "Bremse", RED)
        tk.Label(
            right, text="Die Werte kommen direkt aus dem Führerstand.",
            bg=CARD, fg=MUTED, font=("Segoe UI", 8),
        ).pack(anchor="w", pady=(6, 0))

        # -- Protokoll --------------------------------------------------------
        tk.Label(
            page, text="PROTOKOLL", bg=BG, fg=MUTED, font=("Segoe UI", 8, "bold")
        ).pack(anchor="w", padx=6, pady=(10, 2))
        self.log_box = tk.Text(
            page, height=7, bg=ENTRY_BG, fg=MUTED, relief="flat", bd=0,
            font=("Consolas", 9), wrap="word", padx=10, pady=8,
            highlightthickness=1, highlightbackground=BORDER,
        )
        self.log_box.pack(fill="both", expand=True, padx=2, pady=(0, 2))
        self.log_box.configure(state="disabled")

        self._build_orders(orders_page)
        self._build_map(map_page)
        self._build_history(history_page)
        self._build_chat(chat_page)

    # ---- Fahrtenverlauf --------------------------------------------------
    def _build_history(self, parent):
        bar = tk.Frame(parent, bg=BG)
        bar.pack(fill="x", padx=2, pady=(12, 6))
        tk.Label(
            bar, text="Fahrtenverlauf", bg=BG, fg=FG, font=("Segoe UI Semibold", 12)
        ).pack(side="left")
        self.history_status = tk.Label(
            bar, text="Noch nicht geladen", bg=BG, fg=MUTED, font=("Segoe UI", 9)
        )
        self.history_status.pack(side="left", padx=12)
        self._button(bar, "Aktualisieren", self._refresh_history).pack(side="right")

        tk.Label(
            parent,
            text="Alle abgeschlossenen und abgebrochenen Fahrten mit Abfahrt, Meldezeit, "
            "Verspaetung, Meldeweg und Punkten.",
            bg=BG, fg=MUTED, font=("Segoe UI", 9), anchor="w", justify="left",
        ).pack(fill="x", padx=4, pady=(0, 6))

        box = self._card(parent)
        box.pack(fill="both", expand=True, padx=2, pady=(0, 10))
        self.history_list = tk.Listbox(
            box, bg=ENTRY_BG, fg=FG, selectbackground=RED, selectforeground="#ffffff",
            relief="flat", bd=0, highlightthickness=0, font=("Consolas", 10),
            activestyle="none",
        )
        self.history_list.pack(fill="both", expand=True, padx=10, pady=10)

    def _stamp(self, raw):
        raw = (raw or "").replace("Z", "+00:00")
        try:
            return datetime.fromisoformat(raw).astimezone().strftime("%d.%m. %H:%M")
        except Exception:
            return "--.--. --:--"

    def _refresh_history(self):
        if requests is None:
            return
        key = self._value("key")
        if not key:
            self.history_status.configure(text="Bitte zuerst den Telemetrie-Schluessel eintragen.")
            return

        def work():
            try:
                r = HTTP.get(HISTORY_ENDPOINT, headers={"x-telemetry-key": key}, timeout=6)
                if r.ok:
                    self.queue.put(("history", r.json().get("trips", [])))
                else:
                    self.queue.put(("history_error", f"Fahrtenverlauf: Fehler {r.status_code}"))
            except Exception as exc:
                self.queue.put(("history_error", f"Fahrtenverlauf: {exc}"))

        threading.Thread(target=work, daemon=True).start()

    def _history_tick(self):
        if self._tab_active("history"):
            self._refresh_history()
        self.after(180000, self._history_tick)

    def _update_history(self, trips):
        trips = trips or []
        done = sum(1 for t in trips if t.get("status") == "arrived")
        cancelled = sum(1 for t in trips if t.get("status") == "cancelled")
        points = sum(int(t.get("points") or 0) for t in trips)
        self.history_status.configure(
            text=f"{done} abgeschlossen · {cancelled} abgebrochen · {points} Punkte"
        )
        self.history_list.delete(0, "end")
        for t in trips:
            delay = int(t.get("delay_minutes") or 0)
            delay_text = f"+{delay} Min" if delay else "puenktlich"
            status = "Angekommen" if t.get("status") == "arrived" else "Abgebrochen"
            via = t.get("reported_via")
            via_text = {"client": "Client", "dispatcher": "Leitstelle"}.get(via, "offen")
            self.history_list.insert(
                "end",
                f"{self._stamp(t.get('departure_at')):<13} "
                f"{(t.get('line') or '--'):<3} {(t.get('train_number') or '-----'):<6} "
                f"{(t.get('origin') or '-')} -> {(t.get('destination') or '-')}"
                f"   beendet {self._stamp(t.get('finished_at'))}"
                f"   {delay_text:<11} {status:<12} Meldung: {via_text:<10}"
                f" +{int(t.get('points') or 0)} P",
            )
        if not trips:
            self.history_list.insert("end", "Noch keine beendeten Fahrten.")

    # ---- Leitstellen-Chat ------------------------------------------------
    def _build_chat(self, parent):
        bar = tk.Frame(parent, bg=BG)
        bar.pack(fill="x", padx=2, pady=(12, 6))
        tk.Label(
            bar, text="Leitstellen-Chat", bg=BG, fg=FG, font=("Segoe UI Semibold", 12)
        ).pack(side="left")
        self.chat_status = tk.Label(
            bar, text="Noch nicht geladen", bg=BG, fg=MUTED, font=("Segoe UI", 9)
        )
        self.chat_status.pack(side="left", padx=12)
        self.chat_sound_var = tk.BooleanVar(value=True)
        tk.Checkbutton(
            bar, text="Ton bei neuer Nachricht", variable=self.chat_sound_var,
            bg=BG, fg=MUTED, selectcolor=ENTRY_BG, activebackground=BG,
            activeforeground=FG, font=("Segoe UI", 9),
        ).pack(side="right")
        self._button(bar, "Aktualisieren", self._refresh_chat).pack(side="right", padx=(0, 8))

        box = self._card(parent)
        box.pack(fill="both", expand=True, padx=2, pady=(0, 6))
        self.chat_box = tk.Text(
            box, bg=ENTRY_BG, fg=FG, relief="flat", bd=0, font=("Segoe UI", 10),
            wrap="word", padx=12, pady=10, highlightthickness=0,
        )
        self.chat_box.pack(fill="both", expand=True, padx=10, pady=10)
        self.chat_box.tag_configure("meta", foreground=MUTED, font=("Segoe UI", 8))
        self.chat_box.tag_configure("leitstelle", foreground=RED, font=("Segoe UI", 8, "bold"))
        self.chat_box.configure(state="disabled")

        send_row = tk.Frame(parent, bg=BG)
        send_row.pack(fill="x", padx=2, pady=(0, 8))
        self.chat_input = tk.Entry(
            send_row, bg=ENTRY_BG, fg=FG, insertbackground=FG, relief="flat", bd=0,
            font=("Segoe UI", 10), highlightthickness=1,
            highlightbackground=BORDER, highlightcolor=RED,
        )
        self.chat_input.pack(side="left", fill="x", expand=True, ipady=7)
        self.chat_input.bind("<Return>", lambda _e: self._send_chat())
        self._button(send_row, "Senden", self._send_chat, kind="primary").pack(
            side="left", padx=(8, 0)
        )

    def _play_dong(self):
        if not getattr(self, "chat_sound_var", None) or not self.chat_sound_var.get():
            return
        try:
            if winsound is not None:
                winsound.Beep(880, 160)
                winsound.Beep(520, 260)
            else:
                self.bell()
        except Exception:
            try:
                self.bell()
            except Exception:
                pass

    def _refresh_chat(self):
        if requests is None:
            return
        key = self._value("key")
        if not key:
            self.chat_status.configure(text="Bitte zuerst den Telemetrie-Schlüssel eintragen.")
            return

        def work():
            try:
                r = HTTP.get(CHAT_ENDPOINT, headers={"x-telemetry-key": key}, timeout=6)
                if r.ok:
                    self.queue.put(("chat", r.json().get("messages", [])))
                else:
                    self.queue.put(("chat_error", f"Chat: Fehler {r.status_code}"))
            except Exception as exc:
                self.queue.put(("chat_error", f"Chat: {exc}"))

        threading.Thread(target=work, daemon=True).start()

    def _chat_tick(self):
        self._refresh_chat()
        self.after(5000, self._chat_tick)

    def _send_chat(self):
        text = self.chat_input.get().strip()
        if not text:
            return
        key = self._value("key")
        if requests is None or not key:
            self.chat_status.configure(text="Senden nicht möglich – Schlüssel fehlt.")
            return
        self.chat_input.delete(0, "end")

        def work():
            try:
                r = HTTP.post(
                    CHAT_ENDPOINT, headers={"x-telemetry-key": key},
                    json={"body": text}, timeout=6,
                )
                if not r.ok:
                    self.queue.put(("chat_error", f"Senden fehlgeschlagen ({r.status_code})"))
            except Exception as exc:
                self.queue.put(("chat_error", f"Senden fehlgeschlagen: {exc}"))
            try:
                r = HTTP.get(CHAT_ENDPOINT, headers={"x-telemetry-key": key}, timeout=6)
                if r.ok:
                    self.queue.put(("chat", r.json().get("messages", [])))
            except Exception:
                pass

        threading.Thread(target=work, daemon=True).start()

    def _chat_time(self, message):
        raw = (message.get("created_at") or "").replace("Z", "+00:00")
        try:
            return datetime.fromisoformat(raw).astimezone().strftime("%H:%M")
        except Exception:
            return "--:--"

    def _update_chat(self, messages):
        messages = messages or []
        self.chat_messages = messages
        self.chat_status.configure(
            text=f"{len(messages)} Nachricht(en) · Stand {time.strftime('%H:%M:%S')}"
        )

        self.chat_box.configure(state="normal")
        self.chat_box.delete("1.0", "end")
        for m in messages:
            dispatcher = m.get("sender_role") == "dispatcher"
            label = f"{m.get('sender_name') or 'Unbekannt'}"
            label += " · Leitstelle" if dispatcher else " · Lokführer"
            self.chat_box.insert(
                "end", f"{label}  {self._chat_time(m)}\n",
                "leitstelle" if dispatcher else "meta",
            )
            self.chat_box.insert("end", f"{(m.get('body') or '').strip()}\n\n")
        if not messages:
            self.chat_box.insert("end", "Noch keine Nachrichten der Leitstelle.\n", "meta")
        self.chat_box.see("end")
        self.chat_box.configure(state="disabled")

        newest = messages[-1] if messages else None
        if newest:
            new_id = newest.get("id")
            if (
                self.chat_last_id is not None
                and new_id != self.chat_last_id
                and not newest.get("self")
            ):
                self._play_dong()
                self._log(
                    f"Neue Nachricht von {newest.get('sender_name') or 'Leitstelle'}: "
                    f"{(newest.get('body') or '').strip()}"
                )
            self.chat_last_id = new_id

            # Letzte Meldung auch auf der Multiplayer-Karte anzeigen
            radio = getattr(self, "radio_label", None)
            if radio is not None and radio.winfo_exists():
                absender = newest.get("sender_name") or "Unbekannt"
                if newest.get("sender_role") == "dispatcher":
                    absender += " (Leitstelle)"
                body = (newest.get("body") or "").strip()
                radio.configure(
                    text=f"Funk {self._chat_time(newest)} · {absender}: {body}"[:200],
                    fg=RED if newest.get("sender_role") == "dispatcher" else MUTED,
                )

    def _build_orders(self, parent):
        bar = tk.Frame(parent, bg=BG)
        bar.pack(fill="x", padx=2, pady=(12, 6))
        tk.Label(
            bar, text="Deine Fahraufträge", bg=BG, fg=FG, font=("Segoe UI Semibold", 12)
        ).pack(side="left")
        self.orders_status = tk.Label(
            bar, text="Noch nicht geladen", bg=BG, fg=MUTED, font=("Segoe UI", 9)
        )
        self.orders_status.pack(side="left", padx=12)
        self._button(bar, "Aktualisieren", self._refresh_orders).pack(side="right")
        self._button(
            bar, "Auftrag übernehmen", self._apply_order, kind="primary"
        ).pack(side="right", padx=(0, 8))

        tk.Label(
            parent,
            text="Auftrag auswählen und übernehmen – Zugnummer, Linie, Ziel und Verspätung "
            "werden direkt in die Fahrtdaten eingetragen. Nach der Fahrt den Auftrag als "
            "abgeschlossen oder abgebrochen melden – dafür gibt es Punkte.",
            bg=BG, fg=MUTED, font=("Segoe UI", 9), anchor="w", justify="left",
        ).pack(fill="x", padx=4, pady=(0, 6))

        # Hinweis-Banner, wenn der Client das Fahrtende im Spiel erkennt
        self.trip_end_banner = tk.Frame(parent, bg=CARD)
        banner_inner = tk.Frame(self.trip_end_banner, bg=CARD)
        banner_inner.pack(fill="x", padx=12, pady=10)
        tk.Label(
            banner_inner,
            text="Fahrtende erkannt – Train Sim World meldet keine Fahrt mehr. "
            "Wie ist die Fahrt ausgegangen?",
            bg=CARD, fg=FG, font=("Segoe UI", 9, "bold"), anchor="w", justify="left",
        ).pack(side="left", fill="x", expand=True)
        self._button(
            banner_inner, "Abgebrochen", lambda: self._report_trip("cancelled")
        ).pack(side="right")
        self._button(
            banner_inner, "Abgeschlossen", lambda: self._report_trip("completed"),
            kind="primary",
        ).pack(side="right", padx=(0, 8))

        box = self._card(parent)
        box.pack(fill="both", expand=True, padx=2, pady=(0, 6))
        self.orders_list = tk.Listbox(
            box, bg=ENTRY_BG, fg=FG, selectbackground=RED, selectforeground="#ffffff",
            relief="flat", bd=0, highlightthickness=0, font=("Consolas", 10),
            activestyle="none",
        )
        self.orders_list.pack(fill="both", expand=True, padx=10, pady=10)

        self.order_detail = tk.Label(
            parent, text="Kein Auftrag ausgewählt.", bg=BG, fg=MUTED,
            font=("Segoe UI", 9), anchor="w", justify="left",
        )
        self.order_detail.pack(fill="x", padx=4, pady=(0, 4))

        actions = tk.Frame(parent, bg=BG)
        actions.pack(fill="x", padx=2, pady=(0, 10))
        tk.Label(
            actions, text="Fahrt beenden:", bg=BG, fg=MUTED, font=("Segoe UI", 9)
        ).pack(side="left", padx=(4, 8))
        self._button(
            actions, "✓ Abgeschlossen melden",
            lambda: self._report_trip("completed"), kind="primary",
        ).pack(side="left")
        self._button(
            actions, "✕ Abgebrochen melden", lambda: self._report_trip("cancelled")
        ).pack(side="left", padx=(8, 0))
        self.orders_list.bind("<<ListboxSelect>>", lambda _e: self._show_order_detail())

        tk.Label(
            parent, text="Ereignisse der Leitstelle", bg=BG, fg=FG,
            font=("Segoe UI Semibold", 12), anchor="w",
        ).pack(fill="x", padx=4, pady=(8, 4))
        tk.Label(
            parent,
            text='Betriebs-Ereignisse (z. B. „Fahrgäste warten am Gleis 3") erscheinen hier '
            "sofort – neue Ereignisse melden sich mit einem Signalton.",
            bg=BG, fg=MUTED, font=("Segoe UI", 9), anchor="w", justify="left",
        ).pack(fill="x", padx=4, pady=(0, 6))
        events_box = self._card(parent)
        events_box.pack(fill="x", padx=2, pady=(0, 10))
        self.events_list = tk.Listbox(
            events_box, bg=ENTRY_BG, fg=FG, selectbackground=RED, selectforeground="#ffffff",
            relief="flat", bd=0, highlightthickness=0, font=("Consolas", 10),
            activestyle="none", height=4,
        )
        self.events_list.pack(fill="x", padx=10, pady=(10, 0))
        events_actions = tk.Frame(events_box, bg=CARD)
        events_actions.pack(fill="x", padx=10, pady=(0, 10))
        self._button(
            events_actions, "✓ Ereignis bestätigen", self._ack_event, kind="primary"
        ).pack(side="left")
        tk.Label(
            events_actions,
            text="Damit sieht die Leitstelle, dass du die Durchsage gelesen hast.",
            bg=CARD, fg=MUTED, font=("Segoe UI", 8), anchor="w",
        ).pack(side="left", padx=(8, 0))

    def _order_time(self, order):
        raw = (order.get("departure_at") or "").replace("Z", "+00:00")
        try:
            dt = datetime.fromisoformat(raw).astimezone()
            return dt.strftime("%d.%m. %H:%M")
        except Exception:
            return "--.--. --:--"

    def _refresh_orders(self):
        if requests is None:
            return
        key = self._value("key")
        if not key:
            self.orders_status.configure(text="Bitte zuerst den Telemetrie-Schlüssel eintragen.")
            return

        def work():
            try:
                r = HTTP.get(ORDERS_ENDPOINT, headers={"x-telemetry-key": key}, timeout=6)
                if r.ok:
                    self.queue.put(("orders", r.json().get("trips", [])))
                else:
                    self.queue.put(("orders_error", f"Fahraufträge: Fehler {r.status_code}"))
            except Exception as exc:
                self.queue.put(("orders_error", f"Fahraufträge: {exc}"))

        threading.Thread(target=work, daemon=True).start()

    def _orders_tick(self):
        if self._tab_active("orders") or self.sender is not None:
            self._refresh_orders()
        self.after(60000, self._orders_tick)

    def _refresh_events(self):
        if requests is None:
            return
        key = self._value("key")
        if not key:
            return

        def work():
            try:
                r = HTTP.get(EVENTS_ENDPOINT, headers={"x-telemetry-key": key}, timeout=6)
                if r.ok:
                    self.queue.put(("events", r.json().get("events", [])))
                else:
                    self.queue.put(("events_error", f"Ereignisse: Fehler {r.status_code}"))
            except Exception as exc:
                self.queue.put(("events_error", f"Ereignisse: {exc}"))

        threading.Thread(target=work, daemon=True).start()

    def _events_tick(self):
        if self._tab_active("orders") or self.sender is not None:
            self._refresh_events()
        self.after(10000, self._events_tick)

    def _update_events(self, events):
        events = events or []
        old_ids = self.seen_event_ids
        first_load = old_ids is None
        fresh = [e for e in events if e.get("id") and e.get("id") not in (old_ids or set())]
        if first_load:
            fresh = []
        self.seen_event_ids = {e.get("id") for e in events if e.get("id")}
        self.events = events
        self.events_list.delete(0, "end")
        for e in events:
            raw = (e.get("created_at") or "").replace("Z", "+00:00")
            try:
                stamp = datetime.fromisoformat(raw).astimezone().strftime("%H:%M")
            except Exception:
                stamp = "--:--"
            bestaetigt = "✓" if e.get("acked") else " "
            self.events_list.insert(
                "end",
                f"{bestaetigt} {stamp}  {(e.get('title') or 'Ereignis'):<36} {e.get('message') or ''}",
            )
        if not events:
            self.events_list.insert("end", "Keine aktiven Ereignisse der Leitstelle.")
        if fresh:
            self._play_dong()
            newest = fresh[0]
            self._log(
                f"Ereignis der Leitstelle: {newest.get('title', '')} – "
                f"{newest.get('message', '')}".strip(" –")
            )

    def _ack_event(self):
        """Ausgewaehltes Ereignis bei der Leitstelle als gelesen bestaetigen."""
        sel = self.events_list.curselection()
        if not sel or not self.events:
            messagebox.showinfo("Ereignisse", "Bitte zuerst ein Ereignis in der Liste auswählen.")
            return
        index = sel[0]
        if index >= len(self.events):
            return
        event = self.events[index]
        if event.get("acked"):
            return
        key = self._value("key")
        if not key or requests is None:
            return

        def work():
            try:
                r = HTTP.post(
                    EVENTS_ENDPOINT,
                    headers={"x-telemetry-key": key},
                    json={"event_id": event.get("id")},
                    timeout=6,
                )
                if r.ok:
                    self.queue.put(("event_ack", event.get("id")))
                else:
                    self.queue.put(("events_error", f"Bestätigung: Fehler {r.status_code}"))
            except Exception as exc:
                self.queue.put(("events_error", f"Bestätigung: {exc}"))

        threading.Thread(target=work, daemon=True).start()

    def _on_event_ack(self, event_id):
        for event in self.events:
            if event.get("id") == event_id:
                event["acked"] = True
        self.seen_event_ids = {e.get("id") for e in self.events if e.get("id")}
        self._update_events(self.events)
        self._log("Ereignis bei der Leitstelle bestätigt.")

    def _update_orders(self, orders):
        self.orders = orders or []
        self.orders_status.configure(
            text=f"{len(self.orders)} Auftrag/Aufträge · Stand {time.strftime('%H:%M:%S')}"
        )
        self.orders_list.delete(0, "end")
        for o in self.orders:
            delay = int(o.get("delay_minutes") or 0)
            delay_text = f"+{delay}" if delay else "pünktl."
            belegt = (o.get("occupied_by") or "").strip()
            zeile = (
                f"{self._order_time(o)}  {(o.get('line') or '--'):<3} "
                f"{(o.get('train_number') or '-----'):<6} "
                f"{(o.get('origin') or '-')} → {(o.get('destination') or '-')}"
                f"   Gl. {o.get('platform') or '-'}  {delay_text}"
            )
            if belegt:
                zeile += f"   ⚠ belegt: {belegt}"
            self.orders_list.insert("end", zeile)
        if not self.orders:
            self.orders_list.insert("end", "Aktuell bist du für keine Fahrt eingeteilt.")
            self.order_detail.configure(text="Kein Auftrag ausgewählt.")

    def _selected_order(self):
        sel = self.orders_list.curselection()
        if not sel or not self.orders:
            return None
        index = sel[0]
        if index >= len(self.orders):
            return None
        return self.orders[index]

    def _show_order_detail(self):
        order = self._selected_order()
        if not order:
            return
        info = (order.get("info") or "").strip()
        teile = [
            f"Status: {order.get('status') or '-'} · Gleis {order.get('platform') or '-'} · "
            f"Abfahrt {self._order_time(order)}"
        ]
        if (order.get("occupied_by") or "").strip():
            teile.append(f"⚠ Zug wird gerade von {order['occupied_by']} gefahren")
        if (order.get("handover_name") or "").strip():
            teile.append(f"⇄ Übergabefahrt: Übergabe an {order['handover_name']}")
        if info:
            teile.append(info)
        self.order_detail.configure(text=" · ".join(teile))

    def _apply_order(self):
        order = self._selected_order()
        if not order:
            messagebox.showinfo("Fahrauftrag", "Bitte zuerst einen Auftrag in der Liste auswählen.")
            return
        belegt = (order.get("occupied_by") or "").strip()
        if belegt:
            messagebox.showwarning(
                "Fahrauftrag",
                f"Dieser Zug wird gerade live von {belegt} gefahren. "
                "Er wird erst wieder frei, wenn die Fahrt gemeldet ist.",
            )
            return
        mapping = {
            "zug": order.get("train_number") or "",
            "linie": order.get("line") or "",
            "ziel": order.get("destination") or "",
            "letzter_halt": order.get("origin") or "",
            "verspaetung": str(int(order.get("delay_minutes") or 0)),
        }
        for key, value in mapping.items():
            var = self.vars.get(key)
            if var is not None and value:
                var.set(value)
                entry = self.entries.get(key)
                if entry is not None:
                    entry.configure(fg=FG)
        self._save_config()
        self._log(
            f"Fahrauftrag übernommen: {mapping['linie']} {mapping['zug']} → {mapping['ziel']}"
        )

    # ---- Fahrtende-Erkennung & Meldung -----------------------------------
    def _on_trip_end(self):
        """Wird aufgerufen, wenn Train Sim World mitten in einer Fahrt verschwindet."""
        self._play_dong()
        self._log("Fahrtende erkannt – bitte im Reiter Fahraufträge melden.")
        self.trip_end_banner.pack(fill="x", padx=2, pady=(0, 6), before=self.orders_list.master)

    def _hide_trip_end_banner(self):
        try:
            self.trip_end_banner.pack_forget()
        except Exception:
            pass

    def _active_order(self):
        """Ausgewählter Auftrag, sonst der Auftrag, der zu den Fahrtdaten passt."""
        order = self._selected_order()
        if order:
            return order
        zug = self._value("zug")
        linie = self._value("linie")
        for o in self.orders:
            if (o.get("train_number") or "") == zug and (o.get("line") or "") == linie:
                if o.get("status") not in ("cancelled", "arrived"):
                    return o
        return None

    def _report_trip(self, action):
        order = self._active_order()
        if not order:
            messagebox.showinfo(
                "Fahrt melden",
                "Kein passender Auftrag gefunden – bitte zuerst einen Auftrag "
                "auswählen oder übernehmen.",
            )
            return
        if requests is None:
            return
        key = self._value("key")
        if not key:
            messagebox.showinfo("Fahrt melden", "Bitte zuerst den Telemetrie-Schlüssel eintragen.")
            return
        label = "abgeschlossen" if action == "completed" else "abgebrochen"

        def work():
            try:
                r = HTTP.post(
                    REPORT_ENDPOINT,
                    json={"trip_id": order.get("id"), "action": action},
                    headers={"x-telemetry-key": key},
                    timeout=6,
                )
                self.queue.put(("report", (r.ok, r, label)))
            except Exception as exc:
                self.queue.put(("report_error", f"Meldung fehlgeschlagen: {exc}"))

        threading.Thread(target=work, daemon=True).start()

    def _on_report_result(self, ok, response, label):
        if ok:
            try:
                data = response.json()
            except Exception:
                data = {}
            punkte = data.get("points") or 0
            self._hide_trip_end_banner()
            self._log(f"Fahrt als {label} gemeldet." + (f" +{punkte} Punkte." if punkte else ""))
            messagebox.showinfo(
                "Fahrt gemeldet",
                f"Die Fahrt wurde als {label} gemeldet."
                + (f"\nDu hast {punkte} Punkte erhalten." if punkte else ""),
            )
            self._refresh_orders()
            self._refresh_history()
        else:
            try:
                fehler = response.json().get("error", f"Fehler {response.status_code}")
            except Exception:
                fehler = f"Fehler {response.status_code}"
            self._log(f"Meldung abgelehnt: {fehler}")
            messagebox.showwarning("Fahrt melden", fehler)

    def _show_splash(self):
        """Zeigt beim Start kurz das RegioBahn-Begrüßungsbild."""
        try:
            splash = tk.Toplevel(self)
            splash.overrideredirect(True)
            splash.configure(bg=BG)
            img = tk.PhotoImage(data=SPLASH_PNG, format="PNG")
            tk.Label(splash, image=img, bg=BG, bd=0).pack()
            tk.Label(
                splash, text="Verbindung wird vorbereitet …", bg=BG, fg=MUTED,
                font=("Segoe UI", 9),
            ).pack(fill="x", pady=(0, 12))
            splash._splash_img = img  # Referenz behalten, sonst wird Bild geloescht
            splash.update_idletasks()
            sw, sh = splash.winfo_screenwidth(), splash.winfo_screenheight()
            splash.geometry(f"+{max((sw - img.width()) // 2, 0)}+{max((sh - img.height()) // 2 - 40, 0)}")
            splash.lift()
            splash.attributes("-topmost", True)

            def close():
                try:
                    splash.destroy()
                except Exception:
                    pass
                self.deiconify()

            splash.after(2600, close)
        except Exception:
            self.deiconify()

    # ---- Ingame-Karte ----------------------------------------------------
    def _build_map(self, parent):
        bar = tk.Frame(parent, bg=BG)
        bar.pack(fill="x", padx=2, pady=(12, 6))
        tk.Label(
            bar, text="Multiplayer-Karte", bg=BG, fg=FG,
            font=("Segoe UI Semibold", 13),
        ).pack(side="left")
        tk.Label(
            bar, text="· Gesamtnetz S8 / S9 / RE / RB / ICE / IC", bg=BG, fg=MUTED,
            font=("Segoe UI", 10),
        ).pack(side="left", padx=(6, 0), pady=(2, 0))
        self.map_status = tk.Label(
            bar, text="Noch nicht geladen", bg=BG, fg=MUTED, font=("Segoe UI", 9)
        )
        self.map_status.pack(side="left", padx=14)
        self._button(bar, "Aktualisieren", self._refresh_map).pack(side="right")
        self.overlay_button = self._button(
            bar, "Ingame-Overlay anzeigen", self._toggle_overlay, kind="primary"
        )
        self.overlay_button.pack(side="right", padx=(0, 8))

        legend = tk.Frame(parent, bg=BG)
        legend.pack(fill="x", padx=4, pady=(0, 4))
        for color, text in ((GREEN, "S8/S9 Süd"), (RED, "S8/S9 Nord"), ("#f59e0b", "RE/ICE Fulda"), ("#8b5cf6", "ICE/IC Kassel – Würzburg"), ("#22d3ee", "ICE/RE/RB Nürnberg – Würzburg"), (BLUE, "Dein Zug"), (GREEN, "Andere Lokführer")):
            tk.Label(legend, text="●", bg=BG, fg=color, font=("Segoe UI", 9)).pack(side="left", padx=(8, 2))
            tk.Label(legend, text=text, bg=BG, fg=MUTED, font=("Segoe UI", 8)).pack(side="left", padx=(0, 8))

        # Schnellauswahl: direkt auf eine Strecke zoomen.
        focus = tk.Frame(parent, bg=BG)
        focus.pack(fill="x", padx=4, pady=(0, 6))
        tk.Label(focus, text="Strecke:", bg=BG, fg=MUTED,
                 font=("Segoe UI", 8)).pack(side="left", padx=(6, 4))
        for text, route in (("S-Bahn Süd", ROUTE_SUED), ("S-Bahn Nord", ROUTE_NORD),
                            ("Frankfurt – Fulda", ROUTE_FULDA),
                            ("Kassel – Würzburg", ROUTE_KASSEL),
                            ("Nürnberg – Würzburg", ROUTE_NUERNBERG)):
            self._button(focus, text, lambda r=route: self._map_focus_route(r)).pack(side="left", padx=(0, 4))
        self._button(focus, "Gesamtnetz", self._map_reset).pack(side="left", padx=(6, 0))

        body = tk.Frame(parent, bg=BG)
        body.pack(fill="both", expand=True, padx=2, pady=(2, 2))

        self.map_canvas = tk.Canvas(
            body, bg=ENTRY_BG, highlightthickness=1, highlightbackground=BORDER,
        )
        self.map_canvas.pack(side="left", fill="both", expand=True)
        self.map_canvas.bind("<Configure>", lambda _e: self._draw_map())
        self._bind_map_navigation(self.map_canvas)
        zoom = tk.Frame(bar, bg=BG)
        zoom.pack(side="right", padx=(0, 8))
        self._button(zoom, "−", lambda: self._map_zoom_button(1 / 1.35)).pack(side="left")
        self._button(zoom, "+", lambda: self._map_zoom_button(1.35)).pack(side="left", padx=(4, 4))
        for label, value in (("Netz", 1.0), ("Bereich", 1.8), ("Detail", 3.2)):
            self._button(zoom, label, lambda z=value: self._map_set_zoom(z)).pack(side="left", padx=(0, 4))
        self._button(zoom, "Reset", self._map_reset).pack(side="left")

        side = tk.Frame(body, bg=CARD, width=290, highlightthickness=1,
                        highlightbackground=BORDER)
        side.pack(side="right", fill="y", padx=(8, 0))
        side.pack_propagate(False)

        head = tk.Frame(side, bg=CARD)
        head.pack(fill="x", padx=10, pady=(10, 4))
        tk.Label(
            head, text="Lokführer im Netz", bg=CARD, fg=FG,
            font=("Segoe UI Semibold", 10),
        ).pack(side="left")
        self._button(head, "Funk", self._radio_call, kind="primary").pack(side="right")
        self.follow_button = self._button(
            head, "Verfolgen", self._toggle_follow,
        )
        self.follow_button.pack(side="right", padx=(0, 6))
        self._follow_key = None
        self.follow_status = tk.Label(
            side, text="Kein Zug ausgewählt – wähle einen Zug und tippe auf „Verfolgen“.",
            bg=CARD, fg=MUTED, font=("Segoe UI", 8), anchor="w",
            justify="left", wraplength=260,
        )
        self.follow_status.pack(fill="x", padx=10, pady=(4, 0))

        self.nearby_var = tk.BooleanVar(value=True)
        tk.Checkbutton(
            side, text="Warnton bei Zug in der Nähe",
            variable=self.nearby_var, bg=CARD, fg=MUTED, selectcolor=ENTRY_BG,
            activebackground=CARD, activeforeground=FG, font=("Segoe UI", 8),
            anchor="w",
        ).pack(fill="x", padx=10)

        self.line_filter_var = tk.BooleanVar(value=False)
        tk.Checkbutton(
            side, text="Nur Züge meiner Linie zeigen",
            variable=self.line_filter_var, bg=CARD, fg=MUTED, selectcolor=ENTRY_BG,
            activebackground=CARD, activeforeground=FG, font=("Segoe UI", 8),
            anchor="w", command=lambda: self._update_map(self.trains),
        ).pack(fill="x", padx=10)

        self.ops_label = tk.Label(
            side, text="Betriebslage: noch keine Daten", bg=CARD, fg=MUTED,
            font=("Segoe UI", 8), anchor="w", justify="left", wraplength=260,
        )
        self.ops_label.pack(fill="x", padx=10, pady=(6, 0))

        self.train_list = tk.Listbox(
            side, height=9, bg=ENTRY_BG, fg=FG, selectbackground=RED,
            selectforeground="#ffffff", relief="flat", bd=0, highlightthickness=1,
            highlightbackground=BORDER, font=("Consolas", 9), activestyle="none",
        )
        self.train_list.pack(fill="x", padx=10, pady=(6, 0))
        tk.Label(
            side, text="Tipp: Zug auf der Karte anklicken – Doppelklick startet die Verfolgung.",
            bg=CARD, fg=MUTED, font=("Segoe UI", 8), anchor="w",
            justify="left", wraplength=260,
        ).pack(fill="x", padx=10, pady=(4, 0))

        info = tk.Frame(side, bg=ENTRY_BG, highlightthickness=1,
                        highlightbackground=BORDER)
        info.pack(fill="x", padx=10, pady=(8, 0))
        self.follow_label = tk.Label(
            info, text="Zugfolge: keine Daten", bg=ENTRY_BG, fg=MUTED,
            font=("Segoe UI", 9), anchor="w", justify="left", wraplength=250,
        )
        self.follow_label.pack(fill="x", padx=8, pady=(6, 2))
        self.meet_label = tk.Label(
            info, text="", bg=ENTRY_BG, fg=BLUE, font=("Segoe UI", 9),
            anchor="w", justify="left", wraplength=250,
        )
        self.meet_label.pack(fill="x", padx=8, pady=(0, 2))
        self.conflict_label = tk.Label(
            info, text="", bg=ENTRY_BG, fg=RED, font=("Segoe UI Semibold", 9),
            anchor="w", justify="left", wraplength=250,
        )
        self.conflict_label.pack(fill="x", padx=8, pady=(0, 6))

        self.radio_label = tk.Label(
            side, text="Funk: noch keine Meldung", bg=CARD, fg=MUTED,
            font=("Segoe UI", 8), anchor="w", justify="left", wraplength=260,
        )
        self.radio_label.pack(fill="x", padx=10, pady=(8, 0))

        quick = tk.Frame(side, bg=CARD)
        quick.pack(fill="x", padx=10, pady=(6, 10))
        tk.Label(
            quick, text="Schnellfunk", bg=CARD, fg=MUTED,
            font=("Segoe UI Semibold", 8), anchor="w",
        ).pack(fill="x", pady=(0, 4))
        for label, text in QUICK_RADIO:
            self._button(
                quick, label, lambda t=text: self._quick_radio(t),
            ).pack(fill="x", pady=(0, 4))

    def _tab_active(self, name):
        try:
            if self.state() == "iconic":
                return False
            return self.nb.select() == str(self._tab_widgets[name])
        except Exception:
            return True

    @staticmethod
    def _distance_km(a, b):
        lat1, lng1 = a
        lat2, lng2 = b
        dlat = math.radians(lat2 - lat1)
        dlng = math.radians(lng2 - lng1)
        h = (math.sin(dlat / 2) ** 2
             + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2))
             * math.sin(dlng / 2) ** 2)
        return 6371.0 * 2 * math.asin(min(1.0, math.sqrt(h)))

    # ---- Karten-Navigation (Zoom + Verschieben) --------------------------
    def _view(self, c):
        v = getattr(c, "_view", None)
        if v is None:
            v = {"z": 1.0, "ox": 0.0, "oy": 0.0}
            c._view = v
        return v

    def _clamp_view(self, c):
        v = self._view(c)
        w = max(c.winfo_width(), 200)
        h = max(c.winfo_height(), 160)
        # Karte darf nicht komplett aus dem Fenster rutschen
        mx = (v["z"] - 1.0) * w / 2 + 60
        my = (v["z"] - 1.0) * h / 2 + 60
        v["ox"] = max(-mx, min(mx, v["ox"]))
        v["oy"] = max(-my, min(my, v["oy"]))

    def _bind_map_navigation(self, c):
        c.bind("<MouseWheel>", lambda e: self._map_wheel(c, e))      # Windows/macOS
        c.bind("<Button-4>", lambda e: self._map_wheel(c, e))        # Linux hoch
        c.bind("<Button-5>", lambda e: self._map_wheel(c, e))        # Linux runter
        c.bind("<ButtonPress-1>", lambda e: self._map_press(c, e))
        c.bind("<B1-Motion>", lambda e: self._map_pan(c, e))
        c.bind("<ButtonRelease-1>", lambda e: self._map_release(c, e))
        c.bind("<Double-Button-1>", lambda e: self._map_double(c, e))

    def _map_press(self, c, event):
        c._pan = (event.x, event.y)
        c._press = (event.x, event.y)

    def _map_hit(self, c, event):
        """Zug unter dem Mauszeiger finden (Klick auf die Karte)."""
        beste, dist_best = None, 18.0
        for x, y, train in getattr(c, "_hits", []):
            d = math.hypot(x - event.x, y - event.y)
            if d < dist_best:
                beste, dist_best = train, d
        return beste

    def _map_release(self, c, event):
        start = getattr(c, "_press", None)
        c._press = None
        if not start or math.hypot(event.x - start[0], event.y - start[1]) > 4:
            return  # war ein Verschieben, kein Klick
        train = self._map_hit(c, event)
        if train is None:
            return
        self._select_train(train)

    def _map_double(self, c, event):
        train = self._map_hit(c, event)
        if train is None:
            return
        self._select_train(train)
        self._toggle_follow()

    def _select_train(self, train):
        """Zug in der Liste markieren und Kurzinfo anzeigen."""
        key = self._train_key(train)
        for i, t in enumerate(getattr(self, "_list_trains", [])):
            if self._train_key(t) == key:
                self.train_list.selection_clear(0, "end")
                self.train_list.selection_set(i)
                self.train_list.see(i)
                break
        name = (train.get("driver_name") or "Unbekannt").strip() or "Unbekannt"
        self._log(
            f"Zug ausgewählt: {name} ({train.get('line') or '--'} "
            f"{train.get('train_number') or ''}) → {train.get('destination') or '–'}"
        )

    def _map_wheel(self, c, event):
        v = self._view(c)
        if getattr(event, "delta", 0):
            steps = event.delta / 120.0
        else:
            steps = 1.0 if getattr(event, "num", None) == 4 else -1.0
        z2 = min(max(v["z"] * math.exp(steps * 0.18), 1.0), 6.0)
        if abs(z2 - v["z"]) < 1e-6:
            return
        # Zoom zum Mauszeiger: der Punkt unter dem Zeiger bleibt stehen
        k = z2 / v["z"]
        px = event.x - c.winfo_width() / 2
        py = event.y - c.winfo_height() / 2
        v["ox"] = px - (px - v["ox"]) * k
        v["oy"] = py - (py - v["oy"]) * k
        v["z"] = z2
        if z2 <= 1.0:
            v["ox"] = v["oy"] = 0.0
        self._clamp_view(c)
        self._draw_map()

    def _map_pan(self, c, event):
        start = getattr(c, "_pan", None)
        if not start:
            return
        # Manuelles Verschieben beendet die Verfolgung
        if getattr(self, "_follow_key", None):
            self._follow_key = None
            self._update_follow_status()
        v = self._view(c)
        v["ox"] += event.x - start[0]
        v["oy"] += event.y - start[1]
        c._pan = (event.x, event.y)
        self._clamp_view(c)
        self._draw_map()

    def _map_zoom_button(self, faktor):
        c = getattr(self, "map_canvas", None)
        if c is None or not c.winfo_exists():
            return
        v = self._view(c)
        z2 = min(max(v["z"] * faktor, 1.0), 6.0)
        k = z2 / v["z"] if v["z"] else 1.0
        v["ox"] *= k
        v["oy"] *= k
        v["z"] = z2
        if z2 <= 1.0:
            v["ox"] = v["oy"] = 0.0
        self._clamp_view(c)
        self._draw_map()

    def _map_set_zoom(self, zoom):
        """Setzt eine der drei festen, übersichtlichen Kartenansichten."""
        for c in (getattr(self, "map_canvas", None), getattr(self, "overlay_canvas", None)):
            if c is not None and c.winfo_exists():
                v = self._view(c)
                v["z"] = min(max(float(zoom), 1.0), 3.2)
                v["ox"] = v["oy"] = 0.0
                self._clamp_view(c)
        self._draw_map()

    def _map_reset(self):
        self._focus_route = None
        for c in (getattr(self, "map_canvas", None), getattr(self, "overlay_canvas", None)):

            if c is not None and c.winfo_exists():
                c._view = {"z": 1.0, "ox": 0.0, "oy": 0.0}
        self._draw_map()

    def _map_focus_route(self, route, zoom=2.2):
        # Gewaehlte Strecke merken, damit die anderen gedimmt gezeichnet werden.
        self._focus_route = None if getattr(self, "_focus_route", None) is route else route
        if self._focus_route is None:
            self._map_reset()
            return

        """Zoomt auf eine bestimmte Strecke und rueckt sie in die Mitte."""
        points = [MAP_POINTS[n] for n in route if n in MAP_POINTS]
        if not points:
            return
        mx = sum(p[0] for p in points) / len(points)
        my = sum(p[1] for p in points) / len(points)
        for c in (getattr(self, "map_canvas", None), getattr(self, "overlay_canvas", None)):
            if c is None or not c.winfo_exists():
                continue
            w = max(c.winfo_width(), 1)
            h = max(c.winfo_height(), 1)
            px = 34 + mx / MAP_WIDTH * max(w - 68, 1)
            py = 32 + my / MAP_HEIGHT * max(h - 64, 1)
            v = self._view(c)
            v["z"] = min(max(float(zoom), 1.0), 3.2)
            v["ox"] = (w / 2 - px) * v["z"]
            v["oy"] = (h / 2 - py) * v["z"]
            self._clamp_view(c)
        self._draw_map()

    def _apply_view(self, c, x, y, w, h):
        v = self._view(c)
        return ((x - w / 2) * v["z"] + w / 2 + v["ox"],
                (y - h / 2) * v["z"] + h / 2 + v["oy"])

    # ---- Zugverfolgung --------------------------------------------------
    @staticmethod
    def _train_key(train):
        name = (train.get("driver_name") or "").strip()
        num = (train.get("train_number") or "").strip()
        return f"{name}|{num}"

    def _overlay_route(self):
        """Ermittelt die aktuell befahrene Strecke fuer das kleine Ingame-Overlay."""
        trains = getattr(self, "trains", []) or []
        train = next((item for item in trains if item.get("self")), None)
        if train is None:
            train = self._followed_train()
        if train is None:
            return None

        aliases = {
            "frankfurt (main) hauptbahnhof": "Frankfurt Hbf",
            "frankfurt hauptbahnhof": "Frankfurt Hbf",
            "wuerzburg": "Würzburg Hbf",
            "würzburg": "Würzburg Hbf",
            "wuerzburg hauptbahnhof": "Würzburg Hbf",
            "würzburg hauptbahnhof": "Würzburg Hbf",
            "kassel wilhelmshoehe": "Kassel-Wilhelmshöhe",
            "kassel-wilhelmshoehe": "Kassel-Wilhelmshöhe",
        }

        def station(value):
            text = (value or "").strip()
            return aliases.get(text.lower(), text)

        origin = station(train.get("origin"))
        destination = station(train.get("destination"))
        last_stop = station(train.get("last_station"))
        next_stop = station(train.get("next_station"))
        line = (train.get("line") or "").strip().upper()
        scored = []
        for route in ALL_ROUTES:
            score = 0
            score += 3 if origin and origin in route else 0
            score += 3 if destination and destination in route else 0
            score += 6 if last_stop and last_stop in route else 0
            score += 6 if next_stop and next_stop in route else 0
            if last_stop in route and next_stop in route:
                score += 8 if abs(route.index(last_stop) - route.index(next_stop)) == 1 else 2
            if line in ("S8", "S9") and route in (ROUTE_SUED, ROUTE_NORD):
                score += 2
            elif line in ("RE", "RB") and route in (ROUTE_FULDA, ROUTE_NUERNBERG):
                score += 1
            elif line == "S1" and route is ROUTE_NUERNBERG:
                score += 5
            elif line == "IC" and route is ROUTE_KASSEL:
                score += 3
            if score:
                scored.append((score, route))
        if not scored:
            return None
        return max(scored, key=lambda item: item[0])[1]

    def _visible_trains(self):
        """Zuege nach dem Linienfilter (eigener Zug bleibt immer sichtbar)."""
        trains = getattr(self, "trains", []) or []
        var = getattr(self, "line_filter_var", None)
        if var is None or not var.get():
            return trains
        meine = (self._value("line") or "").strip().lower()
        if not meine:
            return trains
        return [
            t for t in trains
            if t.get("self") or (t.get("line") or "").strip().lower() == meine
        ]

    def _toggle_follow(self):
        sel = self.train_list.curselection()
        if getattr(self, "_follow_key", None):
            # Zweites Tippen beendet die Verfolgung
            self._follow_key = None
            self._update_follow_status()
            return
        if not sel or not getattr(self, "_list_trains", None):
            self._log("Bitte zuerst einen Zug in der Liste auswählen.")
            return
        train = self._list_trains[sel[0]]
        self._follow_key = self._train_key(train)
        self._update_follow_status()
        name = (train.get("driver_name") or "Unbekannt").strip() or "Unbekannt"
        self._log(f"Zugverfolgung aktiv: {name}")
        self._follow_center()

    def _update_follow_status(self):
        label = getattr(self, "follow_status", None)
        button = getattr(self, "follow_button", None)
        key = getattr(self, "_follow_key", None)
        if key:
            name = key.split("|", 1)[0] or "Unbekannt"
            text = f"Verfolge: {name} – Karte bleibt auf dem Zug zentriert."
            if label is not None:
                label.configure(text=text, fg=GREEN)
            if button is not None:
                button.configure(text="Verfolgen aus")
        else:
            if label is not None:
                label.configure(
                    text="Kein Zug ausgewählt – wähle einen Zug und tippe auf „Verfolgen“.",
                    fg=MUTED,
                )
            if button is not None:
                button.configure(text="Verfolgen")

    def _followed_train(self):
        key = getattr(self, "_follow_key", None)
        if not key:
            return None
        for train in getattr(self, "trains", []):
            if self._train_key(train) == key:
                return train
        return None

    def _follow_center(self):
        """Verfolgten Zug auf beiden Karten zentrieren (auch beim Zoomen)."""
        train = self._followed_train()
        if train is None:
            return
        for c in (getattr(self, "map_canvas", None), getattr(self, "overlay_canvas", None)):
            if c is None or not c.winfo_exists():
                continue
            w = max(c.winfo_width(), 200)
            h = max(c.winfo_height(), 160)
            pos = self._train_position(train, w, h)
            if not pos:
                continue
            v = self._view(c)
            # aus _apply_view: screen = (x - w/2)*z + w/2 + ox
            # Zentrieren heisst: ox = (w/2 - x) * z
            v["ox"] = (w / 2 - pos[0]) * v["z"]
            v["oy"] = (h / 2 - pos[1]) * v["z"]
            self._clamp_view(c)
        self._draw_map()


    def _project(self, lat, lng, width, height):
        closest = None
        for route in ALL_ROUTES:
            for index in range(len(route) - 1):
                a_name, b_name = route[index], route[index + 1]
                a, b = STATIONS[a_name], STATIONS[b_name]
                dy, dx = b[0] - a[0], b[1] - a[1]
                length_sq = dx * dx + dy * dy
                t = min(max(((lng - a[1]) * dx + (lat - a[0]) * dy) / length_sq, 0.0), 1.0) if length_sq else 0.0
                distance = (lng - (a[1] + dx * t)) ** 2 + (lat - (a[0] + dy * t)) ** 2
                if closest is None or distance < closest[0]:
                    ma, mb = MAP_POINTS[a_name], MAP_POINTS[b_name]
                    closest = (distance, ma[0] + (mb[0] - ma[0]) * t, ma[1] + (mb[1] - ma[1]) * t)
        map_x, map_y = (closest[1], closest[2]) if closest else (500, 260)
        pad_x, pad_y = 34, 32
        return (
            pad_x + map_x / MAP_WIDTH * max(width - 2 * pad_x, 1),
            pad_y + map_y / MAP_HEIGHT * max(height - 2 * pad_y, 1),
        )

    def _project_station(self, name, width, height):
        point = MAP_POINTS.get(name)
        if not point:
            return None
        pad_x, pad_y = 34, 32
        return (
            pad_x + point[0] / MAP_WIDTH * max(width - 2 * pad_x, 1),
            pad_y + point[1] / MAP_HEIGHT * max(height - 2 * pad_y, 1),
        )

    def _train_position(self, train, width, height):
        lat, lng = train.get("latitude"), train.get("longitude")
        if isinstance(lat, (int, float)) and isinstance(lng, (int, float)):
            return self._project(lat, lng, width, height)
        a = STATIONS.get((train.get("last_station") or "").strip())
        b = STATIONS.get((train.get("next_station") or "").strip())
        if a and b:
            try:
                p = min(max(float(train.get("progress") or 0.0), 0.0), 1.0)
            except (TypeError, ValueError):
                p = 0.0
            return self._project(a[0] + (b[0] - a[0]) * p, a[1] + (b[1] - a[1]) * p, width, height)
        node = a or b
        if node:
            return self._project(node[0], node[1], width, height)
        return None

    def _train_map_position(self, train):
        """Zugposition im festen schematischen Kartenraum fuer das Navi-Overlay."""
        point = self._train_position(train, MAP_WIDTH + 68, MAP_HEIGHT + 64)
        return (point[0] - 34, point[1] - 32) if point else None

    def _smooth_overlay_position(self, train, now, frame_seconds):
        """Laesst Live-Positionen zwischen den Netzabfragen weich weiterlaufen."""
        target = self._train_map_position(train)
        if target is None:
            return None
        key = self._train_key(train)
        state = self._overlay_motion.get(key)
        if state is None:
            state = {"x": target[0], "y": target[1], "seen": now}
            self._overlay_motion[key] = state
            return target

        # Exponentielles Nachziehen verhindert Spruenge bei neuen Messwerten,
        # bleibt aber auch bei unterschiedlichen Bildschirmraten gleich schnell.
        speed = 7.5 if train.get("self") else 5.5
        blend = 1.0 - math.exp(-max(frame_seconds, 0.001) * speed)
        state["x"] += (target[0] - state["x"]) * blend
        state["y"] += (target[1] - state["y"]) * blend
        state["seen"] = now
        return state["x"], state["y"]

    def _animate_overlay(self):
        """Zeichnet das Overlay mit hoher Bildrate, unabhaengig vom Netzwerkabruf."""
        self._overlay_animation = None
        win = getattr(self, "overlay", None)
        canvas = getattr(self, "overlay_canvas", None)
        if win is None or canvas is None or not win.winfo_exists() or not canvas.winfo_exists():
            return
        self._draw_navigation_overlay(canvas)
        self._overlay_animation = self.after(16, self._animate_overlay)

    def _draw_navigation_overlay(self, c):
        """Kompakte, fahrtrichtungsorientierte Ingame-Navigation im OMSI-Stil."""
        w = max(c.winfo_width(), 320)
        h = max(c.winfo_height(), 210)
        c.delete("all")
        c._hits = []

        # Ruhiger Asphalt-Hintergrund mit wenigen Orientierungslinien.
        c.create_rectangle(0, 0, w, h, fill="#080b0f", outline="")
        for y in range(42, h, 42):
            c.create_line(0, y, w, y, fill="#12171d", width=1)
        for x in range(42, w, 42):
            c.create_line(x, 0, x, h, fill="#10151b", width=1)

        trains = getattr(self, "trains", []) or []
        own = next((item for item in trains if item.get("self")), None)
        followed = self._followed_train()
        lead = own or followed
        route = self._overlay_route()
        if lead is None or route is None:
            c.create_text(
                w / 2, h / 2 - 8, text="Warte auf deine TSW-Fahrt …",
                fill=FG, font=("Segoe UI Semibold", 11),
            )
            c.create_text(
                w / 2, h / 2 + 14, text="Die Navigation startet mit der ersten Live-Position.",
                fill=MUTED, font=("Segoe UI", 8),
            )
            return

        now = time.monotonic()
        previous_frame = self._overlay_last_frame
        frame_seconds = min(max(now - previous_frame, 0.001), 0.25) if previous_frame else 0.05
        self._overlay_last_frame = now
        center = self._smooth_overlay_position(lead, now, frame_seconds)
        if center is None:
            return

        last_name = (lead.get("last_station") or "").strip()
        next_name = (lead.get("next_station") or "").strip()
        last_point = MAP_POINTS.get(last_name)
        next_point = MAP_POINTS.get(next_name)
        if last_point and next_point:
            target_heading = math.atan2(next_point[1] - last_point[1], next_point[0] - last_point[0])
        else:
            idx = min(range(len(route)), key=lambda i: (
                (MAP_POINTS[route[i]][0] - center[0]) ** 2 +
                (MAP_POINTS[route[i]][1] - center[1]) ** 2
            ))
            a = MAP_POINTS[route[max(0, idx - 1)]]
            b = MAP_POINTS[route[min(len(route) - 1, idx + 1)]]
            target_heading = math.atan2(b[1] - a[1], b[0] - a[0])

        # Auch beim Wechsel zum naechsten Streckenabschnitt dreht die Karte weich,
        # statt schlagartig auf den neuen Winkel zu springen.
        if self._overlay_heading is None:
            self._overlay_heading = target_heading
        angle_delta = (target_heading - self._overlay_heading + math.pi) % (2 * math.pi) - math.pi
        heading_blend = 1.0 - math.exp(-frame_seconds * 4.5)
        self._overlay_heading += angle_delta * heading_blend
        heading = self._overlay_heading

        rotation = -math.pi / 2 - heading
        cos_a, sin_a = math.cos(rotation), math.sin(rotation)
        route_distances = [
            math.hypot(MAP_POINTS[b][0] - MAP_POINTS[a][0],
                       MAP_POINTS[b][1] - MAP_POINTS[a][1])
            for a, b in zip(route, route[1:])
        ]
        typical = sorted(route_distances)[len(route_distances) // 2] if route_distances else 60
        zoom = self._view(c)["z"]
        scale = min(2.15, max(0.72, 66.0 / max(typical, 1))) * zoom
        origin_x, origin_y = w / 2, h * 0.68

        def nav_xy(mx, my):
            dx, dy = mx - center[0], my - center[1]
            return (
                origin_x + (dx * cos_a - dy * sin_a) * scale,
                origin_y + (dx * sin_a + dy * cos_a) * scale,
            )

        # Das uebrige Netz gibt nur dezenten Kontext; die befahrene Route dominiert.
        for context_route in ALL_ROUTES:
            if context_route is route:
                continue
            pts = []
            for name in context_route:
                point = MAP_POINTS.get(name)
                if point:
                    pts.extend(nav_xy(point[0], point[1]))
            if len(pts) >= 4:
                c.create_line(*pts, fill="#343a40", width=4, smooth=False,
                              capstyle="round", joinstyle="round")

        active_pts = []
        for name in route:
            point = MAP_POINTS.get(name)
            if point:
                active_pts.extend(nav_xy(point[0], point[1]))
        if len(active_pts) >= 4:
            c.create_line(*active_pts, fill="#d8dde3", width=11, smooth=False,
                          capstyle="round", joinstyle="round")
            c.create_line(*active_pts, fill="#4b1118", width=8, smooth=False,
                          capstyle="round", joinstyle="round")
            c.create_line(*active_pts, fill=RED, width=4, smooth=False,
                          capstyle="round", joinstyle="round")

        # Jede Haltestelle der erkannten Strecke bekommt einen Namen. Sichtbare
        # Kacheln werden versetzt, damit auch lange Bahnhofsnamen lesbar bleiben.
        label_boxes = []
        for index, name in enumerate(route):
            point = MAP_POINTS.get(name)
            if not point:
                continue
            x, y = nav_xy(point[0], point[1])
            if x < -190 or x > w + 190 or y < 52 or y > h + 45:
                continue
            is_next = name == next_name
            radius = 10 if is_next or name in MAP_HUBS else 8
            c.create_oval(x - radius, y - radius, x + radius, y + radius,
                          fill="#d6e84d" if is_next else "#a8bf38",
                          outline="#ffffff" if is_next else "#dbe98a",
                          width=2 if is_next else 1)
            c.create_text(x, y, text="H", fill="#18200b",
                          font=("Segoe UI Semibold", 7))
            side = -1 if index % 2 == 0 else 1
            if x < 120:
                side = 1
            elif x > w - 120:
                side = -1
            tx = x + side * (radius + 5)
            anchor = "e" if side < 0 else "w"
            label = MAP_LABELS.get(name, name).replace("\n", " ")
            label_y = y
            tid = c.create_text(tx, label_y, text=label, anchor=anchor,
                                fill="#ffffff" if is_next else "#eef1f4",
                                font=("Segoe UI Semibold", 8 if is_next else 7),
                                width=max(110, min(210, int(w * 0.44))))
            box = c.bbox(tid)
            attempts = 0
            while box and any(not (box[2] < other[0] or box[0] > other[2] or
                                   box[3] < other[1] or box[1] > other[3])
                              for other in label_boxes) and attempts < 4:
                label_y += 15 if attempts % 2 == 0 else -30
                c.coords(tid, tx, label_y)
                box = c.bbox(tid)
                attempts += 1
            if box:
                label_boxes.append(box)
                plate = c.create_rectangle(box[0] - 3, box[1] - 1, box[2] + 3,
                                           box[3] + 1, fill="#080b0f",
                                           outline="#a8bf38" if is_next else "")
                c.tag_lower(plate, tid)

        # Mitspieler bleiben auf derselben Navigationsansicht sichtbar.
        for train in trains:
            if train is lead:
                continue
            pos = self._smooth_overlay_position(train, now, frame_seconds)
            if pos is None:
                continue
            x, y = nav_xy(pos[0], pos[1])
            if not (10 <= x <= w - 10 and 32 <= y <= h - 10):
                continue
            c._hits.append((x, y, train))
            c.create_oval(x - 6, y - 6, x + 6, y + 6, fill=GREEN,
                          outline="#ffffff", width=1, tags="train")
            name = (train.get("driver_name") or "Lokführer").strip() or "Lokführer"
            c.create_text(x + 10, y, text=name, anchor="w", fill="#dce7df",
                          font=("Segoe UI", 7, "bold"), tags="train")

        # Eigener Zug sitzt fest im unteren Drittel und zeigt immer in Fahrtrichtung.
        c.create_oval(origin_x - 18, origin_y - 18, origin_x + 18, origin_y + 18,
                      fill="#07101c", outline="#4c8dff", width=2)
        c.create_polygon(
            origin_x, origin_y - 14,
            origin_x - 9, origin_y + 10,
            origin_x, origin_y + 6,
            origin_x + 9, origin_y + 10,
            fill="#ffffff", outline="#4c8dff", width=2,
        )

        try:
            speed = int(round(float(lead.get("speed_kmh") or 0)))
        except (TypeError, ValueError):
            speed = 0
        line = (lead.get("line") or "Zug").strip() or "Zug"
        destination = (lead.get("destination") or "Ziel nicht gesetzt").strip()
        next_stop = next_name or "Nächster Halt unbekannt"
        c.create_rectangle(10, 10, w - 10, 52, fill="#11161c", outline="#343c46", width=1)
        c.create_text(20, 23, anchor="w", text=f"{line}  →  {destination}", fill="#ffffff",
                      font=("Segoe UI Semibold", 9))
        c.create_text(20, 41, anchor="w", text=f"Nächster Halt  {next_stop}", fill="#a8bf38",
                      font=("Segoe UI Semibold", 8))
        c.create_rectangle(w - 76, h - 39, w - 10, h - 10, fill="#11161c",
                           outline="#343c46", width=1)
        c.create_text(w - 43, h - 25, text=str(speed), fill="#ffffff",
                      font=("Segoe UI Semibold", 13))
        c.create_text(w - 43, h - 13, text="km/h", fill=MUTED, font=("Segoe UI", 6))

    # ---- Ingame-Overlay --------------------------------------------------
    def _pin_overlay_above_game(self, win):
        """Haelt das Overlay unter Windows ohne Fokuswechsel ueber Vollbild-Fenstern."""
        try:
            win.attributes("-topmost", True)
            win.lift()
            if os.name != "nt":
                return

            import ctypes

            user32 = ctypes.windll.user32
            hwnd = win.winfo_id()
            get_style = user32.GetWindowLongW
            set_style = user32.SetWindowLongW
            get_style.argtypes = [ctypes.c_void_p, ctypes.c_int]
            get_style.restype = ctypes.c_long
            set_style.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_long]
            set_style.restype = ctypes.c_long

            # Werkzeugfenster + keine Aktivierung: TSW bleibt im Vordergrund und
            # minimiert sich beim Anzeigen der Karte nicht.
            GWL_EXSTYLE = -20
            WS_EX_TOOLWINDOW = 0x00000080
            WS_EX_NOACTIVATE = 0x08000000
            style = get_style(hwnd, GWL_EXSTYLE)
            set_style(hwnd, GWL_EXSTYLE, style | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE)

            set_pos = user32.SetWindowPos
            set_pos.argtypes = [
                ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int, ctypes.c_int,
                ctypes.c_int, ctypes.c_int, ctypes.c_uint,
            ]
            set_pos.restype = ctypes.c_bool
            HWND_TOPMOST = ctypes.c_void_p(-1)
            SWP_NOSIZE = 0x0001
            SWP_NOMOVE = 0x0002
            SWP_NOACTIVATE = 0x0010
            SWP_SHOWWINDOW = 0x0040
            set_pos(
                ctypes.c_void_p(hwnd), HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_SHOWWINDOW,
            )
        except Exception:
            pass

    def _keep_overlay_above_game(self):
        self._overlay_keepalive = None
        win = getattr(self, "overlay", None)
        if win is None or not win.winfo_exists():
            return
        self._pin_overlay_above_game(win)
        self._overlay_keepalive = self.after(750, self._keep_overlay_above_game)

    def _toggle_overlay(self):
        win = getattr(self, "overlay", None)
        if win is not None and win.winfo_exists():
            self._close_overlay()
            return
        self._open_overlay()

    def _open_overlay(self):
        win = tk.Toplevel(self)
        win.title("RegioBahn – Ingame-Karte")
        win.configure(bg=BG)
        win.geometry("430x390+40+40")
        win.minsize(340, 280)
        try:
            win.overrideredirect(True)
            win.attributes("-topmost", True)
            win.attributes("-alpha", 0.94)
        except Exception:
            pass

        head = tk.Frame(win, bg=CARD, cursor="fleur")
        head.pack(fill="x")
        tk.Label(
            head, text="RegioBahn Navigation", bg=CARD, fg=FG, font=("Segoe UI Semibold", 10)
        ).pack(side="left", padx=(10, 0), pady=6)
        self.overlay_status = tk.Label(
            head, text="lädt …", bg=CARD, fg=MUTED, font=("Segoe UI", 8)
        )
        self.overlay_status.pack(side="left", padx=10)
        tk.Label(
            head, text="Randlos-Vollbild", bg=CARD, fg=GREEN,
            font=("Segoe UI Semibold", 8),
        ).pack(side="right", padx=(4, 2))
        tk.Button(
            head, text="✕", command=self._close_overlay, bg=CARD, fg=MUTED,
            activebackground=CARD, activeforeground=RED, relief="flat", bd=0,
            highlightthickness=0, cursor="hand2", font=("Segoe UI", 10),
        ).pack(side="right", padx=8)

        def start_drag(event):
            win._dx, win._dy = event.x_root - win.winfo_x(), event.y_root - win.winfo_y()

        def do_drag(event):
            win.geometry(f"+{event.x_root - win._dx}+{event.y_root - win._dy}")

        for widget in (head, *head.winfo_children()):
            if isinstance(widget, tk.Button):
                continue
            widget.bind("<Button-1>", start_drag)
            widget.bind("<B1-Motion>", do_drag)

        self.overlay_canvas = tk.Canvas(win, bg=BG, highlightthickness=0)
        self.overlay_canvas.pack(fill="both", expand=True)
        self.overlay_canvas.bind("<Configure>", lambda _e: self._draw_map())
        self._bind_map_navigation(self.overlay_canvas)
        tk.Label(
            head, text="Fahrtrichtung oben · Mausrad: Zoom", bg=CARD, fg=MUTED,
            font=("Segoe UI", 7),
        ).pack(side="left", padx=8)

        grip = tk.Frame(win, bg=CARD, height=10, cursor="bottom_right_corner")
        grip.pack(fill="x", side="bottom")

        def start_size(event):
            win._sw, win._sh = win.winfo_width(), win.winfo_height()
            win._sx, win._sy = event.x_root, event.y_root

        def do_size(event):
            w = max(320, win._sw + event.x_root - win._sx)
            h = max(240, win._sh + event.y_root - win._sy)
            win.geometry(f"{int(w)}x{int(h)}")

        grip.bind("<Button-1>", start_size)
        grip.bind("<B1-Motion>", do_size)

        self.overlay = win
        win.protocol("WM_DELETE_WINDOW", self._close_overlay)
        win.update_idletasks()
        self._pin_overlay_above_game(win)
        win.bind("<Map>", lambda _event: self._pin_overlay_above_game(win))
        win.bind("<Visibility>", lambda _event: self._pin_overlay_above_game(win))
        self._keep_overlay_above_game()
        self._overlay_last_frame = None
        self._overlay_motion = {}
        self._overlay_heading = None
        self._animate_overlay()
        if hasattr(self, "overlay_button"):
            self.overlay_button.configure(text="Overlay ausblenden")
        self._draw_map()
        self._refresh_map()

    def _close_overlay(self):
        win = getattr(self, "overlay", None)
        self.overlay = None
        self.overlay_canvas = None
        keepalive = getattr(self, "_overlay_keepalive", None)
        self._overlay_keepalive = None
        animation = getattr(self, "_overlay_animation", None)
        self._overlay_animation = None
        if keepalive is not None:
            try:
                self.after_cancel(keepalive)
            except Exception:
                pass
        if animation is not None:
            try:
                self.after_cancel(animation)
            except Exception:
                pass
        self._overlay_last_frame = None
        self._overlay_motion = {}
        self._overlay_heading = None
        if win is not None:
            try:
                win.destroy()
            except Exception:
                pass
        if hasattr(self, "overlay_button"):
            self.overlay_button.configure(text="Ingame-Overlay anzeigen")

    def _draw_map(self):
        for canvas in (getattr(self, "map_canvas", None), getattr(self, "overlay_canvas", None)):
            if canvas is not None and canvas.winfo_exists():
                self._draw_map_on(canvas)

    def _draw_map_on(self, c):
        if c is getattr(self, "overlay_canvas", None):
            self._draw_navigation_overlay(c)
            return
        w = max(c.winfo_width(), 200)
        h = max(c.winfo_height(), 160)

        v = self._view(c)

        # Punkt-Gitter (Hintergrund) haengt nur an der Fenstergroesse
        if getattr(c, "_grid_size", None) != (w, h):
            c.delete("grid")
            step = 34
            for gx in range(step // 2, w, step):
                for gy in range(step // 2, h, step):
                    c.create_oval(gx, gy, gx + 1, gy + 1, fill="#16223a",
                                  outline="", tags="grid")
            # Nordpfeil oben rechts
            c.create_line(w - 24, 34, w - 24, 16, fill=MUTED, width=2,
                          arrow="last", tags="grid")
            c.create_text(w - 24, 44, text="N", fill=MUTED,
                          font=("Segoe UI", 8, "bold"), tags="grid")
            c.tag_lower("grid")
            c._grid_size = (w, h)

        mode = "network" if v["z"] < 1.45 else "area" if v["z"] < 2.6 else "detail"

        # Grundnetz (Strecken + Bahnhoefe) wird bei Groesse ODER Zoom neu
        # gezeichnet; dazwischen bleibt es stehen - spart Rechenzeit.
        focus = getattr(self, "_focus_route", None)
        # Das kompakte Ingame-Overlay zeigt alle Haltestellennamen der eigenen
        # Strecke. So bleiben die Namen sichtbar, ohne das gesamte Netz mit
        # gleichzeitig rund 50 Beschriftungen zu ueberladen.
        if c is getattr(self, "overlay_canvas", None) and focus is None:
            focus = self._overlay_route()
        base_key = (w, h, mode, round(v["z"], 3), round(v["ox"], 1), round(v["oy"], 1),
                    id(focus) if focus else 0)
        if getattr(c, "_base_key", None) != base_key:
            c.delete("base")

            # Jede Strecke ist auch im Gesamtnetz sofort unterscheidbar.
            focus_names = set(focus) if focus else None
            for route, color in ((ROUTE_SUED, GREEN), (ROUTE_NORD, RED), (ROUTE_FULDA, "#f59e0b"), (ROUTE_KASSEL, "#8b5cf6"), (ROUTE_NUERNBERG, "#22d3ee")):
                pts = []
                for name in route:
                    point = self._project_station(name, w, h)
                    if point:
                        px, py = point
                        pts.extend(self._apply_view(c, px, py, w, h))
                if len(pts) >= 4:
                    gedimmt = focus is not None and route is not focus
                    # Kein smooth=True: Die Kurve wuerde sonst Ecken wie Fulda
                    # (Knoten Frankfurt-Fulda / Kassel-Wuerzburg) abschneiden und
                    # der Halt laege nicht mehr auf der Linie.
                    if gedimmt:
                        c.create_line(*pts, fill=color, width=3, smooth=False,
                                      stipple="gray25", capstyle="round",
                                      joinstyle="round", tags="base")
                        continue
                    # Dunkle Fassung unter der Farblinie: Kreuzungen bleiben lesbar.
                    c.create_line(*pts, fill=color, width=9, smooth=False,
                                  stipple="gray25", capstyle="round", joinstyle="round", tags="base")
                    c.create_line(*pts, fill="#0b1220", width=7, smooth=False,
                                  capstyle="round", joinstyle="round", tags="base")
                    c.create_line(*pts, fill=color, width=4, smooth=False,
                                  capstyle="round", joinstyle="round", tags="base")

            # In der Netzansicht ersetzen kompakte Regionen die vielen Einzelbeschriftungen.
            if mode == "network" and focus is None:
                for label, mx, my, count in MAP_REGIONS:
                    px = 34 + mx / MAP_WIDTH * max(w - 68, 1)
                    py = 32 + my / MAP_HEIGHT * max(h - 64, 1)
                    x, y = self._apply_view(c, px, py, w, h)
                    c.create_rectangle(x - 56, y - 15, x + 56, y + 15, fill="#101c31",
                                       outline=BORDER, width=1, tags="base")
                    c.create_text(x, y - 3, text=label, fill=FG,
                                  font=("Segoe UI", 8, "bold"), tags="base")
                    c.create_text(x, y + 9, text=f"{count} Stationen", fill=MUTED,
                                  font=("Segoe UI", 6), tags="base")

            # Je näher die Ansicht, desto mehr einzelne Stationen werden eingeblendet.
            station_names = list(STATIONS)
            for index, name in enumerate(station_names):
                if focus_names is not None and name not in focus_names:
                    continue
                if focus_names is None:
                    if mode == "network" and name not in MAP_HUBS:
                        continue
                    if mode == "area" and name not in MAP_HUBS and index % 2:
                        continue
                point = self._project_station(name, w, h)
                if not point:
                    continue
                px, py = point
                x, y = self._apply_view(c, px, py, w, h)
                big = name in MAP_HUBS
                if big:
                    # Knotenbahnhoefe als abgerundete Kachel statt Punkt
                    c.create_rectangle(x - 6, y - 6, x + 6, y + 6, fill="#e8ecf4",
                                       outline="#0b1220", width=2, tags="base")
                else:
                    c.create_oval(x - 4, y - 4, x + 4, y + 4,
                                  fill="#e8ecf4", outline="#0b1220",
                                  width=2, tags="base")
                side, anchor = MAP_POINTS[name][2], MAP_POINTS[name][3]
                dx = -9 if anchor == "e" else 9 if anchor == "w" else 0
                dy = -13 if side == "above" else 15
                text = MAP_LABELS.get(name, name)
                font = ("Segoe UI", 8, "bold") if big else ("Segoe UI", 7, "bold")
                item = c.create_text(x + dx, y + dy, text=text, anchor=anchor,
                                     fill=FG, font=font, tags="base")
                # Dunkle Kachel hinter der Beschriftung haelt sie ueberall lesbar.
                bx1, by1, bx2, by2 = c.bbox(item)
                plate = c.create_rectangle(bx1 - 3, by1 - 1, bx2 + 3, by2 + 1,
                                           fill="#0b1220", outline="", tags="base")
                c.tag_lower(plate, item)
            c.tag_raise("base", "grid")
            c.create_text(12, h - 12, anchor="sw", text={"network": "NETZ", "area": "BEREICH", "detail": "DETAIL"}[mode],
                          fill=MUTED, font=("Segoe UI", 7, "bold"), tags="base")
            c._base_key = base_key



        c.delete("train")
        c._hits = []
        sichtbar = self._visible_trains() if mode != "network" else []
        for train in sichtbar:
            pos = self._train_position(train, w, h)
            if not pos:
                continue
            x, y = self._apply_view(c, pos[0], pos[1], w, h)
            c._hits.append((x, y, train))
            own = bool(train.get("self"))
            color = BLUE if own else GREEN

            # Verfolgter Zug bekommt einen doppelten Zielring
            if getattr(self, "_follow_key", None) and \
                    self._train_key(train) == self._follow_key:
                c.create_oval(x - 18, y - 18, x + 18, y + 18, outline="#ffd166",
                              width=2, tags="train")
                c.create_oval(x - 22, y - 22, x + 22, y + 22, outline="#ffd166",
                              width=1, dash=(3, 3), tags="train")

            # Weicher "Glow" um den Zugpunkt
            c.create_oval(x - 12, y - 12, x + 12, y + 12, outline=color,
                          width=1, stipple="gray50", tags="train")
            # In der Detailansicht zeigt ein klarer Pfeil die Bewegung vom letzten
            # zum nächsten Halt. Stehende Züge bleiben neutrale Kreise.
            last_name = (train.get("last_station") or "").strip()
            next_name = (train.get("next_station") or "").strip()
            last_point = self._project_station(last_name, w, h)
            next_point = self._project_station(next_name, w, h)
            try:
                moving = float(train.get("speed_kmh") or 0) >= 1.0
            except (TypeError, ValueError):
                moving = False
            if mode == "detail" and moving and last_point and next_point:
                lx, ly = self._apply_view(c, last_point[0], last_point[1], w, h)
                nx, ny = self._apply_view(c, next_point[0], next_point[1], w, h)
                dx, dy = nx - lx, ny - ly
                ln = math.hypot(dx, dy)
                if ln > 1:
                    ux, uy = dx / ln, dy / ln
                    px, py = -uy, ux
                    tip = (x + ux * 19, y + uy * 19)
                    left = (x + ux * 8 + px * 6, y + uy * 8 + py * 6)
                    right = (x + ux * 8 - px * 6, y + uy * 8 - py * 6)
                    c.create_polygon(*tip, *left, *right, fill=color,
                                     outline="#ffffff", width=1, tags="train")
            radius = 8 if mode == "detail" else 6
            c.create_oval(x - radius, y - radius, x + radius, y + radius, fill=color,
                          outline="#ffffff", width=2, tags="train")

            # Beschriftung als dunkle Kachel, damit sie immer lesbar ist
            label = (train.get("driver_name") or "Unbekannt").strip() or "Unbekannt"
            line = (train.get("line") or "").strip()
            text = f"{line} · {label}" if line else label
            if mode == "detail":
                try:
                    speed = int(round(float(train.get("speed_kmh") or 0)))
                except (TypeError, ValueError):
                    speed = 0
                text += f" · {speed} km/h"
            tx, ty = x, y + 24
            tid = c.create_text(tx, ty, text=text, fill=FG,
                                font=("Segoe UI", 8, "bold"), tags="train")
            box = c.bbox(tid)
            if box:
                rid = c.create_rectangle(box[0] - 5, box[1] - 2, box[2] + 5,
                                         box[3] + 2, fill="#0a1220",
                                         outline=color, width=1, tags="train")
                c.tag_lower(rid, tid)

        if mode == "network" and self._visible_trains():
            c.create_text(w / 2, h - 22, text="Für einzelne Live-Züge auf Bereich oder Detail zoomen",
                          fill=MUTED, font=("Segoe UI", 9), tags="train")
        elif not sichtbar:
            hinweis = (
                "Kein Zug auf deiner Linie unterwegs."
                if self.trains else "Gerade ist kein Lokführer unterwegs."
            )
            c.create_text(
                w / 2, h / 2, text=hinweis,
                fill=MUTED, font=("Segoe UI", 11), tags="train",
            )

    def _refresh_map(self):
        if requests is None:
            return
        if getattr(self, "_map_fetching", False):
            return
        key = self._value("key")
        if not key:
            self.map_status.configure(text="Bitte zuerst den Telemetrie-Schlüssel eintragen.")
            return

        self._map_fetching = True

        def work():
            try:
                r = HTTP.get(ENDPOINT, headers={"x-telemetry-key": key}, timeout=6)
                if r.ok:
                    self.queue.put(("map", r.json().get("trains", [])))
                else:
                    self.queue.put(("map_error", f"Karte: Fehler {r.status_code}"))
            except Exception as exc:
                self.queue.put(("map_error", f"Karte: {exc}"))
            finally:
                self._map_fetching = False

        threading.Thread(target=work, daemon=True).start()

    def _map_tick(self):
        overlay = getattr(self, "overlay", None)
        live = overlay is not None and overlay.winfo_exists()
        if live or self._tab_active("map"):
            self._refresh_map()
        # Im sichtbaren Overlay kommen neue Positionen deutlich haeufiger an;
        # die 60-FPS-Zeichnung gleicht die Schritte dazwischen weich aus.
        self.after(1000 if live else 9000, self._map_tick)

    def _update_map(self, trains):
        self.trains = trains or []
        sichtbar = self._visible_trains()
        status = f"{len(self.trains)} Zug/Züge live · Stand {time.strftime('%H:%M:%S')}"
        if len(sichtbar) != len(self.trains):
            status += f" · {len(sichtbar)} gefiltert"
        self.map_status.configure(text=status)
        overlay_status = getattr(self, "overlay_status", None)
        if overlay_status is not None and overlay_status.winfo_exists():
            overlay_status.configure(text=status)
        self._draw_map()
        self._update_ops_summary()

        own = next((t for t in self.trains if t.get("self")), None)
        own_pos = None
        if own and isinstance(own.get("latitude"), (int, float)):
            own_pos = (own["latitude"], own["longitude"])

        rows = []
        for t in sichtbar:
            dist = None
            if own_pos and not t.get("self") and isinstance(t.get("latitude"), (int, float)):
                dist = self._distance_km(own_pos, (t["latitude"], t["longitude"]))
            rows.append((dist if dist is not None else 9999.0, dist, t))
        rows.sort(key=lambda r: (not r[2].get("self"), r[0]))

        self.train_list.delete(0, "end")
        self._list_trains = []
        near_now = set()
        for _sort, dist, t in rows:
            name = (t.get("driver_name") or "Unbekannt").strip() or "Unbekannt"
            try:
                speed = int(round(float(t.get("speed_kmh") or 0)))
            except (TypeError, ValueError):
                speed = 0
            marker = "▶" if t.get("self") else " "
            entfernung = f"{dist:>5.1f} km" if dist is not None else "    —   "
            self.train_list.insert(
                "end",
                f"{marker} {(t.get('line') or '--'):>3}  {(t.get('train_number') or '-----'):<6} "
                f"{name:<18} {speed:>3} km/h  {entfernung}  → {t.get('destination') or '-'}"
                f"  (+{t.get('delay_minutes') or 0} min)",
            )
            self._list_trains.append(t)
            if dist is not None and dist <= 2.0:
                near_now.add(name)

        if not self._list_trains:
            self.train_list.insert(
                "end",
                "Kein Zug auf deiner Linie." if self.trains else "Keine aktiven Züge.",
            )
            self._list_trains = []

        # Zugverfolgung: Auswahl in der Liste halten und Karte zentrieren.
        # Auch beim Herauszoomen bleibt der Zug durch die Zentrierung sichtbar.
        if getattr(self, "_follow_key", None):
            idx = None
            for i, t in enumerate(self._list_trains):
                if self._train_key(t) == self._follow_key:
                    idx = i
                    break
            if idx is None:
                name = self._follow_key.split("|", 1)[0] or "Zug"
                self._follow_key = None
                self._update_follow_status()
                self._log(f"Zugverfolgung beendet: {name} ist nicht mehr live.")
            else:
                self.train_list.selection_clear(0, "end")
                self.train_list.selection_set(idx)
                self.train_list.see(idx)
                self._follow_center()

        # Naehe-Warnung: nur beim ersten Auftauchen eines Zuges in der Naehe.
        frisch = near_now - getattr(self, "_near_last", set())
        self._near_last = near_now
        if frisch and getattr(self, "nearby_var", None) and self.nearby_var.get():
            self._play_dong()
            self._log("Zug in der Nähe: " + ", ".join(sorted(frisch)))

        self._update_follow(own, rows)

    def _update_ops_summary(self):
        """Kurze Betriebslage: Zuege, Durchschnittsverspaetung, Puenktlichkeit."""
        label = getattr(self, "ops_label", None)
        if label is None:
            return
        trains = getattr(self, "trains", []) or []
        if not trains:
            label.configure(text="Betriebslage: niemand im Dienst.", fg=MUTED)
            return
        delays = []
        for t in trains:
            try:
                delays.append(int(t.get("delay_minutes") or 0))
            except (TypeError, ValueError):
                delays.append(0)
        schnitt = sum(delays) / len(delays)
        puenktlich = sum(1 for d in delays if d <= 1)
        quote = round(100 * puenktlich / len(delays))
        auslastung = "ruhig" if len(trains) < 3 else ("normal" if len(trains) <= 6 else "dicht")
        label.configure(
            text=(
                f"Betriebslage: {auslastung} · {len(trains)} Lokführer im Dienst "
                f"· Ø {schnitt:.1f} min Verspätung · {quote} % pünktlich"
            ),
            fg=GREEN if quote >= 80 else (RED if quote < 50 else MUTED),
        )

    def _update_follow(self, own, rows):
        """Zugfolge (naechster Zug mit Tendenz) und Gleiskonflikte anzeigen."""
        prev = getattr(self, "_dist_last", {})
        jetzt_ts = time.time()
        prev_ts = getattr(self, "_dist_ts", jetzt_ts)
        self._dist_ts = jetzt_ts
        dt = max(1.0, jetzt_ts - prev_ts)
        now = {}
        naechster = None
        for _sort, dist, t in rows:
            if t.get("self") or dist is None:
                continue
            name = (t.get("driver_name") or "Unbekannt").strip() or "Unbekannt"
            now[name] = dist
            if naechster is None:
                naechster = (name, dist, t)
        self._dist_last = now

        # Begegnungs-/Aufholprognose fuer den naechsten Zug
        meet = getattr(self, "meet_label", None)
        if meet is not None:
            text = ""
            if naechster is not None:
                name, dist, t = naechster
                vorher = prev.get(name)
                if vorher is not None and vorher - dist > 0.02:
                    rate = (vorher - dist) / dt * 3600.0  # km/h Annaeherung
                    if rate > 1:
                        minuten = dist / rate * 60.0
                        if minuten < 45:
                            text = (
                                f"↔ Begegnung mit {name} in ca. {minuten:.0f} min "
                                f"({rate:.0f} km/h Annäherung)"
                            )
            meet.configure(text=text)

        if naechster is None:
            self.follow_label.configure(text="Zugfolge: kein anderer Zug in Sicht.")
        else:
            name, dist, t = naechster
            vorher = prev.get(name)
            if vorher is None or abs(vorher - dist) < 0.05:
                tendenz = "Abstand gleichbleibend"
            elif dist < vorher:
                tendenz = "nähert sich"
            else:
                tendenz = "entfernt sich"
            try:
                speed = int(round(float(t.get("speed_kmh") or 0)))
            except (TypeError, ValueError):
                speed = 0
            self.follow_label.configure(
                text=(
                    f"Zugfolge: {name} ({t.get('line') or '--'} {t.get('train_number') or ''}) "
                    f"– {dist:.1f} km, {speed} km/h, {tendenz} · nächster Halt "
                    f"{t.get('next_station') or '–'}"
                )
            )

        # Gleiskonflikt: andere Zuege mit dem gleichen naechsten Halt
        ziel = ((own or {}).get("next_station") or "").strip()
        andere = [
            (t.get("driver_name") or "Unbekannt").strip()
            for _s, _d, t in rows
            if not t.get("self")
            and ziel
            and (t.get("next_station") or "").strip().lower() == ziel.lower()
        ]

        # Zugfolge-Warnung: Zug derselben Linie dicht vor/hinter dir
        folge_text = ""
        if own:
            eigene_linie = ((own.get("line") or "").strip()).lower()
            eigener_fortschritt = own.get("progress")
            try:
                eigener_fortschritt = float(eigener_fortschritt)
            except (TypeError, ValueError):
                eigener_fortschritt = None
            for _s, dist, t in rows:
                if t.get("self") or dist is None or dist > 1.5:
                    continue
                if ((t.get("line") or "").strip()).lower() != eigene_linie or not eigene_linie:
                    continue
                name = (t.get("driver_name") or "Unbekannt").strip() or "Unbekannt"
                richtung = "in deinem Abschnitt"
                anderer_fortschritt = t.get("progress")
                try:
                    anderer_fortschritt = float(anderer_fortschritt)
                except (TypeError, ValueError):
                    anderer_fortschritt = None
                if eigener_fortschritt is not None and anderer_fortschritt is not None:
                    richtung = (
                        "vor dir" if anderer_fortschritt > eigener_fortschritt else "hinter dir"
                    )
                folge_text = f"⚠ Zugfolge: {name} nur {dist:.1f} km {richtung} – Abstand halten"
                break

        teile = []
        if andere:
            teile.append(f"⚠ Gleiskonflikt in {ziel}: auch {', '.join(sorted(set(andere)))}")
        if folge_text:
            teile.append(folge_text)
        text = "  ·  ".join(teile)
        self.conflict_label.configure(text=text)
        if text and text != getattr(self, "_conflict_last", ""):
            self._log(text)
            if getattr(self, "nearby_var", None) and self.nearby_var.get():
                self._play_dong()
        self._conflict_last = text

    def _quick_radio(self, text):
        """Vorgefertigten Funkspruch an alle senden."""
        zug = (self._value("zug") or "").strip()
        linie = (self._value("linie") or "").strip()
        kennung = " ".join(x for x in (linie, zug) if x)
        self._send_radio(f"[{kennung}] {text}" if kennung else text)

    def _radio_call(self):
        """Kurzen Funkspruch an einen anderen Lokführer schicken (läuft über den Chat)."""
        trains = getattr(self, "_list_trains", [])
        sel = self.train_list.curselection()
        ziel = None
        if sel and sel[0] < len(trains):
            t = trains[sel[0]]
            if not t.get("self"):
                ziel = (t.get("driver_name") or "").strip()
        text = simpledialog.askstring(
            "Funkspruch",
            f"Nachricht an {ziel}:" if ziel else "Nachricht an alle:",
            parent=self,
        )
        if not text or not text.strip():
            return
        self._send_radio(f"@{ziel} {text.strip()}" if ziel else text.strip())

    def _send_radio(self, body):
        body = (body or "").strip()[:500]
        if not body:
            return
        key = self._value("key")
        if HTTP is None or not key:
            self.map_status.configure(text="Funkspruch nicht möglich – Schlüssel fehlt.")
            return

        def work():
            try:
                r = HTTP.post(
                    CHAT_ENDPOINT, headers={"x-telemetry-key": key},
                    json={"body": body}, timeout=6,
                )
                self.queue.put((
                    "log",
                    "Funkspruch gesendet." if r.ok else f"Funkspruch fehlgeschlagen ({r.status_code}).",
                ))
            except Exception as exc:  # noqa: BLE001
                self.queue.put(("log", f"Funkspruch fehlgeschlagen: {exc}"))

        threading.Thread(target=work, daemon=True).start()

    def _tick_clock(self):
        self.clock_label.configure(text=time.strftime("%H:%M:%S"))
        self.after(1000, self._tick_clock)

    def _weather_tick(self):
        if requests is None:
            self.weather_label.configure(text="Wetter: 'requests' fehlt")
            return
        def work():
            try:
                r = HTTP.get(WEATHER_URL, timeout=8)
                r.raise_for_status()
                self.queue.put(("weather", r.json()))
            except Exception as exc:  # noqa: BLE001
                self.queue.put(("weather_error", f"Wetter: {exc}"))
        threading.Thread(target=work, daemon=True).start()
        self.after(600000, self._weather_tick)

    def _update_weather(self, data):
        cur = data.get("current", {})
        temp = cur.get("temperature_2m")
        code = cur.get("weather_code", 0)
        wind = cur.get("wind_speed_10m")
        text = WMO_TEXT.get(code, "Wechselhaft")
        parts = [f"Frankfurt: {temp:.0f} °C, {text}" if temp is not None else text]
        if wind is not None:
            parts.append(f"Wind {wind:.0f} km/h")
        hourly = data.get("hourly", {})
        temps = hourly.get("temperature_2m", [])
        times = hourly.get("time", [])
        rain = hourly.get("precipitation_probability", [])
        now_hour = datetime.now().hour
        forecast = []
        for t, tp, p in zip(times, temps, rain):
            hour = int(t[11:13])
            if hour > now_hour and len(forecast) < 3:
                forecast.append(f"{hour:02d} Uhr {tp:.0f} °C ({p:.0f} %)")
        if forecast:
            parts.append("später: " + " · ".join(forecast))
        self.weather_label.configure(text="  |  ".join(parts), fg=FG)

    def _placeholder(self, entry, var, text):
        if entry.cget("show"):
            return

        def focus_in(_):
            if var.get() == text:
                var.set("")
                entry.configure(fg=FG)

        def focus_out(_):
            if not var.get():
                var.set(text)
                entry.configure(fg="#5c6b8a")

        entry.bind("<FocusIn>", focus_in)
        entry.bind("<FocusOut>", focus_out)
        var.set(text)
        entry.configure(fg="#5c6b8a")
        entry._placeholder = text  # type: ignore[attr-defined]

    def _station_menu(self, button, var, entry):
        """Haltestellen-Auswahl, damit die Namen exakt zum Overlay passen."""
        menu = tk.Menu(self, tearoff=0, bg=CARD, fg=FG, activebackground=RED, activeforeground=FG)
        groups = (
            ("S-Bahn Süd", ROUTE_SUED), ("S-Bahn Nord", ROUTE_NORD),
            ("Frankfurt – Fulda", ROUTE_FULDA), ("Kassel – Würzburg", ROUTE_KASSEL),
            ("Nürnberg – Würzburg", ROUTE_NUERNBERG),
        )
        for title, route in groups:
            sub = tk.Menu(menu, tearoff=0, bg=CARD, fg=FG, activebackground=RED, activeforeground=FG)
            for name in route:
                if name == "Frankfurt Hbf Tief":
                    continue
                sub.add_command(label=name, command=lambda n=name: (var.set(n), entry.configure(fg=FG)))
            menu.add_cascade(label=title, menu=sub)
        try:
            menu.tk_popup(button.winfo_rootx(), button.winfo_rooty() + button.winfo_height())
        finally:
            menu.grab_release()

    def _value(self, key):
        placeholder = dict((k, p) for k, _l, p in FIELDS).get(key, "")
        value = self.vars[key].get().strip()
        return "" if value == placeholder else value

    # ---- Konfiguration ---------------------------------------------------
    def _load_config(self):
        try:
            with open(CONFIG_FILE, "r", encoding="utf-8") as fh:
                cfg = json.load(fh)
        except Exception:
            return
        for key, var in self.vars.items():
            if cfg.get(key):
                var.set(str(cfg[key]))
        self.demo_var.set(bool(cfg.get("demo")))
        self._log("Gespeicherte Einstellungen geladen.")

    def _save_config(self):
        cfg = {key: self._value(key) for key in self.vars}
        cfg["demo"] = self.demo_var.get()
        try:
            os.makedirs(CONFIG_DIR, exist_ok=True)
            with open(CONFIG_FILE, "w", encoding="utf-8") as fh:
                json.dump(cfg, fh, ensure_ascii=False, indent=2)
            self._log("Einstellungen gespeichert.")
        except Exception as exc:
            messagebox.showerror("Speichern fehlgeschlagen", str(exc))

    # ---- Steuerung -------------------------------------------------------
    def _start(self):
        if requests is None:
            messagebox.showerror(
                "Paket fehlt", "Bitte zuerst ausführen: py -m pip install requests"
            )
            return
        key = self._value("key")
        if not key:
            messagebox.showwarning(
                "Schlüssel fehlt",
                "Bitte trage deinen Telemetrie-Schlüssel ein.\n"
                "Du findest ihn auf regiobahn.eu unter „Telemetrie“.",
            )
            return

        cfg = {k: self._value(k) for k in self.vars}
        cfg["key"] = key
        cfg["demo"] = self.demo_var.get()
        cfg["endpoint"] = ENDPOINT
        for num_key, fallback in (("intervall", 2.0), ("abschnitt", 180.0), ("verspaetung", 0)):
            try:
                cfg[num_key] = float(cfg.get(num_key) or fallback)
            except ValueError:
                cfg[num_key] = fallback

        self._save_config()
        self._stats = {"max": 0.0, "km": 0.0, "start": time.time(), "last": None}
        self.sender = Sender(cfg, self.queue)
        self.sender.start()
        self.start_btn.configure(state="disabled")
        self.stop_btn.configure(state="normal")
        self.state_label.configure(text="●  Verbunden", fg=GREEN)
        self._log("Verbindung gestartet.")

    def _stop(self):
        if self.sender:
            self.sender.stop_event.set()
        self.stop_btn.configure(state="disabled")

    def _on_close(self):
        self._stop()
        self.destroy()

    # ---- Aktualisierung --------------------------------------------------
    def _poll(self):
        try:
            while True:
                kind, payload = self.queue.get_nowait()
                if kind == "log":
                    self._log(payload)
                elif kind == "stopped":
                    self.sender = None
                    self.start_btn.configure(state="normal")
                    self.stop_btn.configure(state="disabled")
                    self.state_label.configure(text="●  Getrennt", fg=MUTED)
                    self.speed_label.configure(text="—")
                    self._set_meter(self.throttle_meter, 0)
                    self._set_meter(self.brake_meter, 0)
                    self.detail_label.configure(text="Türen —")
                elif kind == "data":
                    self._update(payload)
                elif kind == "waiting":
                    self.state_label.configure(text="●  Wartet auf Train Sim World", fg=MUTED)
                    self.speed_label.configure(text="—")
                    self._set_meter(self.throttle_meter, 0)
                    self._set_meter(self.brake_meter, 0)
                    self.detail_label.configure(text="Keine Telemetrieübertragung")
                elif kind == "map":
                    self._update_map(payload)
                elif kind == "map_error":
                    self.map_status.configure(text=payload)
                elif kind == "orders":
                    self._update_orders(payload)
                elif kind == "trip_end":
                    self._on_trip_end()
                elif kind == "report":
                    ok, resp, label = payload
                    self._on_report_result(ok, resp, label)
                elif kind == "report_error":
                    self._log(payload)
                    messagebox.showwarning("Fahrt melden", payload)
                elif kind == "orders_error":
                    self.orders_status.configure(text=payload)
                elif kind == "events":
                    self._update_events(payload)
                elif kind == "events_error":
                    self._log(payload)
                elif kind == "event_ack":
                    self._on_event_ack(payload)
                elif kind == "history":
                    self._update_history(payload)
                elif kind == "history_error":
                    self.history_status.configure(text=payload)
                elif kind == "chat":
                    self._update_chat(payload)
                elif kind == "chat_error":
                    self.chat_status.configure(text=payload)
                elif kind == "weather":
                    self._update_weather(payload)
                elif kind == "weather_error":
                    self.weather_label.configure(text=payload, fg=MUTED)
        except queue.Empty:
            pass
        self.after(300, self._poll)

    def _update(self, payload):
        v = payload["values"]
        quelle = "Live aus Train Sim World" if payload["live"] else "Demo-Werte"
        self.state_label.configure(
            text=("●  Sendet – " if payload["ok"] else "●  Problem – ") + quelle,
            fg=GREEN if payload["ok"] else RED,
        )
        limit = f" / max {int(v['speed_limit_kmh'])}" if v["speed_limit_kmh"] else ""
        speed = float(v["speed_kmh"])
        self.speed_label.configure(text=f"{int(round(speed))}{limit}")
        self._set_meter(self.throttle_meter, v["throttle"])
        self._set_meter(self.brake_meter, v["brake"])

        # Fahrtstatistik: Strecke, Hoechsttempo und Dauer der laufenden Schicht.
        now = time.time()
        stats = self._stats
        if stats["start"] is None:
            stats["start"] = now
        if stats["last"] is not None:
            stats["km"] += speed * max(min(now - stats["last"], 30.0), 0.0) / 3600.0
        stats["last"] = now
        stats["max"] = max(stats["max"], speed)
        dauer = int(now - stats["start"])
        detail = (
            f"Türen {'offen' if v['doors_open'] else 'geschlossen'} · "
            f"{stats['km']:.1f} km · max {int(stats['max'])} km/h · "
            f"{dauer // 3600:02d}:{dauer % 3600 // 60:02d}:{dauer % 60:02d}"
        )

        # Tempolimit-Warnung mit Ton (hoechstens alle 20 Sekunden).
        grenze = float(v["speed_limit_kmh"] or 0)
        if grenze > 0 and speed > grenze + 3:
            self.speed_label.configure(fg=RED)
            detail = f"⚠ Tempolimit überschritten · {detail}"
            if now - self._last_overspeed > 20:
                self._last_overspeed = now
                self._play_dong()
                self._log(f"Zu schnell: {int(speed)} km/h bei erlaubten {int(grenze)} km/h.")
        else:
            self.speed_label.configure(fg=FG)

        self.detail_label.configure(text=detail)
        if not payload["ok"]:
            self._log(payload["status"])

    def _log(self, text):
        stamp = time.strftime("%H:%M:%S")
        self.log_box.configure(state="normal")
        self.log_box.insert("end", f"[{stamp}] {text}\n")
        self.log_box.see("end")
        self.log_box.configure(state="disabled")


if __name__ == "__main__":
    App().mainloop()