freecad-robust-mcp-fc111/tests/integration/test_cut_object_for_magnets.py

"""Integration tests for the CutObjectForMagnets macro.

These tests verify the SmartCutter class functionality including:
- Cutting solid objects with boolean hole operations
- Cutting hollow objects with boolean hole operations
- Boolean hole creation method (primary method for CI compatibility)
- Edge cases and error handling

Test Organization:
- TestCutSolidObject: Tests cutting solid objects with boolean holes
- TestCutHollowObject: Tests cutting hollow objects with boolean holes
- TestBooleanHoleFallback: Tests for the boolean hole creation method
- TestEdgeCases: Edge case tests (single hole, many holes)

Note: These tests require a running FreeCAD MCP bridge.
      Start it with: just run-gui or just run-headless

Note: PartDesign::Hole has a CADKernelError bug in some FreeCAD headless
      environments (especially AppImage on Linux CI) where it fails with
      "Cannot make face from profile". These tests use boolean holes instead,
      which work reliably in both GUI and headless mode.

To run these tests:
    pytest tests/integration/test_cut_object_for_magnets.py -v
"""

from __future__ import annotations

from typing import TYPE_CHECKING, Any

import pytest

if TYPE_CHECKING:
    import xmlrpc.client

# Mark all tests in this module as integration tests
pytestmark = pytest.mark.integration

# Note: xmlrpc_proxy fixture is defined in conftest.py


def execute_code(proxy: xmlrpc.client.ServerProxy, code: str) -> dict[str, Any]:
    """Execute Python code via the MCP bridge and return the result."""
    result: dict[str, Any] = proxy.execute(code)  # type: ignore[assignment]
    assert result.get("success"), f"Execution failed: {result.get('error_traceback')}"
    return result


