"""Parametric transforms for pattern replay (translate / mirror / rotate).

A pattern instance re-executes its source feature with every absolute
coordinate parameter transformed (sketch, host frame, axis, positions,
center, nested mirror-plane references).  These helpers own that parameter
algebra; the pattern executors only decide which transform to apply.
"""

from __future__ import annotations

import math
from copy import deepcopy
from typing import TYPE_CHECKING, Any, Callable

from .specs import AxisSpec, PlaneSpec, Vector3, vector_cross, vector_dot, vector_scale, vector_subtract
from .topology import FeaturePlanNode

if TYPE_CHECKING:  # pragma: no cover - import for type checkers only
    from .session import ExecutionSession


def _translated_sketch(sketch: dict[str, Any], offset: Vector3) -> dict[str, Any]:
    output = deepcopy(sketch)
    components = offset
    workplane = output.get("workplane") or {}
    origin = workplane.get("origin_mm") or [0, 0, 0]
    workplane["origin_mm"] = [float(origin[index]) + components[index] for index in range(3)]
    output["workplane"] = workplane
    for key in ("contour_edges_mm", "contour_regions_mm"):
        def translate(value: Any) -> None:
            if isinstance(value, dict):
                for point_key in ("start_mm", "end_mm", "center_mm"):
                    if point_key in value:
                        value[point_key] = [float(value[point_key][index]) + components[index] for index in range(3)]
                if "points_mm" in value:
                    value["points_mm"] = [
                        [float(point[index]) + components[index] for index in range(3)]
                        for point in value["points_mm"]
                    ]
                for child in value.values():
                    translate(child)
            elif isinstance(value, list):
                for child in value:
                    translate(child)
        translate(output.get(key))
    return output


def _transformed_loft_profiles(
    node: FeaturePlanNode,
    params: dict[str, Any],
    instance_id: str,
    session: "ExecutionSession",
    transform: Callable[[dict[str, Any]], dict[str, Any]],
) -> None:
    """为 pattern replay 创建放样截面的变换副本。"""
    if node.atomic_id != "loft_add":
        return
    profile_ids = params.get("profile_sketch_ids") or []
    transformed_ids: list[str] = []
    for index, sketch_id in enumerate(profile_ids):
        source = session.sketches.get(str(sketch_id))
        if source is None:
            raise ValueError(f"loft profile sketch {sketch_id!r} has no replay definition")
        transformed_id = f"{instance_id}.profile.{index}"
        # 不复用原 profile：pattern 中的每个截面都必须与 source feature
        # 使用相同的平移、镜像或旋转，才能保持放样的真实空间位置。
        session.sketches[transformed_id] = transform(source)
        transformed_ids.append(transformed_id)
    params["profile_sketch_ids"] = transformed_ids


def _owner_plane_frame(session: "ExecutionSession", selector: dict[str, Any]) -> dict[str, Any] | None:
    """解析 selector 的 owner 特征（reference_plane）注册的显式平面 frame。

    #6 pattern 引用重解析：pattern 重放 source（pattern_mirror）时，镜像面
    是 selector，其 owner 是 reference_plane 特征；该特征执行时把显式
    PlaneSpec 登记为拓扑上下文，这里取出该 frame 供随实例变换使用。
    """
    owner = selector.get("owner_feature_id")
    if not owner:
        return None
    for record in session.topology.records_for_feature(str(owner)):
        if record.kind == "plane" and isinstance(record.value, PlaneSpec):
            return record.value.as_dict()
    return None


