#!/usr/bin/env python3
"""test_wiki_mode.py — hermetic tests for scripts/wiki-mode.py.

Covers config load/save round-trip, all 4 modes' routing, slugification, ID
minting, and the default-to-generic fallback when .vault-meta/mode.json is
absent. No network, no LLM, no ollama. Pure stdlib + subprocess.

Usage:
  python3 tests/test_wiki_mode.py
"""
import importlib.util
import json
import os
import subprocess
import sys
import tempfile
from pathlib import Path
from unittest import mock

ROOT = Path(__file__).resolve().parent.parent
HELPER = ROOT / "scripts" / "wiki-mode.py"

spec = importlib.util.spec_from_file_location("wiki_mode", HELPER)
wm = importlib.util.module_from_spec(spec)
spec.loader.exec_module(wm)


class Fail(SystemExit):
    pass


def assert_eq(label, expected, actual):
    if expected != actual:
        raise Fail(f"FAIL {label}: expected {expected!r}, got {actual!r}")
    print(f"OK   {label}")


def assert_true(label, cond, hint=""):
    if not cond:
        raise Fail(f"FAIL {label}{(': ' + hint) if hint else ''}")
    print(f"OK   {label}")


# ─── Default-to-generic when no config file ──────────────────────────────────
def test_load_config_defaults_to_generic_when_absent():
    with tempfile.TemporaryDirectory() as tmp:
        with mock.patch.object(wm, "MODE_PATH", Path(tmp) / "nonexistent.json"):
            cfg = wm.load_config()
            assert_eq("absent config → mode=generic", "generic", cfg["mode"])
            assert_eq("schema_version present", 1, cfg["schema_version"])
            assert_true("all 4 mode configs present",
                        set(cfg["config"].keys()) == {"lyt", "para", "zettelkasten", "generic"})


# ─── Config save → load round-trip ───────────────────────────────────────────
def test_save_load_roundtrip():
    with tempfile.TemporaryDirectory() as tmp:
        mode_path = Path(tmp) / "mode.json"
        with mock.patch.object(wm, "MODE_PATH", mode_path), \
             mock.patch.object(wm, "META_DIR", Path(tmp)):
            cfg = wm.load_config()
            cfg["mode"] = "lyt"
            cfg["configured_at"] = "2026-05-17T00:00:00Z"
            wm.save_config(cfg)
            assert_true("mode.json written", mode_path.is_file())
            cfg2 = wm.load_config()
            assert_eq("round-trip mode", "lyt", cfg2["mode"])
            assert_eq("round-trip configured_at", "2026-05-17T00:00:00Z", cfg2["configured_at"])


# ─── Corrupted mode.json falls back to generic with warning ──────────────────
def test_corrupted_config_falls_back_to_generic():
    with tempfile.TemporaryDirectory() as tmp:
        mode_path = Path(tmp) / "mode.json"
        mode_path.write_text("{ this is not valid json", encoding="utf-8")
        with mock.patch.object(wm, "MODE_PATH", mode_path):
            cfg = wm.load_config()
            assert_eq("corrupted config → mode=generic", "generic", cfg["mode"])


# ─── Mode=generic routing matches v1.7 conventions ──────────────────────────
def test_generic_routing():
    cfg = dict(wm.DEFAULT_CONFIG)
    cfg["mode"] = "generic"
    assert_eq("generic source",
              "wiki/sources/Karpathy-2025-essay.md",
              wm.route_path("generic", "source", "Karpathy 2025 essay", cfg))
    assert_eq("generic entity preserves case",
              "wiki/entities/Andrej Karpathy.md",
              wm.route_path("generic", "entity", "Andrej Karpathy", cfg))
    assert_eq("generic concept",
              "wiki/concepts/Compounding Vault.md",
              wm.route_path("generic", "concept", "Compounding Vault", cfg))
    assert_eq("generic session",
              "wiki/sessions/v1-8-launch-prep.md",
              wm.route_path("generic", "session", "v1.8 launch prep", cfg))