# The SmartCutter class code embedded for testing
# This avoids issues with importing the macro file directly
SMART_CUTTER_CODE = '''
import FreeCAD as App
import Part


class HolePlacementError(Exception):
    """Raised when hole placement fails."""
    pass


class SmartCutter:
    """Handles cutting objects and placing magnet holes with collision detection."""

    def __init__(self, obj, params: dict):
        """Initialize the cutter."""
        self.obj = obj
        self.params = params
        self.shape = obj.Shape

    def get_cut_plane_normal_and_point(self):
        """Get plane normal vector and point based on selected plane."""
        plane_type = self.params.get("plane_type", "Preset Plane")

        plane = self.params["plane"]
        offset = self.params["offset"]

        if plane == "XY":
            normal = App.Vector(0, 0, 1)
            point = App.Vector(0, 0, offset)
        elif plane == "XZ":
            normal = App.Vector(0, 1, 0)
            point = App.Vector(0, offset, 0)
        elif plane == "YZ":
            normal = App.Vector(1, 0, 0)
            point = App.Vector(offset, 0, 0)
        else:
            normal = App.Vector(0, 0, 1)
            point = App.Vector(0, 0, offset)

        return normal, point

    def cut_object(self):
        """Cut the object along the specified plane."""
        normal, point = self.get_cut_plane_normal_and_point()

        bbox = self.shape.BoundBox
        size = max(bbox.XLength, bbox.YLength, bbox.ZLength) * 3

        half = size / 2
        box = Part.makeBox(size, size, size, App.Vector(-half, -half, 0))

        z_axis = App.Vector(0, 0, 1)
        rotation = App.Rotation(z_axis, normal)

        box = box.transformed(App.Matrix(rotation.toMatrix()))
        box.translate(point)

        try:
            bottom_part = self.shape.cut(box)
            top_part = self.shape.common(box)
            return bottom_part, top_part
        except Exception as e:
            raise HolePlacementError(f"Failed to cut object: {e!s}") from e

    def get_cut_face_center(self, part, normal):
        """Find the center of the cut face on a part."""
        _, cut_point = self.get_cut_plane_normal_and_point()

        best_face = None
        best_dist = float("inf")

        for face in part.Faces:
            face_normal = face.normalAt(0, 0)
            dot = abs(face_normal.dot(normal))
            if dot > 0.99:
                face_center = face.CenterOfMass
                dist_along_normal = abs((face_center - cut_point).dot(normal))
                if dist_along_normal < best_dist:
                    best_dist = dist_along_normal
                    best_face = face

        if best_face is not None:
            return best_face.CenterOfMass
        return None

    def is_hole_safe(self, center, direction, part, clearance=None):
        """Check if a hole at this position would penetrate the outer surface."""
        diameter = self.params["diameter"]
        depth = self.params["depth"]
        if clearance is None:
            clearance = self.params["clearance_min"]

        dir_normalized = App.Vector(direction).normalize()
        radius_check = (diameter / 2) + clearance
        start_offset = 0.5

        start_pos = center + (dir_normalized * start_offset)
        test_length = depth - start_offset

        if test_length <= 0:
            return True

        test_cylinder = Part.makeCylinder(
            radius_check, test_length, start_pos, dir_normalized
        )

        try:
            intersection = part.common(test_cylinder)
            cylinder_vol = test_cylinder.Volume
            intersection_vol = intersection.Volume

            if intersection_vol < cylinder_vol * 0.95:
                return False

            return True
        except Exception:
            return False

    def generate_hole_positions(self, cut_face_center, cut_face):
        """Generate hole positions evenly distributed along the perimeter."""
        hole_count = self.params["hole_count"]
        clearance = self.params["clearance_preferred"]
        diameter = self.params["diameter"]

        wires = cut_face.Wires
        if not wires:
            return [], None, 0, []

        outer_wire = max(wires, key=lambda w: w.Length)
        perimeter_length = outer_wire.Length

        inset = clearance + (diameter / 2)

        normal, _ = self.get_cut_plane_normal_and_point()
        normal = App.Vector(normal).normalize()

        if hole_count < 1:
            return [], outer_wire, perimeter_length, []

        spacing = perimeter_length / hole_count

        positions = []
        original_params = []

        for i in range(hole_count):
            param = (i * spacing) + (spacing / 2)
            if param >= perimeter_length:
                param = param - perimeter_length

            edge_point = self._get_point_at_length(outer_wire, param)
            if edge_point is None:
                continue

            inset_point = self._get_inset_point(edge_point, cut_face, normal, inset)

            if inset_point:
                positions.append(inset_point)
                original_params.append(param)

        return positions, outer_wire, perimeter_length, original_params

    def _get_point_at_length(self, wire, length):
        """Get a point on the wire at a specific length along it."""
        cumulative_length = 0.0

        for edge in wire.Edges:
            edge_length = edge.Length

            if cumulative_length + edge_length >= length:
                remaining = length - cumulative_length
                param = remaining / edge_length if edge_length > 0 else 0

                first_param = edge.FirstParameter
                last_param = edge.LastParameter
                edge_param = first_param + param * (last_param - first_param)

                try:
                    point = edge.valueAt(edge_param)
                    return App.Vector(point)
                except Exception:
                    return None

            cumulative_length += edge_length

        return None

    def _get_inset_point(self, edge_point, cut_face, normal, inset):
        """Get a point that is inset from the edge toward the face interior."""
        face_center = cut_face.CenterOfMass

        to_center = face_center - edge_point
        to_center = to_center - normal * (to_center.dot(normal))

        if to_center.Length < 0.001:
            return None

        to_center_normalized = App.Vector(to_center).normalize()
        inset_point = edge_point + (to_center_normalized * inset)

        try:
            dist_info = cut_face.distToShape(Part.Vertex(inset_point))
            dist = dist_info[0]

            if dist < 0.5:
                closest_on_face = dist_info[1][0][0]
                return App.Vector(closest_on_face)
            else:
                dist_info = cut_face.distToShape(Part.Vertex(inset_point))
                return App.Vector(dist_info[1][0][0])
        except Exception:
            return None

    def _check_hole_overlap(self, positions, new_pos):
        """Check if a new hole position would overlap with existing holes."""
        diameter = self.params["diameter"]
        min_distance = diameter * 2

        for existing_pos in positions:
            dist = (new_pos - existing_pos).Length
            if dist < min_distance:
                return False

        return True

    def execute(self, progress_callback=None, use_boolean=True):
        """Execute the complete cutting and hole placement operation.

        Args:
            progress_callback: Optional callback for progress updates.
            use_boolean: If True, use boolean holes (CI-compatible).
                         If False, use PartDesign::Hole (may fail in some headless envs).
        """
        bottom_shape, top_shape = self.cut_object()

        normal, _ = self.get_cut_plane_normal_and_point()

        bottom_face_center = self.get_cut_face_center(bottom_shape, -normal)
        top_face_center = self.get_cut_face_center(top_shape, normal)

        if not bottom_face_center or not top_face_center:
            raise HolePlacementError("Could not find cut faces")

        bottom_cut_face = None
        for face in bottom_shape.Faces:
            if face.CenterOfMass.distanceToPoint(bottom_face_center) < 0.1:
                bottom_cut_face = face
                break

        if not bottom_cut_face:
            raise HolePlacementError("Could not find bottom cut face")

        top_cut_face = None
        for face in top_shape.Faces:
            if face.CenterOfMass.distanceToPoint(top_face_center) < 0.1:
                top_cut_face = face
                break

        if not top_cut_face:
            raise HolePlacementError("Could not find top cut face")

        initial_positions, outer_wire, perimeter_length, original_params = (
            self.generate_hole_positions(bottom_face_center, bottom_cut_face)
        )

        if not initial_positions:
            raise HolePlacementError("No valid hole positions found")

        clearance_preferred = self.params["clearance_preferred"]
        validated_positions = []

        for idx, pos in enumerate(initial_positions):
            bottom_safe = self.is_hole_safe(pos, -normal, bottom_shape, clearance_preferred)
            top_safe = self.is_hole_safe(pos, normal, top_shape, clearance_preferred)

            if bottom_safe and top_safe:
                if self._check_hole_overlap(validated_positions, pos):
                    validated_positions.append(pos)

        if not validated_positions:
            raise HolePlacementError("No valid hole positions found after validation")

        if use_boolean:
            # Use boolean holes (works reliably in headless mode)
            bottom_with_holes = self._create_holes_boolean(bottom_shape, -normal, validated_positions)
            top_with_holes = self._create_holes_boolean(top_shape, normal, validated_positions)

            # Create Part::Feature objects for results
            doc = App.ActiveDocument
            bottom_obj = doc.addObject("Part::Feature", f"{self.obj.Label}_Bottom")
            bottom_obj.Shape = bottom_with_holes
            top_obj = doc.addObject("Part::Feature", f"{self.obj.Label}_Top")
            top_obj.Shape = top_with_holes
            doc.recompute()

            return bottom_obj, top_obj
        else:
            # Use PartDesign::Hole (may fail with CADKernelError in some headless envs)
            # Create PartDesign::Body objects from shapes
            bottom_body = self._create_body_from_shape(
                bottom_shape, f"{self.obj.Label}_Bottom"
            )
            top_body = self._create_body_from_shape(top_shape, f"{self.obj.Label}_Top")

            # Find cut face names on the new bodies
            bottom_face_name = self._find_cut_face_name(bottom_body, -normal)
            top_face_name = self._find_cut_face_name(top_body, normal)

            # Create hole sketches with points at validated positions
            bottom_sketch = self._create_hole_sketch(
                bottom_body, bottom_face_name, validated_positions
            )

            top_sketch = self._create_hole_sketch(
                top_body, top_face_name, validated_positions
            )

            # Create PartDesign::Hole features
            self._create_hole_feature(
                bottom_body, bottom_sketch, self.params["diameter"], self.params["depth"]
            )

            self._create_hole_feature(
                top_body, top_sketch, self.params["diameter"], self.params["depth"]
            )

            return bottom_body, top_body

    def _create_body_from_shape(self, shape, name):
        """Create a PartDesign::Body containing the given shape."""
        doc = App.ActiveDocument

        base_feature_name = f"{name}_Base"
        feature = doc.addObject("Part::Feature", base_feature_name)
        feature.Shape = shape

        body = doc.addObject("PartDesign::Body", name)
        body.BaseFeature = feature

        if hasattr(feature, "ViewObject") and feature.ViewObject:
            feature.ViewObject.Visibility = False

        doc.recompute()
        return body

    def _find_cut_face_name(self, body, normal):
        """Find the name of the cut face on a PartDesign::Body's Tip feature."""
        tip_feature = body.Tip
        if tip_feature is None:
            raise HolePlacementError(f"Body {body.Label} has no Tip feature")

        shape = tip_feature.Shape
        target_normal = App.Vector(normal).normalize()

        best_face_idx = None
        best_dot = -1

        for i, face in enumerate(shape.Faces):
            try:
                face_normal = face.normalAt(0.5, 0.5)
                dot = face_normal.dot(target_normal)

                if dot > best_dot:
                    best_dot = dot
                    best_face_idx = i
            except Exception:
                continue

        if best_face_idx is not None and best_dot > 0.99:
            return f"Face{best_face_idx + 1}"

        raise HolePlacementError(
            f"Could not find cut face on body {body.Label}. "
            f"Best match had dot product {best_dot:.3f}"
        )

    def _world_to_sketch_coords(self, world_pos, sketch):
        """Transform world coordinates to sketch-local 2D coordinates."""
        placement = sketch.Placement
        inv_placement = placement.inverse()
        local_pos = inv_placement.multVec(world_pos)
        return App.Vector(local_pos.x, local_pos.y, 0)

    def _create_hole_sketch(self, body, cut_face_name, positions):
        """Create a sketch with points at hole center positions."""
        sketch = body.newObject("Sketcher::SketchObject", "HoleCenters")

        tip_feature = body.Tip
        if tip_feature is None:
            raise HolePlacementError(f"Body {body.Label} has no Tip feature")

        sketch.AttachmentSupport = [(tip_feature, cut_face_name)]
        sketch.MapMode = "FlatFace"

        App.ActiveDocument.recompute()

        for pos in positions:
            local_pos = self._world_to_sketch_coords(pos, sketch)
            sketch.addGeometry(
                Part.Point(App.Vector(local_pos.x, local_pos.y, 0)),
                False,
            )

        App.ActiveDocument.recompute()
        return sketch

    def _create_hole_feature(self, body, sketch, diameter, depth):
        """Create a PartDesign::Hole feature from a sketch with point geometry."""
        hole = body.newObject("PartDesign::Hole", "MagnetHoles")
        hole.Profile = sketch
        hole.Diameter = diameter
        hole.Depth = depth
        hole.DepthType = "Dimension"
        hole.Threaded = False
        hole.HoleCutType = "None"

        App.ActiveDocument.recompute()
        return hole

    def _create_holes_boolean(self, part, direction, positions):
        """Create holes using boolean operations (alternative method).

        This is an alternative to PartDesign::Hole that uses Part boolean
        operations. Both methods work in GUI and headless mode.
        """
        diameter = self.params["diameter"]
        depth = self.params["depth"]

        dir_normalized = App.Vector(direction).normalize()

        result = part
        holes_created = 0

        for pos in positions:
            offset = 0.1
            start_pos = pos - (dir_normalized * offset)
            hole_length = depth + offset

            try:
                hole = Part.makeCylinder(
                    diameter / 2, hole_length, start_pos, dir_normalized
                )
                result = result.cut(hole)
                holes_created += 1
            except Exception:
                pass

        return result
'''