def _translated_node(node: FeaturePlanNode, instance_id: str, offset: Vector3, session: "ExecutionSession") -> FeaturePlanNode:
    params = deepcopy(node.params)
    components = offset
    if isinstance(params.get("plane"), dict) and params["plane"].get("origin_mm"):
        params["plane"]["origin_mm"] = [float(params["plane"]["origin_mm"][index]) + components[index] for index in range(3)]
    host = params.get("host_face")
    host_frame = host.get("frame") if isinstance(host, dict) else None
    positions_are_local = isinstance(host_frame, dict) and all(
        host_frame.get(key) is not None for key in ("origin_mm", "x_dir", "normal")
    )
    if positions_are_local and host_frame.get("origin_mm"):
        host_frame["origin_mm"] = [float(host_frame["origin_mm"][index]) + components[index] for index in range(3)]
    if not positions_are_local:
        for position in params.get("positions") or []:
            if position.get("mm"):
                position["mm"] = [float(position["mm"][index]) + components[index] for index in range(3)]
    axis = params.get("axis") or {}
    if axis.get("origin_mm"):
        axis["origin_mm"] = [float(axis["origin_mm"][index]) + components[index] for index in range(3)]
    center = params.get("center_mm")
    if center:
        # box_add/sphere_add 以世界坐标几何中心定位；平移重放必须随实例移动该中心，
        # 否则阵列副本会静默重合在原位置。
        params["center_mm"] = [float(center[index]) + components[index] for index in range(3)]
    _transformed_loft_profiles(
        node, params, instance_id, session,
        lambda sketch: _translated_sketch(sketch, offset),
    )
    mirror_plane = params.get("mirror_plane")
    if isinstance(mirror_plane, dict) and node.atomic_id == "pattern_mirror":
        # #6 pattern 引用重解析：镜像面是 reference_plane 引用，随实例平移
        # 到新位置后内联为显式 frame；否则重放时 resolve 到原始面，镜像
        # 副本会错误地重合在源特征附近。同时源特征也必须平移后重放：镜像
        # 副本 = reflect(源@t, 面@t)，只平移面不平移源会落在 2P+t-x 处
        # 而非正确位置 2P-x+t。
        frame = _owner_plane_frame(session, mirror_plane)
        if frame is None:
            raise ValueError("mirror plane reference cannot be transformed for pattern replay")
        cloned_selector = deepcopy(mirror_plane)
        cloned_selector["frame"] = {
            "origin_mm": [frame["origin_mm"][index] + components[index] for index in range(3)],
            "x_dir": list(frame["x_dir"]),
            "normal": list(frame["normal"]),
        }
        params["mirror_plane"] = cloned_selector
        transformed_ids: list[str] = []
        for source_id in node.params.get("source_feature_ids") or []:
            source_node = session.replay_definitions.get(str(source_id))
            if source_node is None:
                raise ValueError(f"mirror pattern source feature {source_id} has no replay definition")
            temp_id = f"{instance_id}.src.{source_id}"
            shifted = _translated_node(source_node, temp_id, offset, session)
            if shifted.sketch_id:
                source_sketch = session.sketches.get(str(source_node.sketch_id))
                if source_sketch is not None:
                    temp_sketch_id = f"{temp_id}.sk"
                    session.sketches[temp_sketch_id] = _translated_sketch(source_sketch, offset)
                    shifted = FeaturePlanNode(
                        shifted.feature_id, shifted.atomic_id, shifted.name, shifted.depends_on,
                        shifted.params, shifted.selectors, temp_sketch_id,
                        shifted.declared_status, shifted.source_feature,
                    )
            # 临时 replay 定义同样进入 nodes 表（replay_sources 以此过滤）。
            session.nodes[temp_id] = shifted
            session.replay_definitions[temp_id] = shifted
            transformed_ids.append(temp_id)
        params["source_feature_ids"] = transformed_ids
    return FeaturePlanNode(instance_id, node.atomic_id, node.name, (), params, node.selectors, node.sketch_id, node.declared_status, node.source_feature)


def _reflect_point(point: list[float] | tuple[float, float, float], plane: PlaneSpec, *, vector: bool = False) -> list[float]:
    value = tuple(float(component) for component in point)
    offset = value if vector else vector_subtract(value, plane.origin_mm)
    mirrored = vector_subtract(value, vector_scale(plane.normal, 2 * vector_dot(offset, plane.normal)))
    return list(mirrored)


