"""Issue #78: multi-agent-mux-reset — unit tests for lib_py.reset and
end-to-end tests for reset.sh (populated across Commits 3 and 4).
"""
from __future__ import annotations

import ast
import json
import os
import shlex
import subprocess
import sys
from pathlib import Path

import pytest

REPO = Path(__file__).resolve().parents[1]
SKILLS = REPO / ".agents" / "skills"
if str(SKILLS) not in sys.path:
    sys.path.insert(0, str(SKILLS))

UA = "a7800001-0000-4000-8000-000000000001"
UB = "b7800002-0000-4000-8000-000000000002"
UC = "c7800003-0000-4000-8000-000000000003"
UD = "d7800004-0000-4000-8000-000000000004"
UORC = "e7800005-0000-4000-8000-000000000005"

pytestmark = pytest.mark.usefixtures("own_workspace_root")


def _row(
    name: str,
    agent: str,
    cwd: Path,
    role: str = "reviewer",
    status: str = "running",
    created_at: str = "2026-10-01T00:00:00Z",
    server: str = "default",
    label: str = "ws",
    own_id: str | None = None,
    pid: int = 4242,
) -> dict:
    from lib_py.agents.registry import own_key

    key = own_key(agent) if agent in ("claude", "agy", "codex", "grok", "hermes", "opencode") else "unknown_id"
    return {
        "name": name,
        "status": status,
        "role": role,
        "agent": agent,
        "herdr_session": server,
        "herdr_server": server,
        "herdr_workspace": label,
        "herdr_session_created_at": created_at,
        key: own_id,
        "pane": {"cwd": str(cwd), "pid": pid, "cmd": agent},
    }


def _run_reset_py(args: list[str], state: dict | None = None, stdin_text: str | None = None, env_extra: dict | None = None):
    env = dict(os.environ)
    env["PYTHONPATH"] = str(SKILLS)
    env["PYTHONDONTWRITEBYTECODE"] = "1"
    if state is not None:
        env["MAM_STATE_JSON"] = json.dumps(state)
    if env_extra:
        env.update(env_extra)
    return subprocess.run(
        [sys.executable, "-m", "lib_py.reset", *args],
        env=env,
        input=stdin_text,
        capture_output=True,
        text=True,
        timeout=15,
    )


# --------------------------------------------------------------------------- Unit tests: lib_py.reset

def test_reset_py_python39_syntax():
    src = (SKILLS / "lib_py" / "reset.py").read_text(encoding="utf-8")
    ast.parse(src, filename="reset.py", feature_version=(3, 9))


def test_select_targets_and_plan_cli(tmp_path: Path):
    """§5.2-1: select_targets chooses only status==running rows at realpath(WS),
    resolving symlinks, listing skipped rows with reasons and orchestrator_uuids,
    and refusing running control-root rows with missing agent or empty role.
    """
    ws = tmp_path / "ws"
    ws.mkdir()
    wt = ws / "wt" / "x"
    wt.mkdir(parents=True)
    sym_ws = tmp_path / "sym-ws"
    sym_ws.symlink_to(ws)

    state = {
        "orchestrator_uuids": [UORC],
        "herdr_sessions": [
            _row("reviewer-claude-01", "claude", ws, role="planner,reviewer", own_id=UA, server="srv1", label="lbl1"),
            _row("reviewer-grok-01", "grok", sym_ws, role="reviewer", own_id=UB, server="default", label="lbl2"),
            _row("creator-claude-wt", "claude", wt, role="creator", own_id=UC),
            _row("stopped-codex-01", "codex", ws, status="stopped", own_id=UD),
            _row("dead-hermes-01", "hermes", ws, status="terminated", own_id=None),
        ],
    }

    res = _run_reset_py(["plan", "--workspace", str(ws)], state=state)
    assert res.returncode == 0, res.stderr
    plan = json.loads(res.stdout)
    assert [t["name"] for t in plan["targets"]] == ["reviewer-claude-01", "reviewer-grok-01"]
    assert plan["targets"][0] == {
        "name": "reviewer-claude-01",
        "agent": "claude",
        "role": "planner,reviewer",
        "herdr_server": "srv1",
        "herdr_workspace": "lbl1",
        "old_id": UA,
        "old_created_at": "2026-10-01T00:00:00Z",
    }
    skipped = {s["name"]: s["reason"] for s in plan["skipped"]}
    assert "not the control root" in skipped["creator-claude-wt"]
    assert skipped["stopped-codex-01"] == "status stopped"
    assert skipped["dead-hermes-01"] == "status terminated"
    assert plan["orchestrators"] == [UORC]
    assert plan["errors"] == []

    # Empty role or unknown agent on a running control-root row causes plan & precheck to return 1
    bad_state = {
        "herdr_sessions": [
            _row("bad-role-claude", "claude", ws, role="", own_id=UA),
            {
                "name": "mystery-row",
                "status": "running",
                "role": "reviewer",
                "agent": "not-an-agent",
                "pane": {"cwd": str(ws), "pid": 123, "cmd": "bash"},
            },
        ]
    }
    res_bad = _run_reset_py(["plan", "--workspace", str(ws)], state=bad_state)
    assert res_bad.returncode == 1
    bad_plan = json.loads(res_bad.stdout)
    assert len(bad_plan["errors"]) == 2

    res_pre = _run_reset_py(["precheck", "--workspace", str(ws)], state=bad_state)
    assert res_pre.returncode == 1
    assert "bad-role-claude" in res_pre.stdout
    assert "mystery-row" in res_pre.stdout


