"""tests/state_machine/test_transitions.py
명세 §3 "6개 금지 전이" + 상태 enum 검증 (task-2467)

벨레스(개발6팀 테스터) 작성. 스바로그의 구현 완료 전 선작성(TDD).
"""
from __future__ import annotations

import importlib
import json
import os
import subprocess
import sys
from pathlib import Path

import pytest

WORKSPACE = Path("/home/jay/workspace/.worktrees/task-2467-dev6")
TASKCTL = WORKSPACE / "scripts" / "taskctl.py"


# ---------------------------------------------------------------------------
# helpers
# ---------------------------------------------------------------------------

def _isolated_workspace(tmp_path: Path) -> dict:
    """test마다 .tasks/state/ 와 .tasks/evidence/ 격리."""
    env = {**os.environ}
    env["WORKSPACE_ROOT"] = str(tmp_path)
    (tmp_path / ".tasks" / "state").mkdir(parents=True, exist_ok=True)
    (tmp_path / ".tasks" / "evidence").mkdir(parents=True, exist_ok=True)
    (tmp_path / "memory" / "events").mkdir(parents=True, exist_ok=True)
    (tmp_path / "memory" / "orchestration-audit").mkdir(parents=True, exist_ok=True)
    return env


def _run_taskctl(args: list[str], env: dict) -> subprocess.CompletedProcess:
    return subprocess.run(
        ["python3", str(TASKCTL)] + args,
        capture_output=True, text=True, env=env, timeout=30,
    )


def _state(tmp_path: Path, task_id: str) -> dict:
    p = tmp_path / ".tasks" / "state" / f"{task_id}.json"
    return json.loads(p.read_text())


def _force_state(tmp_path: Path, task_id: str, target_state: str) -> None:
    """테스트 전용: state 파일을 직접 조작하여 체크섬 재계산 후 저장.

    구현이 _compute_checksum 로직을 노출하지 않으므로, 직접 sha256 재계산.
    """
    import hashlib

    p = tmp_path / ".tasks" / "state" / f"{task_id}.json"
    state = json.loads(p.read_text())
    state["current_state"] = target_state
    # 체크섬 재계산 (taskctl과 동일 알고리즘: sort_keys, separators)
    state.pop("_checksum", None)
    payload = {k: v for k, v in state.items() if k != "_checksum"}
    canon = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
    checksum = hashlib.sha256(canon.encode("utf-8")).hexdigest()
    state["_checksum"] = checksum
    p.write_text(json.dumps(state, ensure_ascii=False, indent=2))


# ---------------------------------------------------------------------------
# §3.9 (1): PR_OPEN 없이 VERIFIED 차단
# ---------------------------------------------------------------------------

def test_forbidden_transition_pr_open_to_verified_directly(tmp_path):
    """§3.9 (1): PR_OPEN 없이 VERIFIED 진입 차단.

    init → dispatch → ack → run → verify (PR_OPEN 미경유)
    현재 MVP 상태모델에서 RUNNING → GUARD_PASS(=VERIFIED)는
    PR_OPEN을 거치지 않으므로 허용되면 안 된다.
    신규 14+5 상태모델에서는 RUNNING → COMMITTED → PR_OPEN → ... → VERIFIED 경로만 허용.
    """
    env = _isolated_workspace(tmp_path)
    task_id = "task-forbidden-01"
    assert _run_taskctl(["init", task_id], env).returncode == 0
    assert _run_taskctl(["dispatch", task_id], env).returncode == 0
    assert _run_taskctl(["ack", task_id], env).returncode == 0
    assert _run_taskctl(["run", task_id], env).returncode == 0

    # PR_OPEN 없이 verify 시도
    # 신규 구현: RUNNING 상태에서 verify 거부 (PR_OPEN 또는 REVIEW_READY 필요)
    _run_taskctl(["verify", task_id], env)

    state_file = tmp_path / ".tasks" / "state" / f"{task_id}.json"
    assert state_file.exists(), "state 파일이 존재해야 함"
    state = json.loads(state_file.read_text())
    current = state["current_state"]

    # VERIFIED 또는 GUARD_PASS 상태로 진입하면 안 됨
    # (PR_OPEN → CI_PENDING → GEMINI_PENDING → REVIEW_READY 경유 없음)
    assert current not in {"VERIFIED", "GUARD_PASS"}, (
        f"PR_OPEN 없이 VERIFIED/GUARD_PASS 진입 발생: {current}"
    )


# ---------------------------------------------------------------------------
# §3.9 (2): VERIFIED 없이 HUMAN_APPROVED 차단
# ---------------------------------------------------------------------------