def _mirrored_sketch(sketch: dict[str, Any], plane: PlaneSpec) -> dict[str, Any]:
    output = deepcopy(sketch)
    workplane = output.get("workplane") or {}
    if workplane.get("origin_mm"):
        workplane["origin_mm"] = _reflect_point(workplane["origin_mm"], plane)
    for key in ("x_dir", "y_dir", "normal"):
        if workplane.get(key):
            workplane[key] = _reflect_point(workplane[key], plane, vector=True)
    output["workplane"] = workplane

    # A reflection reverses handedness.  ``PlaneSpec`` reconstructs its local
    # y direction as normal x x, so keeping the reflected normal means that
    # local y is the inverse of the reflected source y.  Profiles represented
    # as local circles (rather than already-transformed contour edges) must
    # therefore invert v to remain at their actual reflected world position.
    def mirror_local_coordinates(value: Any) -> None:
        if isinstance(value, dict):
            for point_key in ("center", "start", "end"):
                point = value.get(point_key)
                if isinstance(point, list) and len(point) == 2:
                    value[point_key] = [float(point[0]), -float(point[1])]
            if isinstance(value.get("points"), list):
                value["points"] = [
                    [float(point[0]), -float(point[1])]
                    for point in value["points"]
                    if isinstance(point, list) and len(point) == 2
                ]
            for child in value.values():
                mirror_local_coordinates(child)
        elif isinstance(value, list):
            for child in value:
                mirror_local_coordinates(child)

    mirror_local_coordinates(output.get("entities"))
    # This is not consumed after sketch resolution, but retaining the same
    # local semantics makes an overridden sketch safe to inspect or replay.
    mirror_local_coordinates(output.get("profile"))

    def mirror(value: Any) -> None:
        if isinstance(value, dict):
            for point_key in ("start_mm", "end_mm", "center_mm"):
                if point_key in value:
                    value[point_key] = _reflect_point(value[point_key], plane)
            if "points_mm" in value:
                value["points_mm"] = [_reflect_point(point, plane) for point in value["points_mm"]]
            if value.get("normal"):
                value["normal"] = _reflect_point(value["normal"], plane, vector=True)
            for child in value.values():
                mirror(child)
        elif isinstance(value, list):
            for child in value:
                mirror(child)
    mirror(output.get("contour_edges_mm"))
    mirror(output.get("contour_regions_mm"))
    return output