# ─── Mode=lyt routing: all atomic notes flat under wiki/notes/ ──────────────
def test_lyt_routing():
    cfg = dict(wm.DEFAULT_CONFIG)
    cfg["mode"] = "lyt"
    src = wm.route_path("lyt", "source", "Karpathy essay", cfg)
    ent = wm.route_path("lyt", "entity", "Andrej Karpathy", cfg)
    con = wm.route_path("lyt", "concept", "Compounding Vault", cfg)
    assert_true("lyt source goes to notes/", src.startswith("wiki/notes/"), hint=src)
    assert_true("lyt entity goes to notes/", ent.startswith("wiki/notes/"), hint=ent)
    assert_true("lyt concept goes to notes/", con.startswith("wiki/notes/"), hint=con)


# ─── Mode=para routing: actionability-based folders ─────────────────────────
def test_para_routing():
    cfg = dict(wm.DEFAULT_CONFIG)
    cfg["mode"] = "para"
    src = wm.route_path("para", "source", "Karpathy essay", cfg)
    ent = wm.route_path("para", "entity", "Andrej Karpathy", cfg)
    sess = wm.route_path("para", "session", "v1.8 prep", cfg)
    res = wm.route_path("para", "research", "compounding-vault", cfg)
    assert_true("para source → resources/incoming/", src.startswith("wiki/resources/incoming/"), hint=src)
    assert_true("para entity → resources/people/", ent.startswith("wiki/resources/people/"), hint=ent)
    assert_true("para session → projects/inbox/", sess.startswith("wiki/projects/inbox/"), hint=sess)
    assert_true("para research → resources/<topic>/", "wiki/resources/compounding-vault/" in res, hint=res)


# ─── Mode=zettelkasten routing: flat, timestamp-prefixed ────────────────────
def test_zettelkasten_routing():
    cfg = dict(wm.DEFAULT_CONFIG)
    cfg["mode"] = "zettelkasten"
    p = wm.route_path("zettelkasten", "source", "Karpathy essay", cfg)
    # Format: wiki/<20-digit-timestamp-with-microseconds>-<slug>.md
    assert_true("zettel path starts with wiki/", p.startswith("wiki/"), hint=p)
    assert_true("zettel no subfolders", p.count("/") == 1, hint=p)
    fname = p.rsplit("/", 1)[1]
    parts = fname.split("-", 1)
    # v1.8.1 fix: IDs are 20 digits (YYYYMMDDHHMMSSffffff) for collision resistance
    assert_true("zettel ID is 20 digits", parts[0].isdigit() and len(parts[0]) == 20, hint=fname)


# ─── Zettel ID format ───────────────────────────────────────────────────────
def test_mint_zettel_id_format():
    zid = wm.mint_zettel_id()
    # 14 (YYYYMMDDHHMMSS) + 6 (microseconds) = 20 digits
    assert_true("zettel ID is 20-digit string", len(zid) == 20 and zid.isdigit(), hint=zid)


def test_mint_zettel_id_collision_resistance():
    """v1.8.1 fix: rapid back-to-back mint calls produce DIFFERENT IDs.
    Microsecond suffix ensures two calls within the same second are distinct.
    """
    ids = [wm.mint_zettel_id() for _ in range(10)]
    assert_eq("zettel IDs all distinct (10 rapid calls)", 10, len(set(ids)))


def test_slugify_extended_unicode():
    """v1.8.1 fix: explicit test coverage for CJK + Cyrillic (verifier LOW).
    The slugify function preserves any Unicode word character; only ASCII
    punctuation and emoji get stripped/converted.
    """
    assert_eq("CJK preserved", "日本語の文書", wm.slugify("日本語の文書"))
    assert_eq("Cyrillic with space", "Привет-мир", wm.slugify("Привет мир"))
    assert_eq("Mixed scripts", "Hello-мир-café", wm.slugify("Hello мир café"))
    # Emoji is stripped (not in \w); surrounding text joined by single hyphen
    assert_eq("Emoji becomes single hyphen between words", "Test-emoji",
              wm.slugify("Test 🎉 emoji"))