class TestCutSolidObject:
    """Tests for cutting solid objects with boolean hole operations.

    These tests work in both GUI and headless mode.
    """

    @pytest.fixture(autouse=True)
    def setup_document(self, xmlrpc_proxy: xmlrpc.client.ServerProxy) -> None:
        """Create a fresh document for each test."""
        execute_code(
            xmlrpc_proxy,
            """
import FreeCAD
if "CutMacroTestDoc" in FreeCAD.listDocuments():
    FreeCAD.closeDocument("CutMacroTestDoc")
doc = FreeCAD.newDocument("CutMacroTestDoc")
_result_ = True
""",
        )

    def test_cut_solid_box_with_boolean_holes(
        self, xmlrpc_proxy: xmlrpc.client.ServerProxy
    ) -> None:
        """Test cutting a solid box and creating boolean holes."""
        result = execute_code(
            xmlrpc_proxy,
            SMART_CUTTER_CODE
            + """
doc = App.ActiveDocument

# Create a solid box: 50x50x40mm
box = Part.makeBox(50, 50, 40)
box_obj = doc.addObject("Part::Feature", "TestBox")
box_obj.Shape = box
doc.recompute()

# Calculate original volume for comparison
original_volume = box.Volume

# Create SmartCutter with parameters
params = {
    "plane_type": "Preset Plane",
    "plane": "XY",
    "offset": 20.0,  # Cut in the middle
    "diameter": 6.0,
    "depth": 3.0,
    "hole_count": 4,
    "clearance_preferred": 2.0,
    "clearance_min": 0.5,
}

cutter = SmartCutter(box_obj, params)

# Execute the cut with boolean holes (use_boolean=True is the default)
bottom_obj, top_obj = cutter.execute()

doc.recompute()

# Calculate expected hole volume
import math
hole_volume = math.pi * (params["diameter"] / 2) ** 2 * params["depth"]

# Verify results
_result_ = {
    "success": True,
    "bottom_type": bottom_obj.TypeId,
    "top_type": top_obj.TypeId,
    "bottom_name": bottom_obj.Label,
    "top_name": top_obj.Label,
    "bottom_volume": bottom_obj.Shape.Volume,
    "top_volume": top_obj.Shape.Volume,
    "bottom_valid": bottom_obj.Shape.isValid(),
    "top_valid": top_obj.Shape.isValid(),
    "original_volume": original_volume,
    "hole_volume_each": hole_volume,
    # Combined volume should be less than original due to holes
    "total_volume": bottom_obj.Shape.Volume + top_obj.Shape.Volume,
}

# Volume should have decreased from original (holes were cut)
_result_["volume_decreased"] = _result_["total_volume"] < original_volume
""",
        )

        assert result["result"]["success"] is True
        # Boolean method produces Part::Feature objects
        assert result["result"]["bottom_type"] == "Part::Feature"
        assert result["result"]["top_type"] == "Part::Feature"
        assert "Bottom" in result["result"]["bottom_name"]
        assert "Top" in result["result"]["top_name"]
        assert result["result"]["bottom_valid"] is True
        assert result["result"]["top_valid"] is True
        # Volumes should be positive
        assert result["result"]["bottom_volume"] > 0
        assert result["result"]["top_volume"] > 0
        # Volume should have decreased due to holes
        assert result["result"]["volume_decreased"] is True