def _mirrored_node(node: FeaturePlanNode, instance_id: str, plane: PlaneSpec, session: "ExecutionSession") -> FeaturePlanNode:
    params = deepcopy(node.params)
    if isinstance(params.get("plane"), dict):
        for key in ("origin_mm", "x_dir", "y_dir", "normal"):
            if params["plane"].get(key):
                params["plane"][key] = _reflect_point(params["plane"][key], plane, vector=key != "origin_mm")
    host = params.get("host_face")
    host_frame = host.get("frame") if isinstance(host, dict) else None
    positions_are_local = isinstance(host_frame, dict) and all(
        host_frame.get(key) is not None for key in ("origin_mm", "x_dir", "normal")
    )
    if positions_are_local:
        for key in ("origin_mm", "x_dir", "normal"):
            if host_frame.get(key):
                host_frame[key] = _reflect_point(host_frame[key], plane, vector=key != "origin_mm")
        # #1 y_dir 保留：PlaneSpec 现在会尊重显式正交 y_dir。镜像后 frame 的
        # canonical y 轴必须是 n×x（x 已反射 → y 反转），否则反射后的 frame
        # 会保留反射前的 y_dir，与下方"局部坐标 v 取反"双重翻转。
        x_reflected = host_frame.get("x_dir")
        n_reflected = host_frame.get("normal")
        if x_reflected is not None and n_reflected is not None:
            host_frame["y_dir"] = [
                n_reflected[1] * x_reflected[2] - n_reflected[2] * x_reflected[1],
                n_reflected[2] * x_reflected[0] - n_reflected[0] * x_reflected[2],
                n_reflected[0] * x_reflected[1] - n_reflected[1] * x_reflected[0],
            ]
        # See _mirrored_sketch: the canonical reflected plane reverses local
        # y, so local hole coordinates must do the same.
        for position in params.get("positions") or []:
            point = position.get("mm")
            if isinstance(point, list) and len(point) == 3:
                position["mm"] = [float(point[0]), -float(point[1]), float(point[2])]
    else:
        for position in params.get("positions") or []:
            if position.get("mm"):
                position["mm"] = _reflect_point(position["mm"], plane)
    axis = params.get("axis") or {}
    if axis.get("origin_mm"):
        axis["origin_mm"] = _reflect_point(axis["origin_mm"], plane)
    if axis.get("direction"):
        axis["direction"] = _reflect_point(axis["direction"], plane, vector=True)
    center = params.get("center_mm")
    if isinstance(center, list) and len(center) == 3:
        # box_add/sphere_add 以世界坐标几何中心定位：反射该中心即可。box_add 固定
        # 世界轴对齐，跨坐标平面镜像后仍保持朝向（斜镜像面在 _execute_mirror_pattern
        # 中已被显式拒绝）。
        params["center_mm"] = _reflect_point(center, plane)
    _transformed_loft_profiles(
        node, params, instance_id, session,
        lambda sketch: _mirrored_sketch(sketch, plane),
    )
    mirror_plane = params.get("mirror_plane")
    if isinstance(mirror_plane, dict) and node.atomic_id == "pattern_mirror":
        # #6 pattern 引用重解析：镜像重放 mirror source 时，其镜像面引用
        # 随本实例的镜像面一起反射（内联为显式 frame），否则重放 resolve
        # 到原始面，嵌套镜像会退化成与源镜像重合的错误几何。源特征同样
        # 反射后重放：镜像副本 = reflect(源@P_B, reflect(面,P_B))。
        frame = _owner_plane_frame(session, mirror_plane)
        if frame is None:
            raise ValueError("mirror plane reference cannot be transformed for pattern replay")
        cloned_selector = deepcopy(mirror_plane)
        cloned_selector["frame"] = {
            "origin_mm": _reflect_point(frame["origin_mm"], plane),
            "x_dir": _reflect_point(frame["x_dir"], plane, vector=True),
            "normal": _reflect_point(frame["normal"], plane, vector=True),
        }
        params["mirror_plane"] = cloned_selector
        transformed_ids: list[str] = []
        for source_id in node.params.get("source_feature_ids") or []:
            source_node = session.replay_definitions.get(str(source_id))
            if source_node is None:
                raise ValueError(f"mirror pattern source feature {source_id} has no replay definition")
            temp_id = f"{instance_id}.src.{source_id}"
            shifted = _mirrored_node(source_node, temp_id, plane, session)
            if shifted.sketch_id:
                source_sketch = session.sketches.get(str(source_node.sketch_id))
                if source_sketch is not None:
                    temp_sketch_id = f"{temp_id}.sk"
                    session.sketches[temp_sketch_id] = _mirrored_sketch(source_sketch, plane)
                    shifted = FeaturePlanNode(
                        shifted.feature_id, shifted.atomic_id, shifted.name, shifted.depends_on,
                        shifted.params, shifted.selectors, temp_sketch_id,
                        shifted.declared_status, shifted.source_feature,
                    )
            # 临时 replay 定义同样进入 nodes 表（replay_sources 以此过滤）。
            session.nodes[temp_id] = shifted
            session.replay_definitions[temp_id] = shifted
            transformed_ids.append(temp_id)
        params["source_feature_ids"] = transformed_ids
    return FeaturePlanNode(instance_id, node.atomic_id, node.name, (), params, node.selectors, node.sketch_id, node.declared_status, node.source_feature)


def _normal_is_coordinate_axis(normal: Any) -> bool:
    # 判断单位法向是否平行于任一世界坐标轴：跨这样的平面镜像会保持轴对齐朝向。
    return (
        isinstance(normal, (list, tuple))
        and len(normal) == 3
        and any(abs(float(normal[index])) > 1 - 1e-9 for index in range(3))
    )


