"""
Process-kill crash-consistency tests for ctx state files.

These tests intentionally terminate subprocesses while they are inside the
write/lock boundaries used by ctx. The invariant is not "the last requested
mutation always appears" after SIGKILL/TerminateProcess. The invariant is that
surviving state remains parseable and subsequent writers are not wedged by
stale advisory locks.
"""

from __future__ import annotations

import json
import os
import subprocess
import sys
import textwrap
import time
from pathlib import Path

import pytest

_SRC_ROOT = Path(__file__).resolve().parents[1]


def _python_env(home: Path | None = None) -> dict[str, str]:
    env = os.environ.copy()
    env["PYTHONPATH"] = str(_SRC_ROOT) + os.pathsep + env.get("PYTHONPATH", "")
    if home is not None:
        env["HOME"] = str(home)
        env["USERPROFILE"] = str(home)
    return env


def _start_child(code: str, args: list[str], *, home: Path | None = None) -> subprocess.Popen[str]:
    return subprocess.Popen(
        [sys.executable, "-c", textwrap.dedent(code), *args],
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True,
        env=_python_env(home),
    )


def _wait_for_file(path: Path, proc: subprocess.Popen[str], timeout: float = 10.0) -> None:
    deadline = time.monotonic() + timeout
    while time.monotonic() < deadline:
        if path.exists():
            return
        if proc.poll() is not None:
            stdout, stderr = proc.communicate(timeout=1)
            pytest.fail(
                f"child exited before {path.name} appeared\n"
                f"rc={proc.returncode}\nstdout={stdout}\nstderr={stderr}"
            )
        time.sleep(0.025)
    proc.kill()
    stdout, stderr = proc.communicate(timeout=5)
    pytest.fail(
        f"timed out waiting for {path.name}\n"
        f"rc={proc.returncode}\nstdout={stdout}\nstderr={stderr}"
    )


def _kill_and_wait(proc: subprocess.Popen[str]) -> None:
    proc.kill()
    proc.communicate(timeout=10)
    assert proc.returncode is not None
    assert proc.returncode != 0


def test_atomic_json_kill_before_replace_preserves_previous_complete_file(
    tmp_path: Path,
) -> None:
    target = tmp_path / "state.json"
    target.write_text(json.dumps({"version": "old"}) + "\n", encoding="utf-8")
    ready = tmp_path / "before-replace.ready"

    proc = _start_child(
        """
        import json
        import time
        from pathlib import Path

        from ctx.utils import _fs_utils

        target = Path(__import__("sys").argv[1])
        ready = Path(__import__("sys").argv[2])
        real_replace = _fs_utils._replace_with_retry

        def pause_before_replace(src, dst, *, attempts=10, delay=0.05):
            ready.write_text("ready", encoding="utf-8")
            time.sleep(30)
            real_replace(src, dst, attempts=attempts, delay=delay)

        _fs_utils._replace_with_retry = pause_before_replace
        _fs_utils.atomic_write_json(target, {"version": "new", "payload": list(range(2000))})
        """,
        [str(target), str(ready)],
    )

    _wait_for_file(ready, proc)
    _kill_and_wait(proc)

    assert json.loads(target.read_text(encoding="utf-8")) == {"version": "old"}


def test_atomic_json_kill_after_replace_leaves_complete_new_file(
    tmp_path: Path,
) -> None:
    target = tmp_path / "state.json"
    target.write_text(json.dumps({"version": "old"}) + "\n", encoding="utf-8")
    ready = tmp_path / "after-replace.ready"
    expected = {"version": "new", "payload": list(range(2000))}

    proc = _start_child(
        """
        import time
        from pathlib import Path

        from ctx.utils import _fs_utils

        target = Path(__import__("sys").argv[1])
        ready = Path(__import__("sys").argv[2])
        real_replace = _fs_utils._replace_with_retry

        def replace_then_pause(src, dst, *, attempts=10, delay=0.05):
            real_replace(src, dst, attempts=attempts, delay=delay)
            ready.write_text("ready", encoding="utf-8")
            time.sleep(30)

        _fs_utils._replace_with_retry = replace_then_pause
        _fs_utils.atomic_write_json(target, {"version": "new", "payload": list(range(2000))})
        """,
        [str(target), str(ready)],
    )

    _wait_for_file(ready, proc)
    _kill_and_wait(proc)

    assert json.loads(target.read_text(encoding="utf-8")) == expected


