kcl_lib/frontend/

trim.rs

use std::f64::consts::TAU;

use indexmap::IndexSet;
use kittycad_modeling_cmds::units::UnitLength;

use crate::execution::types::adjust_length;
use crate::frontend::api::Number;
use crate::frontend::api::Object;
use crate::frontend::api::ObjectId;
use crate::frontend::api::ObjectKind;
use crate::frontend::sketch::Constraint;
use crate::frontend::sketch::Segment;
use crate::frontend::sketch::SegmentCtor;
use crate::pretty::NumericSuffix;

#[cfg(all(feature = "artifact-graph", test))]
mod tests;

// Epsilon constants for geometric calculations
const EPSILON_PARALLEL: f64 = 1e-10;
const EPSILON_POINT_ON_SEGMENT: f64 = 1e-6;

/// Length unit for a numeric suffix (length variants only). Non-length suffixes default to millimeters.
fn suffix_to_unit(suffix: NumericSuffix) -> UnitLength {
    match suffix {
        NumericSuffix::Mm => UnitLength::Millimeters,
        NumericSuffix::Cm => UnitLength::Centimeters,
        NumericSuffix::M => UnitLength::Meters,
        NumericSuffix::Inch => UnitLength::Inches,
        NumericSuffix::Ft => UnitLength::Feet,
        NumericSuffix::Yd => UnitLength::Yards,
        _ => UnitLength::Millimeters,
    }
}

/// Convert a length `Number` to f64 in the target unit. Use when normalizing geometry into a single unit.
fn number_to_unit(n: &Number, target_unit: UnitLength) -> f64 {
    adjust_length(suffix_to_unit(n.units), n.value, target_unit).0
}

/// Convert a length in the given unit to a `Number` in the target suffix.
fn unit_to_number(value: f64, source_unit: UnitLength, target_suffix: NumericSuffix) -> Number {
    let (value, _) = adjust_length(source_unit, value, suffix_to_unit(target_suffix));
    Number {
        value,
        units: target_suffix,
    }
}

/// Convert trim line points from millimeters into the current/default unit.
fn normalize_trim_points_to_unit(points: &[Coords2d], default_unit: UnitLength) -> Vec<Coords2d> {
    points
        .iter()
        .map(|point| Coords2d {
            x: adjust_length(UnitLength::Millimeters, point.x, default_unit).0,
            y: adjust_length(UnitLength::Millimeters, point.y, default_unit).0,
        })
        .collect()
}

/// 2D coordinates in the trim internal unit (current/default length unit).
#[derive(Debug, Clone, Copy)]
pub struct Coords2d {
    pub x: f64,
    pub y: f64,
}

/// Which endpoint of a line segment to get coordinates for
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LineEndpoint {
    Start,
    End,
}

/// Which point of an arc segment to get coordinates for
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArcPoint {
    Start,
    End,
    Center,
}

/// Direction along a segment for finding trim terminations
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TrimDirection {
    Left,
    Right,
}

// Manual serde implementation for Coords2d to serialize as [x, y] array
// This matches TypeScript's Coords2d type which is [number, number]

// A trim spawn is the intersection point of the trim line (drawn by the user) and a segment.
// We travel in both directions along the segment from the trim spawn to determine how to implement the trim.

/// Item from advancing to the next trim spawn (intersection), like an iterator item from `Iterator::next()`.
#[derive(Debug, Clone)]
pub enum TrimItem {
    Spawn {
        trim_spawn_seg_id: ObjectId,
        trim_spawn_coords: Coords2d,
        next_index: usize,
    },
    None {
        next_index: usize,
    },
}

/// Trim termination types
///
/// Trim termination is the term used to figure out each end of a segment after a trim spawn has been found.
/// When a trim spawn is found, we travel in both directions to find this termination. It can be:
/// (1) the end of a segment (floating end), (2) an intersection with another segment, or
/// (3) a coincident point where another segment is coincident with the segment we're traveling along.
#[derive(Debug, Clone)]
pub enum TrimTermination {
    SegEndPoint {
        trim_termination_coords: Coords2d,
    },
    Intersection {
        trim_termination_coords: Coords2d,
        intersecting_seg_id: ObjectId,
    },
    TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
        trim_termination_coords: Coords2d,
        intersecting_seg_id: ObjectId,
        other_segment_point_id: ObjectId,
    },
}

/// Trim terminations for both sides
#[derive(Debug, Clone)]
pub struct TrimTerminations {
    pub left_side: TrimTermination,
    pub right_side: TrimTermination,
}

/// Specifies where a constraint should attach when migrating during split operations
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AttachToEndpoint {
    Start,
    End,
    Segment,
}

/// Specifies which endpoint of a segment was changed
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EndpointChanged {
    Start,
    End,
}

/// Coincident data for split segment operations
#[derive(Debug, Clone)]
pub struct CoincidentData {
    pub intersecting_seg_id: ObjectId,
    pub intersecting_endpoint_point_id: Option<ObjectId>,
    pub existing_point_segment_constraint_id: Option<ObjectId>,
}

/// Constraint to migrate during split operations
#[derive(Debug, Clone)]
pub struct ConstraintToMigrate {
    pub constraint_id: ObjectId,
    pub other_entity_id: ObjectId,
    /// True if the coincident constraint is between two points (point–point).
    /// False if it is between a point and a line/arc/segment (point-segment coincident).
    pub is_point_point: bool,
    pub attach_to_endpoint: AttachToEndpoint,
}

#[derive(Debug, Clone)]
#[allow(clippy::large_enum_variant)]
pub enum TrimOperation {
    SimpleTrim {
        segment_to_trim_id: ObjectId,
    },
    EditSegment {
        segment_id: ObjectId,
        ctor: SegmentCtor,
        endpoint_changed: EndpointChanged,
    },
    AddCoincidentConstraint {
        segment_id: ObjectId,
        endpoint_changed: EndpointChanged,
        segment_or_point_to_make_coincident_to: ObjectId,
        intersecting_endpoint_point_id: Option<ObjectId>,
    },
    SplitSegment {
        segment_id: ObjectId,
        left_trim_coords: Coords2d,
        right_trim_coords: Coords2d,
        original_end_coords: Coords2d,
        left_side: Box<TrimTermination>,
        right_side: Box<TrimTermination>,
        left_side_coincident_data: CoincidentData,
        right_side_coincident_data: CoincidentData,
        constraints_to_migrate: Vec<ConstraintToMigrate>,
        constraints_to_delete: Vec<ObjectId>,
    },
    DeleteConstraints {
        constraint_ids: Vec<ObjectId>,
    },
}

/// Helper to check if a point is on a line segment (within epsilon distance)
///
/// Returns the point if it's on the segment, None otherwise.
pub fn is_point_on_line_segment(
    point: Coords2d,
    segment_start: Coords2d,
    segment_end: Coords2d,
    epsilon: f64,
) -> Option<Coords2d> {
    let dx = segment_end.x - segment_start.x;
    let dy = segment_end.y - segment_start.y;
    let segment_length_sq = dx * dx + dy * dy;

    if segment_length_sq < EPSILON_PARALLEL {
        // Segment is degenerate, i.e it's practically a point
        let dist_sq = (point.x - segment_start.x) * (point.x - segment_start.x)
            + (point.y - segment_start.y) * (point.y - segment_start.y);
        if dist_sq <= epsilon * epsilon {
            return Some(point);
        }
        return None;
    }

    let point_dx = point.x - segment_start.x;
    let point_dy = point.y - segment_start.y;
    let projection_param = (point_dx * dx + point_dy * dy) / segment_length_sq;

    // Check if point projects onto the segment
    if !(0.0..=1.0).contains(&projection_param) {
        return None;
    }

    // Calculate the projected point on the segment
    let projected_point = Coords2d {
        x: segment_start.x + projection_param * dx,
        y: segment_start.y + projection_param * dy,
    };

    // Check if the distance from point to projected point is within epsilon
    let dist_dx = point.x - projected_point.x;
    let dist_dy = point.y - projected_point.y;
    let distance_sq = dist_dx * dist_dx + dist_dy * dist_dy;

    if distance_sq <= epsilon * epsilon {
        Some(point)
    } else {
        None
    }
}

/// Helper to calculate intersection point of two line segments
///
/// Returns the intersection point if segments intersect, None otherwise.
pub fn line_segment_intersection(
    line1_start: Coords2d,
    line1_end: Coords2d,
    line2_start: Coords2d,
    line2_end: Coords2d,
    epsilon: f64,
) -> Option<Coords2d> {
    // First check if any endpoints are on the other segment
    if let Some(point) = is_point_on_line_segment(line1_start, line2_start, line2_end, epsilon) {
        return Some(point);
    }

    if let Some(point) = is_point_on_line_segment(line1_end, line2_start, line2_end, epsilon) {
        return Some(point);
    }

    if let Some(point) = is_point_on_line_segment(line2_start, line1_start, line1_end, epsilon) {
        return Some(point);
    }

    if let Some(point) = is_point_on_line_segment(line2_end, line1_start, line1_end, epsilon) {
        return Some(point);
    }

    // Then check for actual line segment intersection
    let x1 = line1_start.x;
    let y1 = line1_start.y;
    let x2 = line1_end.x;
    let y2 = line1_end.y;
    let x3 = line2_start.x;
    let y3 = line2_start.y;
    let x4 = line2_end.x;
    let y4 = line2_end.y;

    let denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
    if denominator.abs() < EPSILON_PARALLEL {
        // Lines are parallel
        return None;
    }

    let t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / denominator;
    let u = -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / denominator;

    // Check if intersection is within both segments
    if (0.0..=1.0).contains(&t) && (0.0..=1.0).contains(&u) {
        let x = x1 + t * (x2 - x1);
        let y = y1 + t * (y2 - y1);
        return Some(Coords2d { x, y });
    }

    None
}

/// Helper to calculate the parametric position of a point on a line segment
///
/// Returns t where t=0 at segmentStart, t=1 at segmentEnd.
/// t can be < 0 or > 1 if the point projects outside the segment.
pub fn project_point_onto_segment(point: Coords2d, segment_start: Coords2d, segment_end: Coords2d) -> f64 {
    let dx = segment_end.x - segment_start.x;
    let dy = segment_end.y - segment_start.y;
    let segment_length_sq = dx * dx + dy * dy;

    if segment_length_sq < EPSILON_PARALLEL {
        // Segment is degenerate
        return 0.0;
    }

    let point_dx = point.x - segment_start.x;
    let point_dy = point.y - segment_start.y;

    (point_dx * dx + point_dy * dy) / segment_length_sq
}

/// Helper to calculate the perpendicular distance from a point to a line segment
///
/// Returns the distance from the point to the closest point on the segment.
pub fn perpendicular_distance_to_segment(point: Coords2d, segment_start: Coords2d, segment_end: Coords2d) -> f64 {
    let dx = segment_end.x - segment_start.x;
    let dy = segment_end.y - segment_start.y;
    let segment_length_sq = dx * dx + dy * dy;

    if segment_length_sq < EPSILON_PARALLEL {
        // Segment is degenerate, return distance to point
        let dist_dx = point.x - segment_start.x;
        let dist_dy = point.y - segment_start.y;
        return (dist_dx * dist_dx + dist_dy * dist_dy).sqrt();
    }

    // Vector from segment start to point
    let point_dx = point.x - segment_start.x;
    let point_dy = point.y - segment_start.y;

    // Project point onto segment
    let t = (point_dx * dx + point_dy * dy) / segment_length_sq;

    // Clamp t to [0, 1] to get closest point on segment
    let clamped_t = t.clamp(0.0, 1.0);
    let closest_point = Coords2d {
        x: segment_start.x + clamped_t * dx,
        y: segment_start.y + clamped_t * dy,
    };

    // Calculate distance
    let dist_dx = point.x - closest_point.x;
    let dist_dy = point.y - closest_point.y;
    (dist_dx * dist_dx + dist_dy * dist_dy).sqrt()
}

/// Helper to check if a point is on an arc segment (CCW from start to end)
///
/// Returns true if the point is on the arc, false otherwise.
pub fn is_point_on_arc(point: Coords2d, center: Coords2d, start: Coords2d, end: Coords2d, epsilon: f64) -> bool {
    // Calculate radius
    let radius = ((start.x - center.x) * (start.x - center.x) + (start.y - center.y) * (start.y - center.y)).sqrt();

    // Check if point is on the circle (within epsilon)
    let dist_from_center =
        ((point.x - center.x) * (point.x - center.x) + (point.y - center.y) * (point.y - center.y)).sqrt();
    if (dist_from_center - radius).abs() > epsilon {
        return false;
    }

    // Calculate angles
    let start_angle = libm::atan2(start.y - center.y, start.x - center.x);
    let end_angle = libm::atan2(end.y - center.y, end.x - center.x);
    let point_angle = libm::atan2(point.y - center.y, point.x - center.x);

    // Normalize angles to [0, 2π]
    let normalize_angle = |angle: f64| -> f64 {
        if !angle.is_finite() {
            return angle;
        }
        let mut normalized = angle;
        while normalized < 0.0 {
            normalized += TAU;
        }
        while normalized >= TAU {
            normalized -= TAU;
        }
        normalized
    };

    let normalized_start = normalize_angle(start_angle);
    let normalized_end = normalize_angle(end_angle);
    let normalized_point = normalize_angle(point_angle);

    // Check if point is on the arc going CCW from start to end
    // Since arcs always travel CCW, we need to check if the point angle
    // is between start and end when going CCW
    if normalized_start < normalized_end {
        // No wrap around
        normalized_point >= normalized_start && normalized_point <= normalized_end
    } else {
        // Wrap around (e.g., start at 350°, end at 10°)
        normalized_point >= normalized_start || normalized_point <= normalized_end
    }
}

/// Helper to calculate intersection between a line segment and an arc
///
/// Returns the intersection point if found, None otherwise.
pub fn line_arc_intersection(
    line_start: Coords2d,
    line_end: Coords2d,
    arc_center: Coords2d,
    arc_start: Coords2d,
    arc_end: Coords2d,
    epsilon: f64,
) -> Option<Coords2d> {
    // Calculate radius
    let radius = ((arc_start.x - arc_center.x) * (arc_start.x - arc_center.x)
        + (arc_start.y - arc_center.y) * (arc_start.y - arc_center.y))
        .sqrt();

    // Translate line to origin (center at 0,0)
    let translated_line_start = Coords2d {
        x: line_start.x - arc_center.x,
        y: line_start.y - arc_center.y,
    };
    let translated_line_end = Coords2d {
        x: line_end.x - arc_center.x,
        y: line_end.y - arc_center.y,
    };

    // Line equation: p = lineStart + t * (lineEnd - lineStart)
    let dx = translated_line_end.x - translated_line_start.x;
    let dy = translated_line_end.y - translated_line_start.y;

    // Circle equation: x² + y² = r²
    // Substitute line equation into circle equation
    // (x0 + t*dx)² + (y0 + t*dy)² = r²
    // Expand: x0² + 2*x0*t*dx + t²*dx² + y0² + 2*y0*t*dy + t²*dy² = r²
    // Rearrange: t²*(dx² + dy²) + 2*t*(x0*dx + y0*dy) + (x0² + y0² - r²) = 0

    let a = dx * dx + dy * dy;
    let b = 2.0 * (translated_line_start.x * dx + translated_line_start.y * dy);
    let c = translated_line_start.x * translated_line_start.x + translated_line_start.y * translated_line_start.y
        - radius * radius;

    let discriminant = b * b - 4.0 * a * c;

    if discriminant < 0.0 {
        // No intersection
        return None;
    }

    if a.abs() < EPSILON_PARALLEL {
        // Line segment is degenerate
        let dist_from_center = (translated_line_start.x * translated_line_start.x
            + translated_line_start.y * translated_line_start.y)
            .sqrt();
        if (dist_from_center - radius).abs() <= epsilon {
            // Point is on circle, check if it's on the arc
            let point = line_start;
            if is_point_on_arc(point, arc_center, arc_start, arc_end, epsilon) {
                return Some(point);
            }
        }
        return None;
    }

    let sqrt_discriminant = discriminant.sqrt();
    let t1 = (-b - sqrt_discriminant) / (2.0 * a);
    let t2 = (-b + sqrt_discriminant) / (2.0 * a);

    // Check both intersection points
    let mut candidates: Vec<(f64, Coords2d)> = Vec::new();
    if (0.0..=1.0).contains(&t1) {
        let point = Coords2d {
            x: line_start.x + t1 * (line_end.x - line_start.x),
            y: line_start.y + t1 * (line_end.y - line_start.y),
        };
        candidates.push((t1, point));
    }
    if (0.0..=1.0).contains(&t2) && (t2 - t1).abs() > epsilon {
        let point = Coords2d {
            x: line_start.x + t2 * (line_end.x - line_start.x),
            y: line_start.y + t2 * (line_end.y - line_start.y),
        };
        candidates.push((t2, point));
    }

    // Check which candidates are on the arc
    for (_t, point) in candidates {
        if is_point_on_arc(point, arc_center, arc_start, arc_end, epsilon) {
            return Some(point);
        }
    }

    None
}

/// Helper to calculate the parametric position of a point on an arc
/// Returns t where t=0 at start, t=1 at end, based on CCW angle
pub fn project_point_onto_arc(point: Coords2d, arc_center: Coords2d, arc_start: Coords2d, arc_end: Coords2d) -> f64 {
    // Calculate angles
    let start_angle = libm::atan2(arc_start.y - arc_center.y, arc_start.x - arc_center.x);
    let end_angle = libm::atan2(arc_end.y - arc_center.y, arc_end.x - arc_center.x);
    let point_angle = libm::atan2(point.y - arc_center.y, point.x - arc_center.x);

    // Normalize angles to [0, 2π]
    let normalize_angle = |angle: f64| -> f64 {
        if !angle.is_finite() {
            return angle;
        }
        let mut normalized = angle;
        while normalized < 0.0 {
            normalized += TAU;
        }
        while normalized >= TAU {
            normalized -= TAU;
        }
        normalized
    };

    let normalized_start = normalize_angle(start_angle);
    let normalized_end = normalize_angle(end_angle);
    let normalized_point = normalize_angle(point_angle);

    // Calculate arc length (CCW)
    let arc_length = if normalized_start < normalized_end {
        normalized_end - normalized_start
    } else {
        // Wrap around
        TAU - normalized_start + normalized_end
    };

    if arc_length < EPSILON_PARALLEL {
        // Arc is degenerate (full circle or very small)
        return 0.0;
    }

    // Calculate point's position along arc (CCW from start)
    let point_arc_length = if normalized_start < normalized_end {
        if normalized_point >= normalized_start && normalized_point <= normalized_end {
            normalized_point - normalized_start
        } else {
            // Point is not on the arc, return closest endpoint
            let dist_to_start = (normalized_point - normalized_start)
                .abs()
                .min(TAU - (normalized_point - normalized_start).abs());
            let dist_to_end = (normalized_point - normalized_end)
                .abs()
                .min(TAU - (normalized_point - normalized_end).abs());
            return if dist_to_start < dist_to_end { 0.0 } else { 1.0 };
        }
    } else {
        // Wrap around case
        if normalized_point >= normalized_start || normalized_point <= normalized_end {
            if normalized_point >= normalized_start {
                normalized_point - normalized_start
            } else {
                TAU - normalized_start + normalized_point
            }
        } else {
            // Point is not on the arc
            let dist_to_start = (normalized_point - normalized_start)
                .abs()
                .min(TAU - (normalized_point - normalized_start).abs());
            let dist_to_end = (normalized_point - normalized_end)
                .abs()
                .min(TAU - (normalized_point - normalized_end).abs());
            return if dist_to_start < dist_to_end { 0.0 } else { 1.0 };
        }
    };

    // Return parametric position
    point_arc_length / arc_length
}