def _coordinate_axis_direction(direction: Any) -> bool:
    # 判断方向是否平行于任一世界坐标轴（circular 的 box 限制用）。
    # 不依赖输入已是单位向量：非零向量至多一个分量非零即为坐标轴方向
    # （_box_circular_is_exact 对任意长度/含小残差的 direction 都稳健）。
    if not isinstance(direction, (list, tuple)) or len(direction) != 3:
        return False
    return sum(1 for component in direction if abs(float(component)) > 1e-9) == 1


def _rotated_vector(value: Vector3, axis: AxisSpec, angle_rad: float) -> Vector3:
    # Rodrigues 旋转公式：绕单位轴 axis.direction 旋转向量（无平移项）。
    cosine = math.cos(angle_rad)
    sine = math.sin(angle_rad)
    axis_direction = axis.direction
    cross = vector_cross(axis_direction, value)
    dot = vector_dot(axis_direction, value)
    return tuple(  # type: ignore[return-value]
        value[index] * cosine + cross[index] * sine + axis_direction[index] * dot * (1.0 - cosine)
        for index in range(3)
    )


def _rotated_point(point: Any, axis: AxisSpec, angle_rad: float) -> list[float]:
    # 绕轴旋转三维点：先平移到轴原点、旋转向量、再平移回。
    value = tuple(float(component) for component in point)
    relative = vector_subtract(value, axis.origin_mm)
    rotated = _rotated_vector(relative, axis, angle_rad)
    return [axis.origin_mm[index] + rotated[index] for index in range(3)]


def _rotated_sketch(sketch: dict[str, Any], axis: AxisSpec, angle_rad: float) -> dict[str, Any]:
    # 环形阵列实例的草图：工作平面 frame（原点为点、x/y/normal 为向量）绕轴旋转；
    # 2D 局部实体坐标不动（frame 旋转后由草图求解器映射到新世界位置）。与
    # _translated_sketch 对"世界坐标轮廓点"的处理对称，这里把 start/end/center
    # 世界坐标点和圆弧法向绕轴旋转。
    output = deepcopy(sketch)
    workplane = output.get("workplane") or {}
    if workplane.get("origin_mm"):
        workplane["origin_mm"] = _rotated_point(workplane["origin_mm"], axis, angle_rad)
    for key in ("x_dir", "y_dir", "normal"):
        if workplane.get(key):
            workplane[key] = list(_rotated_vector(tuple(float(v) for v in workplane[key]), axis, angle_rad))
    output["workplane"] = workplane

    def rotate(value: Any) -> None:
        if isinstance(value, dict):
            for point_key in ("start_mm", "end_mm", "center_mm"):
                if point_key in value:
                    value[point_key] = _rotated_point(value[point_key], axis, angle_rad)
            if "points_mm" in value:
                value["points_mm"] = [_rotated_point(point, axis, angle_rad) for point in value["points_mm"]]
            if "normal" in value:
                value["normal"] = list(_rotated_vector(tuple(float(v) for v in value["normal"]), axis, angle_rad))
            for child in value.values():
                rotate(child)
        elif isinstance(value, list):
            for child in value:
                rotate(child)

    for key in ("contour_edges_mm", "contour_regions_mm"):
        rotate(output.get(key))
    return output


