import yaml

from investibook.core.eval.eval_registry import default_registry_root, load_suite


EVALUATION_CASES = [
    "progressive-resource-growth-during-steady-workload",
    "intermittent-plan-regression-during-cpu-spike",
    "repeated-component-restarts-during-maintenance-window",
    "intermittent-query-failures-during-partition-maintenance",
    "sustained-node-memory-pressure-during-transaction-workload",
    "transaction-failure-during-concurrent-upsert",
    "component-restart-during-query-cancellation",
    "checkpoint-catchup-slow-after-changefeed-resume",
    "running-changefeed-with-stalled-progress",
    "batch-update-row-processing-anomaly",
]

TRAINING_CASES = [
    "inconsistent-query-result-with-subquery",
    "inconsistent-query-result-with-null-filter",
    "latency-surge-with-tikv-cpu-imbalance",
    "write-latency-during-concurrent-upsert",
    "transaction-outcome-after-node-failure",
    "downstream-sink-transaction-failure",
    "changefeed-stalls-after-ddl-retry",
    "changefeed-stops-on-row-encoding-error",
    "database-time-spike-with-storage-read-wait",
    "insert-latency-degradation-during-incident-window",
]


def test_specialist_diagnosis_case_sets_are_standardized_and_disjoint():
    evaluation = load_suite("specialist-diagnosis-evaluation")
    training = load_suite("specialist-diagnosis-training")

    assert evaluation.data["status"] == "draft"
    assert evaluation.data["baseline_eligible"] is False
    assert [case.id for case in evaluation.cases] == EVALUATION_CASES

    assert training.data["status"] == "draft"
    assert training.data["baseline_eligible"] is False
    assert [case.id for case in training.cases] == TRAINING_CASES

    assert set(EVALUATION_CASES).isdisjoint(TRAINING_CASES)


def test_specialist_cases_exclude_serverless_tiers_and_keep_judging_private():
    root = default_registry_root()

    for case_id in EVALUATION_CASES + TRAINING_CASES:
        case_dir = root / "cases" / case_id
        case_data = yaml.safe_load((case_dir / "case.yaml").read_text())
        judge_data = yaml.safe_load((case_dir / "judge.yaml").read_text())

        assert case_data["status"] == "draft"
        assert case_data["source"] == "jira"
        assert case_data["environment"]["cluster_type"] in {"dedicated", "premium"}
        assert case_data["environment"]["cluster_type"] not in {"essential", "starter"}
        assert "judge" not in case_data
        assert "ground_truth" not in case_data
        assert judge_data["case_id"] == case_id
        assert (case_dir / "expected.md").is_file()

        expected_routes = judge_data["ground_truth"][
            "expected_diagnosis_skill_routes"
        ]
        assert isinstance(expected_routes, list)
        for route in expected_routes:
            assert route["any_of"]

        routing_checks = {
            check["id"]: check
            for check in judge_data["judge"]["evidence_routing"]["checks"]
        }
        specialist_contract = routing_checks["specialist_routing_contract"]
        assert specialist_contract["required"] is True
        assert {
            rule["path"] for rule in specialist_contract["rules"]
        } == {
            "diagnosis_analyst_dispatched",
            "classification_contract_valid",
            "expected_diagnosis_skill_routes_selected",
        }

        assert [
            check["id"] for check in judge_data["judge"]["critical_evidence"]["checks"]
        ] == [
            "primary_symptom_evidence_present",
            "root_cause_mechanism_evidence_present",
            "scope_or_timeline_evidence_present",
        ]
        assert [
            check["id"] for check in judge_data["judge"]["diagnosis"]["checks"]
        ] == [
            "identify_primary_failure_mechanism",
            "explain_causal_chain",
            "recommend_aligned_remediation",
        ]