/// Helper to calculate intersection between two arcs (via circle-circle intersection)
pub fn arc_arc_intersection(
    arc1_center: Coords2d,
    arc1_start: Coords2d,
    arc1_end: Coords2d,
    arc2_center: Coords2d,
    arc2_start: Coords2d,
    arc2_end: Coords2d,
    epsilon: f64,
) -> Option<Coords2d> {
    // Calculate radii
    let r1 = ((arc1_start.x - arc1_center.x) * (arc1_start.x - arc1_center.x)
        + (arc1_start.y - arc1_center.y) * (arc1_start.y - arc1_center.y))
        .sqrt();
    let r2 = ((arc2_start.x - arc2_center.x) * (arc2_start.x - arc2_center.x)
        + (arc2_start.y - arc2_center.y) * (arc2_start.y - arc2_center.y))
        .sqrt();

    // Distance between centers
    let dx = arc2_center.x - arc1_center.x;
    let dy = arc2_center.y - arc1_center.y;
    let d = (dx * dx + dy * dy).sqrt();

    // Check if circles intersect
    if d > r1 + r2 + epsilon || d < (r1 - r2).abs() - epsilon {
        // No intersection
        return None;
    }

    // Check for degenerate cases
    if d < EPSILON_PARALLEL {
        // Concentric circles - no intersection (or infinite if same radius, but we treat as none)
        return None;
    }

    // Calculate intersection points
    // Using the formula from: https://mathworld.wolfram.com/Circle-CircleIntersection.html
    let a = (r1 * r1 - r2 * r2 + d * d) / (2.0 * d);
    let h_sq = r1 * r1 - a * a;

    // If h_sq is negative, no intersection
    if h_sq < 0.0 {
        return None;
    }

    let h = h_sq.sqrt();

    // If h is NaN, no intersection
    if h.is_nan() {
        return None;
    }

    // Unit vector from arc1Center to arc2Center
    let ux = dx / d;
    let uy = dy / d;

    // Perpendicular vector (rotated 90 degrees)
    let px = -uy;
    let py = ux;

    // Midpoint on the line connecting centers
    let mid_point = Coords2d {
        x: arc1_center.x + a * ux,
        y: arc1_center.y + a * uy,
    };

    // Two intersection points
    let intersection1 = Coords2d {
        x: mid_point.x + h * px,
        y: mid_point.y + h * py,
    };
    let intersection2 = Coords2d {
        x: mid_point.x - h * px,
        y: mid_point.y - h * py,
    };

    // Check which intersection point(s) are on both arcs
    let mut candidates: Vec<Coords2d> = Vec::new();

    if is_point_on_arc(intersection1, arc1_center, arc1_start, arc1_end, epsilon)
        && is_point_on_arc(intersection1, arc2_center, arc2_start, arc2_end, epsilon)
    {
        candidates.push(intersection1);
    }

    if (intersection1.x - intersection2.x).abs() > epsilon || (intersection1.y - intersection2.y).abs() > epsilon {
        // Only check second point if it's different from the first
        if is_point_on_arc(intersection2, arc1_center, arc1_start, arc1_end, epsilon)
            && is_point_on_arc(intersection2, arc2_center, arc2_start, arc2_end, epsilon)
        {
            candidates.push(intersection2);
        }
    }

    // Return the first valid intersection (or None if none)
    candidates.first().copied()
}

/// Helper to extract coordinates from a point object in JSON format
// Native type helper - get point coordinates from ObjectId
fn get_point_coords_from_native(objects: &[Object], point_id: ObjectId, default_unit: UnitLength) -> Option<Coords2d> {
    let point_obj = objects.get(point_id.0)?;

    // Check if it's a Point segment
    let ObjectKind::Segment { segment } = &point_obj.kind else {
        return None;
    };

    let Segment::Point(point) = segment else {
        return None;
    };

    // Extract position coordinates in the trim internal unit
    Some(Coords2d {
        x: number_to_unit(&point.position.x, default_unit),
        y: number_to_unit(&point.position.y, default_unit),
    })
}

// Legacy JSON helper (will be removed)
/// Helper to get point coordinates from a Line segment by looking up the point object (native types)
pub fn get_position_coords_for_line(
    segment_obj: &Object,
    which: LineEndpoint,
    objects: &[Object],
    default_unit: UnitLength,
) -> Option<Coords2d> {
    let ObjectKind::Segment { segment } = &segment_obj.kind else {
        return None;
    };

    let Segment::Line(line) = segment else {
        return None;
    };

    // Get the point ID from the segment
    let point_id = match which {
        LineEndpoint::Start => line.start,
        LineEndpoint::End => line.end,
    };

    get_point_coords_from_native(objects, point_id, default_unit)
}

/// Helper to check if a point is coincident with a segment (line or arc) via constraints (native types)
fn is_point_coincident_with_segment_native(point_id: ObjectId, segment_id: ObjectId, objects: &[Object]) -> bool {
    // Find coincident constraints
    for obj in objects {
        let ObjectKind::Constraint { constraint } = &obj.kind else {
            continue;
        };

        let Constraint::Coincident(coincident) = constraint else {
            continue;
        };

        // Check if both pointId and segmentId are in the segments array
        let has_point = coincident.segments.contains(&point_id);
        let has_segment = coincident.segments.contains(&segment_id);

        if has_point && has_segment {
            return true;
        }
    }
    false
}

/// Helper to get point coordinates from an Arc segment by looking up the point object (native types)
pub fn get_position_coords_from_arc(
    segment_obj: &Object,
    which: ArcPoint,
    objects: &[Object],
    default_unit: UnitLength,
) -> Option<Coords2d> {
    let ObjectKind::Segment { segment } = &segment_obj.kind else {
        return None;
    };

    let Segment::Arc(arc) = segment else {
        return None;
    };

    // Get the point ID from the segment
    let point_id = match which {
        ArcPoint::Start => arc.start,
        ArcPoint::End => arc.end,
        ArcPoint::Center => arc.center,
    };

    get_point_coords_from_native(objects, point_id, default_unit)
}

/// Find the next trim spawn (intersection) between trim line and scene segments
///
/// When a user draws a trim line, we loop over each pairs of points of the trim line,
/// until we find an intersection, this intersection is called the trim spawn (to differentiate from
/// segment-segment intersections which are also important for trimming).
/// Below the dashes are segments and the periods are points on the trim line.
///
/// ```
///          /
///         /
///        /    .
/// ------/-------x--------
///      /       .       
///     /       .       
///    /           .   
/// ```
///
/// When we find a trim spawn we stop looping but save the index as we process each trim spawn one at a time.
/// The loop that processes each spawn one at a time is managed by `execute_trim_loop` (or `execute_trim_loop_with_context`).
///
/// Loops through polyline segments starting from startIndex and checks for intersections
/// with all scene segments (both Line and Arc). Returns the first intersection found.
///
/// **Units:** Trim line points are expected in millimeters at the API boundary. Callers should
/// normalize points to the current/default length unit before calling this function (the
/// trim loop does this for you). Segment positions read from `objects` are converted to that same
/// unit internally.
pub fn get_next_trim_spawn(
    points: &[Coords2d],
    start_index: usize,
    objects: &[Object],
    default_unit: UnitLength,
) -> TrimItem {
    // Loop through polyline segments starting from startIndex
    for i in start_index..points.len().saturating_sub(1) {
        let p1 = points[i];
        let p2 = points[i + 1];

        // Check this polyline segment against all scene segments
        for obj in objects.iter() {
            // Check if it's a Segment
            let ObjectKind::Segment { segment } = &obj.kind else {
                continue;
            };

            // Handle Line segments
            if let Segment::Line(_line) = segment {
                let start_point = get_position_coords_for_line(obj, LineEndpoint::Start, objects, default_unit);
                let end_point = get_position_coords_for_line(obj, LineEndpoint::End, objects, default_unit);

                if let (Some(start), Some(end)) = (start_point, end_point)
                    && let Some(intersection) = line_segment_intersection(p1, p2, start, end, EPSILON_POINT_ON_SEGMENT)
                {
                    // Get segment ID from object
                    let seg_id = obj.id;

                    return TrimItem::Spawn {
                        trim_spawn_seg_id: seg_id,
                        trim_spawn_coords: intersection,
                        next_index: i, // Return current index to re-check same polyline segment
                    };
                }
            }

            // Handle Arc segments
            if let Segment::Arc(_arc) = segment {
                let center_point = get_position_coords_from_arc(obj, ArcPoint::Center, objects, default_unit);
                let start_point = get_position_coords_from_arc(obj, ArcPoint::Start, objects, default_unit);
                let end_point = get_position_coords_from_arc(obj, ArcPoint::End, objects, default_unit);

                if let (Some(center), Some(start), Some(end)) = (center_point, start_point, end_point)
                    && let Some(intersection) =
                        line_arc_intersection(p1, p2, center, start, end, EPSILON_POINT_ON_SEGMENT)
                {
                    // Get segment ID from object
                    let seg_id = obj.id;

                    return TrimItem::Spawn {
                        trim_spawn_seg_id: seg_id,
                        trim_spawn_coords: intersection,
                        next_index: i, // Return current index to re-check same polyline segment
                    };
                }
            }
        }
    }

    // No intersection found
    TrimItem::None {
        next_index: points.len().saturating_sub(1),
    }
}

/**
 * For the trim spawn segment and the intersection point on that segment,
 * finds the "trim terminations" in both directions (left and right from the intersection point).
 * A trim termination is the point where trimming should stop in each direction.
 *
 * The function searches for candidates in each direction and selects the closest one,
 * with the following priority when distances are equal: coincident > intersection > endpoint.
 *
 * ## segEndPoint: The segment's own endpoint
 *
 *   ========0
 * OR
 *   ========0
 *            \
 *             \
 *
 *  Returns this when:
 *  - No other candidates are found between the intersection point and the segment end
 *  - An intersection is found at the segment's own endpoint (even if due to numerical precision)
 *  - An intersection is found at another segment's endpoint (without a coincident constraint)
 *  - The closest candidate is the segment's own endpoint
 *
 * ## intersection: Intersection with another segment's body
 *            /
 *           /
 *  ========X=====
 *         /
 *        /
 *
 *  Returns this when:
 *  - A geometric intersection is found with another segment's body (not at an endpoint)
 *  - The intersection is not at our own segment's endpoint
 *  - The intersection is not at the other segment's endpoint (which would be segEndPoint)
 *
 * ## trimSpawnSegmentCoincidentWithAnotherSegmentPoint: Another segment's endpoint coincident with our segment
 *
 *  ========0=====
 *         /
 *        /
 *
 *  Returns this when:
 *  - Another segment's endpoint has a coincident constraint with our trim spawn segment
 *  - The endpoint's perpendicular distance to our segment is within epsilon
 *  - The endpoint is geometrically on our segment (between start and end)
 *  - This takes priority over intersections when distances are equal (within epsilon)
 *
 * ## Fallback
 *  If no candidates are found in a direction, defaults to "segEndPoint".
 * */
/// Find trim terminations for both sides of a trim spawn
///
/// For the trim spawn segment and the intersection point on that segment,
/// finds the "trim terminations" in both directions (left and right from the intersection point).
/// A trim termination is the point where trimming should stop in each direction.
pub fn get_trim_spawn_terminations(
    trim_spawn_seg_id: ObjectId,
    trim_spawn_coords: &[Coords2d],
    objects: &[Object],
    default_unit: UnitLength,
) -> Result<TrimTerminations, String> {
    // Find the trim spawn segment
    let trim_spawn_seg = objects.iter().find(|obj| obj.id == trim_spawn_seg_id);

    let trim_spawn_seg = match trim_spawn_seg {
        Some(seg) => seg,
        None => {
            return Err(format!("Trim spawn segment {} not found", trim_spawn_seg_id.0));
        }
    };

    // Get segment coordinates using native types
    let ObjectKind::Segment { segment } = &trim_spawn_seg.kind else {
        return Err(format!("Trim spawn segment {} is not a segment", trim_spawn_seg_id.0));
    };

    let (segment_start, segment_end, segment_center) = match segment {
        Segment::Line(_) => {
            let start = get_position_coords_for_line(trim_spawn_seg, LineEndpoint::Start, objects, default_unit)
                .ok_or_else(|| {
                    format!(
                        "Could not get start coordinates for line segment {}",
                        trim_spawn_seg_id.0
                    )
                })?;
            let end = get_position_coords_for_line(trim_spawn_seg, LineEndpoint::End, objects, default_unit)
                .ok_or_else(|| format!("Could not get end coordinates for line segment {}", trim_spawn_seg_id.0))?;
            (start, end, None)
        }
        Segment::Arc(_) => {
            let start = get_position_coords_from_arc(trim_spawn_seg, ArcPoint::Start, objects, default_unit)
                .ok_or_else(|| {
                    format!(
                        "Could not get start coordinates for arc segment {}",
                        trim_spawn_seg_id.0
                    )
                })?;
            let end = get_position_coords_from_arc(trim_spawn_seg, ArcPoint::End, objects, default_unit)
                .ok_or_else(|| format!("Could not get end coordinates for arc segment {}", trim_spawn_seg_id.0))?;
            let center = get_position_coords_from_arc(trim_spawn_seg, ArcPoint::Center, objects, default_unit)
                .ok_or_else(|| {
                    format!(
                        "Could not get center coordinates for arc segment {}",
                        trim_spawn_seg_id.0
                    )
                })?;
            (start, end, Some(center))
        }
        _ => {
            return Err(format!(
                "Trim spawn segment {} is not a Line or Arc",
                trim_spawn_seg_id.0
            ));
        }
    };

    // Find intersection point between polyline and trim spawn segment
    // trimSpawnCoords is a polyline, so we check each segment
    // We need to find ALL intersections and use a consistent one to avoid
    // different results for different trim lines in the same area
    let mut all_intersections: Vec<(Coords2d, usize)> = Vec::new();

    for i in 0..trim_spawn_coords.len().saturating_sub(1) {
        let p1 = trim_spawn_coords[i];
        let p2 = trim_spawn_coords[i + 1];

        match segment {
            Segment::Line(_) => {
                if let Some(intersection) =
                    line_segment_intersection(p1, p2, segment_start, segment_end, EPSILON_POINT_ON_SEGMENT)
                {
                    all_intersections.push((intersection, i));
                }
            }
            Segment::Arc(_) => {
                if let Some(center) = segment_center
                    && let Some(intersection) =
                        line_arc_intersection(p1, p2, center, segment_start, segment_end, EPSILON_POINT_ON_SEGMENT)
                {
                    all_intersections.push((intersection, i));
                }
            }
            Segment::Point(_) | Segment::Circle(_) => {
                // Points and circles don't have intersections with line segments in the trim context
            }
        }
    }

    // Use the intersection that's closest to the middle of the polyline
    // This ensures consistent results regardless of which segment intersects first
    let intersection_point = if all_intersections.is_empty() {
        return Err("Could not find intersection point between polyline and trim spawn segment".to_string());
    } else {
        // Find the middle of the polyline
        let mid_index = (trim_spawn_coords.len() - 1) / 2;
        let mid_point = trim_spawn_coords[mid_index];

        // Find the intersection closest to the middle
        let mut min_dist = f64::INFINITY;
        let mut closest_intersection = all_intersections[0].0;

        for (intersection, _) in &all_intersections {
            let dist = ((intersection.x - mid_point.x) * (intersection.x - mid_point.x)
                + (intersection.y - mid_point.y) * (intersection.y - mid_point.y))
                .sqrt();
            if dist < min_dist {
                min_dist = dist;
                closest_intersection = *intersection;
            }
        }

        closest_intersection
    };

    // Project intersection point onto segment to get parametric position
    let intersection_t = match segment {
        Segment::Line(_) => project_point_onto_segment(intersection_point, segment_start, segment_end),
        Segment::Arc(_) => {
            if let Some(center) = segment_center {
                project_point_onto_arc(intersection_point, center, segment_start, segment_end)
            } else {
                return Err("Arc segment missing center".to_string());
            }
        }
        _ => {
            return Err("Invalid segment type for trim spawn".to_string());
        }
    };

    // Find terminations on both sides
    let left_termination = find_termination_in_direction(
        trim_spawn_seg,
        intersection_point,
        intersection_t,
        TrimDirection::Left,
        objects,
        SegmentGeometry {
            start: segment_start,
            end: segment_end,
            center: segment_center,
        },
        default_unit,
    )?;

    let right_termination = find_termination_in_direction(
        trim_spawn_seg,
        intersection_point,
        intersection_t,
        TrimDirection::Right,
        objects,
        SegmentGeometry {
            start: segment_start,
            end: segment_end,
            center: segment_center,
        },
        default_unit,
    )?;

    Ok(TrimTerminations {
        left_side: left_termination,
        right_side: right_termination,
    })
}

/// Segment geometry information
#[derive(Debug, Clone, Copy)]
struct SegmentGeometry {
    start: Coords2d,
    end: Coords2d,
    center: Option<Coords2d>,
}

