aza/AzA march 2026/aza_start_panel.py

# -*- coding: utf-8 -*-
"""
AzA – Einheitliches Startpanel (WebView-Huelle mit MP4-Hintergrund).

Sichtbar: AzA Office | Praxis Chat
Technisch Praxischat = bisheriger MiniChat-Modus (minichat=1), unveraendert.

UI: pywebview + lokalem HTTP (127.0.0.1) fuer MP4/PNG/Logo.
WebView2 blockiert file:// in html= about:blank — daher kein reines as_uri() im Panel.
Fallback nur bei fehlendem pywebview: Tkinter + PNG (kein laufendes Video).
"""
from __future__ import annotations

import html
import mimetypes
import os
import subprocess
import sys
import threading
import tkinter as tk
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

import requests  # module-level fuer SSO-Shell-Session + Testbarkeit
import aza_persistence  # lokales Profil fuer Chat-Office-SSO

_POPEN_NO_CONSOLE: dict = (
    {"creationflags": subprocess.CREATE_NO_WINDOW} if sys.platform == "win32" else {}
)
from pathlib import Path
from tkinter import messagebox
from urllib.parse import parse_qs, unquote, urlencode, urlparse, urlunparse

try:
    from PIL import Image, ImageEnhance, ImageFilter, ImageTk

    _HAS_PIL = True
except Exception:
    _HAS_PIL = False

_ROOT = Path(__file__).resolve().parent
_W, _H = 940, 625
_CARD_W = 270  # Feinschliff 235 px + 15 %

_MP4 = _ROOT / "assets" / "matternhorn-aza-2.mp4"
_PNG = _ROOT / "assets" / "matternhorn.png"
_LOGO = _ROOT / "logo.png"
_WIN_APP_ID = "ch.aza-medwork.startpanel.v1"

_FALLBACK_BG = "#d4e3ef"
_CARD_BG = "#f5f8fb"
_ACCENT = "#1a5f8a"
_ACCENT_HOVER = "#164f73"
_TEXT = "#1a2a3a"
_SUBTLE = "#5a6d7d"
_FONT_TITLE = ("Segoe UI", 18, "bold")
_FONT_SUB = ("Segoe UI", 10)
_FONT_BTN = ("Segoe UI", 10, "bold")
_FONT_FOOT = ("Segoe UI", 8)


def _installed_version_label() -> str:
    """Installierte Version aus kanonischer version.json (gleiche Quelle wie Office/Updater).

    Keine separat fest kodierte Versionsnummer. Diagnose-Log nur mit Pfad und
    Versionsnummer (keine Tokens/Patientendaten).
    """
    try:
        from aza_update_core import load_local_version, find_local_version_file

        info = load_local_version()
        ver = str(info.get("version") or "").strip()
        try:
            vf = find_local_version_file()
            src = str(vf) if vf else "(fallback aza_version.py)"
        except Exception:
            src = "(unbekannt)"
        print(f"[AzA Startpanel] INSTALLED_VERSION={ver or '?'} SOURCE={src}")
        startpanel_exe = (
            str(Path(sys.executable)) if getattr(sys, "frozen", False) else str(_ROOT)
        )
        print(f"[AzA Startpanel] STARTPANEL_PATH={startpanel_exe}")
        if ver:
            return f"Version {ver}"
    except Exception as exc:
        print(f"[AzA Startpanel] VERSION_READ_SKIPPED={type(exc).__name__}")
    return ""


def _file_uri(path: Path) -> str:
    if path.is_file():
        return path.resolve().as_uri()
    return ""


def _short_uri(uri: str, max_len: int = 72) -> str:
    if len(uri) <= max_len:
        return uri
    return uri[: max_len - 1] + "…"


def _log_asset_status(*, asset_mode: str = "", start_url: str = "") -> None:
    video_exists = _MP4.is_file()
    video_size = int(_MP4.stat().st_size) if video_exists else 0
    print(f"[AzA Startpanel] VIDEO_EXISTS={video_exists}")
    print(f"[AzA Startpanel] VIDEO_SIZE_BYTES={video_size}")
    print(f"[AzA Startpanel] VIDEO_URI={_short_uri(_file_uri(_MP4))}")
    print(f"[AzA Startpanel] PNG_EXISTS={_PNG.is_file()}")
    print(f"[AzA Startpanel] LOGO_EXISTS={_LOGO.is_file()}")
    if asset_mode:
        print(f"[AzA Startpanel] ASSET_MODE={asset_mode}")
    if start_url:
        print(f"[AzA Startpanel] START_URL={_short_uri(start_url, 96)}")


def _make_start_panel_handler(root_dir: Path, panel_html_supplier):
    """Liefert nur /start (HTML) und statische Dateien unter Projektroot."""

    class Handler(BaseHTTPRequestHandler):
        def log_message(self, _format, *_args) -> None:
            pass

        def do_GET(self) -> None:
            path = unquote(urlparse(self.path).path)
            if path in ("/start", "/"):
                panel_html = panel_html_supplier()
                self.send_response(200)
                self.send_header("Content-Type", "text/html; charset=utf-8")
                self.send_header("Content-Length", str(len(panel_html)))
                self.send_header("Cache-Control", "no-store")
                self.end_headers()
                self.wfile.write(panel_html)
                return
            rel = path.lstrip("/").replace("/", os.sep)
            if not rel or ".." in rel.split(os.sep):
                self.send_error(404)
                return
            fp = (root_dir / rel).resolve()
            try:
                fp.relative_to(root_dir.resolve())
            except ValueError:
                self.send_error(403)
                return
            if not fp.is_file():
                self.send_error(404)
                return
            data = fp.read_bytes()
            ctype = mimetypes.guess_type(str(fp))[0] or "application/octet-stream"
            self.send_response(200)
            self.send_header("Content-Type", ctype)
            self.send_header("Content-Length", str(len(data)))
            self.send_header("Cache-Control", "no-store")
            self.end_headers()
            self.wfile.write(data)

    return Handler


