"""
Whisper Dictation — local GPU speech-to-text with system tray and settings GUI.
Hold hotkey to record, release to transcribe and type into active window.
"""
import json
import os
import threading
import time
import tkinter as tk
from tkinter import ttk

import numpy as np
import sounddevice as sd
import keyboard
import pystray
from PIL import Image, ImageDraw
from pynput.keyboard import Controller as KeyboardController
from faster_whisper import WhisperModel

# Shared data dir: script directory (= git repo root, synced via git pull).
_script_dir = os.path.dirname(os.path.abspath(__file__))
DATA_DIR    = os.environ.get("WHISPER_DATA_DIR", _script_dir)
os.makedirs(DATA_DIR, exist_ok=True)

# Local config dir: machine-specific settings (audio device, device, compute_type).
# Windows: %LOCALAPPDATA%\WhisperDictation
# Linux:   ~/.local/share/WhisperDictation
_env_local = os.environ.get("WHISPER_LOCAL_DIR")
if _env_local:
    _local_dir = _env_local
elif os.name == "nt":
    _local_dir = os.path.join(os.environ.get("LOCALAPPDATA", _script_dir), "WhisperDictation")
else:
    _local_dir = os.path.join(os.path.expanduser("~"), ".local", "share", "WhisperDictation")
os.makedirs(_local_dir, exist_ok=True)

CONFIG_FILE       = os.path.join(DATA_DIR,   "config.json")      # shared via git
CONFIG_LOCAL_FILE = os.path.join(_local_dir, "config_local.json") # machine-specific, not in git
VOCAB_FILE        = os.path.join(DATA_DIR,   "vocabulary.json")   # shared via git

DEFAULT_CONFIG = {
    "hotkey": "ctrl+shift+space",
    "model": "medium",
    "device": "cuda",
    "compute_type": "float16",
    "language": "de",
    "audio_device": None,
    "sample_rate": 16000,
}

MODELS = ["tiny", "base", "small", "medium", "large-v2", "large-v3"]
LANGUAGES = {"Deutsch": "de", "English": "en", "Français": "fr", "Español": "es", "Italiano": "it", "Auto": None}
DEVICES = ["cuda", "cpu"]
COMPUTE_TYPES = {"float16 (GPU)": "float16", "int8 (CPU/GPU)": "int8", "float32": "float32"}


# ── State ─────────────────────────────────────────────────────────────────────

class AppState:
    IDLE = "idle"
    RECORDING = "recording"
    TRANSCRIBING = "transcribing"

state = AppState.IDLE
audio_chunks = []
model = None
typer = KeyboardController()
config = {}
tray_icon = None
overlay_window = None
overlay_tk = None


# ── Config ────────────────────────────────────────────────────────────────────

LOCAL_KEYS = {"audio_device", "device", "compute_type"}  # keys stored only in config_local.json

def load_config():
    global config
    config = dict(DEFAULT_CONFIG)
    if os.path.exists(CONFIG_FILE):
        with open(CONFIG_FILE) as f:
            config.update(json.load(f))
    if os.path.exists(CONFIG_LOCAL_FILE):
        with open(CONFIG_LOCAL_FILE) as f:
            config.update(json.load(f))

def save_config():
    shared = {k: v for k, v in config.items() if k not in LOCAL_KEYS}
    local  = {k: v for k, v in config.items() if k in LOCAL_KEYS}
    with open(CONFIG_FILE, "w") as f:
        json.dump(shared, f, indent=2)
    with open(CONFIG_LOCAL_FILE, "w") as f:
        json.dump(local, f, indent=2)


# ── Vocabulary ────────────────────────────────────────────────────────────────

vocab = {"words": [], "replacements": []}  # {from, to}

def load_vocab():
    global vocab
    if os.path.exists(VOCAB_FILE):
        with open(VOCAB_FILE) as f:
            vocab = json.load(f)
    else:
        vocab = {"words": [], "replacements": []}

def save_vocab():
    with open(VOCAB_FILE, "w") as f:
        json.dump(vocab, f, indent=2, ensure_ascii=False)

def apply_vocab(text: str) -> str:
    for r in vocab.get("replacements", []):
        text = text.replace(r["from"], r["to"])
    return text

def get_initial_prompt() -> str:
    words = vocab.get("words", [])
    return ", ".join(words) if words else ""


# ── Tray icon ─────────────────────────────────────────────────────────────────

