# -*- coding: utf-8 -*-
"""
TodoMixin – _open_todo_window Methode als Mixin-Klasse.
"""

import os
import tkinter as tk
from tkinter import ttk, messagebox
from tkinter.scrolledtext import ScrolledText
from datetime import datetime
import threading
import json
import re

from aza_persistence import (
    load_todos,
    save_todos,
    load_notes,
    save_notes,
    load_checklists,
    save_checklists,
    load_todo_geometry,
    save_todo_geometry,
    load_todo_inbox,
    save_todo_inbox,
    send_todo_to_inbox,
    cloud_pull_todos,
    cloud_pull_notes,
    cloud_get_status,
    extract_date_from_todo_text,
    load_user_profile,
    load_todo_settings,
    save_todo_settings,
)
from aza_ui_helpers import (
    add_tooltip,
    center_window,
    add_resize_grip,
    add_text_font_size_control,
    setup_window_geometry_saving,
    apply_initial_scaling_to_window,
    load_text_font_size,
    save_text_font_size,
)
from aza_audio import AudioRecorder


class TodoMixin:
    """Mixin-Klasse für das To-Do-Fenster."""

    def _open_todo_window(self):
        """Öffnet ein Todoist-ähnliches To-do Fenster mit Diktat, Kalender und Überfällig-Markierung."""
        from datetime import datetime, date, timedelta
        import calendar as cal_mod

        TODO_MIN_W, TODO_MIN_H = 500, 560
        win = tk.Toplevel(self)
        win.title("To-do")
        win.minsize(TODO_MIN_W, TODO_MIN_H)
        win.configure(bg="#E8F4FA")
        win.attributes("-topmost", True)
        self._register_window(win)

        saved_geom = load_todo_geometry()
        if saved_geom:
            # Gespeicherte Grösse übernehmen, aber immer zentrieren
            try:
                size_part = saved_geom.split("+")[0]
                w_saved, h_saved = [int(x) for x in size_part.split("x")]
            except (ValueError, IndexError):
                w_saved, h_saved = TODO_MIN_W, TODO_MIN_H
            win.geometry(f"{w_saved}x{h_saved}")
            center_window(win, w_saved, h_saved)
        else:
            win.geometry(f"{TODO_MIN_W}x{TODO_MIN_H}")
            center_window(win, TODO_MIN_W, TODO_MIN_H)

        _geom_after = [None]

        def _save_geom(event=None):
            if _geom_after[0]:
                win.after_cancel(_geom_after[0])
            _geom_after[0] = win.after(400, lambda: save_todo_geometry(win.geometry()))

        win.bind("<Configure>", _save_geom)

        # Aufnahme-State
        todo_recorder = [None]
        is_recording = [False]

        def on_close():
            if is_recording[0] and todo_recorder[0]:
                try:
                    is_recording[0] = False
                    wav_path = todo_recorder[0].stop_and_save_wav()
                    if os.path.exists(wav_path):
                        os.remove(wav_path)
                except Exception:
                    pass
                todo_recorder[0] = None
            if _notes_is_recording[0] and _notes_recorder[0]:
                try:
                    _notes_is_recording[0] = False
                    wav_path = _notes_recorder[0].stop_and_save_wav()
                    if os.path.exists(wav_path):
                        os.remove(wav_path)
                except Exception:
                    pass
                _notes_recorder[0] = None
            try:
                save_todo_geometry(win.geometry())
            except Exception:
                pass
            try:
                save_todo_settings({
                    "active_tab": _active_tab[0],
                    "active_category": _active_category[0],
                    "custom_categories": _custom_categories,
                })
            except Exception:
                pass
            if hasattr(self, "_aza_windows"):
                self._aza_windows.discard(win)
            win.destroy()

        win.protocol("WM_DELETE_WINDOW", on_close)

        todos = load_todos()
        todo_widgets = []

        # Inbox prüfen: empfangene Aufgaben importieren
        inbox = load_todo_inbox()
        my_name = self._user_profile.get("name", "")
        imported_count = 0
        remaining_inbox = []
        for inbox_item in inbox:
            if inbox_item.get("recipient", "") == my_name or not inbox_item.get("recipient"):
                new_todo = {
                    "id": inbox_item.get("id", int(datetime.now().timestamp() * 1000)),
                    "text": inbox_item.get("text", ""),
                    "done": False,
                    "date": inbox_item.get("date"),
                    "priority": inbox_item.get("priority", 0),
                    "notes": inbox_item.get("notes", ""),
                    "created": inbox_item.get("sent_at", datetime.now().isoformat()),
                    "sender": inbox_item.get("sender", ""),
                }
                todos.append(new_todo)
                imported_count += 1
            else:
                remaining_inbox.append(inbox_item)
        if imported_count > 0:
            save_todo_inbox(remaining_inbox)
            save_todos(todos)

        # ─── Header ───
        header = tk.Frame(win, bg="#B9ECFA")
        header.pack(fill="x")
        tk.Label(header, text="📋 To-do Liste", font=("Segoe UI", 14, "bold"),
                 bg="#B9ECFA", fg="#1a4d6d").pack(side="left", padx=12, pady=8)

        _todo_minimized = [False]
        _todo_geom_before = [None]
        _todo_restoring = [False]

        def _restore_todo_content():
            """Inhalt wiederherstellen (aus minimiertem Zustand)."""
            if not _todo_minimized[0]:
                return
            _todo_restoring[0] = True
            counter_bar.pack(fill="x", after=header)
            tab_bar.pack(fill="x", after=counter_bar)
            _all_pages[_active_tab[0]].pack(fill="both", expand=True, after=tab_bar)
            btn_minimize_todo.configure(text="—")
            _todo_minimized[0] = False
            win.minsize(500, 560)
            win.after(200, lambda: _todo_restoring.__setitem__(0, False))

        def _toggle_minimize_todo():
            if _todo_minimized[0]:
                _restore_todo_content()
                if _todo_geom_before[0]:
                    try:
                        win.geometry(_todo_geom_before[0])
                    except Exception:
                        pass
            else:
                _todo_geom_before[0] = win.geometry()
                for key, page in _all_pages.items():
                    page.pack_forget()
                tab_bar.pack_forget()
                counter_bar.pack_forget()
                btn_minimize_todo.configure(text="□")
                _todo_minimized[0] = True
                win.minsize(220, 50)
                w_cur = win.winfo_width()
                win.geometry(f"{w_cur}x50")

        def _on_todo_configure(e):
            if e.widget is not win:
                return
            if _todo_minimized[0] and not _todo_restoring[0] and e.height > 80:
                _restore_todo_content()

        win.bind("<Configure>", _on_todo_configure, add="+")

        btn_minimize_todo = tk.Label(header, text="—", font=("Segoe UI", 14, "bold"),
                                     bg="#B9ECFA", fg="#5A90B0", cursor="hand2", padx=6)
        btn_minimize_todo.pack(side="right", padx=(0, 8))
        btn_minimize_todo.bind("<Button-1>", lambda e: _toggle_minimize_todo())
        btn_minimize_todo.bind("<Enter>", lambda e: btn_minimize_todo.configure(fg="#1a4d6d"))
        btn_minimize_todo.bind("<Leave>", lambda e: btn_minimize_todo.configure(fg="#5A90B0"))

        win._aza_minimize = _toggle_minimize_todo
        win._aza_is_minimized = lambda: _todo_minimized[0]
        if hasattr(self, "_aza_windows"):
            self._aza_windows.add(win)

        todo_font_size_key = "todo_list"
        todo_font_size = [load_text_font_size(todo_font_size_key, 11)]

        _fs_fg = "#8AAFC0"
        _fs_fg_hover = "#1a4d6d"

        font_ctrl = tk.Frame(header, bg="#B9ECFA", highlightthickness=0, bd=0)
        font_ctrl.pack(side="right", padx=(0, 4), pady=6)
        tk.Label(font_ctrl, text="Aa", font=("Segoe UI", 8),
                 bg="#B9ECFA", fg=_fs_fg).pack(side="left", padx=(0, 1))

        _fs_size_lbl = tk.Label(font_ctrl, text=str(todo_font_size[0]),
                                font=("Segoe UI", 8), bg="#B9ECFA", fg=_fs_fg,
                                width=2, anchor="center")
        _fs_size_lbl.pack(side="left")

        def _update_todo_font(new_size):
            new_size = max(7, min(16, new_size))
            todo_font_size[0] = new_size
            _fs_size_lbl.configure(text=str(new_size))
            save_text_font_size(todo_font_size_key, new_size)
            rebuild_list()

        _fs_btn_up = tk.Label(font_ctrl, text="\u25B2", font=("Segoe UI", 7),
                              bg="#B9ECFA", fg=_fs_fg, cursor="hand2",
                              bd=0, highlightthickness=0, padx=0, pady=0)
        _fs_btn_up.pack(side="left", padx=(2, 0))

        _fs_btn_down = tk.Label(font_ctrl, text="\u25BC", font=("Segoe UI", 7),
                                bg="#B9ECFA", fg=_fs_fg, cursor="hand2",
                                bd=0, highlightthickness=0, padx=0, pady=0)
        _fs_btn_down.pack(side="left", padx=(0, 0))

        _fs_btn_up.bind("<Button-1>", lambda e: _update_todo_font(todo_font_size[0] + 1))
        _fs_btn_down.bind("<Button-1>", lambda e: _update_todo_font(todo_font_size[0] - 1))
        for _fsw in (_fs_btn_up, _fs_btn_down):
            _fsw.bind("<Enter>", lambda e, ww=_fsw: ww.configure(fg=_fs_fg_hover))
            _fsw.bind("<Leave>", lambda e, ww=_fsw: ww.configure(fg=_fs_fg))

        # Info-Button (ⓘ) für Diktat-Datumserkennung
        _info_popup = [None]

        def _show_diktat_info(event=None):
            if _info_popup[0] and _info_popup[0].winfo_exists():
                _info_popup[0].lift()
                return
            tip = tk.Toplevel(win)
            tip.title("🎤 Diktat-Datumserkennung")
            tip.attributes("-topmost", True)
            tip.configure(bg="#E8F4FA")
            tip.resizable(False, False)
            self._register_window(tip)

            def _close_info():
                _info_popup[0] = None
                tip.destroy()

            tip.protocol("WM_DELETE_WINDOW", _close_info)

            tip_header = tk.Frame(tip, bg="#B9ECFA")
            tip_header.pack(fill="x")
            tk.Label(tip_header, text="🎤 Datumserkennung beim Diktieren",
                     font=("Segoe UI", 10, "bold"), bg="#B9ECFA", fg="#1a4d6d",
                     anchor="w").pack(side="left", padx=10, pady=6)
            close_lbl = tk.Label(tip_header, text=" ✕ ", font=("Segoe UI", 11, "bold"),
                                 bg="#B9ECFA", fg="#999", cursor="hand2")
            close_lbl.pack(side="right", padx=6, pady=6)
            close_lbl.bind("<Button-1>", lambda e: _close_info())
            close_lbl.bind("<Enter>", lambda e: close_lbl.configure(fg="#E87070"))
            close_lbl.bind("<Leave>", lambda e: close_lbl.configure(fg="#999"))

            inner = tk.Frame(tip, bg="white", padx=12, pady=8)
            inner.pack(fill="both", expand=True, padx=1, pady=(0, 1))

            tk.Label(inner, text="Datum im Diktat wird automatisch erkannt und gesetzt:",
                     font=("Segoe UI", 8), bg="white", fg="#666",
                     anchor="w").pack(fill="x", pady=(0, 6))

            table = tk.Frame(inner, bg="white")
            table.pack(fill="x")

            headers = ["Beispiel-Diktat", "Erkanntes Datum"]
            for c, h in enumerate(headers):
                tk.Label(table, text=h, font=("Segoe UI", 8, "bold"), bg="#E8F4FA",
                         fg="#1a4d6d", padx=6, pady=2, anchor="w").grid(row=0, column=c, sticky="ew", padx=1, pady=1)

            examples = [
                ("«…bis morgen»", "morgen"),
                ("«…bis nächsten Mittwoch»", "nächster Mi"),
                ("«…bis 20. März»", "20.03."),
                ("«…in 3 Tagen»", "+3 Tage"),
                ("«…bis Ende Woche»", "Freitag"),
                ("«…bis Ende Monat»", "Monatsende"),
                ("«…am 15.4.»", "15.04."),
                ("«…übermorgen»", "übermorgen"),
                ("«…in einer Woche»", "+1 Woche"),
                ("«…in zwei Monaten»", "+2 Monate"),
            ]
            for r, (ex, dt_txt) in enumerate(examples, start=1):
                bg_r = "#F5FCFF" if r % 2 == 0 else "white"
                tk.Label(table, text=ex, font=("Segoe UI", 8), bg=bg_r,
                         fg="#1a4d6d", padx=6, pady=1, anchor="w").grid(row=r, column=0, sticky="ew", padx=1)
                tk.Label(table, text=dt_txt, font=("Segoe UI", 8, "bold"), bg=bg_r,
                         fg="#5B8DB3", padx=6, pady=1, anchor="w").grid(row=r, column=1, sticky="ew", padx=1)

            tip.update_idletasks()
            x = win.winfo_rootx() + info_btn.winfo_x()
            y = win.winfo_rooty() + info_btn.winfo_y() + info_btn.winfo_height() + 4
            tip.geometry(f"+{max(0, x)}+{y}")

            _info_popup[0] = tip

        info_btn = tk.Label(header, text=" ⓘ ", font=("Segoe UI", 11, "bold"),
                            bg="#7EC8E3", fg="white", cursor="hand2",
                            relief="flat", bd=0, padx=4, pady=2)
        info_btn.pack(side="right", padx=(0, 8), pady=8)
        info_btn.bind("<Button-1>", _show_diktat_info)
        info_btn.bind("<Enter>", lambda e: info_btn.configure(bg="#5B8DB3"))
        info_btn.bind("<Leave>", lambda e: info_btn.configure(bg="#7EC8E3"))

        # 📱 iPhone-App-Button (startet Webserver + zeigt QR-Code)
        _todo_server_thread = [None]
        _todo_server_running = [False]

        def _start_todo_server():
            if _todo_server_running[0]:
                _show_qr_window()
                return
            try:
                from todo_server import _get_local_ip, PORT, TodoHandler, TodoServer, _add_firewall_rule, _supabase_push
                import urllib.request
                local_ip = _get_local_ip()
                url = f"http://{local_ip}:{PORT}"

                # Todos nach Supabase pushen
                try:
                    _supabase_push(todos)
                except Exception:
                    pass

                # Firewall-Regel
                _add_firewall_rule()

                _server_ref = [None]
                _server_error = [None]
                _server_ready = threading.Event()

                def run_server():
                    try:
                        server = TodoServer(("0.0.0.0", PORT), TodoHandler)
                        _server_ref[0] = server
                        _server_ready.set()
                        server.serve_forever()
                    except Exception as e:
                        _server_error[0] = str(e)
                        _server_ready.set()

                t = threading.Thread(target=run_server, daemon=True)
                t.start()
                _todo_server_thread[0] = t
                _server_ready.wait(timeout=3)

                if _server_error[0]:
                    messagebox.showerror(
                        "Server-Fehler",
                        f"Server konnte nicht starten:\n{_server_error[0]}\n\n"
                        f"Evtl. Port {PORT} belegt – Programm neu starten.",
                        parent=win)
                    return

                test_ok = False
                try:
                    resp = urllib.request.urlopen(f"http://localhost:{PORT}/", timeout=3)
                    if resp.status == 200:
                        test_ok = True
                except Exception:
                    pass

                if not test_ok:
                    messagebox.showerror(
                        "Server-Fehler",
                        "Server gestartet, antwortet aber nicht.\n"
                        "Bitte Programm neu starten und erneut versuchen.",
                        parent=win)
                    return

                _todo_server_running[0] = True
                phone_btn.configure(bg="#5BDB7B")

                win.after(300, lambda: _show_qr_window(url))
            except Exception as e:
                messagebox.showerror(
                    "Fehler beim Starten",
                    f"Der To-Do-Server konnte nicht gestartet werden.\n\n"
                    f"Fehler: {e}",
                    parent=win)

        def _show_qr_window(url=None):
            if url is None:
                try:
                    from todo_server import _get_local_ip, PORT
                    url = f"http://{_get_local_ip()}:{PORT}"
                except Exception:
                    return

            try:
                qr_win = tk.Toplevel(win)
                qr_win.title("📱 iPhone To-Do App")
                qr_win.attributes("-topmost", True)
                qr_win.configure(bg="#E8F4FA")
                qr_win.resizable(False, False)
                qr_win.geometry("360x660")
                center_window(qr_win, 360, 660)
                self._register_window(qr_win)

                tk.Label(qr_win, text="📱 AzA To-Do – iPhone App", font=("Segoe UI", 14, "bold"),
                         bg="#B9ECFA", fg="#1a4d6d").pack(fill="x", ipady=10)

                # Cloud-Status
                cloud_frame = tk.Frame(qr_win, bg="#EDF7ED", padx=10, pady=4)
                cloud_frame.pack(fill="x", padx=16, pady=(8, 0))
                tk.Label(cloud_frame,
                         text="☁ Supabase Cloud-Sync aktiv – App funktioniert weltweit!",
                         font=("Segoe UI", 9, "bold"),
                         bg="#EDF7ED", fg="#2A7A2A").pack(anchor="w")
                tk.Label(cloud_frame,
                         text="Die App synchronisiert automatisch, egal ob\n"
                              "WLAN, 5G, unterwegs – von überall auf der Welt.\n"
                              "Kein laufender PC nötig!",
                         font=("Segoe UI", 8), bg="#EDF7ED", fg="#2A7A2A",
                         justify="left").pack(anchor="w")

                tk.Label(qr_win, text="Schritt 1: QR-Code scannen (einmalig, im WLAN):",
                         font=("Segoe UI", 10, "bold"), bg="#E8F4FA", fg="#1a4d6d"
                         ).pack(fill="x", padx=16, pady=(10, 4))

                qr_frame = tk.Frame(qr_win, bg="white", padx=10, pady=10)
                qr_frame.pack(pady=4)

                qr_generated = False
                try:
                    import qrcode
                    from PIL import ImageTk
                    img = qrcode.make(url, box_size=6, border=2)
                    img_tk = ImageTk.PhotoImage(img)
                    qr_label = tk.Label(qr_frame, image=img_tk, bg="white")
                    qr_label.image = img_tk
                    qr_label.pack()
                    qr_generated = True
                except Exception:
                    pass

                if not qr_generated:
                    tk.Label(qr_frame,
                             text="QR-Code nicht verfügbar.\n\n"
                                  "Bitte installieren:\n"
                                  "py -3.11 -m pip install qrcode[pil]\n\n"
                                  "Alternativ diese URL im\n"
                                  "iPhone-Browser öffnen:",
                             font=("Segoe UI", 9), bg="white", fg="#C03030",
                             justify="center").pack(padx=20, pady=10)

                url_label = tk.Label(qr_win, text=url, font=("Segoe UI", 11, "bold"),
                                    bg="#E8F4FA", fg="#5B8DB3", cursor="hand2")
                url_label.pack(pady=2)

                tk.Label(qr_win, text="Schritt 2: Auf dem iPhone → Teilen → Zum\n"
                         "Home-Bildschirm hinzufügen (AzA-Logo erscheint!)",
                         font=("Segoe UI", 9, "bold"), bg="#E8F4FA", fg="#1a4d6d",
                         justify="center").pack(padx=16, pady=(4, 2))

                tk.Label(qr_win, text="Danach funktioniert die App eigenständig –\n"
                         "auch ohne WLAN, von überall auf der Welt!",
                         font=("Segoe UI", 8), bg="#E8F4FA", fg="#4a8aaa",
                         justify="center").pack(padx=16, pady=(0, 4))

                # Server-Status
                status_bg = "#EDF7ED" if _todo_server_running[0] else "#FDECEC"
                status_fg = "#2A7A2A" if _todo_server_running[0] else "#C03030"
                status_txt = "● Server läuft (für Ersteinrichtung)" if _todo_server_running[0] \
                    else "● Server nicht gestartet"
                tk.Label(qr_win, text=status_txt, font=("Segoe UI", 9, "bold"),
                         bg=status_bg, fg=status_fg).pack(fill="x", padx=16, ipady=3, pady=(2, 0))

                # Firewall-Hilfe
                help_frame = tk.Frame(qr_win, bg="#FFF8E0", padx=10, pady=3)
                help_frame.pack(fill="x", padx=16, pady=(4, 0))
                tk.Label(help_frame,
                         text="Falls iPhone nicht verbindet: Firewall öffnen\n"
                              "→ Python bei Privat + Öffentlich anhaken",
                         font=("Segoe UI", 7), bg="#FFF8E0", fg="#806000",
                         justify="left").pack(anchor="w")

                def _open_firewall_settings():
                    try:
                        os.startfile("firewall.cpl")
                    except Exception:
                        pass

                def _open_in_browser():
                    import webbrowser
                    webbrowser.open(url)

                def _close_qr():
                    qr_win.destroy()

                btn_row = tk.Frame(qr_win, bg="#E8F4FA")
                btn_row.pack(pady=6)
                tk.Button(btn_row, text="🔥 Firewall", font=("Segoe UI", 8),
                          bg="#F0D060", fg="#604000", activebackground="#E0C050",
                          relief="flat", padx=8, pady=2, cursor="hand2",
                          command=_open_firewall_settings).pack(side="left", padx=3)
                tk.Button(btn_row, text="🌐 Browser testen", font=("Segoe UI", 8),
                          bg="#7EC8E3", fg="#1a4d6d", activebackground="#6CB8D3",
                          relief="flat", padx=8, pady=2, cursor="hand2",
                          command=_open_in_browser).pack(side="left", padx=3)
                tk.Button(btn_row, text="Schliessen", font=("Segoe UI", 8),
                          bg="#C8DDE6", fg="#1a4d6d", activebackground="#B8CDD6",
                          relief="flat", padx=8, pady=2, cursor="hand2",
                          command=_close_qr).pack(side="left", padx=3)
            except Exception as e:
                messagebox.showerror("Fehler", f"QR-Fenster konnte nicht geöffnet werden:\n{e}", parent=win)

        phone_btn = tk.Label(header, text=" 📱 ", font=("Segoe UI", 11, "bold"),
                             bg="#7EC8E3", fg="white", cursor="hand2",
                             relief="flat", bd=0, padx=4, pady=2)
        phone_btn.pack(side="right", padx=(0, 4), pady=8)
        phone_btn.bind("<Button-1>", lambda e: _start_todo_server())
        phone_btn.bind("<Enter>", lambda e: phone_btn.configure(
            bg="#5BDB7B" if _todo_server_running[0] else "#5B8DB3"))
        phone_btn.bind("<Leave>", lambda e: phone_btn.configure(
            bg="#5BDB7B" if _todo_server_running[0] else "#7EC8E3"))

        counter_bar = tk.Frame(win, bg="#B9ECFA")
        counter_bar.pack(fill="x")
        counter_label = tk.Label(counter_bar, text="", font=("Segoe UI", 9),
                                 bg="#B9ECFA", fg="#4a8aaa")
        counter_label.pack(side="left", padx=12, pady=(0, 4))

        # ─── Gespeicherte Todo-Einstellungen laden ───
        _todo_settings = load_todo_settings()
        _saved_tab = _todo_settings.get("active_tab", "todo")
        _saved_category = _todo_settings.get("active_category", "Allgemein")
        _custom_categories = _todo_settings.get("custom_categories", [])
        _DEFAULT_CATEGORIES = ["Allgemein", "MPA", "Ärzte"]

        def _build_category_list():
            return _DEFAULT_CATEGORIES + _custom_categories + ["Alle"]

        # ─── Tab-Leiste (Aufgaben / Notizen / Checkliste) ───
        tab_bar = tk.Frame(win, bg="#A8D8E8")
        tab_bar.pack(fill="x")

        _active_tab = [_saved_tab if _saved_tab in ("todo", "notes", "checklist") else "todo"]

        todo_page = tk.Frame(win, bg="#E8F4FA")
        notes_page = tk.Frame(win, bg="#E8F4FA")
        checklist_page = tk.Frame(win, bg="#E8F4FA")

        _tab_btn_style_active = {"bg": "#E8F4FA", "fg": "#1a4d6d", "font": ("Segoe UI", 10, "bold")}
        _tab_btn_style_inactive = {"bg": "#A8D8E8", "fg": "#5A90B0", "font": ("Segoe UI", 10)}

        tab_btn_todo = tk.Label(tab_bar, text="📋 Aufgaben", cursor="hand2",
                                padx=16, pady=6, **(_tab_btn_style_active if _active_tab[0] == "todo" else _tab_btn_style_inactive))
        tab_btn_todo.pack(side="left")

        tab_btn_notes = tk.Label(tab_bar, text="📝 Notizen", cursor="hand2",
                                 padx=16, pady=6, **(_tab_btn_style_active if _active_tab[0] == "notes" else _tab_btn_style_inactive))
        tab_btn_notes.pack(side="left")

        tab_btn_checklist = tk.Label(tab_bar, text="✅ Checkliste", cursor="hand2",
                                     padx=16, pady=6, **(_tab_btn_style_active if _active_tab[0] == "checklist" else _tab_btn_style_inactive))
        tab_btn_checklist.pack(side="left")

        _all_tab_btns = {"todo": tab_btn_todo, "notes": tab_btn_notes, "checklist": tab_btn_checklist}
        _all_pages = {"todo": todo_page, "notes": notes_page, "checklist": checklist_page}

        def _switch_tab(tab_name):
            _active_tab[0] = tab_name
            for key, btn in _all_tab_btns.items():
                btn.configure(**((_tab_btn_style_active if key == tab_name else _tab_btn_style_inactive)))
            for key, page in _all_pages.items():
                page.pack_forget()
            _all_pages[tab_name].pack(fill="both", expand=True)
            if tab_name == "notes":
                _rebuild_notes_list()
            elif tab_name == "checklist":
                _rebuild_checklist()

        tab_btn_todo.bind("<Button-1>", lambda e: _switch_tab("todo"))
        tab_btn_notes.bind("<Button-1>", lambda e: _switch_tab("notes"))
        tab_btn_checklist.bind("<Button-1>", lambda e: _switch_tab("checklist"))

        _all_pages[_active_tab[0]].pack(fill="both", expand=True)
        _need_initial_rebuild = [_active_tab[0]]

        # ─── Aufgabenbereiche (Kategorie-Filter) ───
        _TODO_CATEGORIES = _build_category_list()
        _initial_cat = _saved_category if _saved_category in _TODO_CATEGORIES else "Allgemein"
        _active_category = [_initial_cat]

        cat_bar = tk.Frame(todo_page, bg="#D4EEF7", pady=2, padx=8)
        cat_bar.pack(fill="x")
        tk.Label(cat_bar, text="Bereich:", font=("Segoe UI", 8),
                 bg="#D4EEF7", fg="#5A90B0").pack(side="left", padx=(0, 4))

        _cat_btns_frame = tk.Frame(cat_bar, bg="#D4EEF7")
        _cat_btns_frame.pack(side="left", fill="x", expand=True)

        _cat_btns = {}
        _cat_active_style = {"bg": "#5B8DB3", "fg": "white"}
        _cat_inactive_style = {"bg": "#C8DDE6", "fg": "#1a4d6d"}

        def _set_category_filter(cat):
            _active_category[0] = cat
            for c, b in _cat_btns.items():
                if c == cat:
                    b.configure(**_cat_active_style)
                else:
                    b.configure(**_cat_inactive_style)
            rebuild_list()

        def _rebuild_cat_buttons():
            for w in _cat_btns_frame.winfo_children():
                w.destroy()
            _cat_btns.clear()
            _TODO_CATEGORIES.clear()
            _TODO_CATEGORIES.extend(_build_category_list())
            if _active_category[0] not in _TODO_CATEGORIES:
                _active_category[0] = "Allgemein"
            for cat in _TODO_CATEGORIES:
                style = _cat_active_style if cat == _active_category[0] else _cat_inactive_style
                b = tk.Label(_cat_btns_frame, text=cat, font=("Segoe UI", 8),
                             cursor="hand2", padx=8, pady=2, relief="flat", bd=0,
                             **style)
                b.pack(side="left", padx=1)
                b.bind("<Button-1>", lambda e, c=cat: _set_category_filter(c))
                _cat_btns[cat] = b
            _update_cat_combobox()

        def _add_custom_category():
            dlg = tk.Toplevel(win)
            dlg.title("Neuen Bereich erstellen")
            dlg.configure(bg="#E8F4FA")
            dlg.resizable(False, False)
            dlg.attributes("-topmost", True)
            dlg.grab_set()
            center_window(dlg, 320, 130)
            self._register_window(dlg)

            tk.Label(dlg, text="Name des neuen Bereichs:",
                     font=("Segoe UI", 10), bg="#E8F4FA", fg="#1a4d6d").pack(padx=16, pady=(12, 4))
            name_var = tk.StringVar()
            name_entry = tk.Entry(dlg, textvariable=name_var, font=("Segoe UI", 10),
                                  bg="white", fg="#1a4d6d", relief="flat", bd=0,
                                  insertbackground="#1a4d6d")
            name_entry.pack(padx=16, fill="x", ipady=4)
            name_entry.focus_set()

            btn_row = tk.Frame(dlg, bg="#E8F4FA")
            btn_row.pack(pady=10)

            def _do_add():
                name = name_var.get().strip()
                if not name:
                    return
                all_cats = _DEFAULT_CATEGORIES + _custom_categories + ["Alle"]
                if name in all_cats:
                    messagebox.showwarning("Bereich existiert",
                                           f"Der Bereich «{name}» existiert bereits.",
                                           parent=dlg)
                    return
                _custom_categories.append(name)
                _rebuild_cat_buttons()
                _set_category_filter(name)
                dlg.destroy()

            name_entry.bind("<Return>", lambda e: _do_add())
            tk.Button(btn_row, text="Erstellen", font=("Segoe UI", 9, "bold"),
                      bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                      activeforeground="white", relief="flat", bd=0,
                      padx=12, pady=2, cursor="hand2",
                      command=_do_add).pack(side="left", padx=4)
            tk.Button(btn_row, text="Abbrechen", font=("Segoe UI", 9),
                      bg="#C8DDE6", fg="#1a4d6d", activebackground="#B8CDD6",
                      relief="flat", bd=0, padx=12, pady=2, cursor="hand2",
                      command=dlg.destroy).pack(side="left", padx=4)

        def _remove_custom_category():
            removable = [c for c in _custom_categories]
            if not removable:
                messagebox.showinfo("Keine eigenen Bereiche",
                                    "Es gibt keine selbst erstellten Bereiche zum Entfernen.\n"
                                    "Die Standardbereiche (Allgemein, MPA, Ärzte, Alle) können nicht entfernt werden.",
                                    parent=win)
                return

            dlg = tk.Toplevel(win)
            dlg.title("Bereich entfernen")
            dlg.configure(bg="#E8F4FA")
            dlg.resizable(False, False)
            dlg.attributes("-topmost", True)
            dlg.grab_set()
            center_window(dlg, 320, 160)
            self._register_window(dlg)

            tk.Label(dlg, text="Welchen Bereich möchten Sie entfernen?",
                     font=("Segoe UI", 10), bg="#E8F4FA", fg="#1a4d6d").pack(padx=16, pady=(12, 4))

            sel_var = tk.StringVar(value=removable[0])
            combo = ttk.Combobox(dlg, textvariable=sel_var, values=removable,
                                 state="readonly", font=("Segoe UI", 10), width=20)
            combo.pack(padx=16, pady=4)

            btn_row = tk.Frame(dlg, bg="#E8F4FA")
            btn_row.pack(pady=10)

            def _do_remove():
                name = sel_var.get()
                if not name:
                    return
                confirm = messagebox.askyesno(
                    "Bereich entfernen",
                    f"Möchten Sie den Bereich «{name}» wirklich entfernen?\n\n"
                    f"Die Aufgaben in diesem Bereich werden nicht gelöscht,\n"
                    f"sondern in «Allgemein» verschoben.",
                    parent=dlg)
                if not confirm:
                    return
                _custom_categories.remove(name)
                for todo in todos:
                    if todo.get("category") == name:
                        todo["category"] = "Allgemein"
                save_todos(todos)
                if _active_category[0] == name:
                    _active_category[0] = "Allgemein"
                _rebuild_cat_buttons()
                rebuild_list()
                dlg.destroy()

            tk.Button(btn_row, text="Entfernen", font=("Segoe UI", 9, "bold"),
                      bg="#E87070", fg="white", activebackground="#D06060",
                      activeforeground="white", relief="flat", bd=0,
                      padx=12, pady=2, cursor="hand2",
                      command=_do_remove).pack(side="left", padx=4)
            tk.Button(btn_row, text="Abbrechen", font=("Segoe UI", 9),
                      bg="#C8DDE6", fg="#1a4d6d", activebackground="#B8CDD6",
                      relief="flat", bd=0, padx=12, pady=2, cursor="hand2",
                      command=dlg.destroy).pack(side="left", padx=4)

        _cat_pm_frame = tk.Frame(cat_bar, bg="#D4EEF7")
        _cat_pm_frame.pack(side="right")

        _plus_btn = tk.Label(_cat_pm_frame, text="＋", font=("Segoe UI", 9, "bold"),
                             bg="#D4EEF7", fg="#5B8DB3", cursor="hand2", padx=2)
        _plus_btn.pack(side="left")
        _plus_btn.bind("<Button-1>", lambda e: _add_custom_category())
        _plus_btn.bind("<Enter>", lambda e: _plus_btn.configure(fg="#1a4d6d"))
        _plus_btn.bind("<Leave>", lambda e: _plus_btn.configure(fg="#5B8DB3"))

        _minus_btn = tk.Label(_cat_pm_frame, text="−", font=("Segoe UI", 9, "bold"),
                              bg="#D4EEF7", fg="#5B8DB3", cursor="hand2", padx=2)
        _minus_btn.pack(side="left")
        _minus_btn.bind("<Button-1>", lambda e: _remove_custom_category())
        _minus_btn.bind("<Enter>", lambda e: _minus_btn.configure(fg="#E87070"))
        _minus_btn.bind("<Leave>", lambda e: _minus_btn.configure(fg="#5B8DB3"))

        # ─── Eingabebereich ───
        input_frame = tk.Frame(todo_page, bg="#D4EEF7", pady=8, padx=8)
        input_frame.pack(fill="x")

        # Zeile 1: Textfeld + Aufnahme-Button
        entry_frame = tk.Frame(input_frame, bg="#D4EEF7")
        entry_frame.pack(fill="x")

        entry_var = tk.StringVar()
        entry = tk.Entry(entry_frame, textvariable=entry_var, font=("Segoe UI", 11),
                         bg="white", fg="#1a4d6d", relief="flat", bd=0,
                         insertbackground="#1a4d6d")
        entry.pack(side="left", fill="x", expand=True, ipady=6, padx=(0, 6))
        entry.insert(0, "Neue Aufgabe eingeben oder diktieren…")
        entry.configure(fg="#999")

        def on_entry_focus_in(e):
            if entry.get() == "Neue Aufgabe eingeben oder diktieren…":
                entry.delete(0, "end")
                entry.configure(fg="#1a4d6d")

        def on_entry_focus_out(e):
            if not entry.get().strip():
                entry.insert(0, "Neue Aufgabe eingeben oder diktieren…")
                entry.configure(fg="#999")

        entry.bind("<FocusIn>", on_entry_focus_in)
        entry.bind("<FocusOut>", on_entry_focus_out)

        # Aufnahme-Button
        rec_btn = tk.Button(entry_frame, text="⏺", font=("Segoe UI", 14),
                            bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                            activeforeground="white", relief="flat", bd=0,
                            width=3, cursor="hand2")
        rec_btn.pack(side="right")

        rec_status_var = tk.StringVar(value="")
        rec_status_label = tk.Label(input_frame, textvariable=rec_status_var,
                                    font=("Segoe UI", 8), bg="#D4EEF7", fg="#5B8DB3")
        rec_status_label.pack(fill="x")

        def toggle_todo_record():
            if not self.ensure_ready():
                return
            if not is_recording[0]:
                rec = AudioRecorder()
                todo_recorder[0] = rec
                try:
                    rec.start()
                    is_recording[0] = True
                    rec_btn.configure(text="⏹", bg="#C03030", activebackground="#A02020")
                    rec_status_var.set("🔴 Aufnahme läuft… Klicken zum Stoppen.")
                except Exception as e:
                    messagebox.showerror("Aufnahme-Fehler", str(e), parent=win)
                    rec_status_var.set("")
            else:
                is_recording[0] = False
                rec = todo_recorder[0]
                rec_btn.configure(text="⏺", bg="#5B8DB3", activebackground="#4A7A9E")
                rec_status_var.set("Transkribiere…")

                def worker():
                    try:
                        wav_path = rec.stop_and_save_wav()
                        import wave
                        try:
                            with wave.open(wav_path, 'rb') as wf:
                                dur = wf.getnframes() / float(wf.getframerate())
                                if dur < 0.3:
                                    if os.path.exists(wav_path):
                                        os.remove(wav_path)
                                    todo_recorder[0] = None
                                    self.after(0, lambda: rec_status_var.set("Kein Audio erkannt."))
                                    return
                        except Exception:
                            pass
                        transcript_result = self.transcribe_wav(wav_path)
                        if hasattr(transcript_result, 'text'):
                            text = transcript_result.text
                        elif isinstance(transcript_result, str):
                            text = transcript_result
                        else:
                            text = ""
                        try:
                            if os.path.exists(wav_path):
                                os.remove(wav_path)
                        except Exception:
                            pass
                        if not text or not text.strip():
                            todo_recorder[0] = None
                            self.after(0, lambda: rec_status_var.set("Kein Text erkannt."))
                            return
                        text = self._diktat_apply_punctuation(text)
                        cleaned_text, extracted_date = extract_date_from_todo_text(text)
                        def _done(ct=cleaned_text, ed=extracted_date):
                            todo_recorder[0] = None
                            current = entry_var.get()
                            if current == "Neue Aufgabe eingeben oder diktieren…":
                                current = ""
                            new_text = (current + " " + ct).strip() if current.strip() else ct.strip()
                            entry_var.set(new_text)
                            entry.configure(fg="#1a4d6d")
                            entry.icursor("end")
                            if ed:
                                set_date(ed)
                                rec_status_var.set(f"✓ Diktiert – Datum erkannt: {ed.strftime('%d.%m.%Y')}")
                            else:
                                rec_status_var.set("✓ Diktiert – bei Bedarf bearbeiten, dann hinzufügen.")
                        self.after(0, _done)
                    except Exception as e:
                        self.after(0, lambda: rec_status_var.set(f"Fehler: {e}"))
                        todo_recorder[0] = None

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

        rec_btn.configure(command=toggle_todo_record)

        # Zeile 2: Datum (Kalender) + Hinzufügen
        date_frame = tk.Frame(input_frame, bg="#D4EEF7")
        date_frame.pack(fill="x", pady=(4, 0))

        tk.Label(date_frame, text="Fällig:", font=("Segoe UI", 9),
                 bg="#D4EEF7", fg="#4a8aaa").pack(side="left")

        selected_date = [None]

        date_display = tk.Label(date_frame, text="kein Datum", font=("Segoe UI", 10),
                                bg="#D4EEF7", fg="#999")
        date_display.pack(side="left", padx=(4, 4))

        def set_date(d):
            selected_date[0] = d
            if d:
                date_display.configure(text=d.strftime("%d.%m.%Y"), fg="#1a4d6d")
            else:
                date_display.configure(text="kein Datum", fg="#999")

        def clear_date():
            set_date(None)

        # ─── Kalender-Popup ───
        def open_calendar():
            cal_win = tk.Toplevel(win)
            cal_win.title("Datum wählen")
            cal_win.attributes("-topmost", True)
            cal_win.configure(bg="#E8F4FA")
            cal_win.resizable(False, False)
            self._register_window(cal_win)

            today = date.today()
            current = [selected_date[0].year if selected_date[0] else today.year,
                       selected_date[0].month if selected_date[0] else today.month]

            nav = tk.Frame(cal_win, bg="#B9ECFA")
            nav.pack(fill="x")

            month_label = tk.Label(nav, text="", font=("Segoe UI", 11, "bold"),
                                   bg="#B9ECFA", fg="#1a4d6d")

            def update_cal():
                month_label.configure(
                    text=f"{cal_mod.month_name[current[1]]} {current[0]}")
                for w in days_frame.winfo_children():
                    w.destroy()
                weekdays = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
                for c, wd in enumerate(weekdays):
                    fg = "#C03030" if c >= 5 else "#4a8aaa"
                    tk.Label(days_frame, text=wd, font=("Segoe UI", 9, "bold"),
                             bg="#E8F4FA", fg=fg, width=4).grid(row=0, column=c)
                first_wd, num_days = cal_mod.monthrange(current[0], current[1])
                row = 1
                col = first_wd
                for day in range(1, num_days + 1):
                    d = date(current[0], current[1], day)
                    is_today = (d == today)
                    is_selected = (d == selected_date[0])
                    is_past = (d < today)
                    if is_selected:
                        bg, fg = "#5B8DB3", "white"
                    elif is_today:
                        bg, fg = "#D4EEF7", "#1a4d6d"
                    else:
                        bg, fg = "#F5FCFF", ("#999" if is_past else "#1a4d6d")
                    btn = tk.Label(days_frame, text=str(day), font=("Segoe UI", 10),
                                   bg=bg, fg=fg, width=4, cursor="hand2",
                                   relief="flat", bd=0)
                    btn.grid(row=row, column=col, padx=1, pady=1)
                    btn.bind("<Button-1>", lambda e, dd=d: (set_date(dd), cal_win.destroy()))
                    btn.bind("<Enter>", lambda e, b=btn: b.configure(bg="#B9ECFA") if b.cget("bg") not in ("#5B8DB3",) else None)
                    btn.bind("<Leave>", lambda e, b=btn, bg0=bg: b.configure(bg=bg0))
                    col += 1
                    if col > 6:
                        col = 0
                        row += 1

            def prev_month():
                current[1] -= 1
                if current[1] < 1:
                    current[1] = 12
                    current[0] -= 1
                update_cal()

            def next_month():
                current[1] += 1
                if current[1] > 12:
                    current[1] = 1
                    current[0] += 1
                update_cal()

            btn_prev = tk.Label(nav, text="◀", font=("Segoe UI", 12), bg="#B9ECFA",
                                fg="#1a4d6d", cursor="hand2", padx=8)
            btn_prev.pack(side="left")
            btn_prev.bind("<Button-1>", lambda e: prev_month())

            month_label.pack(side="left", fill="x", expand=True)

            btn_next = tk.Label(nav, text="▶", font=("Segoe UI", 12), bg="#B9ECFA",
                                fg="#1a4d6d", cursor="hand2", padx=8)
            btn_next.pack(side="right")
            btn_next.bind("<Button-1>", lambda e: next_month())

            days_frame = tk.Frame(cal_win, bg="#E8F4FA", padx=4, pady=4)
            days_frame.pack(fill="both")

            # Schnellauswahl
            quick = tk.Frame(cal_win, bg="#D4EEF7", pady=4)
            quick.pack(fill="x")
            for label_text, delta in [("Heute", 0), ("Morgen", 1), ("+1 Wo", 7)]:
                d = today + timedelta(days=delta)
                tk.Button(quick, text=label_text, font=("Segoe UI", 8),
                          bg="#C8DDE6", fg="#1a4d6d", activebackground="#B8CDD6",
                          relief="flat", bd=0, padx=6, pady=1, cursor="hand2",
                          command=lambda dd=d: (set_date(dd), cal_win.destroy())
                          ).pack(side="left", padx=2)
            tk.Button(quick, text="Kein Datum", font=("Segoe UI", 8),
                      bg="#E0E0E0", fg="#666", activebackground="#D0D0D0",
                      relief="flat", bd=0, padx=6, pady=1, cursor="hand2",
                      command=lambda: (clear_date(), cal_win.destroy())
                      ).pack(side="right", padx=2)

            update_cal()

            cal_win.update_idletasks()
            x = win.winfo_x() + 50
            y = win.winfo_y() + 120
            cal_win.geometry(f"+{x}+{y}")

        cal_btn = tk.Button(date_frame, text="📅", font=("Segoe UI", 12),
                            bg="#D4EEF7", fg="#1a4d6d", activebackground="#C4DEE7",
                            relief="flat", bd=0, cursor="hand2", command=open_calendar)
        cal_btn.pack(side="left", padx=(0, 4))

        clear_date_btn = tk.Label(date_frame, text="✕", font=("Segoe UI", 9),
                                  bg="#D4EEF7", fg="#ccc", cursor="hand2")
        clear_date_btn.pack(side="left")
        clear_date_btn.bind("<Button-1>", lambda e: clear_date())
        clear_date_btn.bind("<Enter>", lambda e: clear_date_btn.configure(fg="#E87070"))
        clear_date_btn.bind("<Leave>", lambda e: clear_date_btn.configure(fg="#ccc"))

        def _get_new_todo_category():
            cat = _active_category[0]
            return "Allgemein" if cat == "Alle" else cat

        def _update_cat_combobox():
            pass

        _rebuild_cat_buttons()

        add_btn = tk.Button(date_frame, text="＋ Hinzufügen", font=("Segoe UI", 10, "bold"),
                            bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                            activeforeground="white", relief="flat", bd=0, padx=12, pady=2,
                            cursor="hand2")
        add_btn.pack(side="right", padx=(0, 8))

        # ─── Scrollbarer Bereich für To-dos ───
        list_outer = tk.Frame(todo_page, bg="#E8F4FA")
        list_outer.pack(fill="both", expand=True, padx=8, pady=(4, 0))

        canvas = tk.Canvas(list_outer, bg="#E8F4FA", highlightthickness=0)
        scrollbar = ttk.Scrollbar(list_outer, orient="vertical", command=canvas.yview)
        list_frame = tk.Frame(canvas, bg="#E8F4FA")

        list_frame.bind("<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
        canvas.create_window((0, 0), window=list_frame, anchor="nw", tags="list_win")
        canvas.configure(yscrollcommand=scrollbar.set)

        def _resize_list(event):
            canvas.itemconfig("list_win", width=event.width)

        canvas.bind("<Configure>", _resize_list)
        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")

        def _on_mousewheel(event):
            canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")

        def _bind_mousewheel_recursive(widget):
            """Bindet Mausrad-Scrolling an Widget und alle Kinder (rekursiv)."""
            widget.bind("<MouseWheel>", _on_mousewheel)
            for child in widget.winfo_children():
                _bind_mousewheel_recursive(child)

        canvas.bind("<MouseWheel>", _on_mousewheel)
        list_frame.bind("<MouseWheel>", _on_mousewheel)

        # ─── Fusszeile ───
        footer = tk.Frame(todo_page, bg="#D4EEF7", pady=4)
        footer.pack(fill="x", side="bottom")

        btn_del_done = tk.Button(footer, text="🗑 Erledigte löschen", font=("Segoe UI", 9),
                                 bg="#C8DDE6", fg="#1a4d6d", activebackground="#B8CDD6",
                                 relief="flat", bd=0, padx=8, pady=2, cursor="hand2")
        btn_del_done.pack(side="left", padx=8)

        btn_email = tk.Button(footer, text="✉ E-Mail senden", font=("Segoe UI", 9),
                              bg="#A8D8E8", fg="#1a4d6d", activebackground="#98C8D8",
                              relief="flat", bd=0, padx=8, pady=2, cursor="hand2")
        btn_email.pack(side="right", padx=(0, 8))

        btn_medwork = tk.Button(footer, text="📤 An MedWork senden", font=("Segoe UI", 9),
                                bg="#7EC8E3", fg="#1a4d6d", activebackground="#6CB8D3",
                                relief="flat", bd=0, padx=8, pady=2, cursor="hand2")
        btn_medwork.pack(side="right", padx=(0, 4))

        # Senden-Auswahl (Häkchen-Tracking)
        send_selection = {}  # idx -> BooleanVar

        # MedWork-Kontakte (erweiterbar)
        medwork_contacts = [
            "Dr. med. Muster (Innere Medizin)",
            "Dr. med. Beispiel (Chirurgie)",
            "Dr. med. Test (Kardiologie)",
            "Praxis-Team intern",
        ]
        MEDWORK_CONTACTS_FILE = "kg_diktat_medwork_contacts.json"

        def _load_medwork_contacts():
            try:
                p = os.path.join(os.path.dirname(os.path.abspath(__file__)), MEDWORK_CONTACTS_FILE)
                if os.path.isfile(p):
                    with open(p, "r", encoding="utf-8") as f:
                        return json.load(f)
            except Exception:
                pass
            return medwork_contacts[:]

        def _save_medwork_contacts(contacts):
            try:
                p = os.path.join(os.path.dirname(os.path.abspath(__file__)), MEDWORK_CONTACTS_FILE)
                with open(p, "w", encoding="utf-8") as f:
                    json.dump(contacts, f, indent=2, ensure_ascii=False)
            except Exception:
                pass

        def _get_selected_items():
            """Gibt die mit 'senden'-Häkchen ausgewählten To-dos zurück."""
            selected = []
            for i, sv in send_selection.items():
                if sv.get() and 0 <= i < len(todos):
                    selected.append(todos[i])
            return selected

        def _format_todo_for_email(t):
            """Formatiert ein To-do für E-Mail-Text."""
            prio_map = {1: "HOCH", 2: "MITTEL", 0: ""}
            line = f"- {t.get('text', '')}"
            if t.get("date"):
                try:
                    dt = datetime.strptime(t["date"], "%Y-%m-%d")
                    line += f"  [Fällig: {dt.strftime('%d.%m.%Y')}]"
                except Exception:
                    line += f"  [Fällig: {t['date']}]"
            p = prio_map.get(t.get("priority", 0), "")
            if p:
                line += f"  [Priorität: {p}]"
            if t.get("notes", "").strip():
                line += f"\n  Notiz: {t['notes'].strip()}"
            return line

        def _send_items_to_medwork(items):
            """Öffnet Dialog zum Senden von To-do(s) an MedWork (in die Inbox des Empfängers)."""
            if not items:
                messagebox.showinfo("MedWork", "Keine Aufgaben ausgewählt.", parent=win)
                return
            mw_win = tk.Toplevel(win)
            mw_win.title("An MedWork senden")
            mw_win.attributes("-topmost", True)
            mw_win.configure(bg="#E8F4FA")
            mw_win.resizable(False, False)
            mw_win.geometry("420x440")
            center_window(mw_win, 420, 440)
            self._register_window(mw_win)

            tk.Label(mw_win, text="📤 Aufgabe(n) an MedWork senden", font=("Segoe UI", 12, "bold"),
                     bg="#B9ECFA", fg="#1a4d6d").pack(fill="x", ipady=8)

            # Aufgaben-Vorschau
            tk.Label(mw_win, text=f"{len(items)} Aufgabe(n):", font=("Segoe UI", 9, "bold"),
                     bg="#E8F4FA", fg="#1a4d6d").pack(anchor="w", padx=12, pady=(8, 2))
            preview_f = tk.Frame(mw_win, bg="white", padx=6, pady=4)
            preview_f.pack(fill="x", padx=12, pady=(0, 8))
            for it in items[:5]:
                tk.Label(preview_f, text=f"• {it['text'][:55]}{'…' if len(it.get('text',''))>55 else ''}",
                         font=("Segoe UI", 9), bg="white", fg="#1a4d6d", anchor="w").pack(fill="x")
            if len(items) > 5:
                tk.Label(preview_f, text=f"… und {len(items)-5} weitere",
                         font=("Segoe UI", 8, "italic"), bg="white", fg="#999").pack(fill="x")

            # Kontakt-Auswahl
            tk.Label(mw_win, text="Empfänger:", font=("Segoe UI", 9, "bold"),
                     bg="#E8F4FA", fg="#1a4d6d").pack(anchor="w", padx=12, pady=(4, 2))
            contacts = _load_medwork_contacts()
            contact_var = tk.StringVar()
            contact_var.set(contacts[0] if contacts else "")
            contact_menu = ttk.Combobox(mw_win, textvariable=contact_var, values=contacts,
                                        font=("Segoe UI", 10))
            contact_menu.pack(fill="x", padx=12, pady=(0, 8))

            # Nachricht mit Diktat-Button
            msg_label_row = tk.Frame(mw_win, bg="#E8F4FA")
            msg_label_row.pack(fill="x", padx=12, pady=(4, 2))
            tk.Label(msg_label_row, text="Nachricht (optional):", font=("Segoe UI", 9, "bold"),
                     bg="#E8F4FA", fg="#1a4d6d").pack(side="left")

            mw_recorder = [None]
            mw_is_recording = [False]
            mw_rec_status = tk.StringVar(value="")

            mw_rec_btn = tk.Button(msg_label_row, text="⏺", font=("Segoe UI", 11),
                                   bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                                   activeforeground="white", relief="flat", bd=0,
                                   width=3, cursor="hand2")
            mw_rec_btn.pack(side="right")

            msg_text = tk.Text(mw_win, font=("Segoe UI", 10), height=4, bg="white",
                               fg="#1a4d6d", relief="flat", bd=1)
            msg_text.pack(fill="x", padx=12, pady=(0, 2))

            tk.Label(mw_win, textvariable=mw_rec_status, font=("Segoe UI", 8),
                     bg="#E8F4FA", fg="#5B8DB3").pack(fill="x", padx=12, pady=(0, 6))

            def _mw_toggle_record():
                if not self.ensure_ready():
                    return
                if not mw_is_recording[0]:
                    rec = AudioRecorder()
                    mw_recorder[0] = rec
                    try:
                        rec.start()
                        mw_is_recording[0] = True
                        mw_rec_btn.configure(text="⏹", bg="#C03030", activebackground="#A02020")
                        mw_rec_status.set("🔴 Aufnahme läuft…")
                    except Exception as e:
                        messagebox.showerror("Aufnahme-Fehler", str(e), parent=mw_win)
                        mw_rec_status.set("")
                else:
                    mw_is_recording[0] = False
                    rec = mw_recorder[0]
                    mw_rec_btn.configure(text="⏺", bg="#5B8DB3", activebackground="#4A7A9E")
                    mw_rec_status.set("Transkribiere…")

                    def worker():
                        try:
                            wav_path = rec.stop_and_save_wav()
                            import wave as _wave
                            try:
                                with _wave.open(wav_path, 'rb') as wf:
                                    dur = wf.getnframes() / float(wf.getframerate())
                                    if dur < 0.3:
                                        if os.path.exists(wav_path):
                                            os.remove(wav_path)
                                        mw_recorder[0] = None
                                        self.after(0, lambda: mw_rec_status.set("Kein Audio erkannt."))
                                        return
                            except Exception:
                                pass
                            transcript_result = self.transcribe_wav(wav_path)
                            if hasattr(transcript_result, 'text'):
                                text = transcript_result.text
                            elif isinstance(transcript_result, str):
                                text = transcript_result
                            else:
                                text = ""
                            try:
                                if os.path.exists(wav_path):
                                    os.remove(wav_path)
                            except Exception:
                                pass
                            if not text or not text.strip():
                                mw_recorder[0] = None
                                self.after(0, lambda: mw_rec_status.set("Kein Text erkannt."))
                                return
                            text = self._diktat_apply_punctuation(text)
                            def _done():
                                mw_recorder[0] = None
                                current = msg_text.get("1.0", "end").strip()
                                new_t = (current + " " + text).strip() if current else text.strip()
                                msg_text.delete("1.0", "end")
                                msg_text.insert("1.0", new_t)
                                mw_rec_status.set("✓ Diktiert.")
                            self.after(0, _done)
                        except Exception as e:
                            self.after(0, lambda: mw_rec_status.set(f"Fehler: {e}"))
                            mw_recorder[0] = None

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

            mw_rec_btn.configure(command=_mw_toggle_record)

            def _mw_on_close():
                if mw_is_recording[0] and mw_recorder[0]:
                    try:
                        mw_is_recording[0] = False
                        wp = mw_recorder[0].stop_and_save_wav()
                        if os.path.exists(wp):
                            os.remove(wp)
                    except Exception:
                        pass
                    mw_recorder[0] = None
                mw_win.destroy()

            mw_win.protocol("WM_DELETE_WINDOW", _mw_on_close)

            def do_send():
                contact = contact_var.get().strip()
                if not contact:
                    messagebox.showwarning("MedWork", "Bitte Empfänger eingeben.", parent=mw_win)
                    return
                if contact not in contacts:
                    contacts.append(contact)
                    _save_medwork_contacts(contacts)
                sender_name = self._user_profile.get("name", "Unbekannt")
                for it in items:
                    send_todo_to_inbox(it, sender_name, contact)
                messagebox.showinfo(
                    "MedWork",
                    f"{len(items)} Aufgabe(n) gesendet an:\n{contact}\n\n"
                    f"Die Aufgaben erscheinen in der To-Do-Liste des Empfängers.",
                    parent=mw_win,
                )
                mw_win.destroy()

            tk.Button(mw_win, text="📤 Senden", font=("Segoe UI", 11, "bold"),
                      bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                      relief="flat", bd=0, padx=20, pady=6, cursor="hand2",
                      command=do_send).pack(pady=12)

        def _send_items_via_email(items):
            """Öffnet den Standard-E-Mail-Client mit allen To-do-Infos."""
            import urllib.parse
            if not items:
                messagebox.showinfo("E-Mail", "Keine Aufgaben ausgewählt.", parent=win)
                return
            sender = self._user_profile.get("name", "")
            subject = f"To-Do Liste von {sender}" if sender else "To-Do Liste"
            body_lines = [f"To-Do Liste ({date.today().strftime('%d.%m.%Y')})", ""]
            for it in items:
                body_lines.append(_format_todo_for_email(it))
            body_lines.append("")
            body_lines.append(f"Gesendet von AzA – {sender}")
            body = "\n".join(body_lines)
            mailto_url = f"mailto:?subject={urllib.parse.quote(subject)}&body={urllib.parse.quote(body)}"
            try:
                os.startfile(mailto_url)
            except Exception as e:
                messagebox.showerror("E-Mail", f"Konnte E-Mail-Client nicht öffnen:\n{e}", parent=win)

        def send_to_medwork():
            selected = _get_selected_items()
            if selected:
                _send_items_to_medwork(selected)
            else:
                open_items = [t for t in todos if not t.get("done")]
                if not open_items:
                    messagebox.showinfo("MedWork", "Keine offenen Aufgaben zum Senden.", parent=win)
                    return
                _send_items_to_medwork(open_items)

        def send_email():
            selected = _get_selected_items()
            if selected:
                _send_items_via_email(selected)
            else:
                all_items = [t for t in todos if not t.get("done")]
                if not all_items:
                    messagebox.showinfo("E-Mail", "Keine offenen Aufgaben zum Senden.", parent=win)
                    return
                _send_items_via_email(all_items)

        btn_medwork.configure(command=send_to_medwork)
        btn_email.configure(command=send_email)

        # ─── Notizen-Seite ───
        user_notes = load_notes()
        notes_widgets = []
        _notes_recorder = [None]
        _notes_is_recording = [False]
        _notes_target_widget = [None]

        notes_input_frame = tk.Frame(notes_page, bg="#D4EEF7", pady=8, padx=8)
        notes_input_frame.pack(fill="x")

        notes_rec_status_var = tk.StringVar(value="")

        def _notes_generic_toggle_record(target_widget, btn_ref):
            if not self.ensure_ready():
                return
            if not _notes_is_recording[0]:
                rec = AudioRecorder()
                _notes_recorder[0] = rec
                _notes_target_widget[0] = target_widget
                try:
                    rec.start()
                    _notes_is_recording[0] = True
                    btn_ref.configure(text="⏹", bg="#C03030", activebackground="#A02020")
                    notes_rec_status_var.set("🔴 Aufnahme läuft…")
                except Exception as e:
                    messagebox.showerror("Aufnahme-Fehler", str(e), parent=win)
                    notes_rec_status_var.set("")
            else:
                _notes_is_recording[0] = False
                rec = _notes_recorder[0]
                btn_ref.configure(text="⏺", bg="#5B8DB3", activebackground="#4A7A9E")
                notes_rec_status_var.set("Transkribiere…")
                tw_ref = _notes_target_widget[0]
                is_entry = isinstance(tw_ref, tk.Entry)

                def worker():
                    try:
                        wav_path = rec.stop_and_save_wav()
                        import wave as _wave
                        try:
                            with _wave.open(wav_path, 'rb') as wf:
                                dur = wf.getnframes() / float(wf.getframerate())
                                if dur < 0.3:
                                    if os.path.exists(wav_path):
                                        os.remove(wav_path)
                                    _notes_recorder[0] = None
                                    self.after(0, lambda: notes_rec_status_var.set("Kein Audio erkannt."))
                                    return
                        except Exception:
                            pass
                        transcript_result = self.transcribe_wav(wav_path)
                        if hasattr(transcript_result, 'text'):
                            text = transcript_result.text
                        elif isinstance(transcript_result, str):
                            text = transcript_result
                        else:
                            text = ""
                        try:
                            if os.path.exists(wav_path):
                                os.remove(wav_path)
                        except Exception:
                            pass
                        if not text or not text.strip():
                            _notes_recorder[0] = None
                            self.after(0, lambda: notes_rec_status_var.set("Kein Text erkannt."))
                            return
                        text = self._diktat_apply_punctuation(text)
                        def _done(t=text):
                            _notes_recorder[0] = None
                            if is_entry:
                                current = tw_ref.get()
                                if current == "Neue Notiz – Titel eingeben…":
                                    current = ""
                                new_text = (current + " " + t).strip() if current.strip() else t.strip()
                                tw_ref.delete(0, "end")
                                tw_ref.insert(0, new_text)
                                tw_ref.configure(fg="#1a4d6d")
                            else:
                                current = tw_ref.get("1.0", "end").strip()
                                new_text = (current + " " + t).strip() if current else t.strip()
                                tw_ref.delete("1.0", "end")
                                tw_ref.insert("1.0", new_text)
                            notes_rec_status_var.set("✓ Diktiert.")
                        self.after(0, _done)
                    except Exception as e:
                        self.after(0, lambda: notes_rec_status_var.set(f"Fehler: {e}"))
                        _notes_recorder[0] = None

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

        # Titel-Zeile mit Diktier-Button
        tk.Label(notes_input_frame, text="Titel:", font=("Segoe UI", 9, "bold"),
                 bg="#D4EEF7", fg="#1a4d6d").pack(anchor="w")

        notes_entry_frame = tk.Frame(notes_input_frame, bg="#D4EEF7")
        notes_entry_frame.pack(fill="x")

        notes_title_var = tk.StringVar()
        notes_title_entry = tk.Entry(notes_entry_frame, textvariable=notes_title_var,
                                     font=("Segoe UI", 11), bg="white", fg="#1a4d6d",
                                     relief="flat", bd=0, insertbackground="#1a4d6d")
        notes_title_entry.insert(0, "Neue Notiz – Titel eingeben…")
        notes_title_entry.configure(fg="#999")

        notes_title_rec_btn = tk.Button(notes_entry_frame, text="⏺", font=("Segoe UI", 11),
                                        bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                                        activeforeground="white", relief="flat", bd=0,
                                        width=3, cursor="hand2")
        notes_title_rec_btn.pack(side="right")
        notes_title_rec_btn.configure(
            command=lambda: _notes_generic_toggle_record(notes_title_entry, notes_title_rec_btn))
        notes_title_entry.pack(side="left", fill="x", expand=True, ipady=6, padx=(0, 4))

        def _notes_entry_focus_in(e):
            if notes_title_entry.get() == "Neue Notiz – Titel eingeben…":
                notes_title_entry.delete(0, "end")
                notes_title_entry.configure(fg="#1a4d6d")

        def _notes_entry_focus_out(e):
            if not notes_title_entry.get().strip():
                notes_title_entry.insert(0, "Neue Notiz – Titel eingeben…")
                notes_title_entry.configure(fg="#999")

        notes_title_entry.bind("<FocusIn>", _notes_entry_focus_in)
        notes_title_entry.bind("<FocusOut>", _notes_entry_focus_out)

        # Inhalt-Zeile mit Diktier-Button
        notes_text_label_row = tk.Frame(notes_input_frame, bg="#D4EEF7")
        notes_text_label_row.pack(fill="x", pady=(6, 0))
        tk.Label(notes_text_label_row, text="Inhalt:", font=("Segoe UI", 9, "bold"),
                 bg="#D4EEF7", fg="#1a4d6d").pack(side="left")

        notes_text_rec_btn = tk.Button(notes_text_label_row, text="⏺", font=("Segoe UI", 11),
                                       bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                                       activeforeground="white", relief="flat", bd=0,
                                       width=3, cursor="hand2")
        notes_text_rec_btn.pack(side="right")

        notes_text_input = tk.Text(notes_input_frame, font=("Segoe UI", 10), height=3,
                                   bg="white", fg="#1a4d6d", relief="flat", bd=1, wrap="word")
        notes_text_input.pack(fill="x", pady=(2, 0))

        notes_text_rec_btn.configure(
            command=lambda: _notes_generic_toggle_record(notes_text_input, notes_text_rec_btn))

        tk.Label(notes_input_frame, textvariable=notes_rec_status_var, font=("Segoe UI", 8),
                 bg="#D4EEF7", fg="#5B8DB3").pack(fill="x")

        notes_add_frame = tk.Frame(notes_input_frame, bg="#D4EEF7")
        notes_add_frame.pack(fill="x", pady=(4, 0))

        def _add_note(event=None):
            title = notes_title_var.get().strip()
            if not title or title == "Neue Notiz – Titel eingeben…":
                title = "Notiz"
            text_content = notes_text_input.get("1.0", "end").strip()
            new_note = {
                "id": int(datetime.now().timestamp() * 1000),
                "title": title,
                "text": text_content,
                "created": datetime.now().isoformat(),
            }
            user_notes.append(new_note)
            notes_title_var.set("")
            notes_title_entry.delete(0, "end")
            notes_title_entry.insert(0, "Neue Notiz – Titel eingeben…")
            notes_title_entry.configure(fg="#999")
            notes_text_input.delete("1.0", "end")
            notes_rec_status_var.set("")
            save_notes(user_notes)
            _rebuild_notes_list()

        notes_title_entry.bind("<Return>", _add_note)

        tk.Button(notes_add_frame, text="＋ Notiz hinzufügen", font=("Segoe UI", 10, "bold"),
                  bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                  activeforeground="white", relief="flat", bd=0, padx=12, pady=2,
                  cursor="hand2", command=_add_note).pack(side="right")

        # Scrollbarer Bereich für Notizen
        notes_list_outer = tk.Frame(notes_page, bg="#E8F4FA")
        notes_list_outer.pack(fill="both", expand=True, padx=8, pady=(4, 0))

        notes_canvas = tk.Canvas(notes_list_outer, bg="#E8F4FA", highlightthickness=0)
        notes_scrollbar = ttk.Scrollbar(notes_list_outer, orient="vertical", command=notes_canvas.yview)
        notes_list_frame = tk.Frame(notes_canvas, bg="#E8F4FA")

        notes_list_frame.bind("<Configure>",
                              lambda e: notes_canvas.configure(scrollregion=notes_canvas.bbox("all")))
        notes_canvas.create_window((0, 0), window=notes_list_frame, anchor="nw", tags="notes_win")
        notes_canvas.configure(yscrollcommand=notes_scrollbar.set)

        def _notes_resize(event):
            notes_canvas.itemconfig("notes_win", width=event.width)

        notes_canvas.bind("<Configure>", _notes_resize)
        notes_canvas.pack(side="left", fill="both", expand=True)
        notes_scrollbar.pack(side="right", fill="y")

        def _notes_mousewheel(event):
            notes_canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")

        def _bind_notes_mousewheel_recursive(widget):
            widget.bind("<MouseWheel>", _notes_mousewheel)
            for child in widget.winfo_children():
                _bind_notes_mousewheel_recursive(child)

        notes_canvas.bind("<MouseWheel>", _notes_mousewheel)
        notes_list_frame.bind("<MouseWheel>", _notes_mousewheel)

        # Notizen-Fusszeile
        notes_footer = tk.Frame(notes_page, bg="#D4EEF7", pady=4)
        notes_footer.pack(fill="x", side="bottom")

        notes_counter_label = tk.Label(notes_footer, text="", font=("Segoe UI", 9),
                                       bg="#D4EEF7", fg="#4a8aaa")
        notes_counter_label.pack(side="left", padx=8)

        def _open_note_detail(idx):
            if idx < 0 or idx >= len(user_notes):
                return
            note = user_notes[idx]

            nd = tk.Toplevel(win)
            nd.title("Notiz bearbeiten")
            nd.attributes("-topmost", True)
            nd.configure(bg="#E8F4FA")
            nd.resizable(True, True)
            nd.geometry("460x420")
            center_window(nd, 460, 420)
            self._register_window(nd)

            tk.Label(nd, text="📝 Notiz bearbeiten", font=("Segoe UI", 12, "bold"),
                     bg="#B9ECFA", fg="#1a4d6d").pack(fill="x", ipady=8)

            nd_content = tk.Frame(nd, bg="#E8F4FA", padx=12, pady=8)
            nd_content.pack(fill="both", expand=True)

            nd_recorder = [None]
            nd_is_recording = [False]
            nd_target = [None]

            def nd_on_close():
                if nd_is_recording[0] and nd_recorder[0]:
                    try:
                        nd_is_recording[0] = False
                        wp = nd_recorder[0].stop_and_save_wav()
                        if os.path.exists(wp):
                            os.remove(wp)
                    except Exception:
                        pass
                    nd_recorder[0] = None
                nd.destroy()

            nd.protocol("WM_DELETE_WINDOW", nd_on_close)

            def _nd_toggle_record(target_widget, btn_ref, status_var):
                if not self.ensure_ready():
                    return
                if not nd_is_recording[0]:
                    rec = AudioRecorder()
                    nd_recorder[0] = rec
                    nd_target[0] = target_widget
                    try:
                        rec.start()
                        nd_is_recording[0] = True
                        btn_ref.configure(text="⏹", bg="#C03030", activebackground="#A02020")
                        status_var.set("🔴 Aufnahme läuft…")
                    except Exception as e:
                        messagebox.showerror("Aufnahme-Fehler", str(e), parent=nd)
                        status_var.set("")
                else:
                    nd_is_recording[0] = False
                    rec = nd_recorder[0]
                    btn_ref.configure(text="⏺", bg="#5B8DB3", activebackground="#4A7A9E")
                    status_var.set("Transkribiere…")
                    tw = nd_target[0]

                    def worker():
                        try:
                            wav_path = rec.stop_and_save_wav()
                            import wave as _wave
                            try:
                                with _wave.open(wav_path, 'rb') as wf:
                                    dur = wf.getnframes() / float(wf.getframerate())
                                    if dur < 0.3:
                                        if os.path.exists(wav_path):
                                            os.remove(wav_path)
                                        nd_recorder[0] = None
                                        self.after(0, lambda: status_var.set("Kein Audio erkannt."))
                                        return
                            except Exception:
                                pass
                            transcript_result = self.transcribe_wav(wav_path)
                            if hasattr(transcript_result, 'text'):
                                text = transcript_result.text
                            elif isinstance(transcript_result, str):
                                text = transcript_result
                            else:
                                text = ""
                            try:
                                if os.path.exists(wav_path):
                                    os.remove(wav_path)
                            except Exception:
                                pass
                            if not text or not text.strip():
                                nd_recorder[0] = None
                                self.after(0, lambda: status_var.set("Kein Text erkannt."))
                                return
                            text = self._diktat_apply_punctuation(text)
                            def _done(t=text):
                                nd_recorder[0] = None
                                current = tw.get("1.0", "end").strip()
                                new_text = (current + " " + t).strip() if current else t.strip()
                                tw.delete("1.0", "end")
                                tw.insert("1.0", new_text)
                                status_var.set("✓ Diktiert.")
                            self.after(0, _done)
                        except Exception as e:
                            self.after(0, lambda: status_var.set(f"Fehler: {e}"))
                            nd_recorder[0] = None

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

            nd_rec_status = tk.StringVar(value="")

            # Titel
            nd_title_row = tk.Frame(nd_content, bg="#E8F4FA")
            nd_title_row.pack(fill="x", pady=(0, 2))
            tk.Label(nd_title_row, text="Titel:", font=("Segoe UI", 9, "bold"),
                     bg="#E8F4FA", fg="#1a4d6d").pack(side="left")

            nd_title_rec_btn = tk.Button(nd_title_row, text="⏺", font=("Segoe UI", 11),
                                         bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                                         activeforeground="white", relief="flat", bd=0,
                                         width=3, cursor="hand2")
            nd_title_rec_btn.pack(side="right")

            nd_title_edit = tk.Text(nd_content, font=("Segoe UI", 11), height=1, bg="white",
                                    fg="#1a4d6d", relief="flat", bd=1, wrap="word")
            nd_title_edit.pack(fill="x")
            nd_title_edit.insert("1.0", note.get("title", ""))

            nd_title_rec_btn.configure(
                command=lambda: _nd_toggle_record(nd_title_edit, nd_title_rec_btn, nd_rec_status))

            # Text
            nd_text_row = tk.Frame(nd_content, bg="#E8F4FA")
            nd_text_row.pack(fill="x", pady=(8, 2))
            tk.Label(nd_text_row, text="Inhalt:", font=("Segoe UI", 9, "bold"),
                     bg="#E8F4FA", fg="#1a4d6d").pack(side="left")

            nd_text_rec_btn = tk.Button(nd_text_row, text="⏺", font=("Segoe UI", 11),
                                        bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                                        activeforeground="white", relief="flat", bd=0,
                                        width=3, cursor="hand2")
            nd_text_rec_btn.pack(side="right")

            nd_text_edit = tk.Text(nd_content, font=("Segoe UI", 10), height=8, bg="white",
                                   fg="#1a4d6d", relief="flat", bd=1, wrap="word")
            nd_text_edit.pack(fill="both", expand=True)
            add_text_font_size_control(nd_text_row, nd_text_edit, initial_size=10, bg_color="#E8F4FA", save_key="todo_note_detail")
            nd_text_edit.insert("1.0", note.get("text", ""))

            nd_text_rec_btn.configure(
                command=lambda: _nd_toggle_record(nd_text_edit, nd_text_rec_btn, nd_rec_status))

            tk.Label(nd_content, textvariable=nd_rec_status, font=("Segoe UI", 8),
                     bg="#E8F4FA", fg="#5B8DB3").pack(fill="x", pady=(0, 4))

            def _save_note():
                new_title = nd_title_edit.get("1.0", "end").strip()
                if not new_title:
                    new_title = "Notiz"
                user_notes[idx]["title"] = new_title
                user_notes[idx]["text"] = nd_text_edit.get("1.0", "end").strip()
                save_notes(user_notes)
                nd.destroy()
                _rebuild_notes_list()

            nd_btn_frame = tk.Frame(nd, bg="#D4EEF7", pady=8)
            nd_btn_frame.pack(fill="x", side="bottom")
            tk.Button(nd_btn_frame, text="💾 Speichern", font=("Segoe UI", 11, "bold"),
                      bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                      relief="flat", bd=0, padx=20, pady=4, cursor="hand2",
                      command=_save_note).pack(side="left", padx=12)
            tk.Button(nd_btn_frame, text="Abbrechen", font=("Segoe UI", 10),
                      bg="#C8DDE6", fg="#1a4d6d", activebackground="#B8CDD6",
                      relief="flat", bd=0, padx=12, pady=4, cursor="hand2",
                      command=nd.destroy).pack(side="right", padx=12)

        def _delete_note(idx):
            if 0 <= idx < len(user_notes):
                user_notes.pop(idx)
                save_notes(user_notes)
                _rebuild_notes_list()

        _notes_drag = {"active": False, "idx": None, "indicator": None}
        _notes_border_frames = []

        def _notes_drag_start(event, idx):
            _notes_drag["active"] = True
            _notes_drag["idx"] = idx
            event.widget.configure(cursor="fleur")
            if 0 <= idx < len(_notes_border_frames):
                _notes_border_frames[idx].configure(bg="#5B8DB3")

        def _notes_drag_motion(event, idx):
            if not _notes_drag["active"]:
                return
            abs_y = event.widget.winfo_rooty() + event.y
            target = _notes_find_drop_target(abs_y)
            if _notes_drag.get("indicator"):
                _notes_drag["indicator"].destroy()
                _notes_drag["indicator"] = None
            if target is not None and target != _notes_drag["idx"]:
                insert_before = target
                if insert_before < len(_notes_border_frames):
                    ind = tk.Frame(notes_list_frame, bg="#5B8DB3", height=3)
                    ind.pack(before=_notes_border_frames[insert_before], fill="x", pady=0)
                else:
                    ind = tk.Frame(notes_list_frame, bg="#5B8DB3", height=3)
                    ind.pack(fill="x", pady=0)
                _notes_drag["indicator"] = ind

        def _notes_drag_end(event, idx):
            if not _notes_drag["active"]:
                return
            _notes_drag["active"] = False
            if _notes_drag.get("indicator"):
                _notes_drag["indicator"].destroy()
                _notes_drag["indicator"] = None
            event.widget.configure(cursor="hand2")
            abs_y = event.widget.winfo_rooty() + event.y
            target = _notes_find_drop_target(abs_y)
            src = _notes_drag["idx"]
            if target is not None and target != src:
                item = user_notes.pop(src)
                if target > src:
                    target -= 1
                user_notes.insert(target, item)
                save_notes(user_notes)
                _rebuild_notes_list()
            else:
                if 0 <= src < len(_notes_border_frames):
                    _rebuild_notes_list()

        def _notes_find_drop_target(abs_y):
            for i, bf in enumerate(_notes_border_frames):
                try:
                    wy = bf.winfo_rooty()
                    wh = bf.winfo_height()
                    mid = wy + wh // 2
                    if abs_y < mid:
                        return i
                except Exception:
                    pass
            return len(_notes_border_frames)

        def _rebuild_notes_list():
            for w in notes_list_frame.winfo_children():
                w.destroy()
            notes_widgets.clear()
            _notes_border_frames.clear()

            if not user_notes:
                tk.Label(notes_list_frame, text="Noch keine Notizen vorhanden.\n"
                         "Erstellen Sie eine neue Notiz oben.",
                         font=("Segoe UI", 10), bg="#E8F4FA", fg="#999",
                         justify="center").pack(pady=40)
                notes_counter_label.configure(text="0 Notizen")
                return

            fs = todo_font_size[0]
            for idx, note in enumerate(user_notes):
                border_frame = tk.Frame(notes_list_frame, bg="#B0D8E8", padx=1, pady=1)
                border_frame.pack(fill="x", pady=2)
                _notes_border_frames.append(border_frame)

                row = tk.Frame(border_frame, bg="white", padx=8, pady=8, cursor="hand2")
                row.pack(fill="x")

                top_row = tk.Frame(row, bg="white")
                top_row.pack(fill="x")

                drag_handle = tk.Label(top_row, text="≡", font=("Segoe UI", 12, "bold"),
                                       bg="white", fg="#B0C8D8", cursor="hand2")
                drag_handle.pack(side="left", padx=(0, 6))
                drag_handle.bind("<Button-1>", lambda e, i=idx: _notes_drag_start(e, i))
                drag_handle.bind("<B1-Motion>", lambda e, i=idx: _notes_drag_motion(e, i))
                drag_handle.bind("<ButtonRelease-1>", lambda e, i=idx: _notes_drag_end(e, i))
                drag_handle.bind("<Enter>", lambda e, h=drag_handle: h.configure(fg="#5B8DB3"))
                drag_handle.bind("<Leave>", lambda e, h=drag_handle: h.configure(fg="#B0C8D8"))

                title_text = note.get("title", "Notiz")
                title_lbl = tk.Label(top_row, text=title_text, font=("Segoe UI", fs, "bold"),
                                     bg="white", fg="#1a4d6d", anchor="w",
                                     cursor="hand2", wraplength=320, justify="left")
                title_lbl.pack(side="left", fill="x", expand=True)

                note_text = note.get("text", "").strip()
                preview_lbl = None
                if note_text:
                    preview = note_text[:120] + ("\u2026" if len(note_text) > 120 else "")
                    preview_lbl = tk.Label(row, text=preview, font=("Segoe UI", max(fs - 1, 8)),
                             bg="white", fg="#5A8898", anchor="w",
                             cursor="hand2", wraplength=350, justify="left")
                    preview_lbl.pack(fill="x", anchor="w", pady=(2, 0))

                bottom_row = tk.Frame(row, bg="white")
                bottom_row.pack(fill="x", pady=(4, 0))

                created = note.get("created", "")
                try:
                    dt_obj = datetime.fromisoformat(created)
                    date_str = dt_obj.strftime("%d.%m.%Y %H:%M")
                except Exception:
                    date_str = ""
                if date_str:
                    tk.Label(bottom_row, text=date_str, font=("Segoe UI", 7),
                             bg="white", fg="#B0C8D8").pack(side="left")

                del_lbl = tk.Label(bottom_row, text="\u2715", font=("Segoe UI", 10),
                                   bg="white", fg="#ccc", cursor="hand2")
                del_lbl.pack(side="right")
                del_lbl.bind("<Enter>", lambda e, b=del_lbl: b.configure(fg="#E87070"))
                del_lbl.bind("<Leave>", lambda e, b=del_lbl: b.configure(fg="#ccc"))
                del_lbl.bind("<Button-1>", lambda e, i=idx: _delete_note(i))

                for _w in [row, title_lbl]:
                    _w.bind("<Button-1>", lambda e, i=idx: _open_note_detail(i))
                    _w.bind("<Double-Button-1>", lambda e, i=idx: _open_note_detail(i))
                if preview_lbl:
                    preview_lbl.bind("<Button-1>", lambda e, i=idx: _open_note_detail(i))
                    preview_lbl.bind("<Double-Button-1>", lambda e, i=idx: _open_note_detail(i))

                notes_widgets.append(row)

            notes_counter_label.configure(text=f"{len(user_notes)} Notiz{'en' if len(user_notes) != 1 else ''}")
            _bind_notes_mousewheel_recursive(notes_list_frame)

        # ═══════════════════════════════════════════════════
        # ─── Checkliste-Seite ───
        # ═══════════════════════════════════════════════════
        user_checklists = load_checklists()

        cl_input_frame = tk.Frame(checklist_page, bg="#D4EEF7", pady=8, padx=8)
        cl_input_frame.pack(fill="x")
        tk.Label(cl_input_frame, text="Neue Checkliste:", font=("Segoe UI", 9, "bold"),
                 bg="#D4EEF7", fg="#1a4d6d").pack(anchor="w")
        cl_title_frame = tk.Frame(cl_input_frame, bg="#D4EEF7")
        cl_title_frame.pack(fill="x", pady=(2, 0))
        cl_title_var = tk.StringVar()
        cl_title_entry = tk.Entry(cl_title_frame, textvariable=cl_title_var,
                                  font=("Segoe UI", 11), bg="white", fg="#1a4d6d",
                                  relief="flat", bd=0, insertbackground="#1a4d6d")
        cl_title_entry.pack(side="left", fill="x", expand=True, ipady=4, padx=(0, 6))
        cl_title_entry.insert(0, "Titel der Checkliste…")
        cl_title_entry.configure(fg="#999")

        def _cl_focus_in(e):
            if cl_title_entry.get() == "Titel der Checkliste…":
                cl_title_entry.delete(0, "end")
                cl_title_entry.configure(fg="#1a4d6d")
        def _cl_focus_out(e):
            if not cl_title_entry.get().strip():
                cl_title_entry.insert(0, "Titel der Checkliste…")
                cl_title_entry.configure(fg="#999")
        cl_title_entry.bind("<FocusIn>", _cl_focus_in)
        cl_title_entry.bind("<FocusOut>", _cl_focus_out)

        def _add_checklist(event=None):
            title = cl_title_var.get().strip()
            if not title or title == "Titel der Checkliste…":
                return
            new_cl = {
                "id": int(datetime.now().timestamp() * 1000),
                "title": title,
                "items": [],
                "created": datetime.now().isoformat(),
            }
            user_checklists.append(new_cl)
            save_checklists(user_checklists)
            cl_title_var.set("")
            cl_title_entry.delete(0, "end")
            cl_title_entry.insert(0, "Titel der Checkliste…")
            cl_title_entry.configure(fg="#999")
            _rebuild_checklist()

        cl_title_entry.bind("<Return>", _add_checklist)
        tk.Button(cl_title_frame, text="＋", font=("Segoe UI", 11, "bold"),
                  bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                  relief="flat", bd=0, padx=8, cursor="hand2",
                  command=_add_checklist).pack(side="right")

        cl_list_outer = tk.Frame(checklist_page, bg="#E8F4FA")
        cl_list_outer.pack(fill="both", expand=True, padx=8, pady=(4, 0))
        cl_canvas = tk.Canvas(cl_list_outer, bg="#E8F4FA", highlightthickness=0)
        cl_sb = ttk.Scrollbar(cl_list_outer, orient="vertical", command=cl_canvas.yview)
        cl_list_frame = tk.Frame(cl_canvas, bg="#E8F4FA")
        cl_list_frame.bind("<Configure>", lambda e: cl_canvas.configure(scrollregion=cl_canvas.bbox("all")))
        cl_canvas.create_window((0, 0), window=cl_list_frame, anchor="nw", tags="cl_win")
        cl_canvas.configure(yscrollcommand=cl_sb.set)
        cl_canvas.bind("<Configure>", lambda e: cl_canvas.itemconfig("cl_win", width=e.width))
        cl_canvas.pack(side="left", fill="both", expand=True)
        cl_sb.pack(side="right", fill="y")
        def _cl_mw(event):
            cl_canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
        cl_canvas.bind("<MouseWheel>", _cl_mw)

        cl_footer = tk.Frame(checklist_page, bg="#D4EEF7", pady=4)
        cl_footer.pack(fill="x", side="bottom")
        cl_counter = tk.Label(cl_footer, text="", font=("Segoe UI", 9),
                              bg="#D4EEF7", fg="#4a8aaa")
        cl_counter.pack(side="left", padx=8)

        def _rebuild_checklist():
            for w in cl_list_frame.winfo_children():
                w.destroy()

            if not user_checklists:
                tk.Label(cl_list_frame, text="Noch keine Checklisten vorhanden.\n"
                         "Erstellen Sie eine neue Checkliste oben.",
                         font=("Segoe UI", 10), bg="#E8F4FA", fg="#999",
                         justify="center").pack(pady=40)
                cl_counter.configure(text="0 Checklisten")
                return

            for cl_idx, cl in enumerate(user_checklists):
                border = tk.Frame(cl_list_frame, bg="#D0E8F0", padx=1, pady=1)
                border.pack(fill="x", pady=2)
                card = tk.Frame(border, bg="white", padx=8, pady=6)
                card.pack(fill="x")

                # Header: Titel + Löschen
                hdr = tk.Frame(card, bg="white")
                hdr.pack(fill="x")
                tk.Label(hdr, text=cl.get("title", "Checkliste"),
                         font=("Segoe UI", 10, "bold"), bg="white", fg="#1a4d6d",
                         anchor="w").pack(side="left", fill="x", expand=True)

                items_done = sum(1 for it in cl.get("items", []) if it.get("done"))
                items_total = len(cl.get("items", []))
                progress_text = f"{items_done}/{items_total}" if items_total else "leer"
                tk.Label(hdr, text=progress_text, font=("Segoe UI", 8),
                         bg="white", fg="#5B8DB3").pack(side="right", padx=(4, 0))

                del_btn = tk.Label(hdr, text="✕", font=("Segoe UI", 9),
                                   bg="white", fg="#ccc", cursor="hand2")
                del_btn.pack(side="right", padx=(8, 0))
                del_btn.bind("<Enter>", lambda e, b=del_btn: b.configure(fg="#E87070"))
                del_btn.bind("<Leave>", lambda e, b=del_btn: b.configure(fg="#ccc"))
                def _del_cl(i=cl_idx):
                    user_checklists.pop(i)
                    save_checklists(user_checklists)
                    _rebuild_checklist()
                del_btn.bind("<Button-1>", lambda e, i=cl_idx: _del_cl(i))

                # Items
                items = cl.get("items", [])
                for it_idx, item in enumerate(items):
                    it_frame = tk.Frame(card, bg="white")
                    it_frame.pack(fill="x", pady=1)
                    var = tk.BooleanVar(value=item.get("done", False))
                    def _toggle_item(ci=cl_idx, ii=it_idx, v=var):
                        user_checklists[ci]["items"][ii]["done"] = v.get()
                        save_checklists(user_checklists)
                        _rebuild_checklist()
                    cb = tk.Checkbutton(it_frame, variable=var, command=lambda ci=cl_idx, ii=it_idx, v=var: _toggle_item(ci, ii, v),
                                        bg="white", activebackground="white")
                    cb.pack(side="left")
                    txt = item.get("text", "")
                    fg_c = "#999" if item.get("done") else "#1a4d6d"
                    font_c = ("Segoe UI", 9, "overstrike") if item.get("done") else ("Segoe UI", 9)
                    tk.Label(it_frame, text=txt, font=font_c, bg="white", fg=fg_c,
                             anchor="w").pack(side="left", fill="x", expand=True)

                    it_del = tk.Label(it_frame, text="✕", font=("Segoe UI", 7),
                                      bg="white", fg="#ddd", cursor="hand2")
                    it_del.pack(side="right")
                    it_del.bind("<Enter>", lambda e, b=it_del: b.configure(fg="#E87070"))
                    it_del.bind("<Leave>", lambda e, b=it_del: b.configure(fg="#ddd"))
                    def _del_item(ci=cl_idx, ii=it_idx):
                        user_checklists[ci]["items"].pop(ii)
                        save_checklists(user_checklists)
                        _rebuild_checklist()
                    it_del.bind("<Button-1>", lambda e, ci=cl_idx, ii=it_idx: _del_item(ci, ii))

                # Neues Item hinzufügen
                add_frame = tk.Frame(card, bg="white")
                add_frame.pack(fill="x", pady=(4, 0))
                add_var = tk.StringVar()
                add_entry = tk.Entry(add_frame, textvariable=add_var, font=("Segoe UI", 9),
                                     bg="#F5FCFF", fg="#1a4d6d", relief="flat", bd=1,
                                     insertbackground="#1a4d6d")
                add_entry.pack(side="left", fill="x", expand=True, ipady=2, padx=(0, 4))
                add_entry.insert(0, "Neuer Punkt…")
                add_entry.configure(fg="#999")
                add_entry.bind("<FocusIn>", lambda e, en=add_entry: (en.delete(0, "end"), en.configure(fg="#1a4d6d")) if en.get() == "Neuer Punkt…" else None)
                add_entry.bind("<FocusOut>", lambda e, en=add_entry: (en.insert(0, "Neuer Punkt…"), en.configure(fg="#999")) if not en.get().strip() else None)
                def _add_item(ci=cl_idx, v=add_var, en=add_entry):
                    txt = v.get().strip()
                    if not txt or txt == "Neuer Punkt…":
                        return
                    user_checklists[ci]["items"].append({"text": txt, "done": False})
                    save_checklists(user_checklists)
                    _rebuild_checklist()
                add_entry.bind("<Return>", lambda e, ci=cl_idx, v=add_var, en=add_entry: _add_item(ci, v, en))
                tk.Button(add_frame, text="＋", font=("Segoe UI", 9, "bold"),
                          bg="#7EC8E3", fg="white", activebackground="#6CB8D3",
                          relief="flat", bd=0, padx=4, cursor="hand2",
                          command=lambda ci=cl_idx, v=add_var, en=add_entry: _add_item(ci, v, en)).pack(side="right")

            cl_counter.configure(text=f"{len(user_checklists)} Checkliste{'n' if len(user_checklists) != 1 else ''}")
            def _cl_mw_recursive(widget):
                widget.bind("<MouseWheel>", _cl_mw)
                for child in widget.winfo_children():
                    _cl_mw_recursive(child)
            _cl_mw_recursive(cl_list_frame)

        # ─── Detail-Fenster ───
        def open_detail(idx):
            if idx < 0 or idx >= len(todos):
                return
            todo = todos[idx]

            det = tk.Toplevel(win)
            det.title("Aufgabe bearbeiten")
            det.attributes("-topmost", True)
            det.configure(bg="#E8F4FA")
            det.resizable(True, True)
            det.geometry("440x500")
            center_window(det, 440, 500)
            self._register_window(det)

            # Header
            tk.Label(det, text="✏ Aufgabe bearbeiten", font=("Segoe UI", 12, "bold"),
                     bg="#B9ECFA", fg="#1a4d6d").pack(fill="x", ipady=8)

            content = tk.Frame(det, bg="#E8F4FA", padx=12, pady=8)
            content.pack(fill="both", expand=True)

            det_recorder = [None]
            det_is_recording = [False]
            det_target_widget = [None]  # welches Text-Widget gerade diktiert wird

            def det_on_close():
                if det_is_recording[0] and det_recorder[0]:
                    try:
                        det_is_recording[0] = False
                        wp = det_recorder[0].stop_and_save_wav()
                        if os.path.exists(wp):
                            os.remove(wp)
                    except Exception:
                        pass
                    det_recorder[0] = None
                det.destroy()

            det.protocol("WM_DELETE_WINDOW", det_on_close)

            def _det_toggle_record(target_text_widget, rec_btn_ref, status_var):
                if not self.ensure_ready():
                    return
                if not det_is_recording[0]:
                    rec = AudioRecorder()
                    det_recorder[0] = rec
                    det_target_widget[0] = target_text_widget
                    try:
                        rec.start()
                        det_is_recording[0] = True
                        rec_btn_ref.configure(text="⏹", bg="#C03030", activebackground="#A02020")
                        status_var.set("🔴 Aufnahme läuft…")
                    except Exception as e:
                        messagebox.showerror("Aufnahme-Fehler", str(e), parent=det)
                        status_var.set("")
                else:
                    det_is_recording[0] = False
                    rec = det_recorder[0]
                    rec_btn_ref.configure(text="⏺", bg="#5B8DB3", activebackground="#4A7A9E")
                    status_var.set("Transkribiere…")

                    tw_ref = det_target_widget[0]

                    def worker():
                        try:
                            wav_path = rec.stop_and_save_wav()
                            import wave as _wave
                            try:
                                with _wave.open(wav_path, 'rb') as wf:
                                    dur = wf.getnframes() / float(wf.getframerate())
                                    if dur < 0.3:
                                        if os.path.exists(wav_path):
                                            os.remove(wav_path)
                                        det_recorder[0] = None
                                        self.after(0, lambda: status_var.set("Kein Audio erkannt."))
                                        return
                            except Exception:
                                pass
                            transcript_result = self.transcribe_wav(wav_path)
                            if hasattr(transcript_result, 'text'):
                                text = transcript_result.text
                            elif isinstance(transcript_result, str):
                                text = transcript_result
                            else:
                                text = ""
                            try:
                                if os.path.exists(wav_path):
                                    os.remove(wav_path)
                            except Exception:
                                pass
                            if not text or not text.strip():
                                det_recorder[0] = None
                                self.after(0, lambda: status_var.set("Kein Text erkannt."))
                                return
                            text = self._diktat_apply_punctuation(text)
                            cleaned_text, extracted_date = extract_date_from_todo_text(text)
                            def _done(ct=cleaned_text, ed=extracted_date):
                                det_recorder[0] = None
                                current = tw_ref.get("1.0", "end").strip()
                                new_text = (current + " " + ct).strip() if current else ct.strip()
                                tw_ref.delete("1.0", "end")
                                tw_ref.insert("1.0", new_text)
                                if ed:
                                    det_set_date(ed)
                                    status_var.set(f"✓ Datum erkannt: {ed.strftime('%d.%m.%Y')}")
                                else:
                                    status_var.set("✓ Diktiert.")
                            self.after(0, _done)
                        except Exception as e:
                            self.after(0, lambda: status_var.set(f"Fehler: {e}"))
                            det_recorder[0] = None

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

            # Aufgabentext
            text_label_row = tk.Frame(content, bg="#E8F4FA")
            text_label_row.pack(fill="x", pady=(0, 2))
            tk.Label(text_label_row, text="Aufgabe:", font=("Segoe UI", 9, "bold"),
                     bg="#E8F4FA", fg="#1a4d6d").pack(side="left")

            text_rec_status = tk.StringVar(value="")
            text_rec_btn = tk.Button(text_label_row, text="⏺", font=("Segoe UI", 11),
                                     bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                                     activeforeground="white", relief="flat", bd=0,
                                     width=3, cursor="hand2")
            text_rec_btn.pack(side="right")
            text_rec_btn.configure(
                command=lambda: _det_toggle_record(text_edit, text_rec_btn, text_rec_status))

            text_edit = tk.Text(content, font=("Segoe UI", 11), height=3, bg="white",
                                fg="#1a4d6d", relief="flat", bd=1, wrap="word")
            text_edit.pack(fill="x")
            text_edit.insert("1.0", todo.get("text", ""))

            tk.Label(content, textvariable=text_rec_status, font=("Segoe UI", 8),
                     bg="#E8F4FA", fg="#5B8DB3").pack(fill="x", pady=(0, 6))

            # Notizen
            notes_label_row = tk.Frame(content, bg="#E8F4FA")
            notes_label_row.pack(fill="x", pady=(0, 2))
            tk.Label(notes_label_row, text="Notizen:", font=("Segoe UI", 9, "bold"),
                     bg="#E8F4FA", fg="#1a4d6d").pack(side="left")

            notes_rec_status = tk.StringVar(value="")
            notes_rec_btn = tk.Button(notes_label_row, text="⏺", font=("Segoe UI", 11),
                                      bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                                      activeforeground="white", relief="flat", bd=0,
                                      width=3, cursor="hand2")
            notes_rec_btn.pack(side="right")
            notes_rec_btn.configure(
                command=lambda: _det_toggle_record(notes_edit, notes_rec_btn, notes_rec_status))

            notes_edit = tk.Text(content, font=("Segoe UI", 10), height=4, bg="white",
                                 fg="#1a4d6d", relief="flat", bd=1, wrap="word")
            notes_edit.pack(fill="x")
            notes_edit.insert("1.0", todo.get("notes", ""))

            tk.Label(content, textvariable=notes_rec_status, font=("Segoe UI", 8),
                     bg="#E8F4FA", fg="#5B8DB3").pack(fill="x", pady=(0, 6))

            # Datum
            det_date = [None]
            if todo.get("date"):
                try:
                    det_date[0] = datetime.strptime(todo["date"], "%Y-%m-%d").date()
                except Exception:
                    pass

            date_row = tk.Frame(content, bg="#E8F4FA")
            date_row.pack(fill="x", pady=(0, 8))
            tk.Label(date_row, text="Fällig:", font=("Segoe UI", 9, "bold"),
                     bg="#E8F4FA", fg="#1a4d6d").pack(side="left")

            det_date_lbl = tk.Label(date_row, text="kein Datum", font=("Segoe UI", 10),
                                    bg="#E8F4FA", fg="#999")
            det_date_lbl.pack(side="left", padx=(4, 4))

            def det_set_date(d):
                det_date[0] = d
                if d:
                    det_date_lbl.configure(text=d.strftime("%d.%m.%Y"), fg="#1a4d6d")
                else:
                    det_date_lbl.configure(text="kein Datum", fg="#999")

            if det_date[0]:
                det_set_date(det_date[0])

            def det_open_cal():
                dcal = tk.Toplevel(det)
                dcal.title("Datum wählen")
                dcal.attributes("-topmost", True)
                dcal.configure(bg="#E8F4FA")
                dcal.resizable(False, False)
                self._register_window(dcal)
                t = date.today()
                cur = [det_date[0].year if det_date[0] else t.year,
                       det_date[0].month if det_date[0] else t.month]

                nav2 = tk.Frame(dcal, bg="#B9ECFA")
                nav2.pack(fill="x")
                ml2 = tk.Label(nav2, text="", font=("Segoe UI", 11, "bold"),
                               bg="#B9ECFA", fg="#1a4d6d")
                df2 = tk.Frame(dcal, bg="#E8F4FA", padx=4, pady=4)
                df2.pack(fill="both")

                def upd2():
                    ml2.configure(text=f"{cal_mod.month_name[cur[1]]} {cur[0]}")
                    for w2 in df2.winfo_children():
                        w2.destroy()
                    for c2, wd2 in enumerate(["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]):
                        fg2 = "#C03030" if c2 >= 5 else "#4a8aaa"
                        tk.Label(df2, text=wd2, font=("Segoe UI", 9, "bold"),
                                 bg="#E8F4FA", fg=fg2, width=4).grid(row=0, column=c2)
                    fw, nd = cal_mod.monthrange(cur[0], cur[1])
                    r2, c2 = 1, fw
                    for dy in range(1, nd + 1):
                        dd = date(cur[0], cur[1], dy)
                        sel = (dd == det_date[0])
                        bg2 = "#5B8DB3" if sel else ("#D4EEF7" if dd == t else "#F5FCFF")
                        fg2 = "white" if sel else ("#999" if dd < t else "#1a4d6d")
                        lb2 = tk.Label(df2, text=str(dy), font=("Segoe UI", 10),
                                       bg=bg2, fg=fg2, width=4, cursor="hand2")
                        lb2.grid(row=r2, column=c2, padx=1, pady=1)
                        lb2.bind("<Button-1>", lambda e, d2=dd: (det_set_date(d2), dcal.destroy()))
                        c2 += 1
                        if c2 > 6:
                            c2 = 0
                            r2 += 1

                def pm2():
                    cur[1] -= 1
                    if cur[1] < 1:
                        cur[1] = 12
                        cur[0] -= 1
                    upd2()

                def nm2():
                    cur[1] += 1
                    if cur[1] > 12:
                        cur[1] = 1
                        cur[0] += 1
                    upd2()

                tk.Label(nav2, text="◀", font=("Segoe UI", 12), bg="#B9ECFA",
                         fg="#1a4d6d", cursor="hand2", padx=8).pack(side="left")
                nav2.winfo_children()[-1].bind("<Button-1>", lambda e: pm2())
                ml2.pack(side="left", fill="x", expand=True)
                tk.Label(nav2, text="▶", font=("Segoe UI", 12), bg="#B9ECFA",
                         fg="#1a4d6d", cursor="hand2", padx=8).pack(side="right")
                nav2.winfo_children()[-1].bind("<Button-1>", lambda e: nm2())

                q2 = tk.Frame(dcal, bg="#D4EEF7", pady=4)
                q2.pack(fill="x")
                for lt, dl in [("Heute", 0), ("Morgen", 1), ("+1 Wo", 7)]:
                    dd = t + timedelta(days=dl)
                    tk.Button(q2, text=lt, font=("Segoe UI", 8), bg="#C8DDE6", fg="#1a4d6d",
                              relief="flat", bd=0, padx=6, cursor="hand2",
                              command=lambda d2=dd: (det_set_date(d2), dcal.destroy())).pack(side="left", padx=2)
                tk.Button(q2, text="Kein Datum", font=("Segoe UI", 8), bg="#E0E0E0", fg="#666",
                          relief="flat", bd=0, padx=6, cursor="hand2",
                          command=lambda: (det_set_date(None), dcal.destroy())).pack(side="right", padx=2)
                upd2()
                dcal.update_idletasks()
                dcal.geometry(f"+{det.winfo_x()+30}+{det.winfo_y()+100}")

            tk.Button(date_row, text="📅", font=("Segoe UI", 12), bg="#E8F4FA", fg="#1a4d6d",
                      relief="flat", bd=0, cursor="hand2", command=det_open_cal).pack(side="left")

            # Priorität
            prio_row = tk.Frame(content, bg="#E8F4FA")
            prio_row.pack(fill="x", pady=(0, 8))
            tk.Label(prio_row, text="Priorität:", font=("Segoe UI", 9, "bold"),
                     bg="#E8F4FA", fg="#1a4d6d").pack(side="left")

            prio_var = tk.IntVar(value=todo.get("priority", 0))

            prio_colors = {0: ("#E8F4FA", "#1a4d6d"), 1: ("#F8D0D0", "#A03030"), 2: ("#F8ECC8", "#806000")}
            prio_labels = {0: "Keine", 1: "🔴 Hoch", 2: "🟡 Mittel"}
            prio_btns = {}

            def set_prio(p):
                prio_var.set(p)
                for pp, b in prio_btns.items():
                    bg_c, fg_c = prio_colors[pp]
                    if pp == p:
                        b.configure(relief="solid", bd=2)
                    else:
                        b.configure(relief="flat", bd=1)

            for p_val in [1, 2, 0]:
                bg_c, fg_c = prio_colors[p_val]
                b = tk.Button(prio_row, text=prio_labels[p_val], font=("Segoe UI", 9),
                              bg=bg_c, fg=fg_c, activebackground=bg_c,
                              relief="solid" if p_val == prio_var.get() else "flat",
                              bd=2 if p_val == prio_var.get() else 1,
                              padx=8, pady=1, cursor="hand2",
                              command=lambda pv=p_val: set_prio(pv))
                b.pack(side="left", padx=(6, 0))
                prio_btns[p_val] = b

            # Speichern
            def save_detail():
                new_text = text_edit.get("1.0", "end").strip()
                if not new_text:
                    messagebox.showwarning("Fehler", "Aufgabentext darf nicht leer sein.", parent=det)
                    return
                todos[idx]["text"] = new_text
                todos[idx]["notes"] = notes_edit.get("1.0", "end").strip()
                todos[idx]["date"] = det_date[0].isoformat() if det_date[0] else None
                todos[idx]["priority"] = prio_var.get()
                det.destroy()
                rebuild_list()

            btn_frame = tk.Frame(det, bg="#D4EEF7", pady=8)
            btn_frame.pack(fill="x", side="bottom")
            tk.Button(btn_frame, text="💾 Speichern", font=("Segoe UI", 11, "bold"),
                      bg="#5B8DB3", fg="white", activebackground="#4A7A9E",
                      relief="flat", bd=0, padx=20, pady=4, cursor="hand2",
                      command=save_detail).pack(side="left", padx=12)
            tk.Button(btn_frame, text="Abbrechen", font=("Segoe UI", 10),
                      bg="#C8DDE6", fg="#1a4d6d", activebackground="#B8CDD6",
                      relief="flat", bd=0, padx=12, pady=4, cursor="hand2",
                      command=det.destroy).pack(side="right", padx=12)

        # ─── Logik ───
        def update_counter():
            done = sum(1 for t in todos if t.get("done"))
            total = len(todos)
            overdue = 0
            today_str = date.today().isoformat()
            for t in todos:
                if not t.get("done") and t.get("date") and t["date"] < today_str:
                    overdue += 1
            text = f"{done}/{total} erledigt"
            if overdue:
                text += f"  ·  {overdue} überfällig"
            counter_label.configure(text=text)

        # ─── Rechtsklick-Kontextmenü ───
        ctx_menu = tk.Menu(win, tearoff=0, font=("Segoe UI", 9))
        _ctx_idx = [None]

        def _ctx_set_prio(p):
            i = _ctx_idx[0]
            if i is not None and 0 <= i < len(todos):
                todos[i]["priority"] = p
                rebuild_list()

        def _ctx_send_medwork():
            i = _ctx_idx[0]
            if i is not None and 0 <= i < len(todos):
                _send_items_to_medwork([todos[i]])

        def _ctx_send_email():
            i = _ctx_idx[0]
            if i is not None and 0 <= i < len(todos):
                _send_items_via_email([todos[i]])

        def _show_context_menu(event, idx):
            _ctx_idx[0] = idx
            ctx_menu.delete(0, "end")
            prio_menu = tk.Menu(ctx_menu, tearoff=0, font=("Segoe UI", 9))
            prio_menu.add_command(label="🔴 Hoch (1)", command=lambda: _ctx_set_prio(1))
            prio_menu.add_command(label="🟡 Mittel (2)", command=lambda: _ctx_set_prio(2))
            prio_menu.add_command(label="Keine", command=lambda: _ctx_set_prio(0))
            ctx_menu.add_cascade(label="Priorität setzen", menu=prio_menu)
            ctx_menu.add_separator()
            ctx_menu.add_command(label="📤 An MedWork senden", command=_ctx_send_medwork)
            ctx_menu.add_command(label="✉ Per E-Mail senden", command=_ctx_send_email)
            ctx_menu.tk_popup(event.x_root, event.y_root)

        # ─── Drag-and-Drop State ───
        _drag = {"active": False, "idx": None, "indicator": None}
        _border_frames = []

        def _drag_start(event, idx):
            _drag["active"] = True
            _drag["idx"] = idx
            event.widget.configure(cursor="fleur")
            if 0 <= idx < len(_border_frames):
                _border_frames[idx].configure(bg="#5B8DB3")

        def _drag_motion(event, idx):
            if not _drag["active"]:
                return
            abs_y = event.widget.winfo_rooty() + event.y
            target = _find_drop_target(abs_y)
            if _drag.get("indicator"):
                _drag["indicator"].destroy()
                _drag["indicator"] = None
            if target is not None and target != _drag["idx"]:
                insert_before = target
                if insert_before < len(_border_frames):
                    ind = tk.Frame(list_frame, bg="#5B8DB3", height=3)
                    ind.pack(before=_border_frames[insert_before], fill="x", pady=0)
                else:
                    ind = tk.Frame(list_frame, bg="#5B8DB3", height=3)
                    ind.pack(fill="x", pady=0)
                _drag["indicator"] = ind

        def _drag_end(event, idx):
            if not _drag["active"]:
                return
            _drag["active"] = False
            if _drag.get("indicator"):
                _drag["indicator"].destroy()
                _drag["indicator"] = None
            event.widget.configure(cursor="hand2")
            abs_y = event.widget.winfo_rooty() + event.y
            target = _find_drop_target(abs_y)
            src = _drag["idx"]
            if target is not None and target != src:
                item = todos.pop(src)
                if target > src:
                    target -= 1
                todos.insert(target, item)
                save_todos(todos)
                rebuild_list()
            else:
                if 0 <= src < len(_border_frames):
                    rebuild_list()

        def _find_drop_target(abs_y):
            for i, bf in enumerate(_border_frames):
                try:
                    wy = bf.winfo_rooty()
                    wh = bf.winfo_height()
                    mid = wy + wh // 2
                    if abs_y < mid:
                        return i
                except Exception:
                    pass
            return len(_border_frames)

        def rebuild_list():
            for w in list_frame.winfo_children():
                w.destroy()
            todo_widgets.clear()
            send_selection.clear()
            _border_frames.clear()
            today_str = date.today().isoformat()

            active_cat = _active_category[0]

            for idx, todo in enumerate(todos):
                todo_cat = todo.get("category", "Allgemein")
                if active_cat != "Alle" and todo_cat != active_cat:
                    continue
                is_done = todo.get("done", False)
                has_date = bool(todo.get("date"))
                is_overdue = has_date and not is_done and todo["date"] < today_str
                prio = todo.get("priority", 0)
                from_sender = todo.get("sender", "")

                if is_overdue:
                    row_bg = "#FDECEC"
                    border_color = "#E87070"
                elif is_done:
                    row_bg = "#EDF7ED"
                    border_color = "#A8D8A8"
                elif prio == 1:
                    row_bg = "#FDE8E8"
                    border_color = "#E8A0A0"
                elif prio == 2:
                    row_bg = "#FDF5E0"
                    border_color = "#E8D090"
                else:
                    row_bg = "white"
                    border_color = "#D0E8F0"

                border_frame = tk.Frame(list_frame, bg=border_color, padx=1, pady=1)
                border_frame.pack(fill="x", pady=2)
                _border_frames.append(border_frame)

                row = tk.Frame(border_frame, bg=row_bg, padx=4, pady=6)
                row.pack(fill="x")

                # Rechtsklick auf Zeile
                row.bind("<Button-3>", lambda e, i=idx: _show_context_menu(e, i))

                # ≡ Drag-Handle
                drag_handle = tk.Label(row, text="≡", font=("Segoe UI", 12, "bold"),
                                       bg=row_bg, fg="#B0C8D8", cursor="hand2")
                drag_handle.pack(side="left", padx=(0, 2))
                drag_handle.bind("<Button-1>", lambda e, i=idx: _drag_start(e, i))
                drag_handle.bind("<B1-Motion>", lambda e, i=idx: _drag_motion(e, i))
                drag_handle.bind("<ButtonRelease-1>", lambda e, i=idx: _drag_end(e, i))
                drag_handle.bind("<Enter>", lambda e, h=drag_handle: h.configure(fg="#5B8DB3"))
                drag_handle.bind("<Leave>", lambda e, h=drag_handle: h.configure(fg="#B0C8D8"))

                # Checkbox erledigt
                var = tk.BooleanVar(value=is_done)
                cb = tk.Checkbutton(row, variable=var, bg=row_bg, activebackground=row_bg,
                                    command=lambda i=idx, v=var: toggle_done(i, v))
                cb.pack(side="left")

                # Prioritäts-Indikator
                if prio == 1 and not is_done:
                    tk.Label(row, text="🔴", font=("Segoe UI", 8), bg=row_bg).pack(side="left")
                elif prio == 2 and not is_done:
                    tk.Label(row, text="🟡", font=("Segoe UI", 8), bg=row_bg).pack(side="left")

                # Kategorie-Badge
                _cat_colors = {"Allgemein": "#B9ECFA", "MPA": "#D4EEF7", "Ärzte": "#C8E0F0"}
                _cat_fg = {"Allgemein": "#4a8aaa", "MPA": "#2E7D5B", "Ärzte": "#5B6DB3"}
                if active_cat == "Alle":
                    cat_text = todo_cat[:3]
                    cat_bg = _cat_colors.get(todo_cat, "#D0E8F0")
                    cat_fgc = _cat_fg.get(todo_cat, "#4a8aaa")
                    tk.Label(row, text=cat_text, font=("Segoe UI", 6),
                             bg=cat_bg, fg=cat_fgc, padx=3, pady=0,
                             relief="flat", bd=0).pack(side="left", padx=(0, 2))

                # Absender-Info bei empfangenen Aufgaben
                if from_sender:
                    tk.Label(row, text=f"← {from_sender}", font=("Segoe UI", 7, "italic"),
                             bg=row_bg, fg="#7EC8E3").pack(side="left", padx=(0, 4))

                # Text (klickbar → öffnet Detail)
                text_fg = "#999" if is_done else ("#C03030" if is_overdue else "#1a4d6d")
                fs = todo_font_size[0]
                text_font = ("Segoe UI", fs, "overstrike") if is_done else ("Segoe UI", fs)
                lbl = tk.Label(row, text=todo["text"], font=text_font, bg=row_bg, fg=text_fg,
                               anchor="w", wraplength=250, justify="left", cursor="hand2")
                lbl.pack(side="left", fill="x", expand=True, padx=(4, 4))
                lbl.bind("<Button-1>", lambda e, i=idx: open_detail(i))
                lbl.bind("<Button-3>", lambda e, i=idx: _show_context_menu(e, i))

                # Notiz-Indikator
                if todo.get("notes", "").strip():
                    tk.Label(row, text="📝", font=("Segoe UI", 8), bg=row_bg).pack(side="left")

                right_f = tk.Frame(row, bg=row_bg)
                right_f.pack(side="right")

                # "senden"-Checkbox (unauffällig, rechts)
                send_var = tk.BooleanVar(value=False)
                send_selection[idx] = send_var
                send_cb = tk.Checkbutton(right_f, variable=send_var, bg=row_bg,
                                         activebackground=row_bg, highlightthickness=0, bd=0)
                send_cb.pack(side="right", padx=(4, 0))
                send_lbl = tk.Label(right_f, text="senden", font=("Segoe UI", 7),
                                    bg=row_bg, fg="#A0C8D8", cursor="hand2")
                send_lbl.pack(side="right")
                send_lbl.bind("<Button-1>", lambda e, sv=send_var: sv.set(not sv.get()))

                if has_date:
                    try:
                        dt = datetime.strptime(todo["date"], "%Y-%m-%d")
                        date_text = dt.strftime("%d.%m.%Y")
                    except Exception:
                        date_text = todo["date"]
                    if is_overdue:
                        date_fg = "#C03030"
                        date_text = f"⚠ {date_text}"
                    elif is_done:
                        date_fg = "#999"
                    else:
                        date_fg = "#4a8aaa"
                    tk.Label(right_f, text=date_text, font=("Segoe UI", 8), bg=row_bg,
                             fg=date_fg).pack(side="right", padx=(0, 6))

                del_lbl = tk.Label(right_f, text="✕", font=("Segoe UI", 10), bg=row_bg,
                                   fg="#ccc", cursor="hand2")
                del_lbl.pack(side="right", padx=(0, 4))
                del_lbl.bind("<Enter>", lambda e, b=del_lbl: b.configure(fg="#E87070"))
                del_lbl.bind("<Leave>", lambda e, b=del_lbl: b.configure(fg="#ccc"))
                del_lbl.bind("<Button-1>", lambda e, i=idx: delete_todo(i))

                todo_widgets.append(row)

            update_counter()
            save_todos(todos)
            _bind_mousewheel_recursive(list_frame)

        def add_todo(event=None):
            text = entry_var.get().strip()
            if not text or text == "Neue Aufgabe eingeben oder diktieren…":
                return
            date_iso = selected_date[0].isoformat() if selected_date[0] else None
            new_item = {
                "id": int(datetime.now().timestamp() * 1000),
                "text": text,
                "done": False,
                "date": date_iso,
                "priority": 0,
                "notes": "",
                "created": datetime.now().isoformat(),
                "category": _get_new_todo_category(),
            }
            todos.append(new_item)
            entry_var.set("")
            entry.delete(0, "end")
            entry.insert(0, "Neue Aufgabe eingeben oder diktieren…")
            entry.configure(fg="#999")
            clear_date()
            rec_status_var.set("")
            rebuild_list()

        def toggle_done(idx, var):
            if 0 <= idx < len(todos):
                todos[idx]["done"] = var.get()
                rebuild_list()

        def delete_todo(idx):
            if 0 <= idx < len(todos):
                todos.pop(idx)
                rebuild_list()

        def delete_done():
            i = 0
            while i < len(todos):
                if todos[i].get("done"):
                    todos.pop(i)
                else:
                    i += 1
            rebuild_list()

        add_btn.configure(command=add_todo)
        entry.bind("<Return>", add_todo)
        btn_del_done.configure(command=delete_done)

        rebuild_list()
        entry.focus_set()

        if _need_initial_rebuild[0] == "notes":
            win.after(200, _rebuild_notes_list)
        elif _need_initial_rebuild[0] == "checklist":
            win.after(200, _rebuild_checklist)

        if imported_count > 0:
            win.after(300, lambda: messagebox.showinfo(
                "Neue Aufgaben",
                f"📥 {imported_count} neue Aufgabe(n) empfangen!",
                parent=win))