class _LocalAssetServer:
    """localhost-only HTTP fuer WebView2-Assets (MP4/PNG/Logo)."""

    def __init__(self, root_dir: Path) -> None:
        self._root_dir = root_dir
        self._panel_html: bytes = b""
        self._httpd: ThreadingHTTPServer | None = None
        self.base_url = ""

    def _panel_html_bytes(self) -> bytes:
        if not self._panel_html and self.base_url:
            self._panel_html = _build_panel_html(self.base_url).encode("utf-8")
        return self._panel_html

    def start(self) -> str:
        handler = _make_start_panel_handler(self._root_dir, self._panel_html_bytes)
        self._httpd = ThreadingHTTPServer(("127.0.0.1", 0), handler)
        host, port = self._httpd.server_address
        self.base_url = f"http://{host}:{port}"
        self._panel_html_bytes()
        threading.Thread(target=self._httpd.serve_forever, daemon=True).start()
        return f"{self.base_url}/start"

    def stop(self) -> None:
        if self._httpd is not None:
            try:
                self._httpd.shutdown()
            except Exception:
                pass
            try:
                self._httpd.server_close()
            except Exception:
                pass
            self._httpd = None


def _screen_center_xy(width: int, height: int) -> tuple[int, int]:
    """Bildschirmmitte fuer pywebview x/y und Win32-Fallback."""
    sw, sh = 1920, 1080
    if sys.platform == "win32":
        try:
            import ctypes

            user32 = ctypes.windll.user32
            sw = int(user32.GetSystemMetrics(0))
            sh = int(user32.GetSystemMetrics(1))
        except Exception:
            pass
    x = max(0, (sw - width) // 2)
    y = max(0, (sh - height) // 2)
    return x, y


def _center_window(win: tk.Tk, width: int, height: int) -> None:
    win.update_idletasks()
    x, y = _screen_center_xy(width, height)
    win.geometry(f"{width}x{height}+{x}+{y}")


def _win32_center_window(hwnd: int, width: int, height: int) -> bool:
    if sys.platform != "win32" or not hwnd:
        return False
    try:
        import ctypes

        user32 = ctypes.windll.user32
        x, y = _screen_center_xy(width, height)
        SWP_NOSIZE = 0x0001
        SWP_NOZORDER = 0x0004
        user32.SetWindowPos(hwnd, 0, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER)
        return True
    except Exception:
        return False


def _minichat_url() -> str:
    """Technischer URL-Modus minichat=1 (Praxischat)."""
    try:
        from aza_empfang_webview import _build_default_empfang_chat_shell_url

        base = _build_default_empfang_chat_shell_url()
    except Exception:
        base = (
            os.environ.get("AZA_EMPFANG_CHAT_SHELL_URL") or ""
        ).strip() or (
            "https://empfang.aza-medwork.ch/empfang/"
            "?empfang_chat_shell=1&shell_source=empfang_chat_shell"
        )
    try:
        p = urlparse(base)
        qs = parse_qs(p.query, keep_blank_values=True)
        qs["minichat"] = ["1"]
        return urlunparse(p._replace(query=urlencode(qs, doseq=True)))
    except Exception:
        sep = "&" if "?" in base else "?"
        return f"{base}{sep}minichat=1"


def _resolve_office_executable() -> Path | None:
    if getattr(sys, "frozen", False):
        exe_dir = Path(sys.executable).resolve().parent
        for name in ("aza_desktop.exe", "AzA.exe", "AzA_Start.exe"):
            p = exe_dir / name
            if p.is_file():
                return p
        meipass = getattr(sys, "_MEIPASS", "")
        if meipass:
            p = Path(meipass) / "aza_desktop.exe"
            if p.is_file():
                return p
    for p in (_ROOT / "aza_desktop.exe", _ROOT / "dist" / "aza_desktop" / "aza_desktop.exe"):
        if p.is_file():
            return p
    return None


def _resolve_empfang_shell_executable() -> Path | None:
    if getattr(sys, "frozen", False):
        exe_dir = Path(sys.executable).resolve().parent
        p = exe_dir / "AZA_EmpfangShell.exe"
        if p.is_file():
            return p
        meipass = getattr(sys, "_MEIPASS", "")
        if meipass:
            p = Path(meipass) / "AZA_EmpfangShell.exe"
            if p.is_file():
                return p
    for p in (_ROOT / "AZA_EmpfangShell.exe", _ROOT / "dist" / "AZA_EmpfangShell.exe"):
        if p.is_file():
            return p
    return None


def start_office() -> tuple[bool, str]:
    exe = _resolve_office_executable()
    try:
        if exe is not None:
            subprocess.Popen(
                [str(exe)],
                cwd=str(exe.parent),
                close_fds=(sys.platform != "win32"),
                **_POPEN_NO_CONSOLE,
            )
            return True, f"Gestartet: {exe.name}"
        script = _ROOT / "basis14.py"
        if not script.is_file():
            return False, "basis14.py und aza_desktop.exe wurden nicht gefunden."
        subprocess.Popen(
            [sys.executable, str(script)],
            cwd=str(_ROOT),
            close_fds=(sys.platform != "win32"),
            **_POPEN_NO_CONSOLE,
        )
        return True, "AzA Office wird gestartet."
    except Exception as exc:
        return False, f"Office konnte nicht gestartet werden: {exc}"


def _startpanel_backend_url() -> str:
    """Backend-URL standalone (Env MEDWORK_BACKEND_URL oder backend_url.txt neben EXE/Root)."""
    v = (os.environ.get("MEDWORK_BACKEND_URL") or "").strip()
    if v:
        return v.rstrip("/")
    for base in (
        Path(sys.executable).resolve().parent if getattr(sys, "frozen", False) else None,
        _ROOT,
    ):
        if not base:
            continue
        p = base / "backend_url.txt"
        if p.is_file():
            try:
                line = (p.read_text(encoding="utf-8").strip().splitlines() or [""])[0].strip()
                if line:
                    return line.rstrip("/")
            except Exception:
                pass
    return ""


def _startpanel_backend_token() -> str:
    """API-Token standalone (backend_token.txt neben EXE/Root oder MEDWORK_API_TOKENS/_TOKEN)."""
    for base in (
        Path(sys.executable).resolve().parent if getattr(sys, "frozen", False) else None,
        _ROOT,
    ):
        if not base:
            continue
        p = base / "backend_token.txt"
        if p.is_file():
            try:
                line = (p.read_text(encoding="utf-8").strip().splitlines() or [""])[0].strip()
                if line:
                    return line
            except Exception:
                pass
    env = (os.environ.get("MEDWORK_API_TOKENS") or "").strip()
    if env:
        return env.split(",")[0].strip()
    return (os.environ.get("MEDWORK_API_TOKEN") or "").strip()


def _startpanel_logout_marker_active() -> bool:
    """True wenn der Benutzer sich bewusst aus dem Chat abgemeldet hat.

    Verhindert sofortigen ungefragten Auto-Login nach bewusstem Logout. Marker ist eine
    lokale Datei im AzA-Datenverzeichnis (kein Token, keine Credentials).
    """
    try:
        from aza_persistence import get_writable_data_dir

        p = Path(get_writable_data_dir()) / "aza_chat_logout_marker"
        return p.is_file()
    except Exception:
        return False


def _startpanel_office_running() -> bool:
    """Laeuft AzA Office (aza_desktop.exe)? Bevorzugt bestehende Pruefung, sonst leichter Fallback."""
    try:
        import aza_chat_desktop_host

        return bool(aza_chat_desktop_host._office_desktop_running())
    except Exception:
        pass
    if sys.platform != "win32":
        return False
    try:
        r = subprocess.run(
            ["tasklist", "/FI", "IMAGENAME eq aza_desktop.exe", "/NH"],
            capture_output=True, text=True, timeout=5,
            **_POPEN_NO_CONSOLE,
        )
        return "aza_desktop.exe" in (r.stdout or "").lower()
    except Exception:
        return False


def _startpanel_fetch_shell_token() -> str | None:
    """Erzeugt einen kurzlebigen Shell-Session-Token aus dem lokalen Profil.

    Nutzt den bestehenden, serverseitig validierten SSO-Endpunkt
    ``POST /empfang/shell/session`` (validiert practice_id + empfang_user_id).
    Kein Passwort, keine Klartext-Credentials. Token nur als Rueckgabewert (kurzlebig).
    """
    try:
        prof = aza_persistence.load_user_profile() or {}
    except Exception:
        return None
    pid = (prof.get("practice_id") or "").strip()
    uid = (prof.get("empfang_user_id") or "").strip()
    if not pid or not uid:
        return None
    bu = _startpanel_backend_url()
    tok = _startpanel_backend_token()
    if not bu or not tok:
        return None
    hdrs = {
        "X-API-Token": tok,
        "X-Practice-Id": pid,
        "X-AzA-Empfang-User-Id": uid,
    }
    try:
        r = requests.post(f"{bu}/empfang/shell/session", headers=hdrs, json={}, timeout=20)
    except Exception:
        return None
    if getattr(r, "status_code", None) != 200:
        return None
    try:
        data = r.json()
    except Exception:
        return None
    if not isinstance(data, dict):
        return None
    shell_tok = (data.get("shell_token") or "").strip()
    return shell_tok or None


def _launch_praxischat_process(extra_args: list[str] | None = None) -> tuple[bool, str]:
    """Startet die Empfang-Chat-Huelle (minichat). extra_args z.B. ['--handoff-token=...'].

    Der Handoff-Token wird nur als Prozessargument an die eigene Huelle uebergeben; die Huelle
    (aza_empfang_webview) entfernt ihn aus argv und loggt ihn als redacted (kein URL-/Log-Leak)."""
    url = _minichat_url()
    mode_arg = "--shell-mode=empfang_chat_shell"
    w, h = "350", "700"
    pre = list(extra_args or [])
    exe = _resolve_empfang_shell_executable()
    try:
        if exe is not None:
            subprocess.Popen(
                [str(exe), *pre, mode_arg, url, w, h],
                cwd=str(exe.parent),
                close_fds=(sys.platform != "win32"),
                **_POPEN_NO_CONSOLE,
            )
            return True, f"Praxischat wird gestartet ({exe.name})."
        script = _ROOT / "aza_empfang_webview.py"
        if not script.is_file():
            return (
                False,
                "aza_empfang_webview.py und AZA_EmpfangShell.exe wurden nicht gefunden.",
            )
        subprocess.Popen(
            [sys.executable, str(script), *pre, mode_arg, url, w, h],
            cwd=str(_ROOT),
            close_fds=(sys.platform != "win32"),
            **_POPEN_NO_CONSOLE,
        )
        return True, "Praxischat wird gestartet."
    except Exception as exc:
        return False, f"Praxischat konnte nicht gestartet werden: {exc}"


def _show_office_setup_required_window() -> bool:
    """Prioritaet 3: AzA-Design-Fenster 'AzA Office muss einmal eingerichtet werden'.

    Kein graues Standard-Tkinter, kein roter/gruener Button. Button 'AzA Office oeffnen'
    startet AzA Office und schliesst das Fenster. Rueckgabe True wenn Fenster gezeigt wurde.
    """
    _BG = "#EEF4F8"
    _HDR = "#1A4D6D"
    _WHT = "#FFFFFF"
    _TXT = "#1A3D55"
    _SUB = "#5A7A90"
    _ACC = "#1A5F8A"
    _ACC_HOVER = "#164F73"
    _FF = "Segoe UI"
    try:
        win = tk.Toplevel() if tk._default_root is not None else tk.Tk()
    except Exception:
        try:
            win = tk.Tk()
        except Exception:
            return False
    try:
        win.title("AzA Chat")
        win.configure(bg=_BG)
        win.resizable(False, False)
        W, H = 460, 320
        try:
            sw, sh = win.winfo_screenwidth(), win.winfo_screenheight()
            win.geometry(f"{W}x{H}+{max(0,(sw-W)//2)}+{max(0,(sh-H)//2)}")
        except Exception:
            win.geometry(f"{W}x{H}")

        hdr = tk.Frame(win, bg=_HDR, padx=20, pady=16)
        hdr.pack(fill="x")
        tk.Label(hdr, text="AzA Chat", bg=_HDR, fg=_WHT,
                 font=(_FF, 14, "bold")).pack(anchor="w")
        tk.Label(hdr, text="Einrichtung erforderlich", bg=_HDR, fg="#AFCBE0",
                 font=(_FF, 9)).pack(anchor="w", pady=(2, 0))

        card = tk.Frame(win, bg=_WHT, padx=22, pady=20)
        card.pack(fill="both", expand=True, padx=16, pady=16)
        tk.Label(card, text="AzA Office muss einmal eingerichtet werden",
                 bg=_WHT, fg=_TXT, font=(_FF, 11, "bold"),
                 wraplength=380, justify="left").pack(anchor="w")
        tk.Label(card,
                 text="Damit der Chat Ihre Benutzer- und Praxisidentitaet sicher "
                      "uebernehmen kann, oeffnen Sie bitte einmal AzA Office und "
                      "richten Ihr Profil ein. Danach meldet sich der Chat automatisch an.",
                 bg=_WHT, fg=_SUB, font=(_FF, 9),
                 wraplength=380, justify="left").pack(anchor="w", pady=(10, 18))

        def _open_office():
            try:
                ok, _msg = start_office()
            except Exception:
                ok = False
            try:
                win.destroy()
            except Exception:
                pass

        btn = tk.Button(card, text="AzA Office oeffnen", command=_open_office,
                        bg=_ACC, fg=_WHT, activebackground=_ACC_HOVER, activeforeground=_WHT,
                        font=(_FF, 10, "bold"), relief="flat", bd=0,
                        padx=18, pady=9, cursor="hand2")
        btn.pack(anchor="w")
        btn.bind("<Enter>", lambda _e: btn.configure(bg=_ACC_HOVER))
        btn.bind("<Leave>", lambda _e: btn.configure(bg=_ACC))

        try:
            win.lift()
            win.attributes("-topmost", True)
            win.after(600, lambda: win.attributes("-topmost", False))
        except Exception:
            pass
        # Eigenstaendiges Fenster: nur eigenen Loop fahren, wenn dieser Prozess noch keinen hat.
        try:
            if tk._default_root is win:
                win.mainloop()
        except Exception:
            pass
        return True
    except Exception:
        try:
            win.destroy()
        except Exception:
            pass
        return False


def start_praxischat() -> tuple[bool, str]:
    """Praxischat-Start mit Office-SSO (kein separates Chat-Login bei vorhandener Identitaet).

    Reihenfolge (kleinste sichere Loesung, bestehende Pfade wiederverwendet):
      1. Office laeuft  -> bestehende IPC, Office oeffnet die Huelle authentifiziert.
      2. Profil vorhanden + kein bewusster Logout -> Shell-Session-Token holen, Huelle per
         --handoff-token automatisch anmelden.
      3. keine Identitaet -> Einrichtungsfenster ("AzA Office oeffnen"), kein Dauer-Login.
      Sicherer Fallback (Profil vorhanden, aber Token fehlgeschlagen/Logout) -> normale Huelle.
    """
    # Prioritaet 1: laufendes Office verwenden (kein zweiter Login, kein Token noetig).
    try:
        if _startpanel_office_running():
            import aza_empfang_shell_surface

            aza_empfang_shell_surface.request_office_open_empfang_chat_shell_ipc()
            return True, "Praxischat wird ueber das laufende AzA Office geoeffnet."
    except Exception:
        pass

    # Identitaet pruefen.
    try:
        prof = aza_persistence.load_user_profile() or {}
    except Exception:
        prof = {}
    has_identity = bool((prof.get("practice_id") or "").strip()
                        and (prof.get("empfang_user_id") or "").strip())

    # Prioritaet 2: Office aus, gueltiges Profil, kein bewusster Logout -> Token-Handoff.
    if has_identity and not _startpanel_logout_marker_active():
        tok = _startpanel_fetch_shell_token()
        if tok:
            return _launch_praxischat_process(["--handoff-token=" + tok])
        # Token fehlgeschlagen/abgelaufen: sicherer Fallback auf normale Huelle (kein Loop).
        return _launch_praxischat_process()

    # Profil vorhanden, aber bewusster Logout -> normale Huelle (Benutzer meldet sich neu an).
    if has_identity:
        return _launch_praxischat_process()

    # Prioritaet 3: keine Office-Identitaet -> einmaliges Einrichtungsfenster statt Dauer-Login.
    if _show_office_setup_required_window():
        return True, "AzA Office muss einmal eingerichtet werden."
    # Fallback nur falls Setup-Fenster nicht moeglich: bestehende Huelle (zeigt Login).
    return _launch_praxischat_process()


# Alias fuer aeltere HTML-API-Namen
start_minichat = start_praxischat


class StartPanelApi:
    """pywebview JS-API (Chromium/WebView2)."""

    def __init__(self) -> None:
        self._window = None

    def bind_window(self, window) -> None:
        self._window = window

    def _close_on_success(self, ok: bool) -> None:
        if ok and self._window is not None:
            try:
                self._window.destroy()
            except Exception:
                pass

    def open_office(self) -> dict:
        ok, msg = start_office()
        self._close_on_success(ok)
        return {"ok": ok, "message": msg}

    def open_praxischat(self) -> dict:
        ok, msg = start_praxischat()
        self._close_on_success(ok)
        return {"ok": ok, "message": msg}

    # Kompatibilitaet aelterer HTML-Handler
    launch_office = open_office
    launch_minichat = open_praxischat


def _build_panel_html(asset_base: str) -> str:
    """HTML mit http://127.0.0.1:PORT/... Asset-URLs (WebView2-kompatibel)."""
    base = asset_base.rstrip("/")
    png = html.escape(f"{base}/assets/matternhorn.png", quote=True)
    mp4 = ""
    if _MP4.is_file():
        mp4 = html.escape(f"{base}/assets/matternhorn-aza-2.mp4", quote=True)
    favicon = ""
    if _LOGO.is_file():
        favicon = (
            f'<link rel="icon" type="image/png" href="'
            f'{html.escape(f"{base}/logo.png", quote=True)}"/>'
        )
    logo_block = ""
    if _LOGO.is_file():
        logo_u = html.escape(f"{base}/logo.png", quote=True)
        logo_block = (
            f'<img class="logo" id="logoImg" src="{logo_u}" alt="" '
            f'onerror="this.remove()"/>'
        )
    ver_label = _installed_version_label()
    ver_foot = f" · {html.escape(ver_label, quote=True)}" if ver_label else ""
    video_block = ""
    if mp4:
        video_block = f"""
  <div class="bg-wrap">
    <video id="bgVideo" class="bg-video" autoplay muted loop playsinline preload="auto" poster="{png}">
      <source src="{mp4}" type="video/mp4"/>
    </video>
    <img class="bg-fallback" src="{png}" alt=""/>
  </div>"""
    else:
        video_block = f"""
  <div class="bg-wrap">
    <img class="bg-fallback show-fallback" src="{png}" alt=""/>
  </div>"""
    return f"""<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="utf-8"/>
  <title>AzA</title>
  {favicon}
  <style>
    * {{ box-sizing: border-box; margin: 0; padding: 0; }}
    html, body {{
      width: 100%; height: 100%; overflow: hidden;
      font-family: "Segoe UI", system-ui, sans-serif;
      background: #b8c9d8;
    }}
    .bg-wrap {{
      position: fixed; inset: 0; z-index: 0; overflow: hidden;
      width: 100vw; height: 100vh;
    }}
    .bg-video, .bg-fallback {{
      position: absolute; inset: 0; width: 100%; height: 100%;
      object-fit: cover;
    }}
    .bg-fallback {{ display: none; }}
    .bg-fallback.show-fallback {{ display: block; }}
    body.no-video .bg-video {{ display: none; }}
    body.no-video .bg-fallback {{ display: block; }}
    .fog {{
      position: fixed; inset: 0; z-index: 1;
      background: linear-gradient(
        180deg,
        rgba(255, 255, 255, 0.34) 0%,
        rgba(240, 248, 255, 0.58) 50%,
        rgba(230, 240, 250, 0.68) 100%
      );
      pointer-events: none;
    }}
    .stage {{
      position: fixed; inset: 0; z-index: 2;
      display: flex; align-items: center; justify-content: center;
      padding: 25px;
    }}
    .card {{
      width: min({_CARD_W}px, 88vw);
      padding: 18px 18px 15px;
      border-radius: 16px;
      background: rgba(255, 255, 255, 0.51);
      border: 1px solid rgba(255, 255, 255, 0.64);
      box-shadow: 0 9px 33px rgba(20, 40, 60, 0.14);
      backdrop-filter: blur(16px);
      -webkit-backdrop-filter: blur(16px);
      text-align: center;
    }}
    .logo {{
      width: 43px; height: 43px; object-fit: contain;
      margin: 0 auto 7px; display: block;
    }}
    h1 {{ font-size: 1.38rem; font-weight: 700; color: #1a2a3a; }}
    .sub {{ margin: 6px 0 15px; font-size: 0.83rem; color: #5a6d7d; }}
    .btn {{
      display: block; width: 100%; margin-bottom: 9px;
      padding: 12px 15px; border: none; border-radius: 9px;
      font-size: 0.86rem; font-weight: 600; color: #fff;
      background: #1a5f8a; cursor: pointer;
      box-shadow: 0 3px 13px rgba(26, 95, 138, 0.28);
      transition: background 0.15s ease, transform 0.1s ease;
    }}
    .btn:last-of-type {{ margin-bottom: 0; }}
    .btn:hover {{ background: #164f73; }}
    .btn:active {{ transform: scale(0.98); }}
    .btn:disabled {{ opacity: 0.65; cursor: wait; }}
    .foot {{ margin-top: 13px; font-size: 0.67rem; color: #6a7d8c; }}
    .err {{ display: none; margin-top: 9px; font-size: 0.71rem; color: #b42318; }}
    .err.show {{ display: block; }}
  </style>
</head>
<body>
{video_block}
  <div class="fog"></div>
  <div class="stage">
    <div class="card">
      {logo_block}
      <h1>AzA</h1>
      <p class="sub">Was möchten Sie öffnen?</p>
      <button type="button" class="btn" id="btnOffice">AzA Office</button>
      <button type="button" class="btn" id="btnPraxischat">Praxis Chat</button>
      <p class="err" id="errBox"></p>
      <p class="foot">AzA Medwork{ver_foot}</p>
    </div>
  </div>
  <script>
    (function () {{
      function useFallback(reason) {{
        document.body.classList.add("no-video");
        if (reason) console.warn("START_PANEL_VIDEO_FALLBACK", reason);
      }}
      function initVideo() {{
        var v = document.getElementById("bgVideo");
        if (!v) {{
          useFallback("no_video_element");
          return;
        }}
        v.muted = true;
        v.playsInline = true;
        v.setAttribute("playsinline", "");
        v.addEventListener("error", function () {{
          useFallback("error code=" + (v.error ? v.error.code : "?"));
        }});
        v.addEventListener("playing", function () {{
          document.body.classList.remove("no-video");
        }});
        v.addEventListener("canplay", function () {{
          document.body.classList.remove("no-video");
          v.play().catch(function () {{ useFallback("play_rejected"); }});
        }});
        setTimeout(function () {{
          if (v.error) useFallback("timeout_error");
          else if (v.readyState < 2 && v.networkState === 3) useFallback("timeout_no_source");
        }}, 15000);
        try {{ v.load(); }} catch (e) {{ useFallback("load_failed"); }}
        v.play().catch(function () {{}});
      }}
      if (document.readyState === "loading") {{
        document.addEventListener("DOMContentLoaded", initVideo);
      }} else {{
        initVideo();
      }}

      function showErr(msg) {{
        var el = document.getElementById("errBox");
        el.textContent = msg || "";
        el.classList.toggle("show", !!msg);
      }}
      function setBusy(busy) {{
        document.getElementById("btnOffice").disabled = busy;
        document.getElementById("btnPraxischat").disabled = busy;
      }}
      async function callApi(method) {{
        if (!window.pywebview || !pywebview.api || !pywebview.api[method]) {{
          showErr("Start-API nicht verfügbar.");
          return;
        }}
        setBusy(true);
        showErr("");
        try {{
          var r = await pywebview.api[method]();
          if (r && r.ok) return;
          showErr((r && r.message) ? r.message : "Start fehlgeschlagen.");
        }} catch (e) {{
          showErr(String(e && e.message ? e.message : e));
        }} finally {{
          setBusy(false);
        }}
      }}
      document.getElementById("btnOffice").addEventListener("click", function () {{
        callApi("open_office");
      }});
      document.getElementById("btnPraxischat").addEventListener("click", function () {{
        callApi("open_praxischat");
      }});
    }})();
  </script>
</body>
</html>"""


def _webview_storage_dir() -> str:
    appdata = os.environ.get("APPDATA") or os.environ.get("LOCALAPPDATA") or ""
    base = Path(appdata) / "AzA" / "StartPanelWebView" if appdata else _ROOT / ".aza_start_panel_webview"
    try:
        base.mkdir(parents=True, exist_ok=True)
    except OSError:
        pass
    return str(base)


def _has_pywebview() -> bool:
    try:
        import webview  # noqa: F401

        return True
    except ImportError:
        return False


def _should_use_webview() -> bool:
    if os.environ.get("AZA_START_PANEL_FORCE_TK", "").strip().lower() in (
        "1",
        "true",
        "yes",
    ):
        return False
    return _has_pywebview()


def _icon_path() -> str | None:
    return _resolve_native_icon_path()


def _ensure_win32_app_user_model_id() -> None:
    """Eigener Taskleisten-Eintrag statt python.exe (muss vor dem ersten Fenster)."""
    if sys.platform != "win32":
        return
    try:
        import ctypes

        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(_WIN_APP_ID)
    except Exception:
        pass


def _resolve_native_icon_path() -> str | None:
    """logo.ico bevorzugt; sonst logo.png -> temporaeres .ico (nur fuer Fenster-Icon)."""
    ico = _ROOT / "logo.ico"
    if ico.is_file():
        return str(ico.resolve())
    png = _ROOT / "logo.png"
    if png.is_file() and _HAS_PIL:
        cache = _ROOT / ".aza_start_panel_icon_cache.ico"
        try:
            if (not cache.is_file()) or cache.stat().st_mtime < png.stat().st_mtime:
                img = Image.open(png)
                img.save(
                    cache,
                    format="ICO",
                    sizes=[(16, 16), (32, 32), (48, 48)],
                )
            return str(cache.resolve())
        except Exception:
            pass
    return None


def _webview_hwnd(window) -> int | None:
    native = getattr(window, "native", None)
    if native is None:
        return None
    try:
        handle = getattr(native, "Handle", None)
        if handle is not None:
            return int(handle.ToInt32())
    except Exception:
        pass
    return None


def _win32_find_window_hwnd(title: str = "AzA") -> int | None:
    if sys.platform != "win32":
        return None
    import ctypes

    user32 = ctypes.windll.user32

    found: list[int] = []

    def _enum(hwnd, _lparam) -> bool:
        if not user32.IsWindowVisible(hwnd):
            return True
        buf = ctypes.create_unicode_buffer(256)
        if user32.GetWindowTextW(hwnd, buf, 256) and buf.value == title:
            found.append(int(hwnd))
            return False
        return True

    WNDENUMPROC = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
    user32.EnumWindows(WNDENUMPROC(_enum), 0)
    return found[0] if found else None


def _win32_set_window_icon(hwnd: int, icon_path: str) -> bool:
    """WM_SETICON + Klassen-Icon fuer Titelzeile und Taskleiste."""
    if sys.platform != "win32":
        return False
    import ctypes

    user32 = ctypes.windll.user32
    path = os.path.abspath(icon_path)
    if not os.path.isfile(path):
        return False
    WM_SETICON = 0x0080
    ICON_SMALL = 0
    ICON_BIG = 1
    IMAGE_ICON = 1
    LR_LOADFROMFILE = 0x00000010
    GCLP_HICON = -14
    GCLP_HICONSM = -34
    set_class = getattr(user32, "SetClassLongPtrW", None) or user32.SetClassLongW
    ok = False
    h_default = user32.LoadImageW(None, path, IMAGE_ICON, 0, 0, LR_LOADFROMFILE)
    h_small = user32.LoadImageW(None, path, IMAGE_ICON, 16, 16, LR_LOADFROMFILE)
    h_big = user32.LoadImageW(None, path, IMAGE_ICON, 32, 32, LR_LOADFROMFILE) or h_default
    if h_small:
        user32.SendMessageW(hwnd, WM_SETICON, ICON_SMALL, h_small)
        set_class(hwnd, GCLP_HICONSM, h_small)
        ok = True
    if h_big:
        user32.SendMessageW(hwnd, WM_SETICON, ICON_BIG, h_big)
        set_class(hwnd, GCLP_HICON, h_big)
        ok = True
    return ok


def _apply_native_window_icon(window) -> bool:
    path = _resolve_native_icon_path()
    if not path:
        print("[AzA Startpanel] WINDOW_ICON=missing")
        return False
    hwnd = _webview_hwnd(window) or _win32_find_window_hwnd("AzA")
    applied = bool(hwnd and _win32_set_window_icon(hwnd, path))
    print(
        f"[AzA Startpanel] WINDOW_ICON={'ok' if applied else 'pending'} "
        f"file={Path(path).name} hwnd={hwnd or 0}"
    )
    return applied


def _schedule_native_window_icon(window) -> None:
    for delay in (0.15, 0.45, 1.0, 2.5):
        threading.Timer(delay, lambda: _apply_native_window_icon(window)).start()


def _bind_native_icon_on_loaded(window) -> None:
    def _on_loaded() -> None:
        _apply_native_window_icon(window)

    try:
        window.events.loaded += _on_loaded
        window.events.shown += _on_loaded
    except Exception:
        pass
    _schedule_native_window_icon(window)


def _bind_window_center_on_shown(window) -> None:
    def _center() -> None:
        hwnd = _webview_hwnd(window) or _win32_find_window_hwnd("AzA")
        if hwnd:
            _win32_center_window(hwnd, _W, _H)

    try:
        window.events.shown += _center
    except Exception:
        pass
    for delay in (0.05, 0.25, 0.6):
        threading.Timer(delay, _center).start()


def _prime_pywebview_icon(icon_path: str | None) -> None:
    """Icon vor create_window in pywebview-State (winforms liest _state['icon'])."""
    if not icon_path:
        return
    try:
        import webview

        webview._state["icon"] = os.path.abspath(icon_path)
    except Exception:
        pass


def run_webview_panel() -> int:
    import webview

    _ensure_win32_app_user_model_id()
    icon_path = _icon_path()
    _prime_pywebview_icon(icon_path)
    _log_asset_status()
    if not _MP4.is_file():
        print("[AzA Startpanel] START_PANEL_VIDEO_FALLBACK reason=mp4_missing")
    server = _LocalAssetServer(_ROOT)
    start_url = server.start()
    _log_asset_status(asset_mode="http_localhost", start_url=start_url)

    api = StartPanelApi()
    win_x, win_y = _screen_center_xy(_W, _H)
    try:
        win = webview.create_window(
            "AzA",
            url=start_url,
            width=_W,
            height=_H,
            x=win_x,
            y=win_y,
            resizable=False,
            js_api=api,
            background_color="#b8c9d8",
        )
        api.bind_window(win)
        _bind_native_icon_on_loaded(win)
        _bind_window_center_on_shown(win)
        # ARCHITEKTUR: Das Startpanel fuehrt KEINE Updatepruefung mehr aus.
        # Einziger Update-Owner ist AzA Office (basis14.py). Das Panel zeigt
        # nur die installierte Version (Footer) und startet niemals einen
        # Updater/Installer und schreibt kein Pending.
        webview.start(
            private_mode=False,
            storage_path=_webview_storage_dir(),
            icon=icon_path,
        )
    finally:
        server.stop()
    return 0


def _load_logo_photo(master: tk.Misc, size: int = 44) -> tk.PhotoImage | None:
    if not _LOGO.is_file():
        return None
    try:
        if _HAS_PIL:
            img = Image.open(_LOGO).convert("RGBA")
            img = img.resize((size, size), Image.Resampling.LANCZOS)
            return ImageTk.PhotoImage(img, master=master)
        return tk.PhotoImage(file=str(_LOGO), master=master)
    except Exception:
        return None


def _build_background_photo(master: tk.Misc) -> tk.PhotoImage | None:
    if not _PNG.is_file() or not _HAS_PIL:
        return None
    try:
        img = Image.open(_PNG).convert("RGB")
        img = ImageEnhance.Brightness(img).enhance(1.08)
        img = img.resize((_W, _H), Image.Resampling.LANCZOS)
        img = img.filter(ImageFilter.GaussianBlur(radius=1.6))
        fog = Image.new("RGBA", (_W, _H), (245, 248, 252, 140))
        img = Image.alpha_composite(img.convert("RGBA"), fog).convert("RGB")
        return ImageTk.PhotoImage(img, master=master)
    except Exception:
        return None


class AzAStartPanelTk:
    """Nur wenn pywebview fehlt: statisches PNG, kein MP4."""

    def __init__(self) -> None:
        self.root = tk.Tk()
        self.root.title("AzA")
        self.root.resizable(False, False)
        self.root.configure(bg=_FALLBACK_BG)
        _center_window(self.root, _W, _H)

        self._bg_photo: tk.PhotoImage | None = None
        self._logo_photo: tk.PhotoImage | None = None

        self.canvas = tk.Canvas(
            self.root, width=_W, height=_H, highlightthickness=0, bd=0
        )
        self.canvas.pack(fill="both", expand=True)

        self._bg_photo = _build_background_photo(self.root)
        if self._bg_photo is not None:
            self.canvas.create_image(0, 0, anchor="nw", image=self._bg_photo)
        else:
            self.canvas.configure(bg=_FALLBACK_BG)

        card = tk.Frame(
            self.canvas,
            bg=_CARD_BG,
            highlightbackground="#c8d6e4",
            highlightthickness=1,
        )
        self.canvas.create_window(_W // 2, _H // 2, window=card, width=_CARD_W)

        header = tk.Frame(card, bg=_CARD_BG)
        header.pack(pady=(18, 6))

        self._logo_photo = _load_logo_photo(card, 40)
        if self._logo_photo is not None:
            tk.Label(header, image=self._logo_photo, bg=_CARD_BG).pack()

        tk.Label(header, text="AzA", font=_FONT_TITLE, fg=_TEXT, bg=_CARD_BG).pack(
            pady=(8, 2)
        )
        tk.Label(
            header,
            text="Was möchten Sie öffnen?",
            font=_FONT_SUB,
            fg=_SUBTLE,
            bg=_CARD_BG,
        ).pack(pady=(0, 13))

        btn_frame = tk.Frame(card, bg=_CARD_BG)
        btn_frame.pack(padx=21, pady=(0, 6))

        self._mk_btn(btn_frame, "AzA Office", self._on_office).pack(
            fill="x", pady=(0, 9)
        )
        self._mk_btn(btn_frame, "Praxis Chat", self._on_praxischat).pack(fill="x")

        _ver_label = _installed_version_label()
        _foot_text = "AzA Medwork" + (f" · {_ver_label}" if _ver_label else "")
        tk.Label(
            card, text=_foot_text, font=_FONT_FOOT, fg=_SUBTLE, bg=_CARD_BG
        ).pack(pady=(15, 15))

        ico = _icon_path()
        if ico and sys.platform == "win32":
            try:
                self.root.iconbitmap(ico)
            except Exception:
                pass

        if not _has_pywebview():
            tk.Label(
                card,
                text="Hinweis: Video-Hintergrund benötigt pywebview.",
                font=("Segoe UI", 8),
                fg=_SUBTLE,
                bg=_CARD_BG,
                wraplength=_CARD_W - 24,
            ).pack(pady=(0, 8))

        # ARCHITEKTUR: Kein Updatecheck im Startpanel (auch nicht im Tk-Fallback).
        # Einziger Update-Owner ist AzA Office.

    def _mk_btn(self, parent: tk.Misc, text: str, cmd) -> tk.Button:
        btn = tk.Button(
            parent,
            text=text,
            font=_FONT_BTN,
            fg="#ffffff",
            bg=_ACCENT,
            activebackground=_ACCENT_HOVER,
            activeforeground="#ffffff",
            relief="flat",
            bd=0,
            padx=16,
            pady=9,
            cursor="hand2",
            command=cmd,
        )
        btn.bind("<Enter>", lambda _e: btn.configure(bg=_ACCENT_HOVER))
        btn.bind("<Leave>", lambda _e: btn.configure(bg=_ACCENT))
        return btn

    def _on_office(self) -> None:
        ok, msg = start_office()
        if not ok:
            messagebox.showerror("AzA Office", msg, parent=self.root)
        else:
            self.root.destroy()

    def _on_praxischat(self) -> None:
        ok, msg = start_praxischat()
        if not ok:
            messagebox.showerror("Praxischat", msg, parent=self.root)
        else:
            self.root.destroy()

    def run(self) -> None:
        self.root.mainloop()


def main() -> int:
    _ensure_win32_app_user_model_id()
    if _should_use_webview():
        try:
            return run_webview_panel()
        except Exception as exc:
            print(f"[AzA Startpanel] WebView-Fehler: {exc}", file=sys.stderr)
            try:
                root = tk.Tk()
                root.withdraw()
                messagebox.showerror(
                    "AzA Startpanel",
                    "WebView-Huelle konnte nicht starten.\n"
                    f"{exc}\n\nEs wird das statische Fallback geöffnet (ohne Video).",
                    parent=root,
                )
                root.destroy()
            except Exception:
                pass
    AzAStartPanelTk().run()
    return 0


if __name__ == "__main__":
    _ensure_win32_app_user_model_id()
    raise SystemExit(main())