def test_forbidden_transition_verified_to_human_approved_skipping(tmp_path):
    """§3.9 (2): VERIFIED 없이 HUMAN_APPROVED 차단.

    PR_OPEN 상태에서 approve 시도 → 차단 (VERIFIED/GUARD_PASS 필요).
    """
    env = _isolated_workspace(tmp_path)
    task_id = "task-forbidden-02"
    assert _run_taskctl(["init", task_id], env).returncode == 0
    assert _run_taskctl(["dispatch", task_id], env).returncode == 0
    assert _run_taskctl(["ack", task_id], env).returncode == 0
    assert _run_taskctl(["run", task_id], env).returncode == 0
    assert _run_taskctl(["pr-open", task_id, "--pr", "200"], env).returncode == 0

    # PR_OPEN 상태에서 approve 시도 → 거부
    proc = _run_taskctl(["approve", task_id, "--by", "human-reviewer"], env)
    assert proc.returncode != 0, "VERIFIED 없이 HUMAN_APPROVED 진입이 차단되어야 함"

    state = _state(tmp_path, task_id)
    assert state["current_state"] not in {"HUMAN_APPROVED"}, (
        f"VERIFIED 없이 HUMAN_APPROVED 진입 발생: {state['current_state']}"
    )


# ---------------------------------------------------------------------------
# §3.9 (3): HUMAN_APPROVED 없이 MERGING 차단
# ---------------------------------------------------------------------------

def test_forbidden_transition_human_approved_to_merging_skipped(tmp_path):
    """§3.9 (3): HUMAN_APPROVED 없이 MERGING 차단.

    PR_OPEN 상태 (또는 GUARD_PASS/VERIFIED 상태)에서 merge 시도 → 거부.
    """
    env = _isolated_workspace(tmp_path)
    task_id = "task-forbidden-03"
    assert _run_taskctl(["init", task_id], env).returncode == 0
    assert _run_taskctl(["dispatch", task_id], env).returncode == 0
    assert _run_taskctl(["ack", task_id], env).returncode == 0
    assert _run_taskctl(["run", task_id], env).returncode == 0
    assert _run_taskctl(["pr-open", task_id, "--pr", "300"], env).returncode == 0

    # PR_OPEN에서 merge 시도
    proc = _run_taskctl(["merge", task_id, "--dry-run"], env)
    assert proc.returncode != 0, "HUMAN_APPROVED 없이 MERGING 진입이 차단되어야 함"

    state = _state(tmp_path, task_id)
    assert state["current_state"] not in {"MERGING", "MERGED"}, (
        f"HUMAN_APPROVED 없이 MERGING/MERGED 진입 발생: {state['current_state']}"
    )
    # 에러 메시지에 HUMAN_APPROVED 언급 확인
    assert "HUMAN_APPROVED" in proc.stderr or "차단" in proc.stderr or "blocked" in proc.stderr.lower(), (
        f"예상 에러 메시지 없음: {proc.stderr}"
    )


# ---------------------------------------------------------------------------
# §3.9 (4): MERGED 없이 DONE 차단
# ---------------------------------------------------------------------------

def test_forbidden_transition_merged_required_for_done(tmp_path):
    """§3.9 (4): MERGED 없이 DONE 차단.

    PR_OPEN 상태에서 done 명령 시도 → 거부.
    """
    env = _isolated_workspace(tmp_path)
    task_id = "task-forbidden-04"
    assert _run_taskctl(["init", task_id], env).returncode == 0
    assert _run_taskctl(["dispatch", task_id], env).returncode == 0
    assert _run_taskctl(["ack", task_id], env).returncode == 0
    assert _run_taskctl(["run", task_id], env).returncode == 0
    assert _run_taskctl(["pr-open", task_id, "--pr", "400"], env).returncode == 0

    # PR_OPEN 상태에서 done 시도
    proc = _run_taskctl(["done", task_id], env)
    assert proc.returncode != 0, "MERGED 없이 DONE 진입이 차단되어야 함"

    state = _state(tmp_path, task_id)
    assert state["current_state"] not in {"DONE"}, (
        f"MERGED 없이 DONE 진입 발생: {state['current_state']}"
    )


# ---------------------------------------------------------------------------
# §3.9 (5): CANCELLED terminal — 다른 상태 복귀 차단
# ---------------------------------------------------------------------------

def test_forbidden_transition_cancelled_terminal_no_recovery(tmp_path):
    """§3.9 (5): CANCELLED는 terminal — 다른 상태로 복귀 불가.

    init → cancel → run 시도 → 차단.
    """
    env = _isolated_workspace(tmp_path)
    task_id = "task-forbidden-05"
    assert _run_taskctl(["init", task_id], env).returncode == 0
    assert _run_taskctl(["cancel", task_id], env).returncode == 0

    state = _state(tmp_path, task_id)
    assert state["current_state"] == "CANCELLED"

    # CANCELLED 후 run 시도 → 차단
    proc = _run_taskctl(["run", task_id], env)
    assert proc.returncode != 0, "CANCELLED에서 RUN 진입이 차단되어야 함"

    state = _state(tmp_path, task_id)
    assert state["current_state"] == "CANCELLED", (
        f"CANCELLED에서 상태 변경 발생: {state['current_state']}"
    )


def test_forbidden_transition_cancelled_no_approve(tmp_path):
    """§3.9 (5) 보완: CANCELLED 후 approve 시도 → 차단."""
    env = _isolated_workspace(tmp_path)
    task_id = "task-forbidden-05b"
    assert _run_taskctl(["init", task_id], env).returncode == 0
    assert _run_taskctl(["cancel", task_id], env).returncode == 0

    proc = _run_taskctl(["approve", task_id, "--by", "human"], env)
    assert proc.returncode != 0, "CANCELLED에서 approve 시도가 차단되어야 함"

    state = _state(tmp_path, task_id)
    assert state["current_state"] == "CANCELLED"


