from __future__ import annotations

import copy
import importlib.util
import json
import tempfile
import unittest
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]
SCRIPT = ROOT / "scripts" / "designir_pipeline.py"
SPEC = importlib.util.spec_from_file_location("designir_pipeline", SCRIPT)
MODULE = importlib.util.module_from_spec(SPEC)
assert SPEC.loader
SPEC.loader.exec_module(MODULE)


class DesignIRPipelineTests(unittest.TestCase):
    def payload(self) -> dict:
        return json.loads(
            (ROOT / "examples" / "raised_hub_flange.designir.json").read_text()
        )

    def test_example_is_valid_and_compiles(self) -> None:
        payload = MODULE.validate_designir(self.payload())
        with tempfile.TemporaryDirectory() as temporary:
            output = Path(temporary) / "flange.step"
            result = MODULE.compile_designir(payload, output)
            self.assertTrue(output.is_file())
            self.assertEqual(1, result["facts"]["solid_count"])
            self.assertGreater(result["facts"]["volume_mm3"], 30_000)

    def test_teacher_dependency_is_rejected(self) -> None:
        payload = self.payload()
        payload["source_step"] = "teacher.step"
        with self.assertRaisesRegex(MODULE.DesignIRError, "Teacher geometry"):
            MODULE.validate_designir(payload)

    def test_example_compiles_with_simplecadapi_and_exports_graph(self) -> None:
        payload = self.payload()
        with tempfile.TemporaryDirectory() as temporary:
            output = Path(temporary) / "flange.step"
            result = MODULE.compile_designir(
                payload, output, backend="simplecadapi"
            )
            self.assertEqual("simplecadapi", result["backend"])
            self.assertGreater(result["facts"]["volume_mm3"], 30_000)
            self.assertTrue(Path(result["model_json"]).is_file())

    def test_embedded_mesh_is_rejected(self) -> None:
        payload = self.payload()
        payload["features"][0]["mesh"] = {"vertices": [[0, 0, 0]]}
        with self.assertRaisesRegex(MODULE.DesignIRError, "Teacher geometry"):
            MODULE.validate_designir(payload)

    def test_isolated_rebuild_has_no_teacher(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            designir = root / "flange.designir.json"
            designir.write_text(json.dumps(self.payload()), encoding="utf-8")
            output = root / "rebuilt.step"
            result = MODULE.isolated_rebuild(designir, output)
            self.assertTrue(result["valid"])
            self.assertFalse(result["teacher_step_available"])
            self.assertTrue(output.is_file())

    def test_acceptance_passes_identical_designir_rebuild(self) -> None:
        payload = self.payload()
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            teacher = root / "teacher.step"
            rebuilt = root / "rebuilt.step"
            MODULE.compile_designir(payload, teacher)
            MODULE.compile_designir(payload, rebuilt)
            report = MODULE.acceptance_report(teacher, rebuilt, payload)
            self.assertEqual("pass", report["verdict"])
            self.assertEqual("replay_validated", report["next_state"])
            self.assertEqual(
                1.0, report["editability"]["parameter_perturbation_success_rate"]
            )

    def test_unsupported_vocabulary_is_honest_failure(self) -> None:
        payload = self.payload()
        payload["reconstruction_status"] = "unsupported_feature_vocabulary"
        payload["missing_capabilities"] = ["multi_rail_sweep"]
        with self.assertRaisesRegex(MODULE.DesignIRError, "multi_rail_sweep"):
            MODULE.build_shape(payload)

    def test_promotion_requires_independent_replay_validated_cases(self) -> None:
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            reports = []
            for index in range(3):
                report = root / f"case-{index}.json"
                report.write_text(
                    json.dumps(
                        {
                            "model_id": f"case-{index}",
                            "next_state": "replay_validated",
                        }
                    ),
                    encoding="utf-8",
                )
                reports.append(report)
            result = MODULE.promotion_check(
                reports, ROOT / "config" / "promotion-policy.json"
            )
            self.assertTrue(result["eligible"])
            self.assertEqual("promoted", result["next_state"])


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