# Build: build.bat ausfuehren (aus dem Projekt-Root).
# Ergebnis: dist/AnwesenheitPDF/AnwesenheitPDF.exe + alle Abhaengigkeiten
# Build-Artefakte: build/  (temporaer, nicht committen)

import os
import sys
import threading
from datetime import date
from pathlib import Path
from typing import Any, Dict, List, Optional

import customtkinter as ctk
from tkinter import messagebox, filedialog

sys.path.insert(0, str(Path(__file__).parent))

from src.config_loader import load_config
from src.excel_reader import (
    extract_attendance,
    extract_persons,
    extract_year_from_filename,
)
from src.pdf_filler import fill_pdf
from src.validators import validate


# ---------------------------------------------------------------------------
# Module-level helpers
# ---------------------------------------------------------------------------

def _resource_path(relative: str) -> Path:
    """Absolute path to a bundled asset. Handles PyInstaller onefile mode."""
    if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
        return Path(sys._MEIPASS) / relative
    return Path(__file__).parent / relative


def _runtime_dir() -> Path:
    """Root directory for runtime folders (input/, output/, template/)."""
    if getattr(sys, "frozen", False):
        return Path(sys.executable).parent
    return Path(__file__).parent


def _scan_input_folder() -> Optional[Path]:
    """Return the single .xlsx in input/, or None if 0 or >1 found."""
    folder = _runtime_dir() / "input"
    if not folder.exists():
        return None
    files = list(folder.glob("*.xlsx"))
    return files[0] if len(files) == 1 else None


def _scan_template_folder() -> Optional[Path]:
    """Return the single .pdf in template/, or None if 0 or >1 found."""
    folder = _runtime_dir() / "template"
    if not folder.exists():
        return None
    files = list(folder.glob("*.pdf"))
    return files[0] if len(files) == 1 else None


def _count_output_pdfs(config: Dict[str, Any]) -> int:
    """Count .pdf files in the configured output directory."""
    out_dir = _runtime_dir() / config.get("output_dir", "output")
    if not out_dir.exists():
        return 0
    return len(list(out_dir.glob("*.pdf")))


def _build_month_keys(config: Dict[str, Any]) -> List[str]:
    """Return deduplicated month keys from config (preserves insertion order)."""
    seen: set = set()
    keys: List[str] = []
    for k, v in config.get("month_mapping", {}).items():
        if v not in seen:
            seen.add(v)
            keys.append(k)
    return keys


# ---------------------------------------------------------------------------
# Startup: load config once
# ---------------------------------------------------------------------------

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

try:
    _CONFIG: Dict[str, Any] = load_config()
    _CONFIG_ERROR: Optional[str] = None
except Exception as _exc:
    _CONFIG = {}
    _CONFIG_ERROR = str(_exc)

_MONTH_KEYS: List[str] = _build_month_keys(_CONFIG)


# ---------------------------------------------------------------------------
# Application
# ---------------------------------------------------------------------------