# ---------------------------------------------------------------------------
# §3.9 (6): BLOCKED 상태에서 MERGING 차단
# ---------------------------------------------------------------------------

def test_forbidden_transition_blocked_to_merging(tmp_path):
    """§3.9 (6): BLOCKED 상태에서 MERGING 진입 차단.

    state 파일을 BLOCKED로 강제 진입시킨 후 merge 시도 → 차단.
    (신규 구현에서 BLOCKED 상태 진입 명령이 추가되면 해당 명령으로 대체 가능)
    """
    env = _isolated_workspace(tmp_path)
    task_id = "task-forbidden-06"
    assert _run_taskctl(["init", task_id], env).returncode == 0
    assert _run_taskctl(["dispatch", task_id], env).returncode == 0
    assert _run_taskctl(["ack", task_id], env).returncode == 0
    assert _run_taskctl(["run", task_id], env).returncode == 0
    assert _run_taskctl(["pr-open", task_id, "--pr", "600"], env).returncode == 0

    # BLOCKED 상태로 강제 전이 (체크섬 재계산 포함)
    _force_state(tmp_path, task_id, "BLOCKED")

    state = _state(tmp_path, task_id)
    assert state["current_state"] == "BLOCKED", "강제 BLOCKED 설정 실패"

    # BLOCKED에서 merge 시도 → 차단
    proc = _run_taskctl(["merge", task_id, "--dry-run"], env)
    assert proc.returncode != 0, "BLOCKED 상태에서 MERGING 진입이 차단되어야 함"

    state = _state(tmp_path, task_id)
    assert state["current_state"] not in {"MERGING", "MERGED", "DONE"}, (
        f"BLOCKED에서 MERGING 진입 발생: {state['current_state']}"
    )


# ---------------------------------------------------------------------------
# 상태 enum 검증
# ---------------------------------------------------------------------------

def test_state_enum_includes_14_normal_5_exception():
    """STATES enum이 14 정상 + 5 예외 상태를 포함하는지 검증.

    신규 구현 완료 후 통과 예상. 현재 MVP는 11종만 정의.
    """
    sys.path.insert(0, str(WORKSPACE / "scripts"))
    try:
        taskctl_mod = importlib.import_module("taskctl")
        importlib.reload(taskctl_mod)
    finally:
        pass

    states = set(taskctl_mod.STATES)

    expected_normal = {
        "CREATED", "WORKTREE_READY", "RUNNING", "HANDOFF_READY",
        "COMMITTED", "PR_OPEN", "CI_PENDING", "GEMINI_PENDING",
        "REVIEW_READY", "VERIFIED", "HUMAN_APPROVED", "MERGING",
        "MERGED", "DONE",
    }
    expected_exception = {
        "BLOCKED", "CANCELLED", "FAILED", "ESCALATED", "ADMIN_OVERRIDE_USED",
    }

    missing_normal = expected_normal - states
    missing_exception = expected_exception - states

    # 현재 MVP에서는 부분 실패 허용 (스바로그 구현 후 모두 통과)
    assert not missing_exception, f"누락된 예외 상태: {missing_exception}"
    # 정상 상태는 경고만 (MVP alias 허용)
    if missing_normal:
        # MVP alias 매핑: DISPATCHED≡WORKTREE_READY, ACKED≡WORKTREE_READY, GUARD_PASS≡VERIFIED
        alias_map = {
            "WORKTREE_READY": {"DISPATCHED", "ACKED"},
            "VERIFIED": {"GUARD_PASS"},
        }
        unresolved = set()
        for m in missing_normal:
            aliases = alias_map.get(m, set())
            if not (aliases & states):
                unresolved.add(m)
        assert not unresolved, f"누락된 정상 상태 (alias 없음): {unresolved}"


def test_terminal_states_no_transitions_out():
    """DONE/CANCELLED/FAILED/ADMIN_OVERRIDE_USED는 terminal 상태.

    TERMINAL_STATES에 반드시 포함되어야 함.
    """
    sys.path.insert(0, str(WORKSPACE / "scripts"))
    try:
        taskctl_mod = importlib.import_module("taskctl")
        importlib.reload(taskctl_mod)
    finally:
        pass

    terminal = taskctl_mod.TERMINAL_STATES
    expected = {"DONE", "CANCELLED", "FAILED"}
    # ADMIN_OVERRIDE_USED는 신규 추가 상태 — 스바로그 구현 후 포함
    expected_new = {"ADMIN_OVERRIDE_USED"}

    missing_core = expected - terminal
    assert not missing_core, f"누락된 core terminal 상태: {missing_core}"

    # 신규 terminal 상태는 soft check (구현 전 실패 허용)
    missing_new = expected_new - terminal
    if missing_new:
        pytest.xfail(f"신규 terminal 상태 미구현 (스바로그 대기): {missing_new}")