/// Helper to find trim termination in a given direction from the intersection point
///
/// This is called by `get_trim_spawn_terminations` for each direction (left and right).
/// It searches for candidates in the specified direction and selects the closest one,
/// with the following priority when distances are equal: coincident > intersection > endpoint.
///
/// ## segEndPoint: The segment's own endpoint
///
/// ```
///   ========0
/// OR
///   ========0
///            \
///             \
/// ```
///
/// Returns this when:
/// - No other candidates are found between the intersection point and the segment end
/// - An intersection is found at the segment's own endpoint (even if due to numerical precision)
/// - An intersection is found at another segment's endpoint (without a coincident constraint)
/// - The closest candidate is the segment's own endpoint
///
/// ## intersection: Intersection with another segment's body
/// ```
///            /
///           /
///  ========X=====
///         /
///        /
/// ```
///
/// Returns this when:
/// - A geometric intersection is found with another segment's body (not at an endpoint)
/// - The intersection is not at our own segment's endpoint
/// - The intersection is not at the other segment's endpoint (which would be segEndPoint)
///
/// ## trimSpawnSegmentCoincidentWithAnotherSegmentPoint: Another segment's endpoint coincident with our segment
///
/// ```
///  ========0=====
///         /
///        /
/// ```
///
/// Returns this when:
/// - Another segment's endpoint has a coincident constraint with our trim spawn segment
/// - The endpoint's perpendicular distance to our segment is within epsilon
/// - The endpoint is geometrically on our segment (between start and end)
/// - This takes priority over intersections when distances are equal (within epsilon)
///
/// ## Fallback
/// If no candidates are found in a direction, defaults to "segEndPoint".
fn find_termination_in_direction(
    trim_spawn_seg: &Object,
    _intersection_point: Coords2d,
    intersection_t: f64,
    direction: TrimDirection,
    objects: &[Object],
    segment_geometry: SegmentGeometry,
    default_unit: UnitLength,
) -> Result<TrimTermination, String> {
    // Use native types
    let ObjectKind::Segment { segment } = &trim_spawn_seg.kind else {
        return Err("Trim spawn segment is not a segment".to_string());
    };

    // Collect all candidate points: intersections, coincident points, and endpoints
    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
    enum CandidateType {
        Intersection,
        Coincident,
        Endpoint,
    }

    #[derive(Debug, Clone)]
    struct Candidate {
        t: f64,
        point: Coords2d,
        candidate_type: CandidateType,
        segment_id: Option<ObjectId>,
        point_id: Option<ObjectId>,
    }

    let mut candidates: Vec<Candidate> = Vec::new();

    // Add segment endpoints using native types
    match segment {
        Segment::Line(line) => {
            candidates.push(Candidate {
                t: 0.0,
                point: segment_geometry.start,
                candidate_type: CandidateType::Endpoint,
                segment_id: None,
                point_id: Some(line.start),
            });
            candidates.push(Candidate {
                t: 1.0,
                point: segment_geometry.end,
                candidate_type: CandidateType::Endpoint,
                segment_id: None,
                point_id: Some(line.end),
            });
        }
        Segment::Arc(arc) => {
            // For arcs, endpoints are at t=0 and t=1 conceptually
            candidates.push(Candidate {
                t: 0.0,
                point: segment_geometry.start,
                candidate_type: CandidateType::Endpoint,
                segment_id: None,
                point_id: Some(arc.start),
            });
            candidates.push(Candidate {
                t: 1.0,
                point: segment_geometry.end,
                candidate_type: CandidateType::Endpoint,
                segment_id: None,
                point_id: Some(arc.end),
            });
        }
        _ => {}
    }

    // Get trim spawn segment ID for comparison
    let trim_spawn_seg_id = trim_spawn_seg.id;

    // Find intersections with other segments using native types
    for other_seg in objects.iter() {
        // Skip if same segment or not a segment
        let other_id = other_seg.id;

        if other_id == trim_spawn_seg_id {
            continue;
        }

        let ObjectKind::Segment { segment: other_segment } = &other_seg.kind else {
            continue;
        };

        // Handle Line-Line, Line-Arc, Arc-Line, Arc-Arc intersections
        match other_segment {
            Segment::Line(_) => {
                let other_start = get_position_coords_for_line(other_seg, LineEndpoint::Start, objects, default_unit);
                let other_end = get_position_coords_for_line(other_seg, LineEndpoint::End, objects, default_unit);
                if let (Some(os), Some(oe)) = (other_start, other_end) {
                    match segment {
                        Segment::Line(_) => {
                            if let Some(intersection) = line_segment_intersection(
                                segment_geometry.start,
                                segment_geometry.end,
                                os,
                                oe,
                                EPSILON_POINT_ON_SEGMENT,
                            ) {
                                let t = project_point_onto_segment(
                                    intersection,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                );
                                candidates.push(Candidate {
                                    t,
                                    point: intersection,
                                    candidate_type: CandidateType::Intersection,
                                    segment_id: Some(other_id),
                                    point_id: None,
                                });
                            }
                        }
                        Segment::Arc(_) => {
                            if let Some(center) = segment_geometry.center
                                && let Some(intersection) = line_arc_intersection(
                                    os,
                                    oe,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                    EPSILON_POINT_ON_SEGMENT,
                                )
                            {
                                let t = project_point_onto_arc(
                                    intersection,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                );
                                candidates.push(Candidate {
                                    t,
                                    point: intersection,
                                    candidate_type: CandidateType::Intersection,
                                    segment_id: Some(other_id),
                                    point_id: None,
                                });
                            }
                        }
                        _ => {}
                    }
                }
            }
            Segment::Arc(_) => {
                let other_start = get_position_coords_from_arc(other_seg, ArcPoint::Start, objects, default_unit);
                let other_end = get_position_coords_from_arc(other_seg, ArcPoint::End, objects, default_unit);
                let other_center = get_position_coords_from_arc(other_seg, ArcPoint::Center, objects, default_unit);
                if let (Some(os), Some(oe), Some(oc)) = (other_start, other_end, other_center) {
                    match segment {
                        Segment::Line(_) => {
                            if let Some(intersection) = line_arc_intersection(
                                segment_geometry.start,
                                segment_geometry.end,
                                oc,
                                os,
                                oe,
                                EPSILON_POINT_ON_SEGMENT,
                            ) {
                                let t = project_point_onto_segment(
                                    intersection,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                );
                                candidates.push(Candidate {
                                    t,
                                    point: intersection,
                                    candidate_type: CandidateType::Intersection,
                                    segment_id: Some(other_id),
                                    point_id: None,
                                });
                            }
                        }
                        Segment::Arc(_) => {
                            if let Some(center) = segment_geometry.center
                                && let Some(intersection) = arc_arc_intersection(
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                    oc,
                                    os,
                                    oe,
                                    EPSILON_POINT_ON_SEGMENT,
                                )
                            {
                                let t = project_point_onto_arc(
                                    intersection,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                );
                                candidates.push(Candidate {
                                    t,
                                    point: intersection,
                                    candidate_type: CandidateType::Intersection,
                                    segment_id: Some(other_id),
                                    point_id: None,
                                });
                            }
                        }
                        _ => {}
                    }
                }
            }
            _ => {}
        }

        // Check for coincident points (check BEFORE intersections for priority)
        // Check Line segment endpoints
        match other_segment {
            Segment::Line(line) => {
                let other_start_id = line.start;
                let other_end_id = line.end;

                // Check if other segment's start endpoint is coincident with trim spawn segment
                if is_point_coincident_with_segment_native(other_start_id, trim_spawn_seg_id, objects)
                    && let Some(other_start) =
                        get_position_coords_for_line(other_seg, LineEndpoint::Start, objects, default_unit)
                {
                    let (t, is_on_segment) = match segment {
                        Segment::Line(_) => {
                            let t =
                                project_point_onto_segment(other_start, segment_geometry.start, segment_geometry.end);
                            let is_on = (0.0..=1.0).contains(&t)
                                && perpendicular_distance_to_segment(
                                    other_start,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                ) <= EPSILON_POINT_ON_SEGMENT;
                            (t, is_on)
                        }
                        Segment::Arc(_) => {
                            if let Some(center) = segment_geometry.center {
                                let t = project_point_onto_arc(
                                    other_start,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                );
                                let is_on = is_point_on_arc(
                                    other_start,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                    EPSILON_POINT_ON_SEGMENT,
                                );
                                (t, is_on)
                            } else {
                                continue;
                            }
                        }
                        _ => continue,
                    };

                    if is_on_segment {
                        candidates.push(Candidate {
                            t,
                            point: other_start,
                            candidate_type: CandidateType::Coincident,
                            segment_id: Some(other_id),
                            point_id: Some(other_start_id),
                        });
                    }
                }

                // Check if other segment's end endpoint is coincident with trim spawn segment
                if is_point_coincident_with_segment_native(other_end_id, trim_spawn_seg_id, objects)
                    && let Some(other_end) =
                        get_position_coords_for_line(other_seg, LineEndpoint::End, objects, default_unit)
                {
                    let (t, is_on_segment) = match segment {
                        Segment::Line(_) => {
                            let t = project_point_onto_segment(other_end, segment_geometry.start, segment_geometry.end);
                            let is_on = (0.0..=1.0).contains(&t)
                                && perpendicular_distance_to_segment(
                                    other_end,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                ) <= EPSILON_POINT_ON_SEGMENT;
                            (t, is_on)
                        }
                        Segment::Arc(_) => {
                            if let Some(center) = segment_geometry.center {
                                let t = project_point_onto_arc(
                                    other_end,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                );
                                let is_on = is_point_on_arc(
                                    other_end,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                    EPSILON_POINT_ON_SEGMENT,
                                );
                                (t, is_on)
                            } else {
                                continue;
                            }
                        }
                        _ => continue,
                    };

                    if is_on_segment {
                        candidates.push(Candidate {
                            t,
                            point: other_end,
                            candidate_type: CandidateType::Coincident,
                            segment_id: Some(other_id),
                            point_id: Some(other_end_id),
                        });
                    }
                }
            }
            Segment::Arc(arc) => {
                let other_start_id = arc.start;
                let other_end_id = arc.end;

                // Check if other segment's start endpoint is coincident with trim spawn segment
                if is_point_coincident_with_segment_native(other_start_id, trim_spawn_seg_id, objects)
                    && let Some(other_start) =
                        get_position_coords_from_arc(other_seg, ArcPoint::Start, objects, default_unit)
                {
                    let (t, is_on_segment) = match segment {
                        Segment::Line(_) => {
                            let t =
                                project_point_onto_segment(other_start, segment_geometry.start, segment_geometry.end);
                            let is_on = (0.0..=1.0).contains(&t)
                                && perpendicular_distance_to_segment(
                                    other_start,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                ) <= EPSILON_POINT_ON_SEGMENT;
                            (t, is_on)
                        }
                        Segment::Arc(_) => {
                            if let Some(center) = segment_geometry.center {
                                let t = project_point_onto_arc(
                                    other_start,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                );
                                let is_on = is_point_on_arc(
                                    other_start,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                    EPSILON_POINT_ON_SEGMENT,
                                );
                                (t, is_on)
                            } else {
                                continue;
                            }
                        }
                        _ => continue,
                    };

                    if is_on_segment {
                        candidates.push(Candidate {
                            t,
                            point: other_start,
                            candidate_type: CandidateType::Coincident,
                            segment_id: Some(other_id),
                            point_id: Some(other_start_id),
                        });
                    }
                }

                // Check if other segment's end endpoint is coincident with trim spawn segment
                if is_point_coincident_with_segment_native(other_end_id, trim_spawn_seg_id, objects)
                    && let Some(other_end) =
                        get_position_coords_from_arc(other_seg, ArcPoint::End, objects, default_unit)
                {
                    let (t, is_on_segment) = match segment {
                        Segment::Line(_) => {
                            let t = project_point_onto_segment(other_end, segment_geometry.start, segment_geometry.end);
                            let is_on = (0.0..=1.0).contains(&t)
                                && perpendicular_distance_to_segment(
                                    other_end,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                ) <= EPSILON_POINT_ON_SEGMENT;
                            (t, is_on)
                        }
                        Segment::Arc(_) => {
                            if let Some(center) = segment_geometry.center {
                                let t = project_point_onto_arc(
                                    other_end,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                );
                                let is_on = is_point_on_arc(
                                    other_end,
                                    center,
                                    segment_geometry.start,
                                    segment_geometry.end,
                                    EPSILON_POINT_ON_SEGMENT,
                                );
                                (t, is_on)
                            } else {
                                continue;
                            }
                        }
                        _ => continue,
                    };

                    if is_on_segment {
                        candidates.push(Candidate {
                            t,
                            point: other_end,
                            candidate_type: CandidateType::Coincident,
                            segment_id: Some(other_id),
                            point_id: Some(other_end_id),
                        });
                    }
                }
            }
            _ => {}
        }
    }

    // Filter candidates to exclude the intersection point itself and those on the wrong side
    // Use a slightly larger epsilon to account for numerical precision variations
    let intersection_epsilon = EPSILON_POINT_ON_SEGMENT * 10.0; // 0.0001mm
    let filtered_candidates: Vec<Candidate> = candidates
        .into_iter()
        .filter(|candidate| {
            let dist_from_intersection = (candidate.t - intersection_t).abs();
            if dist_from_intersection < intersection_epsilon {
                return false; // Too close to intersection point
            }

            match direction {
                TrimDirection::Left => candidate.t < intersection_t,
                TrimDirection::Right => candidate.t > intersection_t,
            }
        })
        .collect();

    // Sort candidates by distance from intersection (closest first)
    // When distances are equal, prioritize: coincident > intersection > endpoint
    let mut sorted_candidates = filtered_candidates;
    sorted_candidates.sort_by(|a, b| {
        let dist_a = (a.t - intersection_t).abs();
        let dist_b = (b.t - intersection_t).abs();
        let dist_diff = dist_a - dist_b;
        if dist_diff.abs() > EPSILON_POINT_ON_SEGMENT {
            dist_diff.partial_cmp(&0.0).unwrap_or(std::cmp::Ordering::Equal)
        } else {
            // Distances are effectively equal - prioritize by type
            let type_priority = |candidate_type: CandidateType| -> i32 {
                match candidate_type {
                    CandidateType::Coincident => 0,
                    CandidateType::Intersection => 1,
                    CandidateType::Endpoint => 2,
                }
            };
            type_priority(a.candidate_type).cmp(&type_priority(b.candidate_type))
        }
    });

    // Find the first valid trim termination
    let closest_candidate = match sorted_candidates.first() {
        Some(c) => c,
        None => {
            // No trim termination found, default to segment endpoint
            let endpoint = match direction {
                TrimDirection::Left => segment_geometry.start,
                TrimDirection::Right => segment_geometry.end,
            };
            return Ok(TrimTermination::SegEndPoint {
                trim_termination_coords: endpoint,
            });
        }
    };

    // Check if the closest candidate is an intersection that is actually another segment's endpoint
    // According to test case: if another segment's endpoint is on our segment (even without coincident constraint),
    // we should return segEndPoint, not intersection
    if closest_candidate.candidate_type == CandidateType::Intersection
        && let Some(seg_id) = closest_candidate.segment_id
    {
        let intersecting_seg = objects.iter().find(|obj| obj.id == seg_id);

        if let Some(intersecting_seg) = intersecting_seg {
            let mut is_other_seg_endpoint = false;
            // Use a larger epsilon for checking if intersection is at another segment's endpoint
            let endpoint_epsilon = EPSILON_POINT_ON_SEGMENT * 1000.0; // 0.001mm

            if let ObjectKind::Segment { segment: other_segment } = &intersecting_seg.kind {
                match other_segment {
                    Segment::Line(_) => {
                        if let (Some(other_start), Some(other_end)) = (
                            get_position_coords_for_line(intersecting_seg, LineEndpoint::Start, objects, default_unit),
                            get_position_coords_for_line(intersecting_seg, LineEndpoint::End, objects, default_unit),
                        ) {
                            let dist_to_start = ((closest_candidate.point.x - other_start.x)
                                * (closest_candidate.point.x - other_start.x)
                                + (closest_candidate.point.y - other_start.y)
                                    * (closest_candidate.point.y - other_start.y))
                                .sqrt();
                            let dist_to_end = ((closest_candidate.point.x - other_end.x)
                                * (closest_candidate.point.x - other_end.x)
                                + (closest_candidate.point.y - other_end.y)
                                    * (closest_candidate.point.y - other_end.y))
                                .sqrt();
                            is_other_seg_endpoint = dist_to_start < endpoint_epsilon || dist_to_end < endpoint_epsilon;
                        }
                    }
                    Segment::Arc(_) => {
                        if let (Some(other_start), Some(other_end)) = (
                            get_position_coords_from_arc(intersecting_seg, ArcPoint::Start, objects, default_unit),
                            get_position_coords_from_arc(intersecting_seg, ArcPoint::End, objects, default_unit),
                        ) {
                            let dist_to_start = ((closest_candidate.point.x - other_start.x)
                                * (closest_candidate.point.x - other_start.x)
                                + (closest_candidate.point.y - other_start.y)
                                    * (closest_candidate.point.y - other_start.y))
                                .sqrt();
                            let dist_to_end = ((closest_candidate.point.x - other_end.x)
                                * (closest_candidate.point.x - other_end.x)
                                + (closest_candidate.point.y - other_end.y)
                                    * (closest_candidate.point.y - other_end.y))
                                .sqrt();
                            is_other_seg_endpoint = dist_to_start < endpoint_epsilon || dist_to_end < endpoint_epsilon;
                        }
                    }
                    _ => {}
                }
            }

            // If the intersection point is another segment's endpoint (even without coincident constraint),
            // return segEndPoint instead of intersection
            if is_other_seg_endpoint {
                let endpoint = match direction {
                    TrimDirection::Left => segment_geometry.start,
                    TrimDirection::Right => segment_geometry.end,
                };
                return Ok(TrimTermination::SegEndPoint {
                    trim_termination_coords: endpoint,
                });
            }
        }

        // Also check if intersection is at our arc's endpoint
        let endpoint_t = match direction {
            TrimDirection::Left => 0.0,
            TrimDirection::Right => 1.0,
        };
        let endpoint = match direction {
            TrimDirection::Left => segment_geometry.start,
            TrimDirection::Right => segment_geometry.end,
        };
        let dist_to_endpoint_param = (closest_candidate.t - endpoint_t).abs();
        let dist_to_endpoint_coords = ((closest_candidate.point.x - endpoint.x)
            * (closest_candidate.point.x - endpoint.x)
            + (closest_candidate.point.y - endpoint.y) * (closest_candidate.point.y - endpoint.y))
            .sqrt();

        let is_at_endpoint =
            dist_to_endpoint_param < EPSILON_POINT_ON_SEGMENT || dist_to_endpoint_coords < EPSILON_POINT_ON_SEGMENT;

        if is_at_endpoint {
            // Intersection is at our endpoint -> segEndPoint
            return Ok(TrimTermination::SegEndPoint {
                trim_termination_coords: endpoint,
            });
        }
    }

    // Check if the closest candidate is an intersection at an endpoint
    let endpoint_t_for_return = match direction {
        TrimDirection::Left => 0.0,
        TrimDirection::Right => 1.0,
    };
    if closest_candidate.candidate_type == CandidateType::Intersection {
        let dist_to_endpoint = (closest_candidate.t - endpoint_t_for_return).abs();
        if dist_to_endpoint < EPSILON_POINT_ON_SEGMENT {
            // Intersection is at endpoint - check if there's a coincident constraint
            // or if it's just a numerical precision issue
            let endpoint = match direction {
                TrimDirection::Left => segment_geometry.start,
                TrimDirection::Right => segment_geometry.end,
            };
            return Ok(TrimTermination::SegEndPoint {
                trim_termination_coords: endpoint,
            });
        }
    }

    // Check if the closest candidate is an endpoint at the trim spawn segment's endpoint
    let endpoint = match direction {
        TrimDirection::Left => segment_geometry.start,
        TrimDirection::Right => segment_geometry.end,
    };
    if closest_candidate.candidate_type == CandidateType::Endpoint {
        let dist_to_endpoint = (closest_candidate.t - endpoint_t_for_return).abs();
        if dist_to_endpoint < EPSILON_POINT_ON_SEGMENT {
            // This is our own endpoint, return it
            return Ok(TrimTermination::SegEndPoint {
                trim_termination_coords: endpoint,
            });
        }
    }

    // Return appropriate termination type
    if closest_candidate.candidate_type == CandidateType::Coincident {
        // Even if at endpoint, return coincident type because it's a constraint-based termination
        Ok(TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
            trim_termination_coords: closest_candidate.point,
            intersecting_seg_id: closest_candidate
                .segment_id
                .ok_or_else(|| "Missing segment_id for coincident".to_string())?,
            other_segment_point_id: closest_candidate
                .point_id
                .ok_or_else(|| "Missing point_id for coincident".to_string())?,
        })
    } else if closest_candidate.candidate_type == CandidateType::Intersection {
        Ok(TrimTermination::Intersection {
            trim_termination_coords: closest_candidate.point,
            intersecting_seg_id: closest_candidate
                .segment_id
                .ok_or_else(|| "Missing segment_id for intersection".to_string())?,
        })
    } else {
        // endpoint
        Ok(TrimTermination::SegEndPoint {
            trim_termination_coords: closest_candidate.point,
        })
    }
}