# ─── Slugify handles unicode + special chars ────────────────────────────────
def test_slugify():
    # Case is PRESERVED to match v1.7 entity/concept filing conventions.
    assert_eq("ascii slug", "Karpathy-2025-essay", wm.slugify("Karpathy 2025 essay"))
    assert_eq("unicode preserved", "café-résumé", wm.slugify("café résumé"))
    # Periods become hyphens (so v1.7 → v1-7, not v17)
    assert_eq("dots become hyphens", "v1-7-launch-prep", wm.slugify("v1.7 launch! prep?"))
    assert_eq("empty → 'untitled'", "untitled", wm.slugify(""))


# ─── Path-traversal hardening (v1.8.2): entity/concept names cannot escape ──
def test_safe_name_strips_path_separators():
    """v1.8.2 fix: names that intentionally preserve case (entity, concept)
    must not allow path traversal via '../', leading '/', backslashes, NULs,
    or control characters. Spaces and case are still preserved.
    """
    assert_eq("traversal '../' stripped", "etcpasswd", wm.safe_name("../../../etc/passwd"))
    assert_eq("leading '/' stripped", "etcpasswd", wm.safe_name("/etc/passwd"))
    assert_eq("backslash stripped", "etcpasswd", wm.safe_name("..\\..\\etc\\passwd"))
    assert_eq("NUL stripped", "foobar", wm.safe_name("foo\x00bar"))
    assert_eq("control chars stripped", "foobar", wm.safe_name("foo\x01\x02bar"))
    assert_eq("leading dot stripped (no hidden files)", "hidden", wm.safe_name(".hidden"))
    assert_eq("leading hyphen stripped (no flag escapes)", "flag", wm.safe_name("-flag"))
    assert_eq("spaces + case preserved", "Andrej Karpathy", wm.safe_name("Andrej Karpathy"))
    assert_eq("empty after strip → 'untitled'", "untitled", wm.safe_name("/"))


def test_route_path_blocks_traversal_for_generic_entity_and_concept():
    """The end-to-end route must not allow the returned path to escape vault root."""
    import os
    cfg = dict(wm.DEFAULT_CONFIG); cfg["mode"] = "generic"
    vault = os.path.abspath(".")
    for content_type, malicious in [
        ("entity",  "../../../etc/passwd"),
        ("concept", "/etc/passwd"),
        ("entity",  "..\\..\\..\\Windows\\System32"),
        ("research","../escape"),
    ]:
        p = wm.route_path("generic", content_type, malicious, cfg)
        abs_p = os.path.abspath(p)
        assert_true(f"generic {content_type}({malicious!r}) stays inside vault",
                    abs_p.startswith(vault + os.sep), hint=f"got {abs_p}")


def test_route_path_blocks_traversal_for_para_entity_and_concept():
    import os
    cfg = dict(wm.DEFAULT_CONFIG); cfg["mode"] = "para"
    vault = os.path.abspath(".")
    for content_type, malicious in [
        ("entity",  "../../../etc/passwd"),
        ("concept", "/etc/shadow"),
    ]:
        p = wm.route_path("para", content_type, malicious, cfg)
        abs_p = os.path.abspath(p)
        assert_true(f"para {content_type}({malicious!r}) stays inside vault",
                    abs_p.startswith(vault + os.sep), hint=f"got {abs_p}")


# ─── CLI --mode preview override (v1.8.2) ───────────────────────────────────
def test_cli_route_mode_override_previews_without_writing():
    """`route --mode lyt source X` must return an lyt path even when current
    mode is generic, and must NOT modify .vault-meta/mode.json."""
    before = subprocess.run([sys.executable, str(HELPER), "get"],
                            capture_output=True, text=True, timeout=5).stdout.strip()
    result = subprocess.run(
        [sys.executable, str(HELPER), "route", "--mode", "lyt", "source", "Preview Test"],
        capture_output=True, text=True, timeout=5,
    )
    assert_eq("cli route --mode rc=0", 0, result.returncode)
    path = result.stdout.strip()
    assert_true("preview returns lyt notes/ path",
                path.startswith("wiki/notes/"), hint=path)
    after = subprocess.run([sys.executable, str(HELPER), "get"],
                           capture_output=True, text=True, timeout=5).stdout.strip()
    assert_eq("current mode unchanged by preview", before, after)