def test_spec_file_write_read_and_validation(tmp_path: Path):
    """D5: write-spec atomically writes .mam/reset-spec.json; corrupt, wrong-version,
    or wrong-workspace spec files are rejected with 'check it, then remove it by hand'.
    """
    from lib_py.reset import SpecError, read_spec

    ws = tmp_path / "ws"
    ws.mkdir()
    targets = [
        {
            "name": "reviewer-claude-01",
            "agent": "claude",
            "role": "reviewer",
            "herdr_server": "default",
            "herdr_workspace": "ws",
            "old_id": UA,
            "old_created_at": "2026-10-01T00:00:00Z",
        }
    ]
    res = _run_reset_py(
        ["write-spec", "--workspace", str(ws)],
        stdin_text=json.dumps({"targets": targets}),
    )
    assert res.returncode == 0, res.stderr
    spath = ws / ".mam" / "reset-spec.json"
    assert spath.is_file()
    doc = read_spec(str(ws))
    assert doc["version"] == 1
    assert doc["workspace"] == os.path.realpath(str(ws))
    assert doc["agents"] == targets

    # Wrong workspace
    other_ws = tmp_path / "other"
    other_ws.mkdir()
    with pytest.raises(SpecError, match="check it, then remove it by hand"):
        read_spec(str(other_ws))

    # Wrong version
    spath.write_text(json.dumps({"version": 99, "workspace": str(ws), "agents": []}))
    with pytest.raises(SpecError, match="check it, then remove it by hand"):
        read_spec(str(ws))

    # Corrupt JSON
    spath.write_text("{corrupt")
    with pytest.raises(SpecError, match="check it, then remove it by hand"):
        read_spec(str(ws))
    res_entries = _run_reset_py(["entries", "--workspace", str(ws)], state={})
    assert res_entries.returncode == 1
    assert "check it, then remove it by hand" in res_entries.stderr


