"""
compute_paths.py — Deterministischer Pfad-Resolver für den project-session-end-Skill.

Löst alle Layout-Platzhalter ({projects}, {context}, {system} usw.) gegen
bundle.json.vault_layout auf und gibt die resultierenden absoluten Pfade
als JSON auf stdout aus.

Wird von der SKILL.md referenziert und von run_evals.py getestet.

Aufruf:
    PYTHONUTF8=1 python .skills/project-session-end/compute_paths.py \\
        --vault PATH \\
        --project "Projektname mit Leerzeichen und Umläuten"

Ausgabe (JSON auf stdout):
    {
        "paths": {
            "handover_file": "/abs/path/projects/Projektname/Handover.md",
            "project_steckbrief": "/abs/path/projects/Projektname/Projektname.md",
            "glossary_file": "/abs/path/context/Glossar.md",
            "principles_dir": "/abs/path/system/Prinzipien"
        },
        "frontmatter_defaults": {...},
        "features": {...},
        "locale": "de",
        "project_name": "Projektname mit Leerzeichen und Umläuten",
        "today": "YYYY-MM-DD"
    }

Bei fehlender Glossar-Datei und enforce_glossary_check: true:
    stderr-Warnung, exit 0, JSON trotzdem ausgegeben.
"""

from __future__ import annotations

import argparse
import json
import sys
from datetime import datetime
from pathlib import Path

# _lib liegt eine Ebene über diesem Skript im .skills/-Baum.
_SKILL_DIR = Path(__file__).resolve().parent
_SKILLS_ROOT = _SKILL_DIR.parent
if str(_SKILLS_ROOT) not in sys.path:
    sys.path.insert(0, str(_SKILLS_ROOT))

from _lib.config_loader import load_skill_config  # noqa: E402


def build_default_paths(project_name: str) -> dict[str, str]:
    """Erzeugt die skill-eigenen Fallback-Pfade mit Layout-Platzhaltern.

    Der Projektname wird verbatim übernommen — keine Slugifizierung, keine
    URL-Enkodierung. Projektnamen mit Leerzeichen und Umlauten werden direkt
    als Ordnernamen verwendet.
    """
    return {
        "handover_file":      f"{{projects}}/{project_name}/Handover.md",
        "project_steckbrief": f"{{projects}}/{project_name}/{project_name}.md",
        "glossary_file":      "{context}/Glossar.md",
        "principles_dir":     "{system}/Prinzipien",
    }


def check_glossary_warning(
    glossary_path: Path,
    enforce: bool,
) -> None:
    """Gibt bei fehlender Glossar-Datei eine stderr-Warnung aus (kein Crash)."""
    if not enforce:
        return
    if not glossary_path.exists():
        print(
            f"project-session-end: Glossar-Datei nicht gefunden unter {glossary_path}. "
            "Setze `features.enforce_glossary_check: false` um den Check zu deaktivieren.",
            file=sys.stderr,
        )


def main() -> int:
    parser = argparse.ArgumentParser(
        description=(
            "Löst Layout-Platzhalter für den project-session-end-Skill auf "
            "und gibt alle benötigten Pfade als JSON aus."
        )
    )
    parser.add_argument(
        "--vault",
        type=Path,
        default=Path.cwd(),
        help="Vault-Root (absoluter Pfad). Default: aktuelles Verzeichnis.",
    )
    parser.add_argument(
        "--project",
        type=str,
        required=True,
        help=(
            "Projektname verbatim (mit Leerzeichen und Umlauten). "
            "Entspricht dem Ordnernamen unter {projects}/."
        ),
    )
    args = parser.parse_args()

    try:
        vault = args.vault.resolve()
        project_name: str = args.project

        # Skill-Config laden. Fehlt skill.config.yaml → Default-Paths greifen.
        # default_paths enthält alle Fallback-Pfade mit Layout-Platzhaltern.
        # Präzedenz: skill.config.yaml > default_paths > nichts.
        default_paths = build_default_paths(project_name)

        config = load_skill_config(
            skill_dir=_SKILL_DIR,
            vault_root=vault,
            bundle_root=None,
            default_paths=default_paths,
        )

        # Glossar-Warnung bei fehlender Datei (kein Abbruch).
        glossary_path = config.paths.get("glossary_file")
        enforce_glossary = bool(config.features.get("enforce_glossary_check", True))
        if glossary_path is not None:
            check_glossary_warning(glossary_path, enforce_glossary)

        # Pfade als strings serialisieren (Path-Objekte sind nicht JSON-serialisierbar).
        paths_out: dict[str, str] = {
            key: str(val) for key, val in config.paths.items()
        }

        output = {
            "paths": paths_out,
            "frontmatter_defaults": config.frontmatter,
            "features": config.features,
            "locale": config.locale,
            "project_name": project_name,
            "today": datetime.now().strftime("%Y-%m-%d"),
        }

        print(json.dumps(output, ensure_ascii=False, indent=2))
        return 0

    except Exception as exc:  # noqa: BLE001
        print(
            f"project-session-end compute_paths.py: Fehler: {exc}",
            file=sys.stderr,
        )
        return 1


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