class AnwesenheitApp(ctk.CTk):

    def __init__(self) -> None:
        super().__init__()

        self.title("Anwesenheit PDF Generator")
        self.geometry("720x680")
        self.resizable(False, False)

        icon_path = _resource_path("assets/icon.ico")
        if icon_path.exists():
            self.iconbitmap(str(icon_path))

        # Internal state
        self._excel_path: Optional[Path] = None
        self._template_path: Optional[Path] = None
        self._out_dir: Optional[Path] = None

        # Build UI sections
        self._build_input_section()
        self._build_button_section()
        self._build_preview_section()
        self._build_log_section()

        # Auto-scan after event loop starts
        self.after(100, self._scan_and_validate)

    # ------------------------------------------------------------------
    # UI builders
    # ------------------------------------------------------------------

    def _build_input_section(self) -> None:
        frame = ctk.CTkFrame(self)
        frame.pack(fill="x", padx=16, pady=(16, 0))
        frame.columnconfigure(2, weight=1)  # value column expands

        BTN_W = 32

        # Row 0: Excel file
        ctk.CTkLabel(frame, text="Excel-Datei:", width=110, anchor="w").grid(
            row=0, column=0, padx=(12, 4), pady=6, sticky="w"
        )
        ctk.CTkButton(
            frame, text="\U0001f4c2", width=BTN_W, height=28,
            command=self._browse_excel,
        ).grid(row=0, column=1, padx=(0, 6), pady=6)
        self._lbl_excel = ctk.CTkLabel(frame, text="Suche\u2026", anchor="w")
        self._lbl_excel.grid(row=0, column=2, padx=(0, 12), pady=6, sticky="ew")

        # Row 1: Template
        ctk.CTkLabel(frame, text="Template:", width=110, anchor="w").grid(
            row=1, column=0, padx=(12, 4), pady=6, sticky="w"
        )
        ctk.CTkButton(
            frame, text="\U0001f4c2", width=BTN_W, height=28,
            command=self._browse_template,
        ).grid(row=1, column=1, padx=(0, 6), pady=6)
        self._lbl_template = ctk.CTkLabel(frame, text="Suche\u2026", anchor="w")
        self._lbl_template.grid(row=1, column=2, padx=(0, 12), pady=6, sticky="ew")

        # Row 2: Month dropdown
        ctk.CTkLabel(frame, text="Monat:", width=110, anchor="w").grid(
            row=2, column=0, padx=(12, 4), pady=6, sticky="w"
        )
        self._month_var = ctk.StringVar(value=_MONTH_KEYS[0] if _MONTH_KEYS else "")
        self._month_menu = ctk.CTkOptionMenu(
            frame,
            values=_MONTH_KEYS or ["\u2013"],
            variable=self._month_var,
            command=lambda _: self._on_month_changed(),
            width=150,
        )
        self._month_menu.grid(row=2, column=2, padx=(0, 12), pady=6, sticky="w")

        # Row 3: Output dir
        out_label = str((_runtime_dir() / _CONFIG.get("output_dir", "output")).resolve())
        ctk.CTkLabel(frame, text="Ausgabe:", width=110, anchor="w").grid(
            row=3, column=0, padx=(12, 4), pady=6, sticky="w"
        )
        ctk.CTkButton(
            frame, text="\U0001f4c2", width=BTN_W, height=28,
            command=self._open_output_folder,
        ).grid(row=3, column=1, padx=(0, 6), pady=6)
        ctk.CTkLabel(frame, text=out_label, anchor="w").grid(
            row=3, column=2, padx=(0, 12), pady=6, sticky="ew"
        )

        # Row 4: Output warning + "Ordner leeren" link (hidden when 0)
        warning_row = ctk.CTkFrame(frame, fg_color="transparent")
        warning_row.grid(row=4, column=2, padx=(0, 12), pady=(0, 6), sticky="ew")
        self._lbl_warning = ctk.CTkLabel(
            warning_row, text="", anchor="w", text_color="orange"
        )
        self._lbl_warning.pack(side="left")
        self._lbl_clear_link = ctk.CTkLabel(
            warning_row, text="", anchor="w",
            text_color="#EF4444", cursor="hand2",
        )
        self._lbl_clear_link.pack(side="left", padx=(6, 0))
        self._lbl_clear_link.bind("<Button-1>", lambda _: self._confirm_clear_output())

    def _build_button_section(self) -> None:
        frame = ctk.CTkFrame(self)
        frame.pack(fill="x", padx=16, pady=(8, 0))
        self._btn_generate = ctk.CTkButton(
            frame,
            text="Generieren",
            state="disabled",
            command=self._start_generate,
            width=180,
            height=40,
        )
        self._btn_generate.pack(pady=12)

    def _build_preview_section(self) -> None:
        frame = ctk.CTkFrame(self)
        frame.pack(fill="x", padx=16, pady=(8, 0))

        ctk.CTkLabel(frame, text="Vorschau", font=ctk.CTkFont(weight="bold")).grid(
            row=0, column=0, columnspan=4, padx=12, pady=(8, 2), sticky="w"
        )

        fields = [
            ("Datei:", "_pv_datei"),
            ("Jahr:", "_pv_jahr"),
            ("Monat:", "_pv_monat"),
            ("Antragsnummer:", "_pv_antrag"),
            ("Ort:", "_pv_ort"),
            ("Erstelldatum:", "_pv_datum"),
            ("Teilnehmer:", "_pv_teilnehmer"),
            ("Fehler:", "_pv_fehler"),
        ]

        for i, (text, attr) in enumerate(fields):
            row = 1 + i // 2
            col_lbl = (i % 2) * 2
            col_val = col_lbl + 1
            ctk.CTkLabel(frame, text=text, width=110, anchor="w").grid(
                row=row, column=col_lbl, padx=(12, 2), pady=3, sticky="w"
            )
            lbl = ctk.CTkLabel(frame, text="–", anchor="w", width=220)
            lbl.grid(row=row, column=col_val, padx=(0, 8), pady=3, sticky="w")
            setattr(self, attr, lbl)

    def _build_log_section(self) -> None:
        frame = ctk.CTkFrame(self)
        frame.pack(fill="both", expand=True, padx=16, pady=(8, 16))
        frame.rowconfigure(1, weight=1)
        frame.columnconfigure(0, weight=1)

        ctk.CTkLabel(frame, text="Log", font=ctk.CTkFont(weight="bold")).grid(
            row=0, column=0, padx=12, pady=(8, 2), sticky="w"
        )
        self._log_box = ctk.CTkTextbox(
            frame,
            font=ctk.CTkFont(family="Courier New", size=11),
            state="disabled",
        )
        self._log_box.grid(row=1, column=0, padx=12, pady=(0, 12), sticky="nsew")
        # Configure clickable-link tag and bind events on underlying tk.Text
        tb = self._log_box._textbox
        tb.tag_config("pdf_link", foreground="#4FC3F7", underline=True)
        tb.bind("<Button-1>", self._on_log_click)
        tb.bind("<Motion>", self._on_log_motion)

    # ------------------------------------------------------------------
    # Log helpers
    # ------------------------------------------------------------------

    def _log(self, text: str) -> None:
        self._log_box.configure(state="normal")
        self._log_box.insert("end", text + "\n")
        self._log_box.see("end")
        self._log_box.configure(state="disabled")

    def _log_ok(self, text: str) -> None:
        """Insert an [OK] line styled as a clickable PDF link."""
        tb = self._log_box._textbox
        tb.configure(state="normal")
        tb.insert("end", text + "\n")
        insert_line = int(tb.index("end").split(".")[0]) - 1
        tb.tag_add("pdf_link", f"{insert_line}.0", f"{insert_line}.end")
        tb.see("end")
        tb.configure(state="disabled")

    def _clear_log(self) -> None:
        self._log_box.configure(state="normal")
        self._log_box.delete("1.0", "end")
        self._log_box.configure(state="disabled")

    def _on_log_click(self, event) -> None:
        tb = self._log_box._textbox
        idx = tb.index(f"@{event.x},{event.y}")
        line_start = tb.index(f"{idx} linestart")
        line_end = tb.index(f"{idx} lineend")
        line = tb.get(line_start, line_end).strip()
        if line.startswith("[OK]") and self._out_dir:
            # Format: "[OK] filename.pdf  (i/total)"
            rest = line[4:].strip()
            filename = rest.split("  (")[0].strip()
            pdf_path = self._out_dir / filename
            if pdf_path.exists():
                os.startfile(str(pdf_path))

    def _on_log_motion(self, event) -> None:
        tb = self._log_box._textbox
        idx = tb.index(f"@{event.x},{event.y}")
        line_start = tb.index(f"{idx} linestart")
        line_end = tb.index(f"{idx} lineend")
        line = tb.get(line_start, line_end).strip()
        tb.configure(cursor="hand2" if line.startswith("[OK]") else "")

    # ------------------------------------------------------------------
    # Output folder
    # ------------------------------------------------------------------

    def _open_output_folder(self) -> None:
        out_dir = _runtime_dir() / _CONFIG.get("output_dir", "output")
        out_dir.mkdir(parents=True, exist_ok=True)
        os.startfile(str(out_dir))

    # ------------------------------------------------------------------
    # Preview helpers
    # ------------------------------------------------------------------

    def _clear_preview(self) -> None:
        for attr in (
            "_pv_datei", "_pv_jahr", "_pv_monat", "_pv_antrag",
            "_pv_ort", "_pv_datum", "_pv_teilnehmer", "_pv_fehler",
        ):
            getattr(self, attr).configure(text="–", text_color=("gray10", "gray90"))

    # ------------------------------------------------------------------
    # Output warning
    # ------------------------------------------------------------------

    def _refresh_output_warning(self) -> None:
        count = _count_output_pdfs(_CONFIG)
        if count > 0:
            self._lbl_warning.configure(
                text=f"⚠  {count} PDF-Datei(en) bereits in output/"
            )
            self._lbl_clear_link.configure(text="(Ordner leeren)")
        else:
            self._lbl_warning.configure(text="")
            self._lbl_clear_link.configure(text="")

    def _confirm_clear_output(self) -> None:
        out_dir = _runtime_dir() / _CONFIG.get("output_dir", "output")
        count = _count_output_pdfs(_CONFIG)
        if count == 0:
            return
        confirmed = messagebox.askyesno(
            "Ordner leeren",
            f"{count} PDF-Datei(en) in output/ l\u00f6schen?\n\nDieser Vorgang kann nicht r\u00fcckg\u00e4ngig gemacht werden.",
            icon="warning",
            parent=self,
        )
        if confirmed:
            for f in out_dir.glob("*.pdf"):
                try:
                    f.unlink()
                except OSError:
                    pass
            self._refresh_output_warning()

    # ------------------------------------------------------------------
    # File browse helpers
    # ------------------------------------------------------------------

    def _browse_excel(self) -> None:
        path = filedialog.askopenfilename(
            title="Excel-Datei ausw\u00e4hlen",
            filetypes=[("Excel-Dateien", "*.xlsx"), ("Alle Dateien", "*.*")],
        )
        if not path:
            return
        self._excel_path = Path(path)
        self._lbl_excel.configure(
            text=self._excel_path.name, text_color=("gray10", "gray90")
        )
        self._btn_generate.configure(state="disabled")
        self._clear_preview()
        self._clear_log()
        if self._template_path and self._month_var.get():
            threading.Thread(target=self._run_validate, daemon=True).start()

    def _browse_template(self) -> None:
        path = filedialog.askopenfilename(
            title="Template-PDF ausw\u00e4hlen",
            filetypes=[("PDF-Dateien", "*.pdf"), ("Alle Dateien", "*.*")],
        )
        if not path:
            return
        self._template_path = Path(path)
        self._lbl_template.configure(
            text=self._template_path.name, text_color=("gray10", "gray90")
        )
        self._btn_generate.configure(state="disabled")
        self._clear_preview()
        self._clear_log()
        if self._excel_path and self._month_var.get():
            threading.Thread(target=self._run_validate, daemon=True).start()

    # ------------------------------------------------------------------
    # Event handlers
    # ------------------------------------------------------------------

    def _on_month_changed(self) -> None:
        self._btn_generate.configure(state="disabled")
        self._clear_preview()
        self._clear_log()
        self._scan_and_validate()

    def _scan_and_validate(self) -> None:
        if _CONFIG_ERROR:
            self._log(f"[FEHLER] config.json: {_CONFIG_ERROR}")
            return

        # Scan input/
        self._excel_path = _scan_input_folder()
        input_folder = _runtime_dir() / "input"
        if self._excel_path:
            self._lbl_excel.configure(
                text=self._excel_path.name, text_color=("gray10", "gray90")
            )
        elif not input_folder.exists() or not list(input_folder.glob("*.xlsx")):
            self._lbl_excel.configure(
                text="Keine .xlsx in input/ gefunden", text_color="red"
            )
        else:
            n = len(list(input_folder.glob("*.xlsx")))
            self._lbl_excel.configure(
                text=f"Mehrere Dateien gefunden ({n}) — nur eine erlaubt",
                text_color="red",
            )

        # Scan template/
        self._template_path = _scan_template_folder()
        template_folder = _runtime_dir() / "template"
        if self._template_path:
            self._lbl_template.configure(
                text=self._template_path.name, text_color=("gray10", "gray90")
            )
        elif not template_folder.exists() or not list(template_folder.glob("*.pdf")):
            self._lbl_template.configure(
                text="Keine .pdf in template/ gefunden", text_color="red"
            )
        else:
            n = len(list(template_folder.glob("*.pdf")))
            self._lbl_template.configure(
                text=f"Mehrere Dateien gefunden ({n}) — nur eine erlaubt",
                text_color="red",
            )

        # Refresh output warning
        self._refresh_output_warning()

        # Start validation thread if all inputs are ready
        if self._excel_path and self._template_path and self._month_var.get():
            threading.Thread(target=self._run_validate, daemon=True).start()

    # ------------------------------------------------------------------
    # Validation (background thread)
    # ------------------------------------------------------------------

    def _run_validate(self) -> None:
        excel_file = str(self._excel_path)
        month = self._month_var.get()
        result: Dict[str, Any] = {
            "errors": [],
            "year": 0,
            "persons": [],
            "month": month,
            "exception": None,
        }

        try:
            result["errors"] = validate(excel_file, month)
        except Exception as exc:
            result["exception"] = str(exc)
            self.after(0, self._on_validate_done, result)
            return

        try:
            result["year"] = extract_year_from_filename(excel_file, _CONFIG)
        except Exception as exc:
            result["errors"].append(f"Jahr nicht ermittelbar: {exc}")

        try:
            result["persons"] = extract_persons(excel_file, month, _CONFIG)
        except Exception as exc:
            result["errors"].append(f"Teilnehmer nicht lesbar: {exc}")

        self.after(0, self._on_validate_done, result)

    def _on_validate_done(self, result: Dict[str, Any]) -> None:
        if result.get("exception"):
            self._log(f"[FEHLER] {result['exception']}")
            self._btn_generate.configure(state="disabled")
            return

        errors: List[str] = result["errors"]
        year: int = result["year"]
        persons = result["persons"]
        month: str = result["month"]

        month_num = (_CONFIG.get("month_mapping") or {}).get(month, "??")
        default_color = ("gray10", "gray90")

        self._pv_datei.configure(
            text=self._excel_path.name if self._excel_path else "–",
            text_color=default_color,
        )
        self._pv_jahr.configure(
            text=str(year) if year else "–", text_color=default_color
        )
        self._pv_monat.configure(
            text=f"{month} ({month_num})", text_color=default_color
        )
        self._pv_antrag.configure(
            text=_CONFIG.get("antragsnummer", "–"), text_color=default_color
        )
        self._pv_ort.configure(
            text=_CONFIG.get("ort", "–"), text_color=default_color
        )
        self._pv_datum.configure(
            text=date.today().strftime("%d.%m.%Y"), text_color=default_color
        )
        self._pv_teilnehmer.configure(
            text=str(len(persons)), text_color=default_color
        )

        if errors:
            self._pv_fehler.configure(text=str(len(errors)), text_color="red")
            self._clear_log()
            self._log("--- Validierungsfehler ---")
            for err in errors:
                self._log(f"  [!] {err}")
            self._btn_generate.configure(state="disabled")
        else:
            self._pv_fehler.configure(text="0", text_color=default_color)
            self._clear_log()
            self._btn_generate.configure(state="normal")

    # ------------------------------------------------------------------
    # Generation
    # ------------------------------------------------------------------

    def _start_generate(self) -> None:
        count = _count_output_pdfs(_CONFIG)
        if count > 0:
            answer = messagebox.askyesnocancel(
                "Ausgabe-Verzeichnis nicht leer",
                f"{count} PDF-Datei(en) bereits in output/ vorhanden.\n\n"
                "Inhalt vor der Generierung löschen?",
                parent=self,
            )
            if answer is None:   # Cancel
                return
            if answer:           # Yes → delete existing PDFs
                out_dir = _runtime_dir() / _CONFIG.get("output_dir", "output")
                for f in out_dir.glob("*.pdf"):
                    try:
                        f.unlink()
                    except OSError:
                        pass

        self._btn_generate.configure(state="disabled")
        self._clear_log()
        threading.Thread(target=self._run_generate, daemon=True).start()

    def _run_generate(self) -> None:
        excel_file = str(self._excel_path)
        month = self._month_var.get()
        success_count = 0
        total = 0

        try:
            year = extract_year_from_filename(excel_file, _CONFIG)
            persons = extract_persons(excel_file, month, _CONFIG)
            total = len(persons)

            out_dir = _runtime_dir() / _CONFIG.get("output_dir", "output")
            out_dir.mkdir(parents=True, exist_ok=True)
            self._out_dir = out_dir

            for i, person in enumerate(persons, 1):
                try:
                    attendance = extract_attendance(
                        excel_file, month, person, year, _CONFIG
                    )
                    output_filename = f"{person.filename_safe_name}.pdf"
                    output_path = out_dir / output_filename
                    fill_pdf(attendance, self._template_path, output_path, _CONFIG)
                    self.after(0, self._log_ok, f"[OK] {output_filename}  ({i}/{total})")
                    success_count += 1
                except Exception as exc:
                    self.after(0, self._log, f"[FEHLER] {person.name}: {exc}")

        except Exception as exc:
            self.after(0, self._log, f"[FEHLER] {exc}")
            self.after(0, self._on_generate_done, 0, 0)
            return

        self.after(0, self._on_generate_done, success_count, total)

    def _on_generate_done(self, success: int, total: int) -> None:
        self._log(f"\nFertig: {success}/{total} PDFs erzeugt.")
        self._btn_generate.configure(state="normal")
        self._refresh_output_warning()


# ---------------------------------------------------------------------------
# Entry point
# ---------------------------------------------------------------------------

if __name__ == "__main__":
    app = AnwesenheitApp()
    app.mainloop()