def make_icon(color):
    img = Image.new("RGBA", (64, 64), (0, 0, 0, 0))
    d = ImageDraw.Draw(img)
    d.ellipse([4, 4, 60, 60], fill=color)
    return img

ICONS = {
    AppState.IDLE:         make_icon((40, 200, 80)),
    AppState.RECORDING:    make_icon((220, 50, 50)),
    AppState.TRANSCRIBING: make_icon((220, 180, 30)),
}

def set_state(new_state):
    global state
    state = new_state
    if tray_icon:
        tray_icon.icon = ICONS[new_state]
    if new_state == AppState.RECORDING:
        show_overlay()
    else:
        hide_overlay()


# ── Overlay window ────────────────────────────────────────────────────────────

def show_overlay():
    if overlay_tk is None:
        return
    overlay_tk.after(0, _show_overlay_main)

def hide_overlay():
    if overlay_tk is None:
        return
    overlay_tk.after(0, _hide_overlay_main)

def _show_overlay_main():
    overlay_window.deiconify()
    # Position bottom-right
    sw = overlay_tk.winfo_screenwidth()
    sh = overlay_tk.winfo_screenheight()
    overlay_window.geometry(f"220x54+{sw - 240}+{sh - 100}")
    overlay_window.lift()

def _hide_overlay_main():
    overlay_window.withdraw()

def create_overlay(root):
    global overlay_window
    win = tk.Toplevel(root)
    win.withdraw()
    win.overrideredirect(True)
    win.attributes("-topmost", True)
    win.attributes("-alpha", 0.92)
    win.configure(bg="#1a1a1a")

    frame = tk.Frame(win, bg="#1a1a1a", padx=12, pady=10)
    frame.pack(fill="both", expand=True)

    dot = tk.Canvas(frame, width=14, height=14, bg="#1a1a1a", highlightthickness=0)
    dot.create_oval(2, 2, 12, 12, fill="#e03030", outline="")
    dot.pack(side="left", padx=(0, 8))

    tk.Label(frame, text="Aufnahme läuft …", fg="white", bg="#1a1a1a",
             font=("Segoe UI", 11)).pack(side="left")

    overlay_window = win


# ── Audio ─────────────────────────────────────────────────────────────────────

def audio_callback(indata, frames, time_info, status):
    if state == AppState.RECORDING:
        audio_chunks.append(indata.copy())

def get_audio_stream():
    device = config.get("audio_device")
    return sd.InputStream(
        samplerate=config["sample_rate"],
        channels=1,
        device=device,
        callback=audio_callback,
    )


# ── Recording & transcription ─────────────────────────────────────────────────

def start_recording():
    global audio_chunks
    if state == AppState.RECORDING:
        return
    audio_chunks = []
    set_state(AppState.RECORDING)
    print("Recording...", flush=True)

def stop_and_transcribe():
    if state != AppState.RECORDING:
        return
    set_state(AppState.TRANSCRIBING)
    chunks = list(audio_chunks)

    if not chunks:
        set_state(AppState.IDLE)
        return

    audio = np.concatenate(chunks, axis=0).flatten().astype(np.float32)
    duration = len(audio) / config["sample_rate"]
    rms = float(np.sqrt(np.mean(audio ** 2)))
    print(f"Audio: {duration:.1f}s  RMS: {rms:.5f}", flush=True)

    if duration < 0.3 or rms < 0.0005:
        print("Too short or silent — skipped.", flush=True)
        set_state(AppState.IDLE)
        return

    lang = config["language"] if config["language"] else None
    prompt = get_initial_prompt()
    segments, _ = model.transcribe(
        audio, language=lang, beam_size=5, vad_filter=True,
        initial_prompt=prompt if prompt else None,
    )
    text = " ".join(s.text for s in segments).strip()
    text = apply_vocab(text)
    print(f"Result: {repr(text)}", flush=True)

    set_state(AppState.IDLE)
    if text:
        time.sleep(0.15)
        typer.type(text)

def on_space_release(e):
    if state == AppState.RECORDING:
        threading.Thread(target=stop_and_transcribe, daemon=True).start()


# ── Model loading ─────────────────────────────────────────────────────────────

def load_model():
    global model
    print(f"Loading {config['model']} on {config['device']}...", flush=True)
    model = WhisperModel(
        config["model"],
        device=config["device"],
        compute_type=config["compute_type"],
    )
    print("Model ready.", flush=True)


# ── Settings window ───────────────────────────────────────────────────────────

def open_settings():
    if overlay_tk is None:
        return
    overlay_tk.after(0, _open_settings_main)