def test_entries_5_states_and_resumed_row_9b(tmp_path: Path):
    """D6 1-5 & §5.2-9b:
    #1 row absent -> purged
    #2 same created_at (even if normal stop recorded a new id onto old_id=None) -> pending
    #3 new created_at and id == old_id -> pending (resumed original conversation, 9b)
    #4 new created_at and id empty -> created
    #5 new created_at and id != old_id -> done
    """
    from lib_py.reset import write_spec

    ws = tmp_path / "ws"
    ws.mkdir()
    spec_agents = [
        {
            "name": "s1-purged",
            "agent": "claude",
            "role": "reviewer",
            "herdr_server": "default",
            "herdr_workspace": "ws",
            "old_id": UA,
            "old_created_at": "2026-10-01T00:00:00Z",
        },
        {
            "name": "s2-same-inst-newly-recorded",
            "agent": "agy",
            "role": "reviewer",
            "herdr_server": "default",
            "herdr_workspace": "ws",
            "old_id": None,
            "old_created_at": "2026-10-01T00:00:00Z",
        },
        {
            "name": "s3-resumed-same-id",
            "agent": "claude",
            "role": "reviewer",
            "herdr_server": "default",
            "herdr_workspace": "ws",
            "old_id": UB,
            "old_created_at": "2026-10-01T00:00:00Z",
        },
        {
            "name": "s4-created-no-id",
            "agent": "hermes",
            "role": "reviewer",
            "herdr_server": "default",
            "herdr_workspace": "ws",
            "old_id": UC,
            "old_created_at": "2026-10-01T00:00:00Z",
        },
        {
            "name": "s5-done",
            "agent": "codex",
            "role": "reviewer",
            "herdr_server": "default",
            "herdr_workspace": "ws",
            "old_id": None,
            "old_created_at": "2026-10-01T00:00:00Z",
        },
    ]
    write_spec(str(ws), spec_agents)

    state = {
        "herdr_sessions": [
            # #2: normal stop wrote UA onto original row (same created_at, status stopped) -> still pending!
            _row(
                "s2-same-inst-newly-recorded",
                "agy",
                ws,
                status="stopped",
                created_at="2026-10-01T00:00:00Z",
                own_id=UA,
            ),
            # #3 (9b): resumed into a new herdr session (different created_at), but same conversation ID UB -> pending!
            _row(
                "s3-resumed-same-id",
                "claude",
                ws,
                status="running",
                created_at="2026-10-02T00:00:00Z",
                own_id=UB,
            ),
            # #4: newly created session, ID not discovered yet -> created
            _row(
                "s4-created-no-id",
                "hermes",
                ws,
                status="running",
                created_at="2026-10-02T00:00:00Z",
                own_id=None,
            ),
            # #5: newly created session, new ID UD recorded (old_id was None) -> done
            _row(
                "s5-done",
                "codex",
                ws,
                status="running",
                created_at="2026-10-02T00:00:00Z",
                own_id=UD,
            ),
        ]
    }

    res = _run_reset_py(["entries", "--workspace", str(ws)], state=state)
    assert res.returncode == 0, res.stderr
    parsed = {}
    for line in res.stdout.strip().splitlines():
        kv = dict(tok.split("=", 1) for tok in shlex.split(line))
        parsed[kv["R_NAME"]] = kv

    assert parsed["s1-purged"]["R_STATE"] == "purged"
    assert parsed["s2-same-inst-newly-recorded"]["R_STATE"] == "pending"
    assert parsed["s2-same-inst-newly-recorded"]["R_ROW_ID"] == UA
    assert parsed["s3-resumed-same-id"]["R_STATE"] == "pending"
    assert parsed["s4-created-no-id"]["R_STATE"] == "created"
    assert parsed["s5-done"]["R_STATE"] == "done"

    # Check D8 table formatting for these 5 rows (including 9b NEW!=OLD == "no" and 3-1 OLD_ID="-", NEW!=OLD="yes")
    res_tbl = _run_reset_py(
        [
            "table",
            "--workspace",
            str(ws),
            "--skipped",
            "s2-same-inst-newly-recorded:purge_refused",
        ],
        state=state,
    )
    assert res_tbl.returncode == 4  # 4 takes precedence over 5
    rows_by_name = {}
    for line in res_tbl.stdout.strip().splitlines()[1:]:
        cols = line.split(None, 6)
        rows_by_name[cols[0]] = cols

    # s2: original row where step 1 captured UA, then step 3 refused purge -> NEW_ID is '-', RECORDED 'no', NEW!=OLD '-'
    assert rows_by_name["s2-same-inst-newly-recorded"][1:6] == ["agy", "-", "-", "no", "-"]
    assert rows_by_name["s2-same-inst-newly-recorded"][6] == "skipped: purge refused"

    # s3 (9b): resumed row with same ID UB -> NEW_ID is UB, RECORDED 'yes', NEW!=OLD 'no'
    assert rows_by_name["s3-resumed-same-id"][1:6] == ["claude", UB, UB, "yes", "no"]

    # s4: created, no ID yet -> NEW_ID '-', RECORDED 'no', NEW!=OLD '-', RESULT 'created; id not recorded yet'
    assert rows_by_name["s4-created-no-id"][1:6] == ["hermes", UC, "-", "no", "-"]
    assert rows_by_name["s4-created-no-id"][6] == "created; id not recorded yet"

    # s5 (3-1): old_id was None, new_id is UD -> OLD_ID '-', NEW_ID UD, RECORDED 'yes', NEW!=OLD 'yes', RESULT 'done'
    assert rows_by_name["s5-done"][1:6] == ["codex", "-", UD, "yes", "yes"]
    assert rows_by_name["s5-done"][6] == "done"


def test_precheck_open_jobs_and_caller_target(tmp_path: Path):
    """D4-5: precheck reports open jobs with close command and refuses when caller is a target."""
    ws = tmp_path / "ws"
    jobs_dir = ws / ".mam" / "jobs"
    jobs_dir.mkdir(parents=True)
    (jobs_dir / "j123.json").write_text(
        json.dumps(
            {
                "job_id": "j123",
                "agent_session": "herdr:reviewer-claude-01",
                "status": "running",
            }
        )
    )
    state = {
        "herdr_sessions": [
            _row("reviewer-claude-01", "claude", ws, own_id=UA, pid=os.getpid()),
        ]
    }
    res = _run_reset_py(
        ["precheck", "--workspace", str(ws)],
        state=state,
        env_extra={"CLAUDE_CODE_SESSION_ID": UA},
    )
    assert res.returncode == 1
    assert "job j123" in res.stdout
    assert "close --job j123 --request cancelled" in res.stdout
    assert "you are reviewer-claude-01, one of the targets; run the reset from the orchestrator" in res.stdout