def test_cli_route_mode_override_rejects_invalid():
    result = subprocess.run(
        [sys.executable, str(HELPER), "route", "--mode", "bogus", "source", "X"],
        capture_output=True, text=True, timeout=5,
    )
    assert_true("preview rejects bogus mode", result.returncode != 0,
                hint=f"rc={result.returncode}")


# ─── Invalid content type raises ───────────────────────────────────────────
def test_invalid_content_type_raises():
    cfg = dict(wm.DEFAULT_CONFIG)
    try:
        wm.route_path("generic", "garbage", "x", cfg)
        raise Fail("expected SystemExit(4) for invalid type")
    except SystemExit as e:
        assert_eq("invalid type → exit 4", 4, e.code)


# ─── CLI subprocess: `wiki-mode.py get` returns mode string ─────────────────
def test_cli_get_returns_mode():
    """End-to-end CLI test via subprocess; uses the actual vault's mode (or generic if absent)."""
    result = subprocess.run(
        [sys.executable, str(HELPER), "get"],
        capture_output=True, text=True, timeout=5,
    )
    assert_eq("cli get rc=0", 0, result.returncode)
    mode = result.stdout.strip()
    assert_true("cli get returns one of 4 modes",
                mode in ("generic", "lyt", "para", "zettelkasten"), hint=mode)


# ─── CLI subprocess: `wiki-mode.py id` returns 14-digit timestamp ───────────
def test_cli_id_returns_timestamp():
    result = subprocess.run(
        [sys.executable, str(HELPER), "id"],
        capture_output=True, text=True, timeout=5,
    )
    assert_eq("cli id rc=0", 0, result.returncode)
    zid = result.stdout.strip()
    assert_true("cli id is 20-digit", len(zid) == 20 and zid.isdigit(), hint=zid)


# ─── CLI subprocess: `wiki-mode.py route source NAME` returns a path ────────
def test_cli_route_returns_path():
    result = subprocess.run(
        [sys.executable, str(HELPER), "route", "source", "Test Source"],
        capture_output=True, text=True, timeout=5,
    )
    assert_eq("cli route rc=0", 0, result.returncode)
    path = result.stdout.strip()
    assert_true("cli route returns wiki-rooted path",
                path.startswith("wiki/"), hint=path)
    assert_true("cli route returns .md path", path.endswith(".md"), hint=path)


# ─── CLI subprocess: invalid mode rejected ──────────────────────────────────
def test_cli_set_rejects_invalid_mode():
    result = subprocess.run(
        [sys.executable, str(HELPER), "set", "bogus"],
        capture_output=True, text=True, timeout=5,
    )
    assert_true("cli set rejects invalid mode", result.returncode != 0,
                hint=f"rc={result.returncode}")


# ─── CLI subprocess: templates listing returns all 6 ───────────────────────
def test_cli_templates_lists_six():
    result = subprocess.run(
        [sys.executable, str(HELPER), "templates"],
        capture_output=True, text=True, timeout=5,
    )
    assert_eq("cli templates rc=0", 0, result.returncode)
    lines = [l for l in result.stdout.strip().split("\n") if l]
    assert_eq("cli templates returns 6 paths", 6, len(lines))


def main():
    print("=== test_wiki_mode.py ===")
    test_load_config_defaults_to_generic_when_absent()
    test_save_load_roundtrip()
    test_corrupted_config_falls_back_to_generic()
    test_generic_routing()
    test_lyt_routing()
    test_para_routing()
    test_zettelkasten_routing()
    test_mint_zettel_id_format()
    test_mint_zettel_id_collision_resistance()
    test_slugify()
    test_slugify_extended_unicode()
    test_safe_name_strips_path_separators()
    test_route_path_blocks_traversal_for_generic_entity_and_concept()
    test_route_path_blocks_traversal_for_para_entity_and_concept()
    test_cli_route_mode_override_previews_without_writing()
    test_cli_route_mode_override_rejects_invalid()
    test_invalid_content_type_raises()
    test_cli_get_returns_mode()
    test_cli_id_returns_timestamp()
    test_cli_route_returns_path()
    test_cli_set_rejects_invalid_mode()
    test_cli_templates_lists_six()
    print("\nAll wiki-mode tests passed.")


if __name__ == "__main__":
    main()