from __future__ import annotations

import json
import subprocess
import sys
import tempfile
import unittest
from pathlib import Path

from tools.evaluate_a_grade_promotion import SOURCE_HEAD, build_a_grade_report


MODERN_ROOT = Path(__file__).resolve().parents[1]
SOURCE = Path(__file__).resolve().parents[2] / "source"


class AGradePromotionTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        required_reports = [
            MODERN_ROOT / "reports" / "capability_ledger.json",
            MODERN_ROOT / "reports" / "modernization_receipt.json",
        ]
        if all(path.exists() for path in required_reports):
            return
        subprocess.run(
            [
                sys.executable,
                str(MODERN_ROOT / "tools" / "generate_receipts.py"),
                "--source-root",
                str(SOURCE),
                "--db-path",
                str(MODERN_ROOT / "carddemo.sqlite"),
                "--out-dir",
                str(MODERN_ROOT / "reports"),
            ],
            check=True,
            capture_output=True,
            text=True,
        )

    def test_gate_does_not_promote_without_live_legacy_trace_corpus(self) -> None:
        report = build_a_grade_report(MODERN_ROOT, SOURCE)

        self.assertFalse(report["a_grade_gate"]["promotable_to_A"])
        self.assertEqual(50, report["a_grade_gate"]["required_live_matches"])
        self.assertEqual(0, report["a_grade_gate"]["accepted_live_matches"])
        self.assertEqual(50, report["a_grade_gate"]["missing_live_matches"])
        self.assertEqual(50, report["current_static_source_oracle_status"]["grade_counts"]["B"])
        self.assertEqual(0, report["current_static_source_oracle_status"]["grade_counts"]["F"])
        self.assertEqual(0, report["current_static_source_oracle_status"]["gap_count"])
        self.assertTrue(
            any(blocker["code"] == "missing_live_legacy_trace_corpus" for blocker in report["blockers"])
        )

    def test_gate_accepts_only_contract_compliant_live_trace_records(self) -> None:
        with tempfile.TemporaryDirectory() as tmp:
            trace_dir = Path(tmp)
            partial_trace = {
                "capability_matches": [
                    {
                        "capability_id": "online:CC00",
                        "trace_kind": "live_cobol_cics_runtime",
                        "source_head": SOURCE_HEAD,
                        "legacy_runtime_environment": "unit-test-mainframe-runtime",
                        "raw_legacy_trace_hash": "a" * 64,
                        "modern_observation_hash": "b" * 64,
                        "comparator_version": "unit-test",
                        "matched": True,
                    },
                    {
                        "capability_id": "online:CC01",
                        "trace_kind": "static_oracle_replay",
                        "source_head": SOURCE_HEAD,
                        "legacy_runtime_environment": "not-live-runtime",
                        "raw_legacy_trace_hash": "c" * 64,
                        "modern_observation_hash": "d" * 64,
                        "comparator_version": "unit-test",
                        "matched": True,
                    },
                ]
            }
            (trace_dir / "partial_trace.json").write_text(json.dumps(partial_trace), encoding="utf-8")

            report = build_a_grade_report(MODERN_ROOT, SOURCE, trace_dir)

            self.assertFalse(report["a_grade_gate"]["promotable_to_A"])
            self.assertEqual(1, report["a_grade_gate"]["accepted_live_matches"])
            self.assertEqual(49, report["a_grade_gate"]["missing_live_matches"])
            self.assertIn("online:CC00", report["live_trace_scan"]["accepted_matches"])
            rejected_ids = {item.get("capability_id") for item in report["live_trace_scan"]["rejected_records"]}
            self.assertIn("online:CC01", rejected_ids)


if __name__ == "__main__":
    unittest.main()