/// Execute the core trim loop.
/// This function handles the iteration through trim points, finding intersections,
/// and determining strategies. It calls the provided callback to execute operations.
///
/// The callback receives:
/// - The strategy (list of operations to execute)
/// - The current scene graph delta
///
/// The callback should return:
/// - The updated scene graph delta after executing operations
#[cfg(test)]
#[allow(dead_code)]
pub(crate) async fn execute_trim_loop<F, Fut>(
    points: &[Coords2d],
    default_unit: UnitLength,
    initial_scene_graph_delta: crate::frontend::api::SceneGraphDelta,
    mut execute_operations: F,
) -> Result<(crate::frontend::api::SourceDelta, crate::frontend::api::SceneGraphDelta), String>
where
    F: FnMut(Vec<TrimOperation>, crate::frontend::api::SceneGraphDelta) -> Fut,
    Fut: std::future::Future<
            Output = Result<(crate::frontend::api::SourceDelta, crate::frontend::api::SceneGraphDelta), String>,
        >,
{
    // Trim line points are expected in millimeters and normalized to the current unit here.
    let normalized_points = normalize_trim_points_to_unit(points, default_unit);
    let points = normalized_points.as_slice();

    let mut start_index = 0;
    let max_iterations = 1000;
    let mut iteration_count = 0;
    let mut last_result: Option<(crate::frontend::api::SourceDelta, crate::frontend::api::SceneGraphDelta)> = Some((
        crate::frontend::api::SourceDelta { text: String::new() },
        initial_scene_graph_delta.clone(),
    ));
    let mut invalidates_ids = false;
    let mut current_scene_graph_delta = initial_scene_graph_delta;

    while start_index < points.len().saturating_sub(1) && iteration_count < max_iterations {
        iteration_count += 1;

        // Get next trim result
        let next_trim_spawn = get_next_trim_spawn(
            points,
            start_index,
            &current_scene_graph_delta.new_graph.objects,
            default_unit,
        );

        match &next_trim_spawn {
            TrimItem::None { next_index } => {
                let old_start_index = start_index;
                start_index = *next_index;

                // Fail-safe: if start_index didn't advance, force it to advance
                if start_index <= old_start_index {
                    start_index = old_start_index + 1;
                }

                // Early exit if we've reached the end
                if start_index >= points.len().saturating_sub(1) {
                    break;
                }
                continue;
            }
            TrimItem::Spawn {
                trim_spawn_seg_id,
                next_index,
                ..
            } => {
                // Get terminations
                let terminations = match get_trim_spawn_terminations(
                    *trim_spawn_seg_id,
                    points,
                    &current_scene_graph_delta.new_graph.objects,
                    default_unit,
                ) {
                    Ok(terms) => terms,
                    Err(e) => {
                        crate::logln!("Error getting trim spawn terminations: {}", e);
                        let old_start_index = start_index;
                        start_index = *next_index;
                        if start_index <= old_start_index {
                            start_index = old_start_index + 1;
                        }
                        continue;
                    }
                };

                // Get trim strategy
                let trim_spawn_segment = current_scene_graph_delta
                    .new_graph
                    .objects
                    .iter()
                    .find(|obj| obj.id == *trim_spawn_seg_id)
                    .ok_or_else(|| format!("Trim spawn segment {} not found", trim_spawn_seg_id.0))?;

                let strategy = match trim_strategy(
                    *trim_spawn_seg_id,
                    trim_spawn_segment,
                    &terminations.left_side,
                    &terminations.right_side,
                    &current_scene_graph_delta.new_graph.objects,
                    default_unit,
                ) {
                    Ok(ops) => ops,
                    Err(e) => {
                        crate::logln!("Error determining trim strategy: {}", e);
                        let old_start_index = start_index;
                        start_index = *next_index;
                        if start_index <= old_start_index {
                            start_index = old_start_index + 1;
                        }
                        continue;
                    }
                };

                // Check if we deleted a segment (for fail-safe logic later)
                let was_deleted = strategy.iter().any(|op| matches!(op, TrimOperation::SimpleTrim { .. }));

                // Execute operations via callback
                match execute_operations(strategy, current_scene_graph_delta.clone()).await {
                    Ok((source_delta, scene_graph_delta)) => {
                        last_result = Some((source_delta, scene_graph_delta.clone()));
                        invalidates_ids = invalidates_ids || scene_graph_delta.invalidates_ids;
                        current_scene_graph_delta = scene_graph_delta;
                    }
                    Err(e) => {
                        crate::logln!("Error executing trim operations: {}", e);
                        // Continue to next segment
                    }
                }

                // Move to next segment
                let old_start_index = start_index;
                start_index = *next_index;

                // Fail-safe: if start_index didn't advance, force it to advance
                if start_index <= old_start_index && !was_deleted {
                    start_index = old_start_index + 1;
                }
            }
        }
    }

    if iteration_count >= max_iterations {
        return Err(format!("Reached max iterations ({})", max_iterations));
    }

    // Return the last result
    last_result.ok_or_else(|| "No trim operations were executed".to_string())
}

/// Result of executing trim flow
#[cfg(all(feature = "artifact-graph", test))]
#[derive(Debug, Clone)]
pub struct TrimFlowResult {
    pub kcl_code: String,
    pub invalidates_ids: bool,
}

/// Execute a complete trim flow from KCL code to KCL code.
/// This is a high-level function that sets up the frontend state and executes the trim loop.
///
/// This function:
/// 1. Parses the input KCL code
/// 2. Sets up ExecutorContext and FrontendState
/// 3. Executes the initial code to get the scene graph
/// 4. Runs the trim loop using `execute_trim_loop`
/// 5. Returns the resulting KCL code
///
/// This is designed for testing and simple use cases. For more complex scenarios
/// (like WASM with batching), use `execute_trim_loop` directly with a custom callback.
///
/// Note: This function is only available for non-WASM builds (tests) as it requires
/// a real engine connection via `new_with_default_client`.
#[cfg(all(not(target_arch = "wasm32"), feature = "artifact-graph", test))]
pub(crate) async fn execute_trim_flow(
    kcl_code: &str,
    trim_points: &[Coords2d],
    sketch_id: ObjectId,
) -> Result<TrimFlowResult, String> {
    use crate::ExecutorContext;
    use crate::Program;
    use crate::frontend::FrontendState;
    use crate::frontend::api::Version;

    // Parse KCL code
    let parse_result = Program::parse(kcl_code).map_err(|e| format!("Failed to parse KCL: {}", e))?;
    let (program_opt, errors) = parse_result;
    if !errors.is_empty() {
        return Err(format!("Failed to parse KCL: {:?}", errors));
    }
    let program = program_opt.ok_or_else(|| "No AST produced".to_string())?;

    let ctx = ExecutorContext::new_with_default_client()
        .await
        .map_err(|e| format!("Failed to create executor context: {}", e))?;

    let mock_ctx = ExecutorContext::new_mock(None).await;

    // Use a guard to ensure contexts are closed even on error
    let result = async {
        let mut frontend = FrontendState::new();

        // Set the program
        frontend.program = program.clone();

        let exec_outcome = ctx
            .run_with_caching(program.clone())
            .await
            .map_err(|e| format!("Failed to execute program: {}", e.error.message()))?;

        let exec_outcome = frontend.update_state_after_exec(exec_outcome, false);
        #[allow(unused_mut)] // mut is needed when artifact-graph feature is enabled
        let mut initial_scene_graph = frontend.scene_graph.clone();

        // If scene graph is empty, try to get objects from exec_outcome.scene_objects
        // (this is only available when artifact-graph feature is enabled)
        #[cfg(feature = "artifact-graph")]
        if initial_scene_graph.objects.is_empty() && !exec_outcome.scene_objects.is_empty() {
            initial_scene_graph.objects = exec_outcome.scene_objects.clone();
        }

        // Get the sketch ID from the scene graph
        // First try sketch_mode, then try to find a sketch object, then fall back to provided sketch_id
        let actual_sketch_id = if let Some(sketch_mode) = initial_scene_graph.sketch_mode {
            sketch_mode
        } else {
            // Try to find a sketch object in the scene graph
            initial_scene_graph
                .objects
                .iter()
                .find(|obj| matches!(obj.kind, crate::frontend::api::ObjectKind::Sketch { .. }))
                .map(|obj| obj.id)
                .unwrap_or(sketch_id) // Fall back to provided sketch_id
        };

        let version = Version(0);
        let initial_scene_graph_delta = crate::frontend::api::SceneGraphDelta {
            new_graph: initial_scene_graph,
            new_objects: vec![],
            invalidates_ids: false,
            exec_outcome,
        };

        // Execute the trim loop with a callback that executes operations using SketchApi
        // We need to use a different approach since we can't easily capture mutable references in closures
        // Instead, we'll use a helper that takes the necessary parameters
        // Use mock_ctx for operations (SketchApi methods require mock context)
        let (source_delta, scene_graph_delta) = execute_trim_loop_with_context(
            trim_points,
            initial_scene_graph_delta,
            &mut frontend,
            &mock_ctx,
            version,
            actual_sketch_id,
        )
        .await?;

        // Return the source delta text - this should contain the full updated KCL code
        // If it's empty, that means no operations were executed, which is an error
        if source_delta.text.is_empty() {
            return Err("No trim operations were executed - source delta is empty".to_string());
        }

        Ok(TrimFlowResult {
            kcl_code: source_delta.text,
            invalidates_ids: scene_graph_delta.invalidates_ids,
        })
    }
    .await;

    // Clean up contexts regardless of success or failure
    ctx.close().await;
    mock_ctx.close().await;

    result
}

/// Execute the trim loop with a context struct that provides access to FrontendState.
/// This is a convenience wrapper that inlines the loop to avoid borrow checker issues with closures.
/// The core loop logic is duplicated here, but this allows direct access to frontend and ctx.
///
/// Trim line points are expected in millimeters and are normalized to the current/default unit.
pub async fn execute_trim_loop_with_context(
    points: &[Coords2d],
    initial_scene_graph_delta: crate::frontend::api::SceneGraphDelta,
    frontend: &mut crate::frontend::FrontendState,
    ctx: &crate::ExecutorContext,
    version: crate::frontend::api::Version,
    sketch_id: ObjectId,
) -> Result<(crate::frontend::api::SourceDelta, crate::frontend::api::SceneGraphDelta), String> {
    // Trim line points are expected in millimeters and normalized to the current unit here.
    let default_unit = frontend.default_length_unit();
    let normalized_points = normalize_trim_points_to_unit(points, default_unit);

    // We inline the loop logic here to avoid borrow checker issues with closures capturing mutable references
    // This duplicates the loop from execute_trim_loop, but allows us to access frontend and ctx directly
    let mut current_scene_graph_delta = initial_scene_graph_delta.clone();
    let mut last_result: Option<(crate::frontend::api::SourceDelta, crate::frontend::api::SceneGraphDelta)> = Some((
        crate::frontend::api::SourceDelta { text: String::new() },
        initial_scene_graph_delta.clone(),
    ));
    let mut invalidates_ids = false;
    let mut start_index = 0;
    let max_iterations = 1000;
    let mut iteration_count = 0;

    let points = normalized_points.as_slice();

    while start_index < points.len().saturating_sub(1) && iteration_count < max_iterations {
        iteration_count += 1;

        // Get next trim result
        let next_trim_spawn = get_next_trim_spawn(
            points,
            start_index,
            &current_scene_graph_delta.new_graph.objects,
            default_unit,
        );

        match &next_trim_spawn {
            TrimItem::None { next_index } => {
                let old_start_index = start_index;
                start_index = *next_index;
                if start_index <= old_start_index {
                    start_index = old_start_index + 1;
                }
                if start_index >= points.len().saturating_sub(1) {
                    break;
                }
                continue;
            }
            TrimItem::Spawn {
                trim_spawn_seg_id,
                next_index,
                ..
            } => {
                // Get terminations
                let terminations = match get_trim_spawn_terminations(
                    *trim_spawn_seg_id,
                    points,
                    &current_scene_graph_delta.new_graph.objects,
                    default_unit,
                ) {
                    Ok(terms) => terms,
                    Err(e) => {
                        crate::logln!("Error getting trim spawn terminations: {}", e);
                        let old_start_index = start_index;
                        start_index = *next_index;
                        if start_index <= old_start_index {
                            start_index = old_start_index + 1;
                        }
                        continue;
                    }
                };

                // Get trim strategy
                let trim_spawn_segment = current_scene_graph_delta
                    .new_graph
                    .objects
                    .iter()
                    .find(|obj| obj.id == *trim_spawn_seg_id)
                    .ok_or_else(|| format!("Trim spawn segment {} not found", trim_spawn_seg_id.0))?;

                let strategy = match trim_strategy(
                    *trim_spawn_seg_id,
                    trim_spawn_segment,
                    &terminations.left_side,
                    &terminations.right_side,
                    &current_scene_graph_delta.new_graph.objects,
                    default_unit,
                ) {
                    Ok(ops) => ops,
                    Err(e) => {
                        crate::logln!("Error determining trim strategy: {}", e);
                        let old_start_index = start_index;
                        start_index = *next_index;
                        if start_index <= old_start_index {
                            start_index = old_start_index + 1;
                        }
                        continue;
                    }
                };

                // Check if we deleted a segment (for fail-safe logic later)
                let was_deleted = strategy.iter().any(|op| matches!(op, TrimOperation::SimpleTrim { .. }));

                // Execute operations
                match execute_trim_operations_simple(
                    strategy.clone(),
                    &current_scene_graph_delta,
                    frontend,
                    ctx,
                    version,
                    sketch_id,
                )
                .await
                {
                    Ok((source_delta, scene_graph_delta)) => {
                        invalidates_ids = invalidates_ids || scene_graph_delta.invalidates_ids;
                        last_result = Some((source_delta, scene_graph_delta.clone()));
                        current_scene_graph_delta = scene_graph_delta;
                    }
                    Err(e) => {
                        crate::logln!("Error executing trim operations: {}", e);
                    }
                }

                // Move to next segment
                let old_start_index = start_index;
                start_index = *next_index;
                if start_index <= old_start_index && !was_deleted {
                    start_index = old_start_index + 1;
                }
            }
        }
    }

    if iteration_count >= max_iterations {
        return Err(format!("Reached max iterations ({})", max_iterations));
    }

    let (source_delta, mut scene_graph_delta) =
        last_result.ok_or_else(|| "No trim operations were executed".to_string())?;
    // Set invalidates_ids if any operation invalidated IDs
    scene_graph_delta.invalidates_ids = invalidates_ids;
    Ok((source_delta, scene_graph_delta))
}

