"""Unit tests for src/my_deepagent/enums.py."""

import pytest

from my_deepagent.enums import (
    ApprovalDecisionAction,
    ApprovalState,
    Backend,
    Capability,
    ErrorClass,
    RiskLevel,
    RunPhaseState,
    RunState,
    SessionState,
)

# ---------------------------------------------------------------------------
# Backend
# ---------------------------------------------------------------------------


def test_backend_openrouter_value() -> None:
    assert Backend.OPENROUTER == "openrouter"  # type: ignore[comparison-overlap]


def test_backend_anthropic_value() -> None:
    assert Backend.ANTHROPIC == "anthropic"  # type: ignore[comparison-overlap]


def test_backend_openai_value() -> None:
    assert Backend.OPENAI == "openai"  # type: ignore[comparison-overlap]


def test_backend_google_value() -> None:
    assert Backend.GOOGLE == "google"  # type: ignore[comparison-overlap]


def test_backend_fake_value() -> None:
    assert Backend.FAKE == "fake"  # type: ignore[comparison-overlap]


def test_backend_str_equality() -> None:
    # StrEnum members compare equal to their string values
    assert Backend.OPENROUTER == "openrouter"  # type: ignore[comparison-overlap]
    assert str(Backend.OPENROUTER) == "openrouter"


# ---------------------------------------------------------------------------
# Capability
# ---------------------------------------------------------------------------


def test_capability_count() -> None:
    assert len(list(Capability)) == 13


def test_capability_spec_write() -> None:
    assert Capability.SPEC_WRITE == "spec_write"  # type: ignore[comparison-overlap]


def test_capability_code_edit() -> None:
    assert Capability.CODE_EDIT == "code_edit"  # type: ignore[comparison-overlap]


def test_capability_final_report_compose() -> None:
    assert Capability.FINAL_REPORT_COMPOSE == "final_report_compose"  # type: ignore[comparison-overlap]


def test_capability_all_are_str() -> None:
    for cap in Capability:
        assert isinstance(cap, str)


# ---------------------------------------------------------------------------
# RiskLevel
# ---------------------------------------------------------------------------


def test_risk_level_values() -> None:
    assert RiskLevel.LOW == "low"  # type: ignore[comparison-overlap]
    assert RiskLevel.MEDIUM == "medium"  # type: ignore[comparison-overlap]
    assert RiskLevel.HIGH == "high"  # type: ignore[comparison-overlap]


# ---------------------------------------------------------------------------
# ApprovalDecisionAction
# ---------------------------------------------------------------------------


def test_approval_decision_action_approve() -> None:
    assert ApprovalDecisionAction.APPROVE == "approve"  # type: ignore[comparison-overlap]


def test_approval_decision_action_reject() -> None:
    assert ApprovalDecisionAction.REJECT == "reject"  # type: ignore[comparison-overlap]


def test_approval_decision_action_request_changes() -> None:
    assert ApprovalDecisionAction.REQUEST_CHANGES == "request_changes"  # type: ignore[comparison-overlap]


def test_approval_decision_action_abort() -> None:
    assert ApprovalDecisionAction.ABORT == "abort"  # type: ignore[comparison-overlap]


# ---------------------------------------------------------------------------
# ApprovalState
# ---------------------------------------------------------------------------


def test_approval_state_all_values() -> None:
    expected = {"pending", "approved", "rejected", "changes_requested", "aborted", "paused"}
    actual = {s.value for s in ApprovalState}
    assert actual == expected


# ---------------------------------------------------------------------------
# RunState
# ---------------------------------------------------------------------------


def test_run_state_all_values() -> None:
    expected = {
        "created",
        "bound",
        "planning",
        "awaiting_approval",
        "executing",
        "paused",
        "completed",
        "failed",
        "aborted",
    }
    actual = {s.value for s in RunState}
    assert actual == expected


def test_run_state_count() -> None:
    assert len(list(RunState)) == 9


# ---------------------------------------------------------------------------
# RunPhaseState
# ---------------------------------------------------------------------------


def test_run_phase_state_all_values() -> None:
    expected = {
        "pending",
        "running",
        "awaiting_artifact",
        "validating",
        "awaiting_approval",
        "completed",
        "failed",
        "skipped",
    }
    actual = {s.value for s in RunPhaseState}
    assert actual == expected


def test_run_phase_state_count() -> None:
    assert len(list(RunPhaseState)) == 8


# ---------------------------------------------------------------------------
# SessionState
# ---------------------------------------------------------------------------


def test_session_state_all_values() -> None:
    expected = {
        "CREATED",
        "BOOTSTRAPPING",
        "READY",
        "BUSY",
        "WAITING_FOR_APPROVAL",
        "ARTIFACT_TIMEOUT",
        "HUNG",
        "CRASHED",
        "RESUMING",
        "REBOOTSTRAPPED",
        "FAILED_NEEDS_HUMAN",
    }
    actual = {s.value for s in SessionState}
    assert actual == expected


def test_session_state_count() -> None:
    assert len(list(SessionState)) == 11


# ---------------------------------------------------------------------------
# ErrorClass
# ---------------------------------------------------------------------------


def test_error_class_recoverable() -> None:
    assert ErrorClass.RECOVERABLE == "recoverable"  # type: ignore[comparison-overlap]


def test_error_class_human_required() -> None:
    assert ErrorClass.HUMAN_REQUIRED == "human_required"  # type: ignore[comparison-overlap]


def test_error_class_fatal() -> None:
    assert ErrorClass.FATAL == "fatal"  # type: ignore[comparison-overlap]


def test_error_class_count() -> None:
    assert len(list(ErrorClass)) == 3


# ---------------------------------------------------------------------------
# StrEnum serialization / deserialization
# ---------------------------------------------------------------------------


def test_str_enum_from_value() -> None:
    assert Backend("openrouter") is Backend.OPENROUTER


def test_str_enum_in_dict() -> None:
    # StrEnum should work as dict key and compare with string
    d = {Backend.OPENROUTER: "openrouter backend"}
    assert d["openrouter"] == "openrouter backend"  # type: ignore[index]


@pytest.mark.parametrize(
    "state",
    list(RunState),
)
def test_run_state_parametrize(state: RunState) -> None:
    assert isinstance(state, str)
    assert RunState(state.value) is state