class TestCutHollowObject:
    """Tests for cutting hollow objects with boolean hole operations.

    These tests work in both GUI and headless mode.
    """

    @pytest.fixture(autouse=True)
    def setup_document(self, xmlrpc_proxy: xmlrpc.client.ServerProxy) -> None:
        """Create a fresh document for each test."""
        execute_code(
            xmlrpc_proxy,
            """
import FreeCAD
if "CutHollowTestDoc" in FreeCAD.listDocuments():
    FreeCAD.closeDocument("CutHollowTestDoc")
doc = FreeCAD.newDocument("CutHollowTestDoc")
_result_ = True
""",
        )

    def test_cut_hollow_cylinder_with_boolean_holes(
        self, xmlrpc_proxy: xmlrpc.client.ServerProxy
    ) -> None:
        """Test cutting a hollow cylinder (vase shape) with boolean holes."""
        result = execute_code(
            xmlrpc_proxy,
            SMART_CUTTER_CODE
            + """
import math

doc = App.ActiveDocument

# Create a hollow vase-shaped cylinder
# Outer cylinder: radius 20mm, height 60mm
# Inner cylinder: radius 13mm (wall thickness 7mm), height 55mm (5mm bottom)
outer_radius = 20.0
inner_radius = 13.0
height = 60.0
bottom_thickness = 5.0

# Create outer cylinder
outer = Part.makeCylinder(outer_radius, height)

# Create inner cylinder (starting above bottom)
inner = Part.makeCylinder(inner_radius, height - bottom_thickness, App.Vector(0, 0, bottom_thickness))

# Cut inner from outer to make hollow vase
vase_shape = outer.cut(inner)

vase_obj = doc.addObject("Part::Feature", "TestVase")
vase_obj.Shape = vase_shape
doc.recompute()

# Calculate original volume
original_volume = vase_shape.Volume

# Create SmartCutter with parameters
params = {
    "plane_type": "Preset Plane",
    "plane": "XY",
    "offset": 30.0,  # Cut at 30mm height (middle of vase)
    "diameter": 3.0,  # Smaller holes for thin walls
    "depth": 3.0,
    "hole_count": 6,
    "clearance_preferred": 2.0,
    "clearance_min": 0.5,
}

cutter = SmartCutter(vase_obj, params)

# Execute the cut with boolean holes
bottom_obj, top_obj = cutter.execute()

doc.recompute()

# Verify results
_result_ = {
    "success": True,
    "bottom_type": bottom_obj.TypeId,
    "top_type": top_obj.TypeId,
    "bottom_valid": bottom_obj.Shape.isValid(),
    "top_valid": top_obj.Shape.isValid(),
    "bottom_volume": bottom_obj.Shape.Volume,
    "top_volume": top_obj.Shape.Volume,
    "original_volume": original_volume,
    "total_volume": bottom_obj.Shape.Volume + top_obj.Shape.Volume,
}

# Volume should have decreased from original (holes were cut)
_result_["volume_decreased"] = _result_["total_volume"] < original_volume
""",
        )

        assert result["result"]["success"] is True
        # Boolean method produces Part::Feature objects
        assert result["result"]["bottom_type"] == "Part::Feature"
        assert result["result"]["top_type"] == "Part::Feature"
        assert result["result"]["bottom_valid"] is True
        assert result["result"]["top_valid"] is True
        # Volumes should be positive
        assert result["result"]["bottom_volume"] > 0
        assert result["result"]["top_volume"] > 0
        # Volume should have decreased due to holes
        assert result["result"]["volume_decreased"] is True


