"""ASV benchmarks for correction model construction and service operations.

Measures the performance of:
- CorrectionRequest model construction (Pydantic validation)
- CorrectionImpact / CorrectionResult / CorrectionAttempt construction
- CorrectionService.request_correction()
- CorrectionService.analyze_impact()
- CorrectionService.execute_correction()
- CorrectionService.list_corrections()
- CorrectionMode / CorrectionStatus enum access
"""

from __future__ import annotations

import sys
from pathlib import Path

try:
    from cleveragents.application.services.correction_service import (
        CorrectionService,
    )
    from cleveragents.domain.models.core.correction import (
        CorrectionAttempt,
        CorrectionImpact,
        CorrectionMode,
        CorrectionRequest,
        CorrectionResult,
        CorrectionStatus,
    )
except ModuleNotFoundError:
    sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
    from cleveragents.application.services.correction_service import (
        CorrectionService,
    )
    from cleveragents.domain.models.core.correction import (
        CorrectionAttempt,
        CorrectionImpact,
        CorrectionMode,
        CorrectionRequest,
        CorrectionResult,
        CorrectionStatus,
    )


class CorrectionModelSuite:
    """Benchmark correction model construction."""

    def time_correction_request_construction(self) -> None:
        """Benchmark CorrectionRequest creation with Pydantic validation."""
        CorrectionRequest(
            plan_id="plan-bench-1",
            target_decision_id="DEC-001",
            mode=CorrectionMode.REVERT,
            guidance="Benchmark guidance text",
        )

    def time_correction_impact_construction(self) -> None:
        """Benchmark CorrectionImpact creation."""
        CorrectionImpact(
            affected_decisions=["DEC-001", "DEC-002", "DEC-003"],
            affected_files=["src/main.py", "src/utils.py"],
            estimated_cost=1.5,
            risk_level="medium",
        )

    def time_correction_result_construction(self) -> None:
        """Benchmark CorrectionResult creation."""
        CorrectionResult(
            correction_id="test-id",
            status=CorrectionStatus.APPLIED,
            new_decisions=["DEC-004"],
            reverted_decisions=["DEC-001"],
        )

    def time_correction_attempt_construction(self) -> None:
        """Benchmark CorrectionAttempt creation."""
        CorrectionAttempt(
            correction_id="test-id",
            success=True,
            details={"step": "benchmark"},
        )

    def time_correction_mode_enum_access(self) -> None:
        """Benchmark CorrectionMode enum value access."""
        _ = CorrectionMode.REVERT.value
        _ = CorrectionMode.APPEND.value

    def time_correction_status_enum_access(self) -> None:
        """Benchmark CorrectionStatus enum value access."""
        _ = CorrectionStatus.PENDING.value
        _ = CorrectionStatus.ANALYZING.value
        _ = CorrectionStatus.EXECUTING.value
        _ = CorrectionStatus.APPLIED.value
        _ = CorrectionStatus.FAILED.value
        _ = CorrectionStatus.CANCELLED.value


class CorrectionServiceSuite:
    """Benchmark CorrectionService operations."""

    def setup(self) -> None:
        """Create a fresh service for each benchmark."""
        self.service = CorrectionService()

    def time_request_correction(self) -> None:
        """Benchmark creating a correction request."""
        self.service.request_correction(
            plan_id="plan-bench",
            target_decision_id="DEC-001",
            mode=CorrectionMode.REVERT,
            guidance="Benchmark correction",
        )

    def time_analyze_impact(self) -> None:
        """Benchmark impact analysis (stub)."""
        req = self.service.request_correction(
            plan_id="plan-bench",
            target_decision_id="DEC-001",
            mode=CorrectionMode.REVERT,
            guidance="Benchmark analysis",
        )
        self.service.analyze_impact(req.correction_id)

    def time_execute_correction(self) -> None:
        """Benchmark correction execution (stub)."""
        req = self.service.request_correction(
            plan_id="plan-bench",
            target_decision_id="DEC-001",
            mode=CorrectionMode.REVERT,
            guidance="Benchmark execution",
        )
        self.service.execute_correction(req.correction_id)

    def time_list_corrections(self) -> None:
        """Benchmark listing corrections."""
        self.service.list_corrections()

    def time_list_corrections_filtered(self) -> None:
        """Benchmark listing corrections with plan filter."""
        self.service.list_corrections(plan_id="plan-bench")