def test_manifest_lock_releases_after_killed_writer(
    tmp_path: Path,
) -> None:
    home = tmp_path / "home"
    manifest_path = home / ".claude" / "skill-manifest.json"
    manifest_path.parent.mkdir(parents=True)
    manifest_path.write_text(
        json.dumps({
            "load": [{"skill": "baseline", "entity_type": "skill"}],
            "unload": [],
            "warnings": [],
        }),
        encoding="utf-8",
    )
    ready = tmp_path / "manifest-write.ready"

    proc = _start_child(
        """
        import time
        from pathlib import Path

        from ctx.adapters.claude_code import skill_loader

        ready = Path(__import__("sys").argv[1])
        real_write = skill_loader._atomic_write_text

        def pause_before_manifest_write(path, text, encoding="utf-8"):
            ready.write_text("ready", encoding="utf-8")
            time.sleep(30)
            real_write(path, text, encoding=encoding)

        skill_loader._atomic_write_text = pause_before_manifest_write
        skill_loader.update_manifest("killed-before-write", entity_type="skill")
        """,
        [str(ready)],
        home=home,
    )

    _wait_for_file(ready, proc)
    _kill_and_wait(proc)

    follow_up = subprocess.run(
        [
            sys.executable,
            "-c",
            "from ctx.adapters.claude_code import skill_loader; "
            "skill_loader.update_manifest('survivor', entity_type='skill')",
        ],
        env=_python_env(home),
        text=True,
        capture_output=True,
        timeout=20,
        check=False,
    )
    assert follow_up.returncode == 0, follow_up.stderr

    data = json.loads(manifest_path.read_text(encoding="utf-8"))
    loaded = {(entry["skill"], entry.get("entity_type", "skill")) for entry in data["load"]}
    assert ("baseline", "skill") in loaded
    assert ("survivor", "skill") in loaded
    assert ("killed-before-write", "skill") not in loaded


def test_wiki_page_lock_releases_after_killed_writer(
    tmp_path: Path,
) -> None:
    wiki = tmp_path / "wiki"
    ready = tmp_path / "wiki-write.ready"

    setup = subprocess.run(
        [
            sys.executable,
            "-c",
            "from pathlib import Path; "
            "from ctx.core.wiki import wiki_sync; "
            f"wiki_sync.ensure_wiki(Path({str(wiki)!r}))",
        ],
        env=_python_env(),
        text=True,
        capture_output=True,
        timeout=20,
        check=False,
    )
    assert setup.returncode == 0, setup.stderr

    proc = _start_child(
        """
        import time
        from pathlib import Path

        from ctx.core.wiki import wiki_sync

        wiki = Path(__import__("sys").argv[1])
        ready = Path(__import__("sys").argv[2])
        real_write = wiki_sync.atomic_write_text

        def pause_before_wiki_write(path, text, encoding="utf-8"):
            if path.name == "crash-skill.md":
                ready.write_text("ready", encoding="utf-8")
                time.sleep(30)
            real_write(path, text, encoding=encoding)

        wiki_sync.atomic_write_text = pause_before_wiki_write
        wiki_sync.upsert_skill_page(
            wiki,
            "crash-skill",
            {"reason": "crash test", "confidence": 1.0, "repo": "repo"},
            subject_type="skills",
        )
        """,
        [str(wiki), str(ready)],
    )

    _wait_for_file(ready, proc)
    _kill_and_wait(proc)

    follow_up = subprocess.run(
        [
            sys.executable,
            "-c",
            "from pathlib import Path; "
            "from ctx.core.wiki import wiki_sync; "
            f"wiki_sync.upsert_skill_page(Path({str(wiki)!r}), 'crash-skill', "
            "{'reason': 'after kill', 'confidence': 1.0, 'repo': 'repo'}, "
            "subject_type='skills')",
        ],
        env=_python_env(),
        text=True,
        capture_output=True,
        timeout=20,
        check=False,
    )
    assert follow_up.returncode == 0, follow_up.stderr

    page = wiki / "entities" / "skills" / "crash-skill.md"
    content = page.read_text(encoding="utf-8")
    assert "title: crash-skill" in content
    assert "status: installed" in content