class TestBooleanHoleFallback:
    """Tests for the fallback boolean hole creation method."""

    @pytest.fixture(autouse=True)
    def setup_document(self, xmlrpc_proxy: xmlrpc.client.ServerProxy) -> None:
        """Create a fresh document for each test."""
        execute_code(
            xmlrpc_proxy,
            """
import FreeCAD
if "BooleanHoleTestDoc" in FreeCAD.listDocuments():
    FreeCAD.closeDocument("BooleanHoleTestDoc")
doc = FreeCAD.newDocument("BooleanHoleTestDoc")
_result_ = True
""",
        )

    def test_boolean_hole_creation_fallback(
        self, xmlrpc_proxy: xmlrpc.client.ServerProxy
    ) -> None:
        """Test the _create_holes_boolean fallback method directly."""
        result = execute_code(
            xmlrpc_proxy,
            SMART_CUTTER_CODE
            + """
doc = App.ActiveDocument

# Create a solid box: 50x50x20mm
box = Part.makeBox(50, 50, 20)
box_obj = doc.addObject("Part::Feature", "TestBox")
box_obj.Shape = box
doc.recompute()

# Calculate initial volume
initial_volume = box.Volume

# Create SmartCutter with parameters
params = {
    "plane_type": "Preset Plane",
    "plane": "XY",
    "offset": 10.0,  # Cut in the middle
    "diameter": 5.0,
    "depth": 5.0,
    "hole_count": 4,
    "clearance_preferred": 2.0,
    "clearance_min": 0.5,
}

cutter = SmartCutter(box_obj, params)

# First cut the object to get the two halves
bottom_shape, top_shape = cutter.cut_object()

# Get the cut face center and face for hole position generation
normal, _ = cutter.get_cut_plane_normal_and_point()
bottom_face_center = cutter.get_cut_face_center(bottom_shape, -normal)

# Find the actual bottom cut face
bottom_cut_face = None
for face in bottom_shape.Faces:
    if face.CenterOfMass.distanceToPoint(bottom_face_center) < 0.1:
        bottom_cut_face = face
        break

# Generate hole positions
positions, _, _, _ = cutter.generate_hole_positions(bottom_face_center, bottom_cut_face)

# Apply boolean hole method to bottom shape
# Note: holes go in -normal direction (into the bottom part)
bottom_with_holes = cutter._create_holes_boolean(bottom_shape, -normal, positions)

# Calculate expected volume reduction per hole
import math
hole_volume = math.pi * (params["diameter"] / 2) ** 2 * params["depth"]
expected_reduction = hole_volume * len(positions)

# Create Part::Feature objects for the results
bottom_result = doc.addObject("Part::Feature", "BottomWithHoles")
bottom_result.Shape = bottom_with_holes
doc.recompute()

# Verify results
_result_ = {
    "success": True,
    "initial_volume": initial_volume,
    "bottom_half_volume_before": bottom_shape.Volume,
    "bottom_with_holes_volume": bottom_with_holes.Volume,
    "positions_count": len(positions),
    "hole_volume_each": hole_volume,
    "expected_volume_reduction": expected_reduction,
    "actual_volume_reduction": bottom_shape.Volume - bottom_with_holes.Volume,
    "bottom_valid": bottom_with_holes.isValid(),
    "result_type": bottom_result.TypeId,
}

# Volume should have decreased by approximately the hole volumes
volume_diff = abs(_result_["actual_volume_reduction"] - expected_reduction)
_result_["volume_reduction_accurate"] = volume_diff < 1.0  # Within 1 mm^3 tolerance
""",
        )

        assert result["result"]["success"] is True
        assert result["result"]["bottom_valid"] is True
        assert (
            result["result"]["result_type"] == "Part::Feature"
        )  # Boolean result is Part::Feature, not PartDesign
        assert result["result"]["positions_count"] >= 1
        # Volume should have decreased
        assert (
            result["result"]["bottom_with_holes_volume"]
            < result["result"]["bottom_half_volume_before"]
        )
        # Volume reduction should be close to expected
        assert result["result"]["volume_reduction_accurate"] is True

    def test_boolean_method_consistency(
        self, xmlrpc_proxy: xmlrpc.client.ServerProxy
    ) -> None:
        """Verify boolean hole method produces consistent results on identical objects."""
        result = execute_code(
            xmlrpc_proxy,
            SMART_CUTTER_CODE
            + """
doc = App.ActiveDocument

# Create two identical solid boxes
box1 = Part.makeBox(50, 50, 20)
box1_obj = doc.addObject("Part::Feature", "Box1")
box1_obj.Shape = box1

box2 = Part.makeBox(50, 50, 20)
box2_obj = doc.addObject("Part::Feature", "Box2")
box2_obj.Shape = box2

doc.recompute()

# Same parameters for both
params = {
    "plane_type": "Preset Plane",
    "plane": "XY",
    "offset": 10.0,
    "diameter": 5.0,
    "depth": 5.0,
    "hole_count": 4,
    "clearance_preferred": 3.0,
    "clearance_min": 1.0,
}

# Run 1: Boolean method on box1
cutter1 = SmartCutter(box1_obj, params)
result1_bottom, result1_top = cutter1.execute()  # use_boolean=True is default

# Run 2: Boolean method on box2 (identical operation)
cutter2 = SmartCutter(box2_obj, params)
result2_bottom, result2_top = cutter2.execute()

doc.recompute()

# Compare results - should be identical for same inputs
vol1_bottom = result1_bottom.Shape.Volume
vol1_top = result1_top.Shape.Volume
vol2_bottom = result2_bottom.Shape.Volume
vol2_top = result2_top.Shape.Volume

_result_ = {
    "success": True,
    "run1_bottom_volume": vol1_bottom,
    "run1_top_volume": vol1_top,
    "run2_bottom_volume": vol2_bottom,
    "run2_top_volume": vol2_top,
    "run1_bottom_type": result1_bottom.TypeId,
    "run2_bottom_type": result2_bottom.TypeId,
    # Volumes should be identical for same inputs
    "volumes_match": abs(vol1_bottom - vol2_bottom) < 0.01 and abs(vol1_top - vol2_top) < 0.01,
    "run1_bottom_valid": result1_bottom.Shape.isValid(),
    "run1_top_valid": result1_top.Shape.isValid(),
    "run2_bottom_valid": result2_bottom.Shape.isValid(),
    "run2_top_valid": result2_top.Shape.isValid(),
}
""",
        )

        assert result["result"]["success"] is True
        # Both runs should produce valid shapes
        assert result["result"]["run1_bottom_valid"] is True
        assert result["result"]["run1_top_valid"] is True
        assert result["result"]["run2_bottom_valid"] is True
        assert result["result"]["run2_top_valid"] is True
        # Boolean method produces Part::Feature objects
        assert result["result"]["run1_bottom_type"] == "Part::Feature"
        assert result["result"]["run2_bottom_type"] == "Part::Feature"
        # Volumes should be identical for same inputs
        assert result["result"]["volumes_match"] is True


