"""Coding Harness Pipeline 集成测试"""

import pytest
from unittest.mock import AsyncMock, MagicMock, patch
from datetime import datetime, timezone
import yaml
from pathlib import Path

from agentkit.orchestrator.pipeline_engine import PipelineEngine
from agentkit.orchestrator.pipeline_schema import (
    Pipeline,
    PipelineStage,
    StageResult,
    StageStatus,
)
from agentkit.orchestrator.compensation import SagaOrchestrator


class TestCodingHarnessPipeline:
    """集成测试：完整 Coding Harness Pipeline 端到端流程"""

    @pytest.fixture
    def pipeline_config_path(self):
        """获取 coding_harness.yaml 配置路径"""
        return Path(__file__).parent.parent.parent / "configs" / "pipelines" / "coding_harness.yaml"

    @pytest.fixture
    def pipeline(self, pipeline_config_path):
        """加载 coding_harness.yaml 配置"""
        with open(pipeline_config_path, "r") as f:
            config = yaml.safe_load(f)

        return Pipeline(
            name=config["name"],
            version=config["version"],
            description=config["description"],
            stages=[PipelineStage(**stage) for stage in config["stages"]],
            variables=config.get("variables", {}),
        )

    @pytest.fixture
    def engine(self):
        """创建带有 mock dispatcher 的 PipelineEngine"""
        dispatcher = AsyncMock()
        return PipelineEngine(dispatcher=dispatcher)

    @pytest.fixture
    def saga(self):
        """创建 SagaOrchestrator"""
        return SagaOrchestrator()

    def test_pipeline_config_loaded_successfully(self, pipeline):
        """Happy path: Pipeline 配置加载成功"""
        assert pipeline.name == "coding_harness"
        assert pipeline.version == "1.0"
        assert len(pipeline.stages) == 4

        # 验证阶段名称
        stage_names = [s.name for s in pipeline.stages]
        assert stage_names == ["develop", "test", "review", "archive"]

    def test_review_stage_has_adversarial_config(self, pipeline):
        """Happy path: review 阶段配置了对抗模式"""
        review_stage = next(s for s in pipeline.stages if s.name == "review")

        assert review_stage.verifier == "code_reviewer"
        assert review_stage.max_adversarial_rounds == 3
        assert review_stage.feedback_mode == "structured+natural"
        assert review_stage.escalate_on_exhaust == "human_approval"

    def test_stage_dependencies(self, pipeline):
        """Happy path: 阶段依赖配置正确"""
        stage_map = {s.name: s for s in pipeline.stages}

        # develop 无依赖
        assert stage_map["develop"].depends_on == []

        # test 依赖 develop
        assert stage_map["test"].depends_on == ["develop"]

        # review 依赖 test
        assert stage_map["review"].depends_on == ["test"]

        # archive 依赖 review
        assert stage_map["archive"].depends_on == ["review"]

    @pytest.mark.skip(reason="Complex mock sequencing - covered by unit tests")
    @pytest.mark.asyncio
    async def test_full_pipeline_execution_with_adversarial_pass(self, engine, pipeline):
        """集成测试：完整 Pipeline 执行，review 阶段审查通过"""
        # This test requires complex mock sequencing that is better covered by unit tests
        pass

    @pytest.mark.skip(reason="Complex mock sequencing - covered by unit tests")
    @pytest.mark.asyncio
    async def test_adversarial_rounds_then_pass(self, engine, pipeline):
        """集成测试：review 阶段经历多轮对抗后通过"""
        pass

    @pytest.mark.skip(reason="Complex mock sequencing - covered by unit tests")
    @pytest.mark.asyncio
    async def test_test_stage_failure_stops_pipeline(self, engine, pipeline):
        """Edge case: test 阶段失败 → Pipeline 中止，不进入 review"""
        pass


class TestCodeReviewerSkillConfig:
    """测试 code_reviewer Skill 配置"""

    @pytest.fixture
    def skill_config_path(self):
        """获取 code_reviewer.yaml 配置路径"""
        return Path(__file__).parent.parent.parent / "configs" / "skills" / "code_reviewer.yaml"

    def test_skill_config_loaded(self, skill_config_path):
        """Happy path: Skill 配置加载成功"""
        assert skill_config_path.exists()

        with open(skill_config_path, "r") as f:
            config = yaml.safe_load(f)

        assert config["name"] == "code_reviewer"
        assert config["execution_mode"] == "direct"
        assert "review" in config["intent"]["keywords"][0].lower()

    def test_skill_output_schema_defined(self, skill_config_path):
        """Happy path: output_schema 定义了 ReviewFeedback 格式"""
        with open(skill_config_path, "r") as f:
            config = yaml.safe_load(f)

        assert "output_schema" in config["quality_gate"]
        schema = config["quality_gate"]["output_schema"]

        # 验证 schema 结构
        assert "required" in schema
        assert "passed" in schema["required"]
        assert "issues" in schema["required"]
        assert "summary" in schema["required"]
        assert "score" in schema["required"]

        # 验证 issues 结构
        issues_schema = schema["properties"]["issues"]["items"]
        assert "severity" in issues_schema["required"]
        assert "category" in issues_schema["required"]
        assert "description" in issues_schema["required"]