def _rotated_node(node: FeaturePlanNode, instance_id: str, axis: AxisSpec, angle_rad: float, session: "ExecutionSession") -> FeaturePlanNode:
    # 环形阵列实例节点：把源特征的全部绝对坐标参数绕 axis 旋转（参数键布局与
    # _translated_node/_mirrored_node 一致）。workplane/宿主 frame 的轴方向旋转，
    # 世界坐标点旋转；局部 positions（随宿主 frame）不动。特征自带 axis（圆柱轴/
    # 旋转轴/嵌套 circular 轴）与几何中心 center_mm 随实例旋转。嵌套 pattern
    # source（pattern_mirror/pattern_circular）带绝对引用：镜像面 frame / 内层
    # 源需连同本实例一起旋转，否则重放会退化成与源重合的错误几何。
    params = deepcopy(node.params)
    plane = params.get("plane")
    if isinstance(plane, dict):
        for key in ("origin_mm", "x_dir", "y_dir", "normal"):
            if plane.get(key):
                if key == "origin_mm":
                    plane[key] = _rotated_point(plane[key], axis, angle_rad)
                else:
                    plane[key] = list(_rotated_vector(tuple(float(v) for v in plane[key]), axis, angle_rad))
    path = params.get("path")
    path_plane = path.get("workplane") if isinstance(path, dict) else None
    if isinstance(path_plane, dict):
        if path_plane.get("origin_mm"):
            path_plane["origin_mm"] = _rotated_point(path_plane["origin_mm"], axis, angle_rad)
        for key in ("x_dir", "y_dir", "normal"):
            if path_plane.get(key):
                path_plane[key] = list(_rotated_vector(tuple(float(v) for v in path_plane[key]), axis, angle_rad))
    elif isinstance(path, dict) and isinstance(path.get("segments"), list):
        # A source-only spatial sweep path has no common workplane. Its
        # captured points and directions are absolute, so replayed circular
        # pattern instances must rotate each geometric field independently.
        for segment in path["segments"]:
            if not isinstance(segment, dict):
                continue
            for key in ("start_mm", "end_mm", "center_mm"):
                value = segment.get(key)
                if isinstance(value, list) and len(value) == 3:
                    segment[key] = _rotated_point(value, axis, angle_rad)
            points = segment.get("points_mm")
            if isinstance(points, list):
                segment["points_mm"] = [
                    _rotated_point(point, axis, angle_rad)
                    for point in points
                    if isinstance(point, list) and len(point) == 3
                ]
            for key in ("normal", "start_tangent_mm", "end_tangent_mm"):
                value = segment.get(key)
                if isinstance(value, list) and len(value) == 3:
                    segment[key] = list(_rotated_vector(tuple(float(v) for v in value), axis, angle_rad))
    host = params.get("host_face")
    host_frame = host.get("frame") if isinstance(host, dict) else None
    positions_are_local = isinstance(host_frame, dict) and all(
        host_frame.get(key) is not None for key in ("origin_mm", "x_dir", "normal")
    )
    if positions_are_local:
        if host_frame.get("origin_mm"):
            host_frame["origin_mm"] = _rotated_point(host_frame["origin_mm"], axis, angle_rad)
        for key in ("x_dir", "normal"):
            if host_frame.get(key):
                host_frame[key] = list(_rotated_vector(tuple(float(v) for v in host_frame[key]), axis, angle_rad))
    else:
        for position in params.get("positions") or []:
            if position.get("mm"):
                position["mm"] = _rotated_point(position["mm"], axis, angle_rad)
    feature_axis = params.get("axis")
    if isinstance(feature_axis, dict):
        if feature_axis.get("origin_mm"):
            feature_axis["origin_mm"] = _rotated_point(feature_axis["origin_mm"], axis, angle_rad)
        if feature_axis.get("direction"):
            feature_axis["direction"] = list(_rotated_vector(tuple(float(v) for v in feature_axis["direction"]), axis, angle_rad))
    center = params.get("center_mm")
    if isinstance(center, list) and len(center) == 3:
        params["center_mm"] = _rotated_point(center, axis, angle_rad)
    _transformed_loft_profiles(
        node, params, instance_id, session,
        lambda sketch: _rotated_sketch(sketch, axis, angle_rad),
    )
    if node.atomic_id in {"pattern_mirror", "pattern_circular"}:
        # pattern 引用旋转重解析：镜像面 / 内层源随本实例一起旋转，否则嵌套
        # pattern 作为 circular source 时重放会退化成错误几何（见 _translated_node）。
        if node.atomic_id == "pattern_mirror":
            mirror_plane = params.get("mirror_plane")
            if not isinstance(mirror_plane, dict):
                raise ValueError("mirror pattern replayed by circular pattern has no mirror plane reference")
            frame = _owner_plane_frame(session, mirror_plane)
            if frame is None:
                raise ValueError("mirror plane reference cannot be transformed for circular pattern replay")
            cloned_selector = deepcopy(mirror_plane)
            cloned_selector["frame"] = {
                "origin_mm": _rotated_point(frame["origin_mm"], axis, angle_rad),
                "x_dir": list(_rotated_vector(tuple(frame["x_dir"]), axis, angle_rad)),
                "normal": list(_rotated_vector(tuple(frame["normal"]), axis, angle_rad)),
            }
            params["mirror_plane"] = cloned_selector
        transformed_ids: list[str] = []
        for source_id in node.params.get("source_feature_ids") or []:
            source_node = session.replay_definitions.get(str(source_id))
            if source_node is None:
                raise ValueError(f"pattern source feature {source_id} has no replay definition")
            temp_id = f"{instance_id}.src.{source_id}"
            shifted = _rotated_node(source_node, temp_id, axis, angle_rad, session)
            if shifted.sketch_id:
                source_sketch = session.sketches.get(str(source_node.sketch_id))
                if source_sketch is not None:
                    temp_sketch_id = f"{temp_id}.sk"
                    session.sketches[temp_sketch_id] = _rotated_sketch(source_sketch, axis, angle_rad)
                    shifted = FeaturePlanNode(
                        shifted.feature_id, shifted.atomic_id, shifted.name, shifted.depends_on,
                        shifted.params, shifted.selectors, temp_sketch_id,
                        shifted.declared_status, shifted.source_feature,
                    )
            # 临时 replay 定义同样进入 nodes 表（replay_sources 以此过滤）。
            session.nodes[temp_id] = shifted
            session.replay_definitions[temp_id] = shifted
            transformed_ids.append(temp_id)
        params["source_feature_ids"] = transformed_ids
    return FeaturePlanNode(instance_id, node.atomic_id, node.name, (), params, node.selectors, node.sketch_id, node.declared_status, node.source_feature)


