gui.py

"""
GameTextbox GUI.

Moderne GUI mit customtkinter fuer das GameTextbox-Tool.
Live-Preview, Progress-Bar, threaded rendering.
"""
from __future__ import annotations

import os
import sys
import subprocess
import threading
import traceback
from pathlib import Path

import customtkinter as ctk
from PIL import Image
from tkinter import filedialog, messagebox

# PyInstaller-safe Pfadaufloesung
def _resource_base() -> Path:
    if getattr(sys, "frozen", False):
        return Path(sys._MEIPASS)  # type: ignore[attr-defined]
    return Path(__file__).parent

# damit Import in frozen + Dev funktioniert
sys.path.insert(0, str(_resource_base()))

from gametextbox import RenderConfig, TextboxRenderer, find_free_path  # noqa: E402
from presets import list_presets, get_preset  # noqa: E402


APP_TITLE = "GameTextbox"
APP_VERSION = "1.0"

ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue")


class GameTextboxGUI(ctk.CTk):
    def __init__(self):
        super().__init__()
        self.title(f"{APP_TITLE} {APP_VERSION} - Videospiel-Textbox Generator")
        self.geometry("1320x820")
        self.minsize(1100, 700)

        self._preview_job = None
        self._preview_image = None
        self._render_thread = None
        self._last_output = None

        self.grid_columnconfigure(1, weight=1)
        self.grid_rowconfigure(0, weight=1)

        self._build_left_panel()
        self._build_right_panel()
        self._build_status_bar()

        # erster Preview
        self.after(300, self._schedule_preview)

    # ---------- UI aufbauen ----------

    def _build_left_panel(self):
        left = ctk.CTkScrollableFrame(self, width=420, corner_radius=0)
        left.grid(row=0, column=0, sticky="ns", padx=0, pady=0)
        left.grid_columnconfigure(0, weight=1)

        row = 0

        ctk.CTkLabel(left, text="GameTextbox", font=ctk.CTkFont(size=26, weight="bold")).grid(
            row=row, column=0, sticky="w", padx=20, pady=(16, 0)
        )
        row += 1
        ctk.CTkLabel(
            left,
            text="Videospiel-Textbox mit Typewriter-Effekt",
            text_color="gray70",
        ).grid(row=row, column=0, sticky="w", padx=20, pady=(0, 18))
        row += 1

        # --- Text ---
        self._section(left, "Text", row); row += 1
        self.text_box = ctk.CTkTextbox(left, height=120, wrap="word")
        self.text_box.grid(row=row, column=0, sticky="ew", padx=20, pady=(0, 12))
        self.text_box.insert("0.0", "Hallo Welt!\nDas ist deine neue Textbox-Software.")
        self.text_box.bind("<KeyRelease>", lambda e: self._schedule_preview())
        row += 1

        # --- Preset ---
        self._section(left, "Style", row); row += 1
        preset_frame = ctk.CTkFrame(left, fg_color="transparent")
        preset_frame.grid(row=row, column=0, sticky="ew", padx=20, pady=(0, 12))
        preset_frame.grid_columnconfigure(0, weight=1)

        self.preset_var = ctk.StringVar(value="classic_rpg")
        self.preset_menu = ctk.CTkOptionMenu(
            preset_frame,
            values=list_presets(),
            variable=self.preset_var,
            command=lambda _: self._schedule_preview(),
        )
        self.preset_menu.grid(row=0, column=0, sticky="ew")
        row += 1

        # --- Geschwindigkeit ---
        self._section(left, "Typewriter-Geschwindigkeit", row); row += 1
        speed_frame = ctk.CTkFrame(left, fg_color="transparent")
        speed_frame.grid(row=row, column=0, sticky="ew", padx=20, pady=(0, 12))
        speed_frame.grid_columnconfigure(0, weight=1)

        self.speed_var = ctk.DoubleVar(value=35)
        self.speed_slider = ctk.CTkSlider(
            speed_frame,
            from_=8,
            to=80,
            variable=self.speed_var,
            command=lambda _v: (self._update_speed_label(), self._schedule_preview()),
        )
        self.speed_slider.grid(row=0, column=0, sticky="ew")
        self.speed_label = ctk.CTkLabel(speed_frame, text="35 CPS", width=70)
        self.speed_label.grid(row=0, column=1, padx=(10, 0))
        row += 1

        # --- Sprecher ---
        self._section(left, "Sprecher (nur Visual Novel)", row); row += 1
        self.speaker_entry = ctk.CTkEntry(left, placeholder_text="z.B. Mikshade")
        self.speaker_entry.grid(row=row, column=0, sticky="ew", padx=20, pady=(0, 12))
        self.speaker_entry.bind("<KeyRelease>", lambda e: self._schedule_preview())
        row += 1

        # --- Ausgabe ---
        self._section(left, "Ausgabe", row); row += 1
        out_frame = ctk.CTkFrame(left, fg_color="transparent")
        out_frame.grid(row=row, column=0, sticky="ew", padx=20, pady=(0, 8))
        out_frame.grid_columnconfigure(0, weight=1)

        default_out = str(Path.cwd() / "output" / "textbox.mov")
        self.output_entry = ctk.CTkEntry(out_frame)
        self.output_entry.grid(row=0, column=0, sticky="ew")
        self.output_entry.insert(0, default_out)
        ctk.CTkButton(out_frame, text="...", width=40, command=self._pick_output).grid(
            row=0, column=1, padx=(6, 0)
        )
        row += 1

        # Format + Breite
        fmt_frame = ctk.CTkFrame(left, fg_color="transparent")
        fmt_frame.grid(row=row, column=0, sticky="ew", padx=20, pady=(0, 12))
        fmt_frame.grid_columnconfigure((0, 1), weight=1)

        ctk.CTkLabel(fmt_frame, text="Format").grid(row=0, column=0, sticky="w")
        ctk.CTkLabel(fmt_frame, text="Breite").grid(row=0, column=1, sticky="w", padx=(10, 0))

        self.format_var = ctk.StringVar(value="prores")
        fmt_menu = ctk.CTkOptionMenu(
            fmt_frame,
            values=["prores", "webm"],
            variable=self.format_var,
            command=self._on_format_change,
        )
        fmt_menu.grid(row=1, column=0, sticky="ew")

        self.width_var = ctk.StringVar(value="1920")
        width_menu = ctk.CTkOptionMenu(
            fmt_frame,
            values=["1280", "1920", "2560", "3840"],
            variable=self.width_var,
            command=lambda _: self._schedule_preview(),
        )
        width_menu.grid(row=1, column=1, sticky="ew", padx=(10, 0))
        row += 1

        # FPS + Font-Size
        adv_frame = ctk.CTkFrame(left, fg_color="transparent")
        adv_frame.grid(row=row, column=0, sticky="ew", padx=20, pady=(0, 12))
        adv_frame.grid_columnconfigure((0, 1), weight=1)

        ctk.CTkLabel(adv_frame, text="FPS").grid(row=0, column=0, sticky="w")
        ctk.CTkLabel(adv_frame, text="Font-Groesse").grid(row=0, column=1, sticky="w", padx=(10, 0))

        self.fps_var = ctk.StringVar(value="60")
        fps_menu = ctk.CTkOptionMenu(
            adv_frame, values=["24", "25", "30", "60"], variable=self.fps_var
        )
        fps_menu.grid(row=1, column=0, sticky="ew")

        self.font_size_var = ctk.StringVar(value="auto")
        fs_menu = ctk.CTkOptionMenu(
            adv_frame,
            values=["auto", "32", "40", "48", "56", "64", "72"],
            variable=self.font_size_var,
            command=lambda _: self._schedule_preview(),
        )
        fs_menu.grid(row=1, column=1, sticky="ew", padx=(10, 0))
        row += 1

        # Font-Datei
        font_frame = ctk.CTkFrame(left, fg_color="transparent")
        font_frame.grid(row=row, column=0, sticky="ew", padx=20, pady=(0, 16))
        font_frame.grid_columnconfigure(0, weight=1)
        self.font_entry = ctk.CTkEntry(font_frame, placeholder_text="Font (optional, .ttf/.otf)")
        self.font_entry.grid(row=0, column=0, sticky="ew")
        self.font_entry.bind("<KeyRelease>", lambda e: self._schedule_preview())
        ctk.CTkButton(font_frame, text="...", width=40, command=self._pick_font).grid(
            row=0, column=1, padx=(6, 0)
        )
        row += 1

        # --- Render-Button ---
        self.render_btn = ctk.CTkButton(
            left,
            text="Video rendern",
            height=44,
            font=ctk.CTkFont(size=15, weight="bold"),
            command=self._on_render,
        )
        self.render_btn.grid(row=row, column=0, sticky="ew", padx=20, pady=(8, 8))
        row += 1

        # Open output-folder button
        self.open_btn = ctk.CTkButton(
            left,
            text="Ausgabe-Ordner oeffnen",
            command=self._open_output_folder,
            fg_color="gray30",
            hover_color="gray25",
        )
        self.open_btn.grid(row=row, column=0, sticky="ew", padx=20, pady=(0, 20))
        row += 1

    def _section(self, parent, text, row):
        ctk.CTkLabel(parent, text=text, font=ctk.CTkFont(size=13, weight="bold")).grid(
            row=row, column=0, sticky="w", padx=20, pady=(4, 4)
        )

    def _build_right_panel(self):
        right = ctk.CTkFrame(self, corner_radius=0, fg_color="gray15")
        right.grid(row=0, column=1, sticky="nsew")
        right.grid_rowconfigure(1, weight=1)
        right.grid_columnconfigure(0, weight=1)

        header = ctk.CTkFrame(right, fg_color="transparent")
        header.grid(row=0, column=0, sticky="ew", padx=24, pady=(18, 8))
        ctk.CTkLabel(
            header, text="Live-Vorschau", font=ctk.CTkFont(size=18, weight="bold")
        ).pack(side="left")
        self.preview_info = ctk.CTkLabel(header, text="", text_color="gray60")
        self.preview_info.pack(side="left", padx=(12, 0))

        self.preview_bg = ctk.CTkFrame(right, fg_color="gray10", corner_radius=8)
        self.preview_bg.grid(row=1, column=0, sticky="nsew", padx=24, pady=(0, 16))

        self.preview_label = ctk.CTkLabel(self.preview_bg, text="")
        self.preview_label.place(relx=0.5, rely=0.5, anchor="center")

    def _build_status_bar(self):
        bar = ctk.CTkFrame(self, height=72, corner_radius=0, fg_color="gray12")
        bar.grid(row=1, column=0, columnspan=2, sticky="ew")
        bar.grid_columnconfigure(1, weight=1)

        self.status_label = ctk.CTkLabel(bar, text="Bereit.", anchor="w", width=260)
        self.status_label.grid(row=0, column=0, sticky="w", padx=16, pady=(16, 2))

        self.progress = ctk.CTkProgressBar(bar)
        self.progress.grid(row=0, column=1, sticky="ew", padx=16, pady=(20, 2))
        self.progress.set(0)

        self.detail_label = ctk.CTkLabel(bar, text="", text_color="gray60", anchor="w")
        self.detail_label.grid(row=1, column=0, columnspan=2, sticky="w", padx=16, pady=(0, 10))

    # ---------- Actions ----------

    def _pick_output(self):
        initial = self.output_entry.get()
        is_prores = self.format_var.get() == "prores"
        defaultext = ".mov" if is_prores else ".webm"
        filetypes = [("QuickTime ProRes", "*.mov")] if is_prores else [("WebM", "*.webm")]
        filetypes.append(("Alle Dateien", "*.*"))
        p = filedialog.asksaveasfilename(
            initialfile=Path(initial).name,
            initialdir=Path(initial).parent if initial else str(Path.cwd()),
            defaultextension=defaultext,
            filetypes=filetypes,
        )
        if p:
            self.output_entry.delete(0, "end")
            self.output_entry.insert(0, p)

    def _pick_font(self):
        p = filedialog.askopenfilename(
            filetypes=[("Font-Dateien", "*.ttf *.otf"), ("Alle Dateien", "*.*")]
        )
        if p:
            self.font_entry.delete(0, "end")
            self.font_entry.insert(0, p)
            self._schedule_preview()

    def _open_output_folder(self):
        path = self._last_output if self._last_output else Path(self.output_entry.get()).parent
        path = Path(path)
        if path.is_file():
            path = path.parent
        if not path.exists():
            messagebox.showinfo(APP_TITLE, f"Ordner existiert noch nicht:\n{path}")
            return
        try:
            os.startfile(str(path))  # Windows
        except Exception:
            subprocess.run(["explorer", str(path)])

    def _on_format_change(self, value):
        # suffix in output-path anpassen
        current = self.output_entry.get()
        if current:
            p = Path(current)
            new_ext = ".mov" if value == "prores" else ".webm"
            new_path = str(p.with_suffix(new_ext))
            self.output_entry.delete(0, "end")
            self.output_entry.insert(0, new_path)

    def _update_speed_label(self):
        self.speed_label.configure(text=f"{int(self.speed_var.get())} CPS")

    # ---------- Preview ----------

    def _schedule_preview(self):
        if self._preview_job is not None:
            self.after_cancel(self._preview_job)
        self._preview_job = self.after(400, self._render_preview)

    def _build_config(self, for_preview: bool = False) -> RenderConfig:
        text = self.text_box.get("0.0", "end").strip("\n")
        preset_name = self.preset_var.get()
        width = int(self.width_var.get())
        fps = int(self.fps_var.get())

        overrides = {"animation": {"chars_per_second": float(self.speed_var.get())}}
        if self.font_size_var.get() != "auto":
            overrides["text"] = {"font_size": int(self.font_size_var.get())}

        font_path = self.font_entry.get().strip() or None

        output_path = self.output_entry.get().strip() or "output/textbox.mov"

        return RenderConfig(
            text=text if text else " ",
            width=width,
            height=280,
            fps=fps,
            preset=preset_name,
            font_path=font_path,
            speaker_name=self.speaker_entry.get().strip(),
            output_path=output_path,
            format=self.format_var.get(),
            overrides=overrides,
        )

    def _render_preview(self):
        self._preview_job = None
        try:
            cfg = self._build_config(for_preview=True)
            renderer = TextboxRenderer(cfg)
            # Frame nach Ende des Typewriters (Cursor sichtbar)
            total = renderer.total_frames()
            intro = renderer.anim_cfg["box_intro_frames"]
            import math as _m
            chars_frames = _m.ceil(
                renderer.total_chars * cfg.fps / renderer.anim_cfg["chars_per_second"]
            )
            show_frame = min(total - 1, intro + chars_frames + 3)
            img = renderer.render_frame(show_frame)

            # skalieren auf Preview-Area
            pv_w = max(400, self.preview_bg.winfo_width() - 40)
            pv_h = max(200, self.preview_bg.winfo_height() - 40)
            scale = min(pv_w / img.width, pv_h / img.height, 1.0)
            new_size = (max(1, int(img.width * scale)), max(1, int(img.height * scale)))

            display = img.resize(new_size, Image.LANCZOS)
            # Checkerboard background fuer Alpha-Hinweis
            bg = Image.new("RGBA", new_size, (0, 0, 0, 0))
            _draw_checkerboard(bg, cell=12)
            bg.alpha_composite(display)

            self._preview_image = ctk.CTkImage(bg, size=new_size)
            self.preview_label.configure(image=self._preview_image, text="")
            self.preview_info.configure(
                text=f"{img.width}x{img.height} | {total} Frames | {total / cfg.fps:.2f}s"
            )
        except Exception as e:
            self.preview_label.configure(image=None, text=f"Preview-Fehler:\n{e}")
            self.preview_info.configure(text="")

    # ---------- Rendering ----------

    def _on_render(self):
        if self._render_thread and self._render_thread.is_alive():
            return
        try:
            cfg = self._build_config()
        except Exception as e:
            messagebox.showerror(APP_TITLE, f"Ungueltige Konfiguration:\n{e}")
            return

        self.render_btn.configure(state="disabled", text="Rendere...")
        self.progress.set(0)
        self.status_label.configure(text="Starte Rendering...")
        self.detail_label.configure(text="")

        self._render_thread = threading.Thread(
            target=self._render_worker, args=(cfg,), daemon=True
        )
        self._render_thread.start()

    def _render_worker(self, cfg: RenderConfig):
        try:
            # Nicht ueberschreiben: freien Namen finden (auto _2, _3, ...)
            original_path = Path(cfg.output_path)
            resolved_path = find_free_path(original_path)
            if resolved_path != original_path:
                cfg.output_path = str(resolved_path)
                self.after(0, self._set_output_entry, str(resolved_path))
                self.after(
                    0,
                    self.detail_label.configure,
                    {"text": f"Datei existierte bereits, speichere als: {resolved_path.name}"},
                )

            renderer = TextboxRenderer(cfg)
            total = renderer.total_frames()

            def on_progress(stage, current, total_):
                if stage == "frames":
                    frac = 0.85 * (current / max(1, total))
                    self.after(0, self._update_progress, frac, f"Frame {current}/{total}")
                elif stage == "encode":
                    self.after(0, self._update_progress, 0.9, "Encodiere mit FFmpeg...")
                elif stage == "done":
                    self.after(0, self._update_progress, 1.0, "Fertig.")

            def on_log(msg):
                self.after(0, self.detail_label.configure, {"text": msg})

            out_path = renderer.render_video(
                progress_callback=on_progress, log_callback=on_log
            )
            self._last_output = out_path
            self.after(0, self._render_finished, True, str(out_path))
        except FileNotFoundError as e:
            self.after(0, self._render_finished, False, f"FFmpeg nicht gefunden: {e}")
        except Exception:
            tb = traceback.format_exc()
            self.after(0, self._render_finished, False, tb)

    def _update_progress(self, frac, detail):
        self.progress.set(frac)
        self.status_label.configure(text=detail)

    def _set_output_entry(self, path: str):
        self.output_entry.delete(0, "end")
        self.output_entry.insert(0, path)

    def _render_finished(self, success: bool, info: str):
        self.render_btn.configure(state="normal", text="Video rendern")
        if success:
            self.status_label.configure(text="Fertig!")
            self.detail_label.configure(text=f"Gespeichert: {info}")
            self.progress.set(1.0)
        else:
            self.status_label.configure(text="Fehler")
            self.detail_label.configure(text="Siehe Dialog")
            self.progress.set(0)
            messagebox.showerror(APP_TITLE, f"Rendering fehlgeschlagen:\n\n{info}")


def _draw_checkerboard(img: Image.Image, cell: int = 12):
    """Checkerboard-Hintergrund malen (zeigt Transparenz an)."""
    from PIL import ImageDraw
    d = ImageDraw.Draw(img)
    c1 = (60, 60, 60, 255)
    c2 = (90, 90, 90, 255)
    for y in range(0, img.height, cell):
        for x in range(0, img.width, cell):
            color = c1 if (x // cell + y // cell) % 2 == 0 else c2
            d.rectangle((x, y, x + cell, y + cell), fill=color)


def main():
    app = GameTextboxGUI()
    app.mainloop()


if __name__ == "__main__":
    main()