/// Determine the trim strategy based on the terminations found on both sides
///
/// Once we have the termination of both sides, we have all the information we need to come up with a trim strategy.
/// In the below x is the trim spawn.
///
/// ## When both sides are the end of a segment
///
/// ```
/// o - -----x - -----o
/// ```
///
/// This is the simplest and we just delete the segment. This includes when the ends of the segment have
/// coincident constraints, as the delete API cascade deletes these constraints
///
/// ## When one side is the end of the segment and the other side is either an intersection or has another segment endpoint coincident with it
///
/// ```
///        /
/// -------/---x--o
///      /
/// ```
/// OR
/// ```
/// ----o---x---o
///    /
///   /
/// ```
///
/// In both of these cases, we need to edit one end of the segment to be the location of the
/// intersection/coincident point of this other segment though:
/// - If it's an intersection, we need to create a point-segment coincident constraint
/// ```
///        /
/// -------o
///      /
/// ```
/// - If it's a coincident endpoint, we need to create a point-point coincident constraint
///
/// ```
/// ----o
///    /
///   /
/// ```
///
/// ## When both sides are either intersections or coincident endpoints
///
/// ```
///        /
/// -------/---x----o------
///      /         |
/// ```
///
/// We need to split the segment in two, which basically means editing the existing segment to be one side
/// of the split, and adding a new segment for the other side of the split. And then there is lots of
/// complications around how to migrate constraints applied to each side of the segment, to list a couple
/// of considerations:
/// - Coincident constraints on either side need to be migrated to the correct side
/// - Angle based constraints (parallel, perpendicular, horizontal, vertical), need to be applied to both sides of the trim
/// - If the segment getting split is an arc, and there's a constraints applied to an arc's center, this should be applied to both arcs after they are split.
pub(crate) fn trim_strategy(
    trim_spawn_id: ObjectId,
    trim_spawn_segment: &Object,
    left_side: &TrimTermination,
    right_side: &TrimTermination,
    objects: &[Object],
    default_unit: UnitLength,
) -> Result<Vec<TrimOperation>, String> {
    // Simple trim: both sides are endpoints
    if matches!(left_side, TrimTermination::SegEndPoint { .. })
        && matches!(right_side, TrimTermination::SegEndPoint { .. })
    {
        return Ok(vec![TrimOperation::SimpleTrim {
            segment_to_trim_id: trim_spawn_id,
        }]);
    }

    // Helper to check if a side is an intersection or coincident
    let is_intersect_or_coincident = |side: &TrimTermination| -> bool {
        matches!(
            side,
            TrimTermination::Intersection { .. }
                | TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint { .. }
        )
    };

    let left_side_needs_tail_cut = is_intersect_or_coincident(left_side) && !is_intersect_or_coincident(right_side);
    let right_side_needs_tail_cut = is_intersect_or_coincident(right_side) && !is_intersect_or_coincident(left_side);

    // Validate trim spawn segment using native types
    let ObjectKind::Segment { segment } = &trim_spawn_segment.kind else {
        return Err("Trim spawn segment is not a segment".to_string());
    };

    let (_segment_type, ctor) = match segment {
        Segment::Line(line) => ("Line", &line.ctor),
        Segment::Arc(arc) => ("Arc", &arc.ctor),
        _ => {
            return Err("Trim spawn segment is not a Line or Arc".to_string());
        }
    };

    // Extract units from the existing ctor's start point
    let units = match ctor {
        SegmentCtor::Line(line_ctor) => match &line_ctor.start.x {
            crate::frontend::api::Expr::Var(v) | crate::frontend::api::Expr::Number(v) => v.units,
            _ => NumericSuffix::Mm,
        },
        SegmentCtor::Arc(arc_ctor) => match &arc_ctor.start.x {
            crate::frontend::api::Expr::Var(v) | crate::frontend::api::Expr::Number(v) => v.units,
            _ => NumericSuffix::Mm,
        },
        _ => NumericSuffix::Mm,
    };

    // Helper to find distance constraints that reference a segment (via owned points)
    let find_distance_constraints_for_segment = |segment_id: ObjectId| -> Vec<ObjectId> {
        let mut constraint_ids = Vec::new();
        for obj in objects {
            let ObjectKind::Constraint { constraint } = &obj.kind else {
                continue;
            };

            let Constraint::Distance(distance) = constraint else {
                continue;
            };

            // Only delete distance constraints where BOTH points are owned by this segment.
            // Distance constraints that reference points on other segments should be preserved,
            // as they define relationships between this segment and other geometry that remain valid
            // even when this segment is trimmed. Only constraints that measure distances between
            // points on the same segment (e.g., segment length constraints) should be deleted.
            let points_owned_by_segment: Vec<bool> = distance
                .points
                .iter()
                .map(|point_id| {
                    if let Some(point_obj) = objects.iter().find(|o| o.id == *point_id)
                        && let ObjectKind::Segment { segment } = &point_obj.kind
                        && let Segment::Point(point) = segment
                        && let Some(owner_id) = point.owner
                    {
                        return owner_id == segment_id;
                    }
                    false
                })
                .collect();

            // Only include if ALL points are owned by this segment
            if points_owned_by_segment.len() == 2 && points_owned_by_segment.iter().all(|&owned| owned) {
                constraint_ids.push(obj.id);
            }
        }
        constraint_ids
    };

    // Helper to find existing point-segment coincident constraint (using native types)
    let find_existing_point_segment_coincident =
        |trim_seg_id: ObjectId, intersecting_seg_id: ObjectId| -> CoincidentData {
            // If the intersecting id itself is a point, try a fast lookup using it directly
            let lookup_by_point_id = |point_id: ObjectId| -> Option<CoincidentData> {
                for obj in objects {
                    let ObjectKind::Constraint { constraint } = &obj.kind else {
                        continue;
                    };

                    let Constraint::Coincident(coincident) = constraint else {
                        continue;
                    };

                    let involves_trim_seg = coincident
                        .segments
                        .iter()
                        .any(|id| *id == trim_seg_id || *id == point_id);
                    let involves_point = coincident.segments.contains(&point_id);

                    if involves_trim_seg && involves_point {
                        return Some(CoincidentData {
                            intersecting_seg_id,
                            intersecting_endpoint_point_id: Some(point_id),
                            existing_point_segment_constraint_id: Some(obj.id),
                        });
                    }
                }
                None
            };

            // Collect trim endpoints using native types
            let trim_seg = objects.iter().find(|obj| obj.id == trim_seg_id);

            let mut trim_endpoint_ids: Vec<ObjectId> = Vec::new();
            if let Some(seg) = trim_seg
                && let ObjectKind::Segment { segment } = &seg.kind
            {
                match segment {
                    Segment::Line(line) => {
                        trim_endpoint_ids.push(line.start);
                        trim_endpoint_ids.push(line.end);
                    }
                    Segment::Arc(arc) => {
                        trim_endpoint_ids.push(arc.start);
                        trim_endpoint_ids.push(arc.end);
                    }
                    _ => {}
                }
            }

            let intersecting_obj = objects.iter().find(|obj| obj.id == intersecting_seg_id);

            if let Some(obj) = intersecting_obj
                && let ObjectKind::Segment { segment } = &obj.kind
                && let Segment::Point(_) = segment
                && let Some(found) = lookup_by_point_id(intersecting_seg_id)
            {
                return found;
            }

            // Collect intersecting endpoint IDs using native types
            let mut intersecting_endpoint_ids: Vec<ObjectId> = Vec::new();
            if let Some(obj) = intersecting_obj
                && let ObjectKind::Segment { segment } = &obj.kind
            {
                match segment {
                    Segment::Line(line) => {
                        intersecting_endpoint_ids.push(line.start);
                        intersecting_endpoint_ids.push(line.end);
                    }
                    Segment::Arc(arc) => {
                        intersecting_endpoint_ids.push(arc.start);
                        intersecting_endpoint_ids.push(arc.end);
                    }
                    _ => {}
                }
            }

            // Also include the intersecting_seg_id itself (it might already be a point id)
            intersecting_endpoint_ids.push(intersecting_seg_id);

            // Search for constraints involving trim segment (or trim endpoints) and intersecting endpoints/points
            for obj in objects {
                let ObjectKind::Constraint { constraint } = &obj.kind else {
                    continue;
                };

                let Constraint::Coincident(coincident) = constraint else {
                    continue;
                };

                let constraint_segment_ids: Vec<ObjectId> = coincident.segments.to_vec();

                // Check if constraint involves the trim segment itself OR any trim endpoint
                let involves_trim_seg = constraint_segment_ids.contains(&trim_seg_id)
                    || trim_endpoint_ids.iter().any(|&id| constraint_segment_ids.contains(&id));

                if !involves_trim_seg {
                    continue;
                }

                // Check if any intersecting endpoint/point is involved
                if let Some(&intersecting_endpoint_id) = intersecting_endpoint_ids
                    .iter()
                    .find(|&&id| constraint_segment_ids.contains(&id))
                {
                    return CoincidentData {
                        intersecting_seg_id,
                        intersecting_endpoint_point_id: Some(intersecting_endpoint_id),
                        existing_point_segment_constraint_id: Some(obj.id),
                    };
                }
            }

            // No existing constraint found
            CoincidentData {
                intersecting_seg_id,
                intersecting_endpoint_point_id: None,
                existing_point_segment_constraint_id: None,
            }
        };

    // Helper to find point-segment coincident constraints on an endpoint (using native types)
    let find_point_segment_coincident_constraints = |endpoint_point_id: ObjectId| -> Vec<serde_json::Value> {
        let mut constraints: Vec<serde_json::Value> = Vec::new();
        for obj in objects {
            let ObjectKind::Constraint { constraint } = &obj.kind else {
                continue;
            };

            let Constraint::Coincident(coincident) = constraint else {
                continue;
            };

            // Check if this constraint involves the endpoint
            if !coincident.segments.contains(&endpoint_point_id) {
                continue;
            }

            // Find the other entity
            let other_segment_id = coincident.segments.iter().find_map(|seg_id| {
                if *seg_id != endpoint_point_id {
                    Some(*seg_id)
                } else {
                    None
                }
            });

            if let Some(other_id) = other_segment_id
                && let Some(other_obj) = objects.iter().find(|o| o.id == other_id)
            {
                // Check if other is a segment (not a point)
                if matches!(&other_obj.kind, ObjectKind::Segment { segment } if !matches!(segment, Segment::Point(_))) {
                    constraints.push(serde_json::json!({
                        "constraintId": obj.id.0,
                        "segmentOrPointId": other_id.0,
                    }));
                }
            }
        }
        constraints
    };

    // Helper to find point-point coincident constraints on an endpoint (using native types)
    // Returns constraint IDs
    let find_point_point_coincident_constraints = |endpoint_point_id: ObjectId| -> Vec<ObjectId> {
        let mut constraint_ids = Vec::new();
        for obj in objects {
            let ObjectKind::Constraint { constraint } = &obj.kind else {
                continue;
            };

            let Constraint::Coincident(coincident) = constraint else {
                continue;
            };

            // Check if this constraint involves the endpoint
            if !coincident.segments.contains(&endpoint_point_id) {
                continue;
            }

            // Check if this is a point-point constraint (all segments are points)
            let is_point_point = coincident.segments.iter().all(|seg_id| {
                if let Some(seg_obj) = objects.iter().find(|o| o.id == *seg_id) {
                    matches!(&seg_obj.kind, ObjectKind::Segment { segment } if matches!(segment, Segment::Point(_)))
                } else {
                    false
                }
            });

            if is_point_point {
                constraint_ids.push(obj.id);
            }
        }
        constraint_ids
    };

    // Helper to find point-segment coincident constraints on an endpoint (using native types)
    // Returns constraint IDs
    let find_point_segment_coincident_constraint_ids = |endpoint_point_id: ObjectId| -> Vec<ObjectId> {
        let mut constraint_ids = Vec::new();
        for obj in objects {
            let ObjectKind::Constraint { constraint } = &obj.kind else {
                continue;
            };

            let Constraint::Coincident(coincident) = constraint else {
                continue;
            };

            // Check if this constraint involves the endpoint
            if !coincident.segments.contains(&endpoint_point_id) {
                continue;
            }

            // Find the other entity
            let other_segment_id = coincident.segments.iter().find_map(|seg_id| {
                if *seg_id != endpoint_point_id {
                    Some(*seg_id)
                } else {
                    None
                }
            });

            if let Some(other_id) = other_segment_id
                && let Some(other_obj) = objects.iter().find(|o| o.id == other_id)
            {
                // Check if other is a segment (not a point) - this is a point-segment constraint
                if matches!(&other_obj.kind, ObjectKind::Segment { segment } if !matches!(segment, Segment::Point(_))) {
                    constraint_ids.push(obj.id);
                }
            }
        }
        constraint_ids
    };

    // Cut tail: one side intersects, one is endpoint
    if left_side_needs_tail_cut || right_side_needs_tail_cut {
        let side = if left_side_needs_tail_cut {
            left_side
        } else {
            right_side
        };

        let intersection_coords = match side {
            TrimTermination::Intersection {
                trim_termination_coords,
                ..
            }
            | TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                trim_termination_coords,
                ..
            } => *trim_termination_coords,
            TrimTermination::SegEndPoint { .. } => {
                return Err("Logic error: side should not be segEndPoint here".to_string());
            }
        };

        let endpoint_to_change = if left_side_needs_tail_cut {
            EndpointChanged::End
        } else {
            EndpointChanged::Start
        };

        let intersecting_seg_id = match side {
            TrimTermination::Intersection {
                intersecting_seg_id, ..
            }
            | TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                intersecting_seg_id, ..
            } => *intersecting_seg_id,
            TrimTermination::SegEndPoint { .. } => {
                return Err("Logic error".to_string());
            }
        };

        let coincident_data = if matches!(
            side,
            TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint { .. }
        ) {
            let point_id = match side {
                TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                    other_segment_point_id, ..
                } => *other_segment_point_id,
                _ => return Err("Logic error".to_string()),
            };
            let mut data = find_existing_point_segment_coincident(trim_spawn_id, intersecting_seg_id);
            data.intersecting_endpoint_point_id = Some(point_id);
            data
        } else {
            find_existing_point_segment_coincident(trim_spawn_id, intersecting_seg_id)
        };

        // Find the endpoint that will be trimmed using native types
        let trim_seg = objects.iter().find(|obj| obj.id == trim_spawn_id);

        let endpoint_point_id = if let Some(seg) = trim_seg {
            let ObjectKind::Segment { segment } = &seg.kind else {
                return Err("Trim spawn segment is not a segment".to_string());
            };
            match segment {
                Segment::Line(line) => {
                    if endpoint_to_change == EndpointChanged::Start {
                        Some(line.start)
                    } else {
                        Some(line.end)
                    }
                }
                Segment::Arc(arc) => {
                    if endpoint_to_change == EndpointChanged::Start {
                        Some(arc.start)
                    } else {
                        Some(arc.end)
                    }
                }
                _ => None,
            }
        } else {
            None
        };

        // Find point-point and point-segment constraints to delete
        let coincident_end_constraint_to_delete_ids = if let Some(point_id) = endpoint_point_id {
            let mut constraint_ids = find_point_point_coincident_constraints(point_id);
            // Also find point-segment constraints where the point is the endpoint being trimmed
            constraint_ids.extend(find_point_segment_coincident_constraint_ids(point_id));
            constraint_ids
        } else {
            Vec::new()
        };

        let mut operations: Vec<TrimOperation> = Vec::new();

        // Edit the segment - create new ctor with updated endpoint
        let new_ctor = match ctor {
            SegmentCtor::Line(line_ctor) => {
                // Convert to segment units only; rounding happens at final conversion to output if needed.
                let new_point = crate::frontend::sketch::Point2d {
                    x: crate::frontend::api::Expr::Var(unit_to_number(intersection_coords.x, default_unit, units)),
                    y: crate::frontend::api::Expr::Var(unit_to_number(intersection_coords.y, default_unit, units)),
                };
                if endpoint_to_change == EndpointChanged::Start {
                    SegmentCtor::Line(crate::frontend::sketch::LineCtor {
                        start: new_point,
                        end: line_ctor.end.clone(),
                        construction: line_ctor.construction,
                    })
                } else {
                    SegmentCtor::Line(crate::frontend::sketch::LineCtor {
                        start: line_ctor.start.clone(),
                        end: new_point,
                        construction: line_ctor.construction,
                    })
                }
            }
            SegmentCtor::Arc(arc_ctor) => {
                // Convert to segment units only; rounding happens at final conversion to output if needed.
                let new_point = crate::frontend::sketch::Point2d {
                    x: crate::frontend::api::Expr::Var(unit_to_number(intersection_coords.x, default_unit, units)),
                    y: crate::frontend::api::Expr::Var(unit_to_number(intersection_coords.y, default_unit, units)),
                };
                if endpoint_to_change == EndpointChanged::Start {
                    SegmentCtor::Arc(crate::frontend::sketch::ArcCtor {
                        start: new_point,
                        end: arc_ctor.end.clone(),
                        center: arc_ctor.center.clone(),
                        construction: arc_ctor.construction,
                    })
                } else {
                    SegmentCtor::Arc(crate::frontend::sketch::ArcCtor {
                        start: arc_ctor.start.clone(),
                        end: new_point,
                        center: arc_ctor.center.clone(),
                        construction: arc_ctor.construction,
                    })
                }
            }
            _ => {
                return Err("Unsupported segment type for edit".to_string());
            }
        };
        operations.push(TrimOperation::EditSegment {
            segment_id: trim_spawn_id,
            ctor: new_ctor,
            endpoint_changed: endpoint_to_change,
        });

        // Add coincident constraint
        let add_coincident = TrimOperation::AddCoincidentConstraint {
            segment_id: trim_spawn_id,
            endpoint_changed: endpoint_to_change,
            segment_or_point_to_make_coincident_to: intersecting_seg_id,
            intersecting_endpoint_point_id: coincident_data.intersecting_endpoint_point_id,
        };
        operations.push(add_coincident);

        // Delete old constraints
        let mut all_constraint_ids_to_delete: Vec<ObjectId> = Vec::new();
        if let Some(constraint_id) = coincident_data.existing_point_segment_constraint_id {
            all_constraint_ids_to_delete.push(constraint_id);
        }
        all_constraint_ids_to_delete.extend(coincident_end_constraint_to_delete_ids);

        // Delete distance constraints that reference this segment
        // When trimming an endpoint, the distance constraint no longer makes sense
        let distance_constraint_ids = find_distance_constraints_for_segment(trim_spawn_id);
        all_constraint_ids_to_delete.extend(distance_constraint_ids);

        if !all_constraint_ids_to_delete.is_empty() {
            operations.push(TrimOperation::DeleteConstraints {
                constraint_ids: all_constraint_ids_to_delete,
            });
        }

        return Ok(operations);
    }

    // Split segment: both sides intersect
    let left_side_intersects = is_intersect_or_coincident(left_side);
    let right_side_intersects = is_intersect_or_coincident(right_side);

    if left_side_intersects && right_side_intersects {
        // This is the most complex case - split segment
        // Get coincident data for both sides
        let left_intersecting_seg_id = match left_side {
            TrimTermination::Intersection {
                intersecting_seg_id, ..
            }
            | TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                intersecting_seg_id, ..
            } => *intersecting_seg_id,
            TrimTermination::SegEndPoint { .. } => {
                return Err("Logic error: left side should not be segEndPoint".to_string());
            }
        };

        let right_intersecting_seg_id = match right_side {
            TrimTermination::Intersection {
                intersecting_seg_id, ..
            }
            | TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                intersecting_seg_id, ..
            } => *intersecting_seg_id,
            TrimTermination::SegEndPoint { .. } => {
                return Err("Logic error: right side should not be segEndPoint".to_string());
            }
        };

        let left_coincident_data = if matches!(
            left_side,
            TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint { .. }
        ) {
            let point_id = match left_side {
                TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                    other_segment_point_id, ..
                } => *other_segment_point_id,
                _ => return Err("Logic error".to_string()),
            };
            let mut data = find_existing_point_segment_coincident(trim_spawn_id, left_intersecting_seg_id);
            data.intersecting_endpoint_point_id = Some(point_id);
            data
        } else {
            find_existing_point_segment_coincident(trim_spawn_id, left_intersecting_seg_id)
        };

        let right_coincident_data = if matches!(
            right_side,
            TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint { .. }
        ) {
            let point_id = match right_side {
                TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                    other_segment_point_id, ..
                } => *other_segment_point_id,
                _ => return Err("Logic error".to_string()),
            };
            let mut data = find_existing_point_segment_coincident(trim_spawn_id, right_intersecting_seg_id);
            data.intersecting_endpoint_point_id = Some(point_id);
            data
        } else {
            find_existing_point_segment_coincident(trim_spawn_id, right_intersecting_seg_id)
        };

        // Find the endpoints of the segment being split using native types
        let (original_start_point_id, original_end_point_id) = match segment {
            Segment::Line(line) => (Some(line.start), Some(line.end)),
            Segment::Arc(arc) => (Some(arc.start), Some(arc.end)),
            _ => (None, None),
        };

        // Get the original end point coordinates before editing using native types
        let original_end_point_coords = match segment {
            Segment::Line(_) => {
                get_position_coords_for_line(trim_spawn_segment, LineEndpoint::End, objects, default_unit)
            }
            Segment::Arc(_) => get_position_coords_from_arc(trim_spawn_segment, ArcPoint::End, objects, default_unit),
            _ => None,
        };

        let Some(original_end_coords) = original_end_point_coords else {
            return Err(
                "Could not get original end point coordinates before editing - this is required for split trim"
                    .to_string(),
            );
        };

        // Calculate trim coordinates for both sides
        let left_trim_coords = match left_side {
            TrimTermination::SegEndPoint {
                trim_termination_coords,
            }
            | TrimTermination::Intersection {
                trim_termination_coords,
                ..
            }
            | TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                trim_termination_coords,
                ..
            } => *trim_termination_coords,
        };

        let right_trim_coords = match right_side {
            TrimTermination::SegEndPoint {
                trim_termination_coords,
            }
            | TrimTermination::Intersection {
                trim_termination_coords,
                ..
            }
            | TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                trim_termination_coords,
                ..
            } => *trim_termination_coords,
        };

        // Check if the split point is at the original end point
        let dist_to_original_end = ((right_trim_coords.x - original_end_coords.x)
            * (right_trim_coords.x - original_end_coords.x)
            + (right_trim_coords.y - original_end_coords.y) * (right_trim_coords.y - original_end_coords.y))
            .sqrt();
        if dist_to_original_end < EPSILON_POINT_ON_SEGMENT {
            return Err(
                "Split point is at original end point - this should be handled as cutTail, not split".to_string(),
            );
        }

        // For now, implement a simplified version that creates the split operation
        // The full constraint migration logic is very complex and can be refined during testing
        let mut constraints_to_migrate: Vec<ConstraintToMigrate> = Vec::new();
        let mut constraints_to_delete_set: IndexSet<ObjectId> = IndexSet::new();

        // Add existing point-segment constraints from terminations to delete list
        if let Some(constraint_id) = left_coincident_data.existing_point_segment_constraint_id {
            constraints_to_delete_set.insert(constraint_id);
        }
        if let Some(constraint_id) = right_coincident_data.existing_point_segment_constraint_id {
            constraints_to_delete_set.insert(constraint_id);
        }

        // Find point-point constraints on end endpoint to migrate
        if let Some(end_id) = original_end_point_id {
            let end_point_point_constraint_ids = find_point_point_coincident_constraints(end_id);
            for constraint_id in end_point_point_constraint_ids {
                // Identify the other point in the coincident constraint
                let other_point_id_opt = objects.iter().find_map(|obj| {
                    if obj.id != constraint_id {
                        return None;
                    }
                    let ObjectKind::Constraint { constraint } = &obj.kind else {
                        return None;
                    };
                    let Constraint::Coincident(coincident) = constraint else {
                        return None;
                    };
                    coincident
                        .segments
                        .iter()
                        .find_map(|seg_id| if *seg_id != end_id { Some(*seg_id) } else { None })
                });

                if let Some(other_point_id) = other_point_id_opt {
                    constraints_to_delete_set.insert(constraint_id);
                    // Migrate as point-point constraint to the new end endpoint
                    constraints_to_migrate.push(ConstraintToMigrate {
                        constraint_id,
                        other_entity_id: other_point_id,
                        is_point_point: true,
                        attach_to_endpoint: AttachToEndpoint::End,
                    });
                }
            }
        }

        // Find point-segment constraints on end endpoint to migrate
        if let Some(end_id) = original_end_point_id {
            let end_point_segment_constraints = find_point_segment_coincident_constraints(end_id);
            for constraint_json in end_point_segment_constraints {
                if let Some(constraint_id_usize) = constraint_json
                    .get("constraintId")
                    .and_then(|v| v.as_u64())
                    .map(|id| id as usize)
                {
                    let constraint_id = ObjectId(constraint_id_usize);
                    constraints_to_delete_set.insert(constraint_id);
                    // Add to migrate list (simplified)
                    if let Some(other_id_usize) = constraint_json
                        .get("segmentOrPointId")
                        .and_then(|v| v.as_u64())
                        .map(|id| id as usize)
                    {
                        constraints_to_migrate.push(ConstraintToMigrate {
                            constraint_id,
                            other_entity_id: ObjectId(other_id_usize),
                            is_point_point: false,
                            attach_to_endpoint: AttachToEndpoint::End,
                        });
                    }
                }
            }
        }

        // Find point-segment constraints where the point is geometrically at the original end point
        // These should migrate to [newSegmentEndPointId, pointId] (point-point), not [pointId, newSegmentId] (point-segment)
        // We need to find these by checking all point-segment constraints involving the segment ID
        // and checking if the point is at the original end point
        if let Some(end_id) = original_end_point_id {
            for obj in objects {
                let ObjectKind::Constraint { constraint } = &obj.kind else {
                    continue;
                };

                let Constraint::Coincident(coincident) = constraint else {
                    continue;
                };

                // Only consider constraints that involve the segment ID but NOT the endpoint IDs directly
                // Note: We want to find constraints like [pointId, segmentId] where pointId is a point
                // that happens to be at the endpoint geometrically, but the constraint doesn't reference
                // the endpoint ID directly
                if !coincident.segments.contains(&trim_spawn_id) {
                    continue;
                }
                // Skip constraints that involve endpoint IDs directly (those are handled by endpoint constraint migration)
                // But we still want to find constraints where a point (not an endpoint ID) is at the endpoint
                if let (Some(start_id), Some(end_id_val)) = (original_start_point_id, Some(end_id))
                    && coincident
                        .segments
                        .iter()
                        .any(|id| *id == start_id || *id == end_id_val)
                {
                    continue; // Skip constraints that involve endpoint IDs directly
                }

                // Find the other entity (should be a point)
                let other_id = coincident
                    .segments
                    .iter()
                    .find_map(|seg_id| if *seg_id != trim_spawn_id { Some(*seg_id) } else { None });

                if let Some(other_id) = other_id {
                    // Check if the other entity is a point
                    if let Some(other_obj) = objects.iter().find(|o| o.id == other_id) {
                        let ObjectKind::Segment { segment: other_segment } = &other_obj.kind else {
                            continue;
                        };

                        let Segment::Point(point) = other_segment else {
                            continue;
                        };

                        // Get point coordinates in the trim internal unit
                        let point_coords = Coords2d {
                            x: number_to_unit(&point.position.x, default_unit),
                            y: number_to_unit(&point.position.y, default_unit),
                        };

                        // Check if point is at original end point (geometrically)
                        // Use post-solve coordinates for original end point if available, otherwise use the coordinates we have
                        let original_end_point_post_solve_coords = if let Some(end_id) = original_end_point_id {
                            if let Some(end_point_obj) = objects.iter().find(|o| o.id == end_id) {
                                if let ObjectKind::Segment {
                                    segment: Segment::Point(end_point),
                                } = &end_point_obj.kind
                                {
                                    Some(Coords2d {
                                        x: number_to_unit(&end_point.position.x, default_unit),
                                        y: number_to_unit(&end_point.position.y, default_unit),
                                    })
                                } else {
                                    None
                                }
                            } else {
                                None
                            }
                        } else {
                            None
                        };

                        let reference_coords = original_end_point_post_solve_coords.unwrap_or(original_end_coords);
                        let dist_to_original_end = ((point_coords.x - reference_coords.x)
                            * (point_coords.x - reference_coords.x)
                            + (point_coords.y - reference_coords.y) * (point_coords.y - reference_coords.y))
                            .sqrt();

                        if dist_to_original_end < EPSILON_POINT_ON_SEGMENT {
                            // Point is at the original end point - migrate as point-point constraint
                            // Check if there's already a point-point constraint between this point and the original end point
                            let has_point_point_constraint = find_point_point_coincident_constraints(end_id)
                                .iter()
                                .any(|&constraint_id| {
                                    if let Some(constraint_obj) = objects.iter().find(|o| o.id == constraint_id) {
                                        if let ObjectKind::Constraint {
                                            constraint: Constraint::Coincident(coincident),
                                        } = &constraint_obj.kind
                                        {
                                            coincident.segments.contains(&other_id)
                                        } else {
                                            false
                                        }
                                    } else {
                                        false
                                    }
                                });

                            if !has_point_point_constraint {
                                // No existing point-point constraint - migrate as point-point constraint
                                constraints_to_migrate.push(ConstraintToMigrate {
                                    constraint_id: obj.id,
                                    other_entity_id: other_id,
                                    is_point_point: true, // Convert to point-point constraint
                                    attach_to_endpoint: AttachToEndpoint::End, // Attach to new segment's end
                                });
                            }
                            // Always delete the old point-segment constraint (whether we migrate or not)
                            constraints_to_delete_set.insert(obj.id);
                        }
                    }
                }
            }
        }

        // Find point-segment constraints on the segment body (not at endpoints)
        // These are constraints [pointId, segmentId] where the point is on the segment body
        // They should be migrated to [pointId, newSegmentId] if the point is after the split point
        let split_point = right_trim_coords; // Use right trim coords as split point
        let segment_start_coords = match segment {
            Segment::Line(_) => {
                get_position_coords_for_line(trim_spawn_segment, LineEndpoint::Start, objects, default_unit)
            }
            Segment::Arc(_) => get_position_coords_from_arc(trim_spawn_segment, ArcPoint::Start, objects, default_unit),
            _ => None,
        };
        let segment_end_coords = match segment {
            Segment::Line(_) => {
                get_position_coords_for_line(trim_spawn_segment, LineEndpoint::End, objects, default_unit)
            }
            Segment::Arc(_) => get_position_coords_from_arc(trim_spawn_segment, ArcPoint::End, objects, default_unit),
            _ => None,
        };
        let segment_center_coords = match segment {
            Segment::Line(_) => None,
            Segment::Arc(_) => {
                get_position_coords_from_arc(trim_spawn_segment, ArcPoint::Center, objects, default_unit)
            }
            _ => None,
        };

        if let (Some(start_coords), Some(end_coords)) = (segment_start_coords, segment_end_coords) {
            // Calculate split point parametric position
            let split_point_t_opt = match segment {
                Segment::Line(_) => Some(project_point_onto_segment(split_point, start_coords, end_coords)),
                Segment::Arc(_) => segment_center_coords
                    .map(|center| project_point_onto_arc(split_point, center, start_coords, end_coords)),
                _ => None,
            };

            if let Some(split_point_t) = split_point_t_opt {
                // Find all coincident constraints involving the segment
                for obj in objects {
                    let ObjectKind::Constraint { constraint } = &obj.kind else {
                        continue;
                    };

                    let Constraint::Coincident(coincident) = constraint else {
                        continue;
                    };

                    // Check if constraint involves the segment being split
                    if !coincident.segments.contains(&trim_spawn_id) {
                        continue;
                    }

                    // Skip if constraint also involves endpoint IDs directly (those are handled separately)
                    if let (Some(start_id), Some(end_id)) = (original_start_point_id, original_end_point_id)
                        && coincident.segments.iter().any(|id| *id == start_id || *id == end_id)
                    {
                        continue;
                    }

                    // Find the other entity in the constraint
                    let other_id = coincident
                        .segments
                        .iter()
                        .find_map(|seg_id| if *seg_id != trim_spawn_id { Some(*seg_id) } else { None });

                    if let Some(other_id) = other_id {
                        // Check if the other entity is a point
                        if let Some(other_obj) = objects.iter().find(|o| o.id == other_id) {
                            let ObjectKind::Segment { segment: other_segment } = &other_obj.kind else {
                                continue;
                            };

                            let Segment::Point(point) = other_segment else {
                                continue;
                            };

                            // Get point coordinates in the trim internal unit
                            let point_coords = Coords2d {
                                x: number_to_unit(&point.position.x, default_unit),
                                y: number_to_unit(&point.position.y, default_unit),
                            };

                            // Project the point onto the segment to get its parametric position
                            let point_t = match segment {
                                Segment::Line(_) => project_point_onto_segment(point_coords, start_coords, end_coords),
                                Segment::Arc(_) => {
                                    if let Some(center) = segment_center_coords {
                                        project_point_onto_arc(point_coords, center, start_coords, end_coords)
                                    } else {
                                        continue; // Skip this constraint if no center
                                    }
                                }
                                _ => continue, // Skip non-line/arc segments
                            };

                            // Check if point is at the original end point (skip if so - already handled above)
                            // Use post-solve coordinates for original end point if available
                            let original_end_point_post_solve_coords = if let Some(end_id) = original_end_point_id {
                                if let Some(end_point_obj) = objects.iter().find(|o| o.id == end_id) {
                                    if let ObjectKind::Segment {
                                        segment: Segment::Point(end_point),
                                    } = &end_point_obj.kind
                                    {
                                        Some(Coords2d {
                                            x: number_to_unit(&end_point.position.x, default_unit),
                                            y: number_to_unit(&end_point.position.y, default_unit),
                                        })
                                    } else {
                                        None
                                    }
                                } else {
                                    None
                                }
                            } else {
                                None
                            };

                            let reference_coords = original_end_point_post_solve_coords.unwrap_or(original_end_coords);
                            let dist_to_original_end = ((point_coords.x - reference_coords.x)
                                * (point_coords.x - reference_coords.x)
                                + (point_coords.y - reference_coords.y) * (point_coords.y - reference_coords.y))
                                .sqrt();

                            if dist_to_original_end < EPSILON_POINT_ON_SEGMENT {
                                // This should have been handled in the first loop, but if we find it here,
                                // make sure it's deleted (it might have been missed due to filtering)
                                // Also check if we should migrate it as point-point constraint
                                let has_point_point_constraint = if let Some(end_id) = original_end_point_id {
                                    find_point_point_coincident_constraints(end_id)
                                        .iter()
                                        .any(|&constraint_id| {
                                            if let Some(constraint_obj) = objects.iter().find(|o| o.id == constraint_id)
                                            {
                                                if let ObjectKind::Constraint {
                                                    constraint: Constraint::Coincident(coincident),
                                                } = &constraint_obj.kind
                                                {
                                                    coincident.segments.contains(&other_id)
                                                } else {
                                                    false
                                                }
                                            } else {
                                                false
                                            }
                                        })
                                } else {
                                    false
                                };

                                if !has_point_point_constraint {
                                    // No existing point-point constraint - migrate as point-point constraint
                                    constraints_to_migrate.push(ConstraintToMigrate {
                                        constraint_id: obj.id,
                                        other_entity_id: other_id,
                                        is_point_point: true, // Convert to point-point constraint
                                        attach_to_endpoint: AttachToEndpoint::End, // Attach to new segment's end
                                    });
                                }
                                // Always delete the old point-segment constraint
                                constraints_to_delete_set.insert(obj.id);
                                continue; // Already handled as point-point constraint migration above
                            }

                            // Check if point is at the current start endpoint (skip if so - handled separately)
                            let dist_to_start = ((point_coords.x - start_coords.x) * (point_coords.x - start_coords.x)
                                + (point_coords.y - start_coords.y) * (point_coords.y - start_coords.y))
                                .sqrt();
                            let is_at_start = (point_t - 0.0).abs() < EPSILON_POINT_ON_SEGMENT
                                || dist_to_start < EPSILON_POINT_ON_SEGMENT;

                            if is_at_start {
                                continue; // Handled by endpoint constraint migration
                            }

                            // Check if point is at the split point (don't migrate - would pull halves together)
                            let dist_to_split = (point_t - split_point_t).abs();
                            if dist_to_split < EPSILON_POINT_ON_SEGMENT * 100.0 {
                                continue; // Too close to split point
                            }

                            // If point is after split point (closer to end), migrate to new segment
                            if point_t > split_point_t {
                                constraints_to_migrate.push(ConstraintToMigrate {
                                    constraint_id: obj.id,
                                    other_entity_id: other_id,
                                    is_point_point: false, // Keep as point-segment, but replace the segment
                                    attach_to_endpoint: AttachToEndpoint::Segment, // Replace old segment with new segment
                                });
                                constraints_to_delete_set.insert(obj.id);
                            }
                        }
                    }
                }
            } // End of if let Some(split_point_t)
        } // End of if let (Some(start_coords), Some(end_coords))

        // Find distance constraints that reference the segment being split
        // These need to be deleted and re-added with new endpoints after split
        // BUT: For arcs, we need to exclude distance constraints that reference the center point
        // (those will be migrated separately in the execution code)
        let distance_constraint_ids_for_split = find_distance_constraints_for_segment(trim_spawn_id);

        // Get the center point ID if this is an arc, so we can exclude center point constraints
        let arc_center_point_id: Option<ObjectId> = match segment {
            Segment::Arc(arc) => Some(arc.center),
            _ => None,
        };

        for constraint_id in distance_constraint_ids_for_split {
            // Skip if this is a center point constraint for an arc (will be migrated separately)
            if let Some(center_id) = arc_center_point_id {
                // Check if this constraint references the center point
                if let Some(constraint_obj) = objects.iter().find(|o| o.id == constraint_id)
                    && let ObjectKind::Constraint { constraint } = &constraint_obj.kind
                    && let Constraint::Distance(distance) = constraint
                    && distance.points.contains(&center_id)
                {
                    // This is a center point constraint - skip deletion, it will be migrated
                    continue;
                }
            }

            constraints_to_delete_set.insert(constraint_id);
        }

        // Find angle constraints (Parallel, Perpendicular, Horizontal, Vertical) that reference the segment being split
        // Note: We don't delete these - they still apply to the original (trimmed) segment
        // We'll add new constraints for the new segment in the execution code

        // Catch-all: Find any remaining point-segment constraints involving the segment
        // that we might have missed (e.g., due to coordinate precision issues)
        // This ensures we don't leave orphaned constraints
        for obj in objects {
            let ObjectKind::Constraint { constraint } = &obj.kind else {
                continue;
            };

            let Constraint::Coincident(coincident) = constraint else {
                continue;
            };

            // Only consider constraints that involve the segment ID
            if !coincident.segments.contains(&trim_spawn_id) {
                continue;
            }

            // Skip if already marked for deletion
            if constraints_to_delete_set.contains(&obj.id) {
                continue;
            }

            // Skip if this constraint involves an endpoint directly (handled separately)
            // BUT: if the other entity is a point that's at the original end point geometrically,
            // we still want to handle it here even if it's not the same point object
            // So we'll check this after we verify the other entity is a point and check its coordinates

            // Find the other entity (should be a point)
            let other_id = coincident
                .segments
                .iter()
                .find_map(|seg_id| if *seg_id != trim_spawn_id { Some(*seg_id) } else { None });

            if let Some(other_id) = other_id {
                // Check if the other entity is a point
                if let Some(other_obj) = objects.iter().find(|o| o.id == other_id) {
                    let ObjectKind::Segment { segment: other_segment } = &other_obj.kind else {
                        continue;
                    };

                    let Segment::Point(point) = other_segment else {
                        continue;
                    };

                    // Skip if this constraint involves an endpoint directly (handled separately)
                    // BUT: if the point is at the original end point geometrically, we still want to handle it
                    let _is_endpoint_constraint =
                        if let (Some(start_id), Some(end_id)) = (original_start_point_id, original_end_point_id) {
                            coincident.segments.iter().any(|id| *id == start_id || *id == end_id)
                        } else {
                            false
                        };

                    // Get point coordinates in the trim internal unit
                    let point_coords = Coords2d {
                        x: number_to_unit(&point.position.x, default_unit),
                        y: number_to_unit(&point.position.y, default_unit),
                    };

                    // Check if point is at original end point (with relaxed tolerance for catch-all)
                    let original_end_point_post_solve_coords = if let Some(end_id) = original_end_point_id {
                        if let Some(end_point_obj) = objects.iter().find(|o| o.id == end_id) {
                            if let ObjectKind::Segment {
                                segment: Segment::Point(end_point),
                            } = &end_point_obj.kind
                            {
                                Some(Coords2d {
                                    x: number_to_unit(&end_point.position.x, default_unit),
                                    y: number_to_unit(&end_point.position.y, default_unit),
                                })
                            } else {
                                None
                            }
                        } else {
                            None
                        }
                    } else {
                        None
                    };

                    let reference_coords = original_end_point_post_solve_coords.unwrap_or(original_end_coords);
                    let dist_to_original_end = ((point_coords.x - reference_coords.x)
                        * (point_coords.x - reference_coords.x)
                        + (point_coords.y - reference_coords.y) * (point_coords.y - reference_coords.y))
                        .sqrt();

                    // Use a slightly more relaxed tolerance for catch-all to catch edge cases
                    // Also handle endpoint constraints that might have been missed
                    let is_at_original_end = dist_to_original_end < EPSILON_POINT_ON_SEGMENT * 2.0;

                    if is_at_original_end {
                        // Point is at or very close to original end point - delete the constraint
                        // Check if we should migrate it as point-point constraint
                        let has_point_point_constraint = if let Some(end_id) = original_end_point_id {
                            find_point_point_coincident_constraints(end_id)
                                .iter()
                                .any(|&constraint_id| {
                                    if let Some(constraint_obj) = objects.iter().find(|o| o.id == constraint_id) {
                                        if let ObjectKind::Constraint {
                                            constraint: Constraint::Coincident(coincident),
                                        } = &constraint_obj.kind
                                        {
                                            coincident.segments.contains(&other_id)
                                        } else {
                                            false
                                        }
                                    } else {
                                        false
                                    }
                                })
                        } else {
                            false
                        };

                        if !has_point_point_constraint {
                            // No existing point-point constraint - migrate as point-point constraint
                            constraints_to_migrate.push(ConstraintToMigrate {
                                constraint_id: obj.id,
                                other_entity_id: other_id,
                                is_point_point: true, // Convert to point-point constraint
                                attach_to_endpoint: AttachToEndpoint::End, // Attach to new segment's end
                            });
                        }
                        // Always delete the old point-segment constraint
                        constraints_to_delete_set.insert(obj.id);
                    }
                }
            }
        }

        // Create split segment operation
        let constraints_to_delete: Vec<ObjectId> = constraints_to_delete_set.iter().copied().collect();
        let operations = vec![TrimOperation::SplitSegment {
            segment_id: trim_spawn_id,
            left_trim_coords,
            right_trim_coords,
            original_end_coords,
            left_side: Box::new(left_side.clone()),
            right_side: Box::new(right_side.clone()),
            left_side_coincident_data: CoincidentData {
                intersecting_seg_id: left_intersecting_seg_id,
                intersecting_endpoint_point_id: left_coincident_data.intersecting_endpoint_point_id,
                existing_point_segment_constraint_id: left_coincident_data.existing_point_segment_constraint_id,
            },
            right_side_coincident_data: CoincidentData {
                intersecting_seg_id: right_intersecting_seg_id,
                intersecting_endpoint_point_id: right_coincident_data.intersecting_endpoint_point_id,
                existing_point_segment_constraint_id: right_coincident_data.existing_point_segment_constraint_id,
            },
            constraints_to_migrate,
            constraints_to_delete,
        }];

        return Ok(operations);
    }

    // Only three strategy cases should exist: simple trim (endpoint/endpoint),
    // tail cut (intersection+endpoint), or split (intersection+intersection).
    // If we get here, trim termination pairing was unexpected or a new variant
    // was added without updating the strategy mapping.
    Err(format!(
        "Unsupported trim termination combination: left={:?} right={:?}",
        left_side, right_side
    ))
}