def _open_settings_main():
    # ── Palette: "Precision Audio" ──────────────────────────────────────────
    BG      = "#18181f"   # deep void
    BG2     = "#22222c"   # panel
    BG3     = "#2c2c38"   # elevated
    BORDER  = "#38384a"
    FG      = "#e8e8f0"
    FG2     = "#7878a0"
    AMBER   = "#f5a623"
    AMBER2  = "#c8831a"
    GREEN   = "#4ade80"
    FONT    = ("Consolas", 11)
    FONT_UI = ("Segoe UI", 11)
    FONT_B  = ("Segoe UI", 11, "bold")
    FONT_S  = ("Segoe UI", 9)
    FONT_H  = ("Segoe UI Semibold", 16)

    win = tk.Toplevel(overlay_tk)
    win.title("Whisper Dictation")
    win.configure(bg=BG)
    win.attributes("-topmost", True)
    win.resizable(False, False)

    # Center
    W, H = 680, 660
    win.update_idletasks()
    sw, sh = win.winfo_screenwidth(), win.winfo_screenheight()
    win.geometry(f"{W}x{H}+{(sw-W)//2}+{(sh-H)//2}")

    # Global option for OptionMenu dropdowns (dark listbox)
    win.option_add("*Menu.background",       BG3)
    win.option_add("*Menu.foreground",        FG)
    win.option_add("*Menu.activeBackground",  AMBER)
    win.option_add("*Menu.activeForeground",  BG)
    win.option_add("*Menu.font",              FONT_UI)

    # ── Header ──
    hdr = tk.Frame(win, bg=BG2, pady=20)
    hdr.pack(fill="x")
    # Amber accent bar
    tk.Frame(hdr, bg=AMBER, height=3).pack(fill="x")
    tk.Label(hdr, text="WHISPER DICTATION", font=FONT_H,
             bg=BG2, fg=FG, pady=12).pack()
    tk.Label(hdr, text="Lokale GPU-Transkription  ·  offline  ·  privat",
             font=FONT_S, bg=BG2, fg=FG2).pack()

    # ── Scrollable content ──
    canvas = tk.Canvas(win, bg=BG, highlightthickness=0)
    canvas.pack(fill="both", expand=True)
    content = tk.Frame(canvas, bg=BG, padx=36, pady=16)
    canvas.create_window((0, 0), window=content, anchor="nw")

    def section(label):
        f = tk.Frame(content, bg=BG)
        f.pack(fill="x", pady=(18, 6))
        tk.Label(f, text=label, font=("Consolas", 9, "bold"),
                 bg=BG, fg=AMBER).pack(side="left")
        tk.Frame(f, bg=BORDER, height=1).pack(side="left", fill="x", expand=True, padx=(10, 0), pady=6)

    def dd(frame, var, values, width=14):
        """Create dark OptionMenu directly in frame as parent."""
        m = tk.OptionMenu(frame, var, *values)
        m.config(bg=BG3, fg=FG, activebackground=BG3, activeforeground=FG,
                 highlightbackground=BORDER, highlightthickness=1,
                 relief="flat", font=FONT_UI, anchor="w", bd=0, width=width)
        m["menu"].config(bg=BG3, fg=FG, activebackground=AMBER,
                         activeforeground=BG, relief="flat", bd=0)
        return m

    def row(label, hint=None):
        """Returns frame — add controls to frame after calling."""
        f = tk.Frame(content, bg=BG)
        f.pack(fill="x", pady=5)
        tk.Label(f, text=label, width=17, anchor="w", font=FONT_UI,
                 bg=BG, fg=FG2).pack(side="left")
        if hint:
            tk.Label(f, text=hint, font=FONT_S, bg=BG, fg=FG2).pack(side="right")
        return f

    # ── AUDIO ──
    section("AUDIO")
    devices = [(i, d["name"]) for i, d in enumerate(sd.query_devices())
               if d["max_input_channels"] > 0]
    dev_names = ["Standard"] + [f"{i}: {n}" for i, n in devices]
    dev_var = tk.StringVar()
    cur_dev = config.get("audio_device")
    dev_var.set("Standard" if cur_dev is None else
                next((f"{i}: {n}" for i, n in devices if i == cur_dev), "Standard"))
    f = row("Mikrofon")
    dd(f, dev_var, dev_names, width=44).pack(side="left")

    # ── MODELL ──
    section("MODELL")
    model_hints = {
        "tiny":     "~1 GB VRAM  ·  sehr schnell",
        "base":     "~1 GB VRAM",
        "small":    "~2 GB VRAM",
        "medium":   "~5 GB VRAM  ·  empfohlen ✓",
        "large-v2": "~10 GB VRAM",
        "large-v3": "~10 GB VRAM  ·  bestes Ergebnis",
    }
    model_var = tk.StringVar(value=config["model"])
    f_model = row("Modell")
    dd(f_model, model_var, MODELS, 14).pack(side="left")
    hint_lbl = tk.Label(f_model, text=model_hints.get(config["model"], ""),
                        font=FONT_S, bg=BG, fg=FG2)
    hint_lbl.pack(side="left", padx=(14, 0))
    model_var.trace_add("write", lambda *_: hint_lbl.config(text=model_hints.get(model_var.get(), "")))

    lang_display = {v: k for k, v in LANGUAGES.items()}
    lang_var = tk.StringVar(value=lang_display.get(config["language"], "Deutsch"))
    f = row("Sprache")
    dd(f, lang_var, list(LANGUAGES.keys()), 14).pack(side="left")

    # ── LEISTUNG ──
    section("LEISTUNG")
    device_var = tk.StringVar(value=config["device"])
    f = row("Gerät (GPU/CPU)", hint="cuda = NVIDIA GPU empfohlen")
    dd(f, device_var, DEVICES, 8).pack(side="left")

    ct_display = {v: k for k, v in COMPUTE_TYPES.items()}
    ct_var = tk.StringVar(value=ct_display.get(config["compute_type"], "float16 (GPU)"))
    f = row("Compute Type")
    dd(f, ct_var, list(COMPUTE_TYPES.keys()), 18).pack(side="left")

    # ── STEUERUNG ──
    section("STEUERUNG")
    hotkey_var = tk.StringVar(value=config["hotkey"])
    f_hk = row("Hotkey", hint="z.B.  ctrl+shift+space")
    tk.Entry(f_hk, textvariable=hotkey_var, font=FONT, width=24,
             bg=BG3, fg=FG, insertbackground=AMBER,
             relief="flat", bd=6,
             highlightbackground=BORDER, highlightthickness=1).pack(side="left")

    # ── Buttons ──
    tk.Frame(win, bg=BORDER, height=1).pack(fill="x")
    btn_bar = tk.Frame(win, bg=BG2, pady=16, padx=32)
    btn_bar.pack(fill="x")

    def save():
        sel = dev_var.get()
        config["audio_device"] = None if sel == "Standard" else int(sel.split(":")[0])
        config["model"] = model_var.get()
        config["language"] = LANGUAGES[lang_var.get()]
        config["device"] = device_var.get()
        config["compute_type"] = COMPUTE_TYPES[ct_var.get()]
        config["hotkey"] = hotkey_var.get()
        save_config()
        win.destroy()
        threading.Thread(target=reload_model_and_hotkey, daemon=True).start()

    def btn_hover(b, c_in, c_out):
        b.bind("<Enter>", lambda _: b.config(bg=c_in))
        b.bind("<Leave>", lambda _: b.config(bg=c_out))

    save_btn = tk.Button(btn_bar, text="Speichern & Neuladen", command=save,
                         bg=AMBER, fg=BG, font=FONT_B,
                         relief="flat", padx=20, pady=9, cursor="hand2", bd=0)
    save_btn.pack(side="right")
    btn_hover(save_btn, AMBER2, AMBER)

    cancel_btn = tk.Button(btn_bar, text="Abbrechen", command=win.destroy,
                           bg=BG3, fg=FG2, font=FONT_UI,
                           relief="flat", padx=20, pady=9, cursor="hand2", bd=0)
    cancel_btn.pack(side="right", padx=(0, 10))
    btn_hover(cancel_btn, BORDER, BG3)


