"""Tests for BRep tracking: boolean operation history capture via OCC Modified/Generated/IsDeleted."""

import unittest

import simplecadapi as scad
from simplecadapi.topology import (
    TopoKind,
    TopoEvent,
    TopoRef,
    TopoDelta,
    OperationNode,
    OperationGraph,
)
from simplecadapi.tracking import (
    tracked_cut,
    tracked_union,
    tracked_intersect,
    TrackedBooleanResult,
)


class TestTrackedCut(unittest.TestCase):
    """Test cut with full face-level history."""

    def setUp(self):
        self.body = scad.make_box_rsolid(10, 10, 10)
        self.tool = scad.make_cylinder_rsolid(
            2.0, 15.0, bottom_face_center=(3, 3, -2.5)
        )

    def test_tracked_cut_returns_solid_and_delta(self):
        result = tracked_cut(self.body, self.tool)
        self.assertIsInstance(result, TrackedBooleanResult)
        self.assertIsNotNone(result.solid)
        self.assertIsInstance(result.delta, TopoDelta)

    def test_tracked_cut_has_preserved_faces(self):
        result = tracked_cut(self.body, self.tool)
        preserved_face_refs = [
            r for r in result.delta.preserved if r.kind == TopoKind.FACE
        ]
        # After a cylinder cut through a box, most original faces should be
        # either modified or preserved; some should survive
        self.assertGreater(len(preserved_face_refs), 0)

    def test_tracked_cut_has_proven_changed_faces(self):
        result = tracked_cut(self.body, self.tool)
        changed_faces = [
            entry
            for entry in result.delta.entries
            if entry.ref.kind == TopoKind.FACE
            and entry.event in {TopoEvent.MODIFIED, TopoEvent.GENERATED}
            and entry.metadata["status"] == "proven"
        ]
        self.assertGreater(len(changed_faces), 0)

    def test_tracked_cut_volume_decreased(self):
        result = tracked_cut(self.body, self.tool)
        original_vol = self.body.get_volume()
        result_vol = result.solid.get_volume()
        self.assertLess(result_vol, original_vol)

    def test_tracked_cut_total_faces_increased(self):
        """A cylinder cut through a box adds the cylindrical hole face."""
        result = tracked_cut(self.body, self.tool)
        original_faces = len(self.body.get_faces())
        result_faces = len(result.solid.get_faces())
        # Cylinder through box: at least 1 new face (cylindrical hole)
        self.assertGreaterEqual(result_faces, original_faces)

    def test_tracked_cut_tool_with_tool_face_labels(self):
        """Faces from the tool should be labeled with origin_role='tool'."""
        result = tracked_cut(self.body, self.tool)
        tool_outputs = [
            entry
            for entry in result.delta.entries
            if entry.ref.kind == TopoKind.FACE
            and entry.origin_role == "tool"
            and entry.event in {TopoEvent.MODIFIED, TopoEvent.GENERATED}
        ]
        self.assertGreater(len(tool_outputs), 0)
        self.assertTrue(all(entry.parent_refs for entry in tool_outputs))

    def test_tracked_cut_preserves_volume_accuracy(self):
        result = tracked_cut(self.body, self.tool)
        # Volume should be original minus roughly the cylinder volume
        expected_min = self.body.get_volume() - 3.14159 * 2.0**2 * 15.0
        self.assertGreater(result.solid.get_volume(), 0)