/// Execute the trim operations determined by the trim strategy
///
/// Once we have a trim strategy, it then needs to be executed. This function is separate just to keep
/// one function just collecting info (`trim_strategy`), and the other actually mutating things.
///
/// This function takes the list of trim operations from `trim_strategy` and executes them, which may include:
/// - Deleting segments (SimpleTrim)
/// - Editing segment endpoints (EditSegment)
/// - Adding coincident constraints (AddCoincidentConstraint)
/// - Splitting segments (SplitSegment)
/// - Migrating constraints (MigrateConstraint)
pub(crate) async fn execute_trim_operations_simple(
    strategy: Vec<TrimOperation>,
    current_scene_graph_delta: &crate::frontend::api::SceneGraphDelta,
    frontend: &mut crate::frontend::FrontendState,
    ctx: &crate::ExecutorContext,
    version: crate::frontend::api::Version,
    sketch_id: ObjectId,
) -> Result<(crate::frontend::api::SourceDelta, crate::frontend::api::SceneGraphDelta), String> {
    use crate::frontend::SketchApi;
    use crate::frontend::sketch::Constraint;
    use crate::frontend::sketch::ExistingSegmentCtor;
    use crate::frontend::sketch::SegmentCtor;

    let default_unit = frontend.default_length_unit();

    let mut op_index = 0;
    let mut last_result: Option<(crate::frontend::api::SourceDelta, crate::frontend::api::SceneGraphDelta)> = None;
    let mut invalidates_ids = false;

    while op_index < strategy.len() {
        let mut consumed_ops = 1;
        let operation_result = match &strategy[op_index] {
            TrimOperation::SimpleTrim { segment_to_trim_id } => {
                // Delete the segment
                frontend
                    .delete_objects(
                        ctx,
                        version,
                        sketch_id,
                        Vec::new(),                // constraint_ids
                        vec![*segment_to_trim_id], // segment_ids
                    )
                    .await
                    .map_err(|e| format!("Failed to delete segment: {}", e.msg))
            }
            TrimOperation::EditSegment {
                segment_id,
                ctor,
                endpoint_changed,
            } => {
                // Try to batch tail-cut sequence: EditSegment + AddCoincidentConstraint (+ DeleteConstraints)
                // This matches the batching logic in kcl-wasm-lib/src/api.rs
                if op_index + 1 < strategy.len() {
                    if let TrimOperation::AddCoincidentConstraint {
                        segment_id: coincident_seg_id,
                        endpoint_changed: coincident_endpoint_changed,
                        segment_or_point_to_make_coincident_to,
                        intersecting_endpoint_point_id,
                    } = &strategy[op_index + 1]
                    {
                        if segment_id == coincident_seg_id && endpoint_changed == coincident_endpoint_changed {
                            // This is a tail-cut sequence - batch it!
                            let mut delete_constraint_ids: Vec<ObjectId> = Vec::new();
                            consumed_ops = 2;

                            if op_index + 2 < strategy.len()
                                && let TrimOperation::DeleteConstraints { constraint_ids } = &strategy[op_index + 2]
                            {
                                delete_constraint_ids = constraint_ids.to_vec();
                                consumed_ops = 3;
                            }

                            // Use ctor directly
                            let segment_ctor = ctor.clone();

                            // Get endpoint point id from current scene graph (IDs stay the same after edit)
                            let edited_segment = current_scene_graph_delta
                                .new_graph
                                .objects
                                .iter()
                                .find(|obj| obj.id == *segment_id)
                                .ok_or_else(|| format!("Failed to find segment {} for tail-cut batch", segment_id.0))?;

                            let endpoint_point_id = match &edited_segment.kind {
                                crate::frontend::api::ObjectKind::Segment { segment } => match segment {
                                    crate::frontend::sketch::Segment::Line(line) => {
                                        if *endpoint_changed == EndpointChanged::Start {
                                            line.start
                                        } else {
                                            line.end
                                        }
                                    }
                                    crate::frontend::sketch::Segment::Arc(arc) => {
                                        if *endpoint_changed == EndpointChanged::Start {
                                            arc.start
                                        } else {
                                            arc.end
                                        }
                                    }
                                    _ => {
                                        return Err("Unsupported segment type for tail-cut batch".to_string());
                                    }
                                },
                                _ => {
                                    return Err("Edited object is not a segment (tail-cut batch)".to_string());
                                }
                            };

                            let coincident_segments = if let Some(point_id) = intersecting_endpoint_point_id {
                                vec![endpoint_point_id, *point_id]
                            } else {
                                vec![endpoint_point_id, *segment_or_point_to_make_coincident_to]
                            };

                            let constraint = Constraint::Coincident(crate::frontend::sketch::Coincident {
                                segments: coincident_segments,
                            });

                            let segment_to_edit = ExistingSegmentCtor {
                                id: *segment_id,
                                ctor: segment_ctor,
                            };

                            // Batch the operations - this is the key optimization!
                            // Note: consumed_ops is set above (2 or 3), and we'll use it after the match
                            frontend
                                .batch_tail_cut_operations(
                                    ctx,
                                    version,
                                    sketch_id,
                                    vec![segment_to_edit],
                                    vec![constraint],
                                    delete_constraint_ids,
                                )
                                .await
                                .map_err(|e| format!("Failed to batch tail-cut operations: {}", e.msg))
                        } else {
                            // Not same segment/endpoint - execute EditSegment normally
                            let segment_to_edit = ExistingSegmentCtor {
                                id: *segment_id,
                                ctor: ctor.clone(),
                            };

                            frontend
                                .edit_segments(ctx, version, sketch_id, vec![segment_to_edit])
                                .await
                                .map_err(|e| format!("Failed to edit segment: {}", e.msg))
                        }
                    } else {
                        // Not followed by AddCoincidentConstraint - execute EditSegment normally
                        let segment_to_edit = ExistingSegmentCtor {
                            id: *segment_id,
                            ctor: ctor.clone(),
                        };

                        frontend
                            .edit_segments(ctx, version, sketch_id, vec![segment_to_edit])
                            .await
                            .map_err(|e| format!("Failed to edit segment: {}", e.msg))
                    }
                } else {
                    // No following op to batch with - execute EditSegment normally
                    let segment_to_edit = ExistingSegmentCtor {
                        id: *segment_id,
                        ctor: ctor.clone(),
                    };

                    frontend
                        .edit_segments(ctx, version, sketch_id, vec![segment_to_edit])
                        .await
                        .map_err(|e| format!("Failed to edit segment: {}", e.msg))
                }
            }
            TrimOperation::AddCoincidentConstraint {
                segment_id,
                endpoint_changed,
                segment_or_point_to_make_coincident_to,
                intersecting_endpoint_point_id,
            } => {
                // Find the edited segment to get the endpoint point ID
                let edited_segment = current_scene_graph_delta
                    .new_graph
                    .objects
                    .iter()
                    .find(|obj| obj.id == *segment_id)
                    .ok_or_else(|| format!("Failed to find edited segment {}", segment_id.0))?;

                // Get the endpoint ID after editing
                let new_segment_endpoint_point_id = match &edited_segment.kind {
                    crate::frontend::api::ObjectKind::Segment { segment } => match segment {
                        crate::frontend::sketch::Segment::Line(line) => {
                            if *endpoint_changed == EndpointChanged::Start {
                                line.start
                            } else {
                                line.end
                            }
                        }
                        crate::frontend::sketch::Segment::Arc(arc) => {
                            if *endpoint_changed == EndpointChanged::Start {
                                arc.start
                            } else {
                                arc.end
                            }
                        }
                        _ => {
                            return Err("Unsupported segment type for addCoincidentConstraint".to_string());
                        }
                    },
                    _ => {
                        return Err("Edited object is not a segment".to_string());
                    }
                };

                // Determine coincident segments
                let coincident_segments = if let Some(point_id) = intersecting_endpoint_point_id {
                    vec![new_segment_endpoint_point_id, *point_id]
                } else {
                    vec![new_segment_endpoint_point_id, *segment_or_point_to_make_coincident_to]
                };

                let constraint = Constraint::Coincident(crate::frontend::sketch::Coincident {
                    segments: coincident_segments,
                });

                frontend
                    .add_constraint(ctx, version, sketch_id, constraint)
                    .await
                    .map_err(|e| format!("Failed to add constraint: {}", e.msg))
            }
            TrimOperation::DeleteConstraints { constraint_ids } => {
                // Delete constraints
                let constraint_object_ids: Vec<ObjectId> = constraint_ids.to_vec();

                frontend
                    .delete_objects(
                        ctx,
                        version,
                        sketch_id,
                        constraint_object_ids,
                        Vec::new(), // segment_ids
                    )
                    .await
                    .map_err(|e| format!("Failed to delete constraints: {}", e.msg))
            }
            TrimOperation::SplitSegment {
                segment_id,
                left_trim_coords,
                right_trim_coords,
                original_end_coords,
                left_side,
                right_side,
                constraints_to_migrate,
                constraints_to_delete,
                ..
            } => {
                // SplitSegment is a complex multi-step operation
                // Ported from kcl-wasm-lib/src/api.rs execute_trim function

                // Step 1: Find and validate original segment
                let original_segment = current_scene_graph_delta
                    .new_graph
                    .objects
                    .iter()
                    .find(|obj| obj.id == *segment_id)
                    .ok_or_else(|| format!("Failed to find original segment {}", segment_id.0))?;

                // Extract point IDs from original segment
                let (original_segment_start_point_id, original_segment_end_point_id, original_segment_center_point_id) =
                    match &original_segment.kind {
                        crate::frontend::api::ObjectKind::Segment { segment } => match segment {
                            crate::frontend::sketch::Segment::Line(line) => (Some(line.start), Some(line.end), None),
                            crate::frontend::sketch::Segment::Arc(arc) => {
                                (Some(arc.start), Some(arc.end), Some(arc.center))
                            }
                            _ => (None, None, None),
                        },
                        _ => (None, None, None),
                    };

                // Store center point constraints to migrate BEFORE edit_segments modifies the scene graph
                let mut center_point_constraints_to_migrate: Vec<(Constraint, ObjectId)> = Vec::new();
                if let Some(original_center_id) = original_segment_center_point_id {
                    for obj in &current_scene_graph_delta.new_graph.objects {
                        let crate::frontend::api::ObjectKind::Constraint { constraint } = &obj.kind else {
                            continue;
                        };

                        // Find coincident constraints that reference the original center point
                        if let Constraint::Coincident(coincident) = constraint
                            && coincident.segments.contains(&original_center_id)
                        {
                            center_point_constraints_to_migrate.push((constraint.clone(), original_center_id));
                        }

                        // Find distance constraints that reference the original center point
                        if let Constraint::Distance(distance) = constraint
                            && distance.points.contains(&original_center_id)
                        {
                            center_point_constraints_to_migrate.push((constraint.clone(), original_center_id));
                        }
                    }
                }

                // Extract segment and ctor
                let (_segment_type, original_ctor) = match &original_segment.kind {
                    crate::frontend::api::ObjectKind::Segment { segment } => match segment {
                        crate::frontend::sketch::Segment::Line(line) => ("Line", line.ctor.clone()),
                        crate::frontend::sketch::Segment::Arc(arc) => ("Arc", arc.ctor.clone()),
                        _ => {
                            return Err("Original segment is not a Line or Arc".to_string());
                        }
                    },
                    _ => {
                        return Err("Original object is not a segment".to_string());
                    }
                };

                // Extract units from the existing ctor
                let units = match &original_ctor {
                    SegmentCtor::Line(line_ctor) => match &line_ctor.start.x {
                        crate::frontend::api::Expr::Var(v) | crate::frontend::api::Expr::Number(v) => v.units,
                        _ => crate::pretty::NumericSuffix::Mm,
                    },
                    SegmentCtor::Arc(arc_ctor) => match &arc_ctor.start.x {
                        crate::frontend::api::Expr::Var(v) | crate::frontend::api::Expr::Number(v) => v.units,
                        _ => crate::pretty::NumericSuffix::Mm,
                    },
                    _ => crate::pretty::NumericSuffix::Mm,
                };

                // Helper to convert Coords2d (current trim unit) to Point2d in segment units.
                // No rounding here; rounding happens at final conversion to output if needed.
                let coords_to_point =
                    |coords: Coords2d| -> crate::frontend::sketch::Point2d<crate::frontend::api::Number> {
                        crate::frontend::sketch::Point2d {
                            x: unit_to_number(coords.x, default_unit, units),
                            y: unit_to_number(coords.y, default_unit, units),
                        }
                    };

                // Convert Point2d<Number> to Point2d<Expr> for SegmentCtor
                let point_to_expr = |point: crate::frontend::sketch::Point2d<crate::frontend::api::Number>| -> crate::frontend::sketch::Point2d<crate::frontend::api::Expr> {
                    crate::frontend::sketch::Point2d {
                        x: crate::frontend::api::Expr::Var(point.x),
                        y: crate::frontend::api::Expr::Var(point.y),
                    }
                };

                // Step 2: Create new segment (right side) first to get its IDs
                let new_segment_ctor = match &original_ctor {
                    SegmentCtor::Line(line_ctor) => SegmentCtor::Line(crate::frontend::sketch::LineCtor {
                        start: point_to_expr(coords_to_point(*right_trim_coords)),
                        end: point_to_expr(coords_to_point(*original_end_coords)),
                        construction: line_ctor.construction,
                    }),
                    SegmentCtor::Arc(arc_ctor) => SegmentCtor::Arc(crate::frontend::sketch::ArcCtor {
                        start: point_to_expr(coords_to_point(*right_trim_coords)),
                        end: point_to_expr(coords_to_point(*original_end_coords)),
                        center: arc_ctor.center.clone(),
                        construction: arc_ctor.construction,
                    }),
                    _ => {
                        return Err("Unsupported segment type for new segment".to_string());
                    }
                };

                let (_add_source_delta, add_scene_graph_delta) = frontend
                    .add_segment(ctx, version, sketch_id, new_segment_ctor, None)
                    .await
                    .map_err(|e| format!("Failed to add new segment: {}", e.msg))?;

                // Step 3: Find the newly created segment
                let new_segment_id = *add_scene_graph_delta
                    .new_objects
                    .iter()
                    .find(|&id| {
                        if let Some(obj) = add_scene_graph_delta.new_graph.objects.iter().find(|o| o.id == *id) {
                            matches!(
                                &obj.kind,
                                crate::frontend::api::ObjectKind::Segment { segment }
                                    if matches!(segment, crate::frontend::sketch::Segment::Line(_) | crate::frontend::sketch::Segment::Arc(_))
                            )
                        } else {
                            false
                        }
                    })
                    .ok_or_else(|| "Failed to find newly created segment".to_string())?;

                let new_segment = add_scene_graph_delta
                    .new_graph
                    .objects
                    .iter()
                    .find(|o| o.id == new_segment_id)
                    .ok_or_else(|| format!("New segment not found with id {}", new_segment_id.0))?;

                // Extract endpoint IDs
                let (new_segment_start_point_id, new_segment_end_point_id, new_segment_center_point_id) =
                    match &new_segment.kind {
                        crate::frontend::api::ObjectKind::Segment { segment } => match segment {
                            crate::frontend::sketch::Segment::Line(line) => (line.start, line.end, None),
                            crate::frontend::sketch::Segment::Arc(arc) => (arc.start, arc.end, Some(arc.center)),
                            _ => {
                                return Err("New segment is not a Line or Arc".to_string());
                            }
                        },
                        _ => {
                            return Err("New segment is not a segment".to_string());
                        }
                    };

                // Step 4: Edit the original segment (trim left side)
                let edited_ctor = match &original_ctor {
                    SegmentCtor::Line(line_ctor) => SegmentCtor::Line(crate::frontend::sketch::LineCtor {
                        start: line_ctor.start.clone(),
                        end: point_to_expr(coords_to_point(*left_trim_coords)),
                        construction: line_ctor.construction,
                    }),
                    SegmentCtor::Arc(arc_ctor) => SegmentCtor::Arc(crate::frontend::sketch::ArcCtor {
                        start: arc_ctor.start.clone(),
                        end: point_to_expr(coords_to_point(*left_trim_coords)),
                        center: arc_ctor.center.clone(),
                        construction: arc_ctor.construction,
                    }),
                    _ => {
                        return Err("Unsupported segment type for split".to_string());
                    }
                };

                let (_edit_source_delta, edit_scene_graph_delta) = frontend
                    .edit_segments(
                        ctx,
                        version,
                        sketch_id,
                        vec![ExistingSegmentCtor {
                            id: *segment_id,
                            ctor: edited_ctor,
                        }],
                    )
                    .await
                    .map_err(|e| format!("Failed to edit segment: {}", e.msg))?;
                // Track invalidates_ids from edit_segments call
                invalidates_ids = invalidates_ids || edit_scene_graph_delta.invalidates_ids;

                // Get left endpoint ID from edited segment
                let edited_segment = edit_scene_graph_delta
                    .new_graph
                    .objects
                    .iter()
                    .find(|obj| obj.id == *segment_id)
                    .ok_or_else(|| format!("Failed to find edited segment {}", segment_id.0))?;

                let left_side_endpoint_point_id = match &edited_segment.kind {
                    crate::frontend::api::ObjectKind::Segment { segment } => match segment {
                        crate::frontend::sketch::Segment::Line(line) => line.end,
                        crate::frontend::sketch::Segment::Arc(arc) => arc.end,
                        _ => {
                            return Err("Edited segment is not a Line or Arc".to_string());
                        }
                    },
                    _ => {
                        return Err("Edited segment is not a segment".to_string());
                    }
                };

                // Step 5: Prepare constraints for batch
                let mut batch_constraints = Vec::new();

                // Left constraint
                let left_intersecting_seg_id = match &**left_side {
                    TrimTermination::Intersection {
                        intersecting_seg_id, ..
                    }
                    | TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                        intersecting_seg_id, ..
                    } => *intersecting_seg_id,
                    _ => {
                        return Err("Left side is not an intersection or coincident".to_string());
                    }
                };
                let left_coincident_segments = match &**left_side {
                    TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                        other_segment_point_id,
                        ..
                    } => {
                        vec![left_side_endpoint_point_id, *other_segment_point_id]
                    }
                    _ => {
                        vec![left_side_endpoint_point_id, left_intersecting_seg_id]
                    }
                };
                batch_constraints.push(Constraint::Coincident(crate::frontend::sketch::Coincident {
                    segments: left_coincident_segments,
                }));

                // Right constraint - need to check if intersection is at endpoint
                let right_intersecting_seg_id = match &**right_side {
                    TrimTermination::Intersection {
                        intersecting_seg_id, ..
                    }
                    | TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                        intersecting_seg_id, ..
                    } => *intersecting_seg_id,
                    _ => {
                        return Err("Right side is not an intersection or coincident".to_string());
                    }
                };

                let mut intersection_point_id: Option<ObjectId> = None;
                if matches!(&**right_side, TrimTermination::Intersection { .. }) {
                    let intersecting_seg = edit_scene_graph_delta
                        .new_graph
                        .objects
                        .iter()
                        .find(|obj| obj.id == right_intersecting_seg_id);

                    if let Some(seg) = intersecting_seg {
                        let endpoint_epsilon = 1e-3; // In current trim unit
                        let right_trim_coords_value = *right_trim_coords;

                        if let crate::frontend::api::ObjectKind::Segment { segment } = &seg.kind {
                            match segment {
                                crate::frontend::sketch::Segment::Line(_) => {
                                    if let (Some(start_coords), Some(end_coords)) = (
                                        crate::frontend::trim::get_position_coords_for_line(
                                            seg,
                                            crate::frontend::trim::LineEndpoint::Start,
                                            &edit_scene_graph_delta.new_graph.objects,
                                            default_unit,
                                        ),
                                        crate::frontend::trim::get_position_coords_for_line(
                                            seg,
                                            crate::frontend::trim::LineEndpoint::End,
                                            &edit_scene_graph_delta.new_graph.objects,
                                            default_unit,
                                        ),
                                    ) {
                                        let dist_to_start = ((right_trim_coords_value.x - start_coords.x)
                                            * (right_trim_coords_value.x - start_coords.x)
                                            + (right_trim_coords_value.y - start_coords.y)
                                                * (right_trim_coords_value.y - start_coords.y))
                                            .sqrt();
                                        if dist_to_start < endpoint_epsilon {
                                            if let crate::frontend::sketch::Segment::Line(line) = segment {
                                                intersection_point_id = Some(line.start);
                                            }
                                        } else {
                                            let dist_to_end = ((right_trim_coords_value.x - end_coords.x)
                                                * (right_trim_coords_value.x - end_coords.x)
                                                + (right_trim_coords_value.y - end_coords.y)
                                                    * (right_trim_coords_value.y - end_coords.y))
                                                .sqrt();
                                            if dist_to_end < endpoint_epsilon
                                                && let crate::frontend::sketch::Segment::Line(line) = segment
                                            {
                                                intersection_point_id = Some(line.end);
                                            }
                                        }
                                    }
                                }
                                crate::frontend::sketch::Segment::Arc(_) => {
                                    if let (Some(start_coords), Some(end_coords)) = (
                                        crate::frontend::trim::get_position_coords_from_arc(
                                            seg,
                                            crate::frontend::trim::ArcPoint::Start,
                                            &edit_scene_graph_delta.new_graph.objects,
                                            default_unit,
                                        ),
                                        crate::frontend::trim::get_position_coords_from_arc(
                                            seg,
                                            crate::frontend::trim::ArcPoint::End,
                                            &edit_scene_graph_delta.new_graph.objects,
                                            default_unit,
                                        ),
                                    ) {
                                        let dist_to_start = ((right_trim_coords_value.x - start_coords.x)
                                            * (right_trim_coords_value.x - start_coords.x)
                                            + (right_trim_coords_value.y - start_coords.y)
                                                * (right_trim_coords_value.y - start_coords.y))
                                            .sqrt();
                                        if dist_to_start < endpoint_epsilon {
                                            if let crate::frontend::sketch::Segment::Arc(arc) = segment {
                                                intersection_point_id = Some(arc.start);
                                            }
                                        } else {
                                            let dist_to_end = ((right_trim_coords_value.x - end_coords.x)
                                                * (right_trim_coords_value.x - end_coords.x)
                                                + (right_trim_coords_value.y - end_coords.y)
                                                    * (right_trim_coords_value.y - end_coords.y))
                                                .sqrt();
                                            if dist_to_end < endpoint_epsilon
                                                && let crate::frontend::sketch::Segment::Arc(arc) = segment
                                            {
                                                intersection_point_id = Some(arc.end);
                                            }
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }

                let right_coincident_segments = if let Some(point_id) = intersection_point_id {
                    vec![new_segment_start_point_id, point_id]
                } else if let TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                    other_segment_point_id,
                    ..
                } = &**right_side
                {
                    vec![new_segment_start_point_id, *other_segment_point_id]
                } else {
                    vec![new_segment_start_point_id, right_intersecting_seg_id]
                };
                batch_constraints.push(Constraint::Coincident(crate::frontend::sketch::Coincident {
                    segments: right_coincident_segments,
                }));

                // Migrate constraints
                let mut points_constrained_to_new_segment_start = std::collections::HashSet::new();
                let mut points_constrained_to_new_segment_end = std::collections::HashSet::new();

                if let TrimTermination::TrimSpawnSegmentCoincidentWithAnotherSegmentPoint {
                    other_segment_point_id,
                    ..
                } = &**right_side
                {
                    points_constrained_to_new_segment_start.insert(other_segment_point_id);
                }

                for constraint_to_migrate in constraints_to_migrate.iter() {
                    if constraint_to_migrate.attach_to_endpoint == AttachToEndpoint::End
                        && constraint_to_migrate.is_point_point
                    {
                        points_constrained_to_new_segment_end.insert(constraint_to_migrate.other_entity_id);
                    }
                }

                for constraint_to_migrate in constraints_to_migrate.iter() {
                    // Skip migrating point-segment constraints if the point is already constrained
                    if constraint_to_migrate.attach_to_endpoint == AttachToEndpoint::Segment
                        && (points_constrained_to_new_segment_start.contains(&constraint_to_migrate.other_entity_id)
                            || points_constrained_to_new_segment_end.contains(&constraint_to_migrate.other_entity_id))
                    {
                        continue; // Skip redundant constraint
                    }

                    let constraint_segments = if constraint_to_migrate.attach_to_endpoint == AttachToEndpoint::Segment {
                        vec![constraint_to_migrate.other_entity_id, new_segment_id]
                    } else {
                        let target_endpoint_id = if constraint_to_migrate.attach_to_endpoint == AttachToEndpoint::Start
                        {
                            new_segment_start_point_id
                        } else {
                            new_segment_end_point_id
                        };
                        vec![target_endpoint_id, constraint_to_migrate.other_entity_id]
                    };
                    batch_constraints.push(Constraint::Coincident(crate::frontend::sketch::Coincident {
                        segments: constraint_segments,
                    }));
                }

                // Find distance constraints that reference both endpoints of the original segment
                let mut distance_constraints_to_re_add: Vec<(
                    crate::frontend::api::Number,
                    crate::frontend::sketch::ConstraintSource,
                )> = Vec::new();
                if let (Some(original_start_id), Some(original_end_id)) =
                    (original_segment_start_point_id, original_segment_end_point_id)
                {
                    for obj in &edit_scene_graph_delta.new_graph.objects {
                        let crate::frontend::api::ObjectKind::Constraint { constraint } = &obj.kind else {
                            continue;
                        };

                        let Constraint::Distance(distance) = constraint else {
                            continue;
                        };

                        let references_start = distance.points.contains(&original_start_id);
                        let references_end = distance.points.contains(&original_end_id);

                        if references_start && references_end {
                            distance_constraints_to_re_add.push((distance.distance, distance.source.clone()));
                        }
                    }
                }

                // Re-add distance constraints
                if let Some(original_start_id) = original_segment_start_point_id {
                    for (distance_value, source) in distance_constraints_to_re_add {
                        batch_constraints.push(Constraint::Distance(crate::frontend::sketch::Distance {
                            points: vec![original_start_id, new_segment_end_point_id],
                            distance: distance_value,
                            source,
                        }));
                    }
                }

                // Migrate center point constraints for arcs
                if let Some(new_center_id) = new_segment_center_point_id {
                    for (constraint, original_center_id) in center_point_constraints_to_migrate {
                        match constraint {
                            Constraint::Coincident(coincident) => {
                                let new_segments: Vec<ObjectId> = coincident
                                    .segments
                                    .iter()
                                    .map(|seg_id| {
                                        if *seg_id == original_center_id {
                                            new_center_id
                                        } else {
                                            *seg_id
                                        }
                                    })
                                    .collect();

                                batch_constraints.push(Constraint::Coincident(crate::frontend::sketch::Coincident {
                                    segments: new_segments,
                                }));
                            }
                            Constraint::Distance(distance) => {
                                let new_points: Vec<ObjectId> = distance
                                    .points
                                    .iter()
                                    .map(|pt| if *pt == original_center_id { new_center_id } else { *pt })
                                    .collect();

                                batch_constraints.push(Constraint::Distance(crate::frontend::sketch::Distance {
                                    points: new_points,
                                    distance: distance.distance,
                                    source: distance.source.clone(),
                                }));
                            }
                            _ => {}
                        }
                    }
                }

                // Re-add angle constraints (Parallel, Perpendicular, Horizontal, Vertical)
                for obj in &edit_scene_graph_delta.new_graph.objects {
                    let crate::frontend::api::ObjectKind::Constraint { constraint } = &obj.kind else {
                        continue;
                    };

                    let should_migrate = match constraint {
                        Constraint::Parallel(parallel) => parallel.lines.contains(segment_id),
                        Constraint::Perpendicular(perpendicular) => perpendicular.lines.contains(segment_id),
                        Constraint::Horizontal(horizontal) => horizontal.line == *segment_id,
                        Constraint::Vertical(vertical) => vertical.line == *segment_id,
                        _ => false,
                    };

                    if should_migrate {
                        let migrated_constraint = match constraint {
                            Constraint::Parallel(parallel) => {
                                let new_lines: Vec<ObjectId> = parallel
                                    .lines
                                    .iter()
                                    .map(|line_id| {
                                        if *line_id == *segment_id {
                                            new_segment_id
                                        } else {
                                            *line_id
                                        }
                                    })
                                    .collect();
                                Constraint::Parallel(crate::frontend::sketch::Parallel { lines: new_lines })
                            }
                            Constraint::Perpendicular(perpendicular) => {
                                let new_lines: Vec<ObjectId> = perpendicular
                                    .lines
                                    .iter()
                                    .map(|line_id| {
                                        if *line_id == *segment_id {
                                            new_segment_id
                                        } else {
                                            *line_id
                                        }
                                    })
                                    .collect();
                                Constraint::Perpendicular(crate::frontend::sketch::Perpendicular { lines: new_lines })
                            }
                            Constraint::Horizontal(horizontal) => {
                                if horizontal.line == *segment_id {
                                    Constraint::Horizontal(crate::frontend::sketch::Horizontal { line: new_segment_id })
                                } else {
                                    continue;
                                }
                            }
                            Constraint::Vertical(vertical) => {
                                if vertical.line == *segment_id {
                                    Constraint::Vertical(crate::frontend::sketch::Vertical { line: new_segment_id })
                                } else {
                                    continue;
                                }
                            }
                            _ => continue,
                        };
                        batch_constraints.push(migrated_constraint);
                    }
                }

                // Step 6: Batch all remaining operations
                let constraint_object_ids: Vec<ObjectId> = constraints_to_delete.to_vec();

                let batch_result = frontend
                    .batch_split_segment_operations(
                        ctx,
                        version,
                        sketch_id,
                        Vec::new(), // edit_segments already done
                        batch_constraints,
                        constraint_object_ids,
                        crate::frontend::sketch::NewSegmentInfo {
                            segment_id: new_segment_id,
                            start_point_id: new_segment_start_point_id,
                            end_point_id: new_segment_end_point_id,
                            center_point_id: new_segment_center_point_id,
                        },
                    )
                    .await
                    .map_err(|e| format!("Failed to batch split segment operations: {}", e.msg));
                // Track invalidates_ids from batch_split_segment_operations call
                if let Ok((_, ref batch_delta)) = batch_result {
                    invalidates_ids = invalidates_ids || batch_delta.invalidates_ids;
                }
                batch_result
            }
        };

        match operation_result {
            Ok((source_delta, scene_graph_delta)) => {
                // Track invalidates_ids from each operation result
                invalidates_ids = invalidates_ids || scene_graph_delta.invalidates_ids;
                last_result = Some((source_delta, scene_graph_delta.clone()));
            }
            Err(e) => {
                crate::logln!("Error executing trim operation {}: {}", op_index, e);
                // Continue to next operation
            }
        }

        op_index += consumed_ops;
    }

    let (source_delta, mut scene_graph_delta) =
        last_result.ok_or_else(|| "No operations were executed successfully".to_string())?;
    // Set invalidates_ids if any operation invalidated IDs
    scene_graph_delta.invalidates_ids = invalidates_ids;
    Ok((source_delta, scene_graph_delta))
}