class TestEdgeCases:
    """Tests for edge cases and error handling.

    These tests work in both GUI and headless mode.
    """

    @pytest.fixture(autouse=True)
    def setup_document(self, xmlrpc_proxy: xmlrpc.client.ServerProxy) -> None:
        """Create a fresh document for each test."""
        execute_code(
            xmlrpc_proxy,
            """
import FreeCAD
if "EdgeCaseTestDoc" in FreeCAD.listDocuments():
    FreeCAD.closeDocument("EdgeCaseTestDoc")
doc = FreeCAD.newDocument("EdgeCaseTestDoc")
_result_ = True
""",
        )

    def test_small_hole_count(self, xmlrpc_proxy: xmlrpc.client.ServerProxy) -> None:
        """Test with a small number of holes on a larger box for reliable placement."""
        result = execute_code(
            xmlrpc_proxy,
            SMART_CUTTER_CODE
            + """
import math

doc = App.ActiveDocument

# Use a larger box for better hole placement with small hole counts
box = Part.makeBox(80, 80, 40)
box_obj = doc.addObject("Part::Feature", "TestBox")
box_obj.Shape = box
doc.recompute()

original_volume = box.Volume

params = {
    "plane_type": "Preset Plane",
    "plane": "XY",
    "offset": 20.0,
    "diameter": 4.0,  # Smaller holes
    "depth": 3.0,
    "hole_count": 4,  # 4 holes on 80mm box = good spacing
    "clearance_preferred": 3.0,  # Increased clearance
    "clearance_min": 1.0,
}

cutter = SmartCutter(box_obj, params)
bottom_obj, top_obj = cutter.execute()

doc.recompute()

# Calculate expected hole volume for verification
hole_volume = math.pi * (params["diameter"] / 2) ** 2 * params["depth"]

_result_ = {
    "success": True,
    "bottom_valid": bottom_obj.Shape.isValid(),
    "top_valid": top_obj.Shape.isValid(),
    "bottom_volume": bottom_obj.Shape.Volume,
    "top_volume": top_obj.Shape.Volume,
    "original_volume": original_volume,
    "total_volume": bottom_obj.Shape.Volume + top_obj.Shape.Volume,
    "hole_volume_each": hole_volume,
}

# Volume should have decreased from original (holes were cut)
_result_["volume_decreased"] = _result_["total_volume"] < original_volume
""",
        )

        assert result["result"]["success"] is True
        assert result["result"]["bottom_valid"] is True
        assert result["result"]["top_valid"] is True
        # Volume should have decreased due to holes
        assert result["result"]["volume_decreased"] is True

    def test_many_holes(self, xmlrpc_proxy: xmlrpc.client.ServerProxy) -> None:
        """Test with many holes requested (some may be skipped due to overlap)."""
        result = execute_code(
            xmlrpc_proxy,
            SMART_CUTTER_CODE
            + """
import math

doc = App.ActiveDocument

# Create a larger box to fit more holes
box = Part.makeBox(100, 100, 40)
box_obj = doc.addObject("Part::Feature", "TestBox")
box_obj.Shape = box
doc.recompute()

original_volume = box.Volume

params = {
    "plane_type": "Preset Plane",
    "plane": "XY",
    "offset": 20.0,
    "diameter": 4.0,
    "depth": 3.0,
    "hole_count": 20,  # Many holes
    "clearance_preferred": 2.0,
    "clearance_min": 0.5,
}

cutter = SmartCutter(box_obj, params)
bottom_obj, top_obj = cutter.execute()

doc.recompute()

# Calculate expected hole volume for verification
hole_volume = math.pi * (params["diameter"] / 2) ** 2 * params["depth"]

_result_ = {
    "success": True,
    "bottom_valid": bottom_obj.Shape.isValid(),
    "top_valid": top_obj.Shape.isValid(),
    "bottom_volume": bottom_obj.Shape.Volume,
    "top_volume": top_obj.Shape.Volume,
    "original_volume": original_volume,
    "total_volume": bottom_obj.Shape.Volume + top_obj.Shape.Volume,
    "hole_volume_each": hole_volume,
}

# Volume should have decreased from original (holes were cut)
_result_["volume_decreased"] = _result_["total_volume"] < original_volume
""",
        )

        assert result["result"]["success"] is True
        assert result["result"]["bottom_valid"] is True
        assert result["result"]["top_valid"] is True
        # Volume should have decreased due to holes
        assert result["result"]["volume_decreased"] is True