class TestTrackedUnion(unittest.TestCase):
    def setUp(self):
        self.body = scad.make_box_rsolid(10, 10, 10)
        # Use a cylinder to ensure curved intersection edges
        self.tool = scad.make_cylinder_rsolid(4.0, 10.0, bottom_face_center=(3, 3, 0))

    def test_tracked_union_returns_solid_and_delta(self):
        result = tracked_union(self.body, self.tool)
        self.assertIsInstance(result, TrackedBooleanResult)
        self.assertIsNotNone(result.solid)

    def test_tracked_union_volume_increased(self):
        result = tracked_union(self.body, self.tool)
        original_vol = self.body.get_volume()
        result_vol = result.solid.get_volume()
        # Union of two overlapping boxes should be less than sum but more than either
        self.assertGreater(result_vol, original_vol)

    def test_tracked_union_has_section_edges(self):
        # OCC may suppress SectionEdges under glue mode; disabling glue should expose them.
        result = tracked_union(self.body, self.tool, glue=False)
        section_edges = result.delta.section_edges
        self.assertGreater(len(section_edges), 0)

        for section_ref in section_edges:
            entries = [
                entry
                for entry in result.delta.entries
                if entry.ref == section_ref
            ]
            self.assertGreaterEqual(len(entries), 2)
            self.assertEqual(
                {entry.origin_role for entry in entries}, {"body", "tool"}
            )
            self.assertTrue(all(entry.parent_refs for entry in entries))

    def test_nary_union_tracks_every_input_through_clean_history(self):
        solids = [
            scad.make_box_rsolid(
                1.0,
                1.0,
                1.0,
                bottom_face_center=(float(index), 0.0, 0.0),
            )
            for index in range(3)
        ]

        result = scad.union_rsolid(*solids, glue=False)
        tracks = [face.get_metadata("track") for face in result.get_faces()]

        self.assertEqual(len(result.get_faces()), 6)
        self.assertTrue(all(track["status"] == "proven" for track in tracks))
        self.assertEqual(
            {role for track in tracks for role in track["origin_roles"]},
            {"body", "tool", "tool_2"},
        )
        self.assertTrue(result.get_metadata("track")["has_delta"])

    def test_nary_union_keeps_modified_face_lineage_after_clean(self):
        barrel = scad.make_cylinder_rsolid(
            16.0,
            120.0,
            bottom_face_center=(-60.0, 0.0, 0.0),
            axis=(1.0, 0.0, 0.0),
        )
        flange = scad.make_cylinder_rsolid(
            22.0,
            12.0,
            bottom_face_center=(50.0, 0.0, 0.0),
            axis=(1.0, 0.0, 0.0),
        )
        nose = scad.make_cylinder_rsolid(
            13.0,
            10.0,
            bottom_face_center=(58.0, 0.0, 0.0),
            axis=(1.0, 0.0, 0.0),
        )
        source_face = max(flange.get_faces(), key=lambda face: face.get_center().x)
        scad.apply_tag(source_face, "cap.face.end")

        result = scad.union_rsolid(barrel, flange, nose, glue=False)
        descendants = [
            face
            for face in result.get_faces()
            if "cap.face.end" in scad.list_tags(face, scope="lineage")
        ]

        self.assertEqual(len(descendants), 1)
        self.assertAlmostEqual(descendants[0].get_center().x, 62.0, places=6)
        self.assertAlmostEqual(descendants[0].get_area(), 989.6016859, places=5)
        self.assertEqual(descendants[0].get_metadata("track")["event"], "modified")
        self.assertNotIn("cap.face.end", scad.list_tags(descendants[0]))

    def test_nary_union_respects_face_binding_lineage_policy(self):
        barrel = scad.make_cylinder_rsolid(
            16.0,
            120.0,
            bottom_face_center=(-60.0, 0.0, 0.0),
            axis=(1.0, 0.0, 0.0),
        )
        flange = scad.make_cylinder_rsolid(
            22.0,
            12.0,
            bottom_face_center=(50.0, 0.0, 0.0),
            axis=(1.0, 0.0, 0.0),
        )
        nose = scad.make_cylinder_rsolid(
            13.0,
            10.0,
            bottom_face_center=(58.0, 0.0, 0.0),
            axis=(1.0, 0.0, 0.0),
        )
        source_face = max(flange.get_faces(), key=lambda face: face.get_center().x)
        flange = scad.apply_tag_rselection(
            flange,
            [source_face],
            "cap.face.end",
            lineage_policy=scad.LineagePolicy.NONE,
        )

        result = scad.union_rsolid(barrel, flange, nose, glue=False)

        self.assertFalse(
            any("cap.face.end" in scad.list_tags(face) for face in result.get_faces())
        )

    def test_nary_union_face_binding_stays_directly_queryable_after_cut(self):
        flange = scad.extrude_rsolid(
            scad.make_circle_rface(
                center=(0.0, 0.0, 0.0),
                radius=2.0,
                normal=(1.0, 0.0, 0.0),
            ),
            direction=(1.0, 0.0, 0.0),
            distance=2.0,
            start_face_tag="cap.face.start",
            end_face_tag="cap.face.end",
            side_faces_tag="cap.face.side",
        )
        source_end = scad.select_faces_by_tag(flange, "cap.face.end")[0]
        source_explanation = scad.explain_tag(
            source_end, "cap.face.end", scope="local"
        )[0]
        body = scad.make_cylinder_rsolid(
            1.5,
            4.0,
            bottom_face_center=(-1.0, 0.0, 0.0),
            axis=(1.0, 0.0, 0.0),
        )
        bridge = scad.make_box_rsolid(
            1.0,
            1.0,
            1.0,
            bottom_face_center=(-0.5, -0.5, -0.5),
        )
        fused = scad.union_rsolid(body, flange, bridge, glue=False)
        result = scad.cut_rsolid(
            fused,
            scad.make_cylinder_rsolid(
                0.25,
                4.0,
                bottom_face_center=(-1.0, 1.0, 0.0),
                axis=(1.0, 0.0, 0.0),
            ),
        )

        end_faces = scad.select_faces_by_tag(result, "cap.face.end")

        self.assertEqual(len(end_faces), 1)
        projected = scad.explain_tag(
            end_faces[0], "cap.face.end", scope="local"
        )[0]["binding"]["evidence"]
        self.assertEqual(
            projected["source_binding_id"], source_explanation["binding_id"]
        )
        self.assertEqual(projected["source_topo_id"], source_end.topo_id)

    def test_nary_union_tracks_faces_without_cleaning(self):
        solids = [
            scad.make_box_rsolid(
                1.0,
                1.0,
                1.0,
                bottom_face_center=(float(index), 0.0, 0.0),
            )
            for index in range(3)
        ]

        result = scad.union_rsolid(*solids, clean=False, glue=False)

        self.assertEqual(len(result.get_faces()), 14)
        self.assertTrue(
            all(
                face.get_metadata("track")["status"] == "proven"
                for face in result.get_faces()
            )
        )


class TestTrackedIntersect(unittest.TestCase):
    def setUp(self):
        self.body = scad.make_box_rsolid(10, 10, 10)
        self.tool = scad.make_cylinder_rsolid(6.0, 10.0, bottom_face_center=(3, 3, 0))

    def test_tracked_intersect_returns_solid_and_delta(self):
        result = tracked_intersect(self.body, self.tool)
        self.assertIsInstance(result, TrackedBooleanResult)
        self.assertIsNotNone(result.solid)

    def test_tracked_intersect_volume_less_than_both(self):
        result = tracked_intersect(self.body, self.tool)
        self.assertLess(result.solid.get_volume(), self.body.get_volume())
        self.assertLess(result.solid.get_volume(), self.tool.get_volume())


class TestDeltaEntries(unittest.TestCase):
    """Test that delta_entries provides origin_role info."""

    def setUp(self):
        self.body = scad.make_box_rsolid(10, 10, 10)
        self.tool = scad.make_cylinder_rsolid(
            3.0, 15.0, bottom_face_center=(3, 3, -2.5)
        )

    def test_body_faces_labeled(self):
        result = tracked_cut(self.body, self.tool)
        body_preserved = [
            r
            for r in result.delta.preserved
            if r.kind == TopoKind.FACE
            and result.delta_entries.get(r.topo_id, {}).get("origin_role") == "body"
        ]
        self.assertGreater(len(body_preserved), 0)

    def test_modified_faces_labeled(self):
        result = tracked_cut(self.body, self.tool)
        body_modified = [
            r
            for r in result.delta.modified
            if r.kind == TopoKind.FACE
            and result.delta_entries.get(r.topo_id, {}).get("origin_role") == "body"
        ]
        # Some faces from body should be modified
        self.assertGreater(len(body_modified), 0)


class TestSolidMapping(unittest.TestCase):
    """Test that the result solid is a valid SimpleCADAPI Solid."""

    def setUp(self):
        self.body = scad.make_box_rsolid(10, 10, 10)
        self.tool = scad.make_cylinder_rsolid(
            2.0, 15.0, bottom_face_center=(3, 3, -2.5)
        )

    def test_result_is_solid(self):
        result = tracked_cut(self.body, self.tool)
        self.assertIsInstance(result.solid, scad.Solid)

    def test_result_has_faces(self):
        result = tracked_cut(self.body, self.tool)
        faces = result.solid.get_faces()
        self.assertGreater(len(faces), 0)

    def test_result_has_valid_volume(self):
        result = tracked_cut(self.body, self.tool)
        self.assertGreater(result.solid.get_volume(), 0)


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