def open_vocab():
    if overlay_tk is None:
        return
    overlay_tk.after(0, _open_vocab_main)

def _open_vocab_main():
    BG     = "#18181f"
    BG2    = "#22222c"
    BG3    = "#2c2c38"
    BORDER = "#38384a"
    FG     = "#e8e8f0"
    FG2    = "#7878a0"
    AMBER  = "#f5a623"
    AMBER2 = "#c8831a"
    RED    = "#f87171"
    FONT   = ("Segoe UI", 11)
    FONT_B = ("Segoe UI", 11, "bold")
    FONT_S = ("Segoe UI", 9)
    FONT_H = ("Segoe UI Semibold", 14)
    FONT_M = ("Consolas", 10)

    win = tk.Toplevel(overlay_tk)
    win.title("Vokabular")
    win.configure(bg=BG)
    win.attributes("-topmost", True)
    win.resizable(False, False)
    W, H = 600, 620
    win.update_idletasks()
    sw, sh = win.winfo_screenwidth(), win.winfo_screenheight()
    win.geometry(f"{W}x{H}+{(sw-W)//2}+{(sh-H)//2}")
    win.option_add("*Menu.background", BG3)
    win.option_add("*Menu.foreground", FG)
    win.option_add("*Menu.activeBackground", AMBER)
    win.option_add("*Menu.activeForeground", BG)

    # ── Header ──
    hdr = tk.Frame(win, bg=BG2)
    hdr.pack(fill="x")
    tk.Frame(hdr, bg=AMBER, height=3).pack(fill="x")
    tk.Label(hdr, text="VOKABULAR & KORREKTUREN", font=FONT_H,
             bg=BG2, fg=FG, pady=14).pack()
    tk.Label(hdr, text="Wörter lernen  ·  Ersetzungen definieren",
             font=FONT_S, bg=BG2, fg=FG2).pack(pady=(0, 10))

    content = tk.Frame(win, bg=BG, padx=28, pady=12)
    content.pack(fill="both", expand=True)

    # ── Add-word form ─────────────────────────────────────────────────────────
    is_correction = tk.BooleanVar(value=False)

    form = tk.Frame(content, bg=BG3, padx=16, pady=14)
    form.pack(fill="x", pady=(0, 16))

    # Toggle row
    tog_row = tk.Frame(form, bg=BG3)
    tog_row.pack(fill="x", pady=(0, 10))
    tk.Label(tog_row, text="Korrektur (falsch → richtig)", font=FONT,
             bg=BG3, fg=FG).pack(side="left")

    def toggle_form(*_):
        if is_correction.get():
            entry_from.pack(side="left", padx=(0, 6))
            arrow_lbl.pack(side="left", padx=4)
            entry_to.pack(side="left")
            entry_word.pack_forget()
        else:
            entry_word.pack(side="left", fill="x", expand=True)
            entry_from.pack_forget()
            arrow_lbl.pack_forget()
            entry_to.pack_forget()

    tog_btn = tk.Checkbutton(tog_row, variable=is_correction, command=toggle_form,
                             bg=BG3, fg=FG2, activebackground=BG3,
                             selectcolor=AMBER, relief="flat", bd=0,
                             indicatoron=True)
    tog_btn.pack(side="right")

    # Input row
    inp_row = tk.Frame(form, bg=BG3)
    inp_row.pack(fill="x")

    entry_style = dict(font=FONT_M, bg=BG, fg=FG, insertbackground=AMBER,
                       relief="flat", bd=6, highlightbackground=BORDER, highlightthickness=1)

    entry_word = tk.Entry(inp_row, width=32, **entry_style)
    entry_word.insert(0, "")
    entry_from = tk.Entry(inp_row, width=14, **entry_style)
    arrow_lbl  = tk.Label(inp_row, text="→", font=("Segoe UI", 14), bg=BG3, fg=AMBER)
    entry_to   = tk.Entry(inp_row, width=14, **entry_style)
    entry_word.pack(side="left", fill="x", expand=True)

    def add_entry():
        if is_correction.get():
            frm = entry_from.get().strip()
            to  = entry_to.get().strip()
            if frm and to:
                vocab["replacements"].append({"from": frm, "to": to})
                entry_from.delete(0, tk.END)
                entry_to.delete(0, tk.END)
        else:
            w = entry_word.get().strip()
            if w and w not in vocab["words"]:
                vocab["words"].append(w)
                entry_word.delete(0, tk.END)
        save_vocab()
        refresh_lists()

    win.bind("<Return>", lambda _: add_entry())

    add_btn = tk.Button(inp_row, text="Hinzufügen", command=add_entry,
                        bg=AMBER, fg=BG, font=FONT_B,
                        relief="flat", padx=14, pady=5, cursor="hand2", bd=0)
    add_btn.pack(side="right", padx=(10, 0))
    add_btn.bind("<Enter>", lambda _: add_btn.config(bg=AMBER2))
    add_btn.bind("<Leave>", lambda _: add_btn.config(bg=AMBER))

    # ── Lists ─────────────────────────────────────────────────────────────────
    lists_frame = tk.Frame(content, bg=BG)
    lists_frame.pack(fill="both", expand=True)
    lists_frame.columnconfigure(0, weight=1)
    lists_frame.columnconfigure(1, weight=2)

    def section_label(parent, text):
        tk.Label(parent, text=text, font=("Consolas", 9, "bold"),
                 bg=BG, fg=AMBER).pack(anchor="w", pady=(0, 6))

    # Words column
    col_w = tk.Frame(lists_frame, bg=BG)
    col_w.grid(row=0, column=0, sticky="nsew", padx=(0, 12))
    section_label(col_w, "WÖRTER")

    words_box = tk.Listbox(col_w, font=FONT_M, bg=BG3, fg=FG,
                           selectbackground=AMBER, selectforeground=BG,
                           relief="flat", bd=0, highlightthickness=0,
                           activestyle="none", height=10)
    words_box.pack(fill="both", expand=True)

    def del_word():
        sel = words_box.curselection()
        if sel:
            vocab["words"].pop(sel[0])
            save_vocab()
            refresh_lists()

    tk.Button(col_w, text="− Entfernen", command=del_word,
              bg=BG3, fg=RED, font=FONT_S, relief="flat",
              padx=8, pady=3, cursor="hand2", bd=0).pack(anchor="e", pady=(4, 0))

    # Replacements column
    col_r = tk.Frame(lists_frame, bg=BG)
    col_r.grid(row=0, column=1, sticky="nsew")
    section_label(col_r, "KORREKTUREN")

    repl_box = tk.Listbox(col_r, font=FONT_M, bg=BG3, fg=FG,
                          selectbackground=AMBER, selectforeground=BG,
                          relief="flat", bd=0, highlightthickness=0,
                          activestyle="none", height=10)
    repl_box.pack(fill="both", expand=True)

    def del_repl():
        sel = repl_box.curselection()
        if sel:
            vocab["replacements"].pop(sel[0])
            save_vocab()
            refresh_lists()

    tk.Button(col_r, text="− Entfernen", command=del_repl,
              bg=BG3, fg=RED, font=FONT_S, relief="flat",
              padx=8, pady=3, cursor="hand2", bd=0).pack(anchor="e", pady=(4, 0))

    def refresh_lists():
        words_box.delete(0, tk.END)
        for w in vocab.get("words", []):
            words_box.insert(tk.END, f"  {w}")
        repl_box.delete(0, tk.END)
        for r in vocab.get("replacements", []):
            repl_box.insert(tk.END, f"  {r['from']}  →  {r['to']}")

    refresh_lists()

    # ── Footer ──
    tk.Frame(win, bg=BORDER, height=1).pack(fill="x")
    tk.Label(win, text="Wörter fließen als Kontext in Whisper ein  ·  Korrekturen werden nach der Transkription angewendet",
             font=FONT_S, bg=BG2, fg=FG2, pady=8).pack()