def _pattern_operation_node(node: FeaturePlanNode, operation_mode: str) -> FeaturePlanNode:
    # REMOVE pattern 的实例必须沿用 source 的 profile/extent，但以 cut 而不是
    # add 写入当前主体。lowering 已将初始 source 同步改写，运行时保留此处以
    # 支持完整的 CDSL replay contract。
    if operation_mode != "remove": return node
    atomic_id = {
        "extrude_add_blind": "extrude_cut_blind",
        "extrude_add_two_sided": "extrude_cut_two_sided",
        "revolve_add": "revolve_cut",
    }.get(node.atomic_id, node.atomic_id)
    if atomic_id == node.atomic_id and "cut" not in atomic_id:
        raise ValueError("REMOVE pattern source is not a replayable cutting feature")
    params = {key: value for key, value in node.params.items() if key != "result_mode"}
    return FeaturePlanNode(
        node.feature_id, atomic_id, node.name, node.depends_on, params,
        node.selectors, node.sketch_id, node.declared_status, node.source_feature,
    )


def _box_circular_is_exact(axis: AxisSpec, angle_rad: float) -> bool:
    # box_add 是固定世界轴对齐的原生图元：绕轴旋转任意角度会使其棱偏离坐标轴，
    # 当前参数语义无法表达 → 仅坐标轴旋转且每份转角为 180° 的整数倍时精确
    # （180° 翻转把轴对齐 box 映射回轴对齐 box）。与 _execute_mirror_pattern 的
    # box 坐标平面限制同思路：宁可显式拒绝，也不静默产出错误几何。
    if not _coordinate_axis_direction(axis.direction):
        return False
    half_turns = abs(math.degrees(angle_rad)) / 180.0
    return abs(half_turns - round(half_turns)) < 1e-9