def reload_model_and_hotkey():
    keyboard.unhook_all()
    load_model()
    keyboard.add_hotkey(config["hotkey"], start_recording, suppress=True)
    keyboard.on_release_key(config["hotkey"].split("+")[-1], on_space_release)
    print(f"Hotkey updated: {config['hotkey']}", flush=True)


# ── Main ──────────────────────────────────────────────────────────────────────

def main():
    global tray_icon, overlay_tk

    load_config()
    load_vocab()
    load_model()

    # Tkinter root (hidden) for overlay and settings
    root = tk.Tk()
    root.withdraw()
    overlay_tk = root
    create_overlay(root)

    # Audio stream
    stream = get_audio_stream()
    stream.start()

    # Hotkey
    last_key = config["hotkey"].split("+")[-1]
    keyboard.add_hotkey(config["hotkey"], start_recording, suppress=True)
    keyboard.on_release_key(last_key, on_space_release)

    # Tray
    menu = pystray.Menu(
        pystray.MenuItem("Einstellungen", lambda: open_settings()),
        pystray.MenuItem("Vokabular", lambda: open_vocab()),
        pystray.Menu.SEPARATOR,
        pystray.MenuItem("Beenden", lambda: quit_app(stream)),
    )
    tray_icon = pystray.Icon("whisper", ICONS[AppState.IDLE], "Whisper Dictation", menu)

    threading.Thread(target=tray_icon.run, daemon=True).start()

    print(f"Ready. Hotkey: {config['hotkey']}", flush=True)
    root.mainloop()

    stream.stop()

def quit_app(stream):
    stream.stop()
    tray_icon.stop()
    overlay_tk.after(0, overlay_tk.quit)


if __name__ == "__main__":
    main()