//! Viewport overlay widgets.

use std::cell::RefCell;
use std::collections::HashMap;

use glam::{Mat4, Vec3};
use iced::mouse;
use iced::widget::canvas;
use iced::{Color, Element, Length, Point, Size, Theme};

use crate::app::Message;
use crate::app::settings::{CursorType, IsoPlane};
use crate::scene::model::object::GripShape;
use crate::scene::SelectionState;

use crate::snap::SnapType;
use std::sync::Arc;

/// Original crosshair geometry retained at the default setting values.
pub const CROSSHAIR_SQ: f32 = 7.5;
pub const CROSSHAIR_ARM: f32 = 60.0;
const DEFAULT_CURSOR_SIZE: i32 = 5;
const DEFAULT_PICK_BOX: i32 = 3;
const DEFAULT_PICK_APERTURE: f32 = 8.0;
const CONSTRAINT_GLYPH_SIZE: f32 = 14.0;
const CONSTRAINT_GLYPH_PAD_X: f32 = 7.0;
const CONSTRAINT_GLYPH_PAD_Y: f32 = 4.0;
const CONSTRAINT_GLYPH_GAP: f32 = 6.0;
const CONSTRAINT_GLYPH_ROW_GAP: f32 = 4.0;
const CONSTRAINT_HOVER_MARKER_RADIUS: f32 = 7.0;
const COINCIDENT_GLYPH_SIZE: f32 = 9.0;

fn is_compact_coincident_glyph(label: &str) -> bool {
    matches!(label, "≡" | "∈")
}

fn constraint_glyph_size(label: &str) -> Size {
    if is_compact_coincident_glyph(label) {
        return Size::new(COINCIDENT_GLYPH_SIZE, COINCIDENT_GLYPH_SIZE);
    }
    if label == "G²" {
        let side = CONSTRAINT_GLYPH_SIZE + CONSTRAINT_GLYPH_PAD_Y * 2.0;
        return Size::new(side, side);
    }
    let w = label.chars().count() as f32 * CONSTRAINT_GLYPH_SIZE * 0.62
        + CONSTRAINT_GLYPH_PAD_X * 2.0;
    let h = CONSTRAINT_GLYPH_SIZE + CONSTRAINT_GLYPH_PAD_Y * 2.0;
    Size::new(w, h)
}

fn draw_smooth_constraint_glyph(frame: &mut canvas::Frame, center: Point, color: Color) {
    let curve = canvas::Path::new(|builder| {
        for step in 0..=16 {
            let x = -7.0 + step as f32 * 0.875;
            let y = 0.012 * x * x * x;
            let point = Point::new(center.x + x, center.y - y);
            if step == 0 {
                builder.move_to(point);
            } else {
                builder.line_to(point);
            }
        }
    });
    frame.stroke(
        &curve,
        canvas::Stroke::default().with_color(color).with_width(1.45),
    );
    frame.fill(&canvas::Path::circle(center, 1.35), color);
}

fn draw_tangent_constraint_glyph(
    frame: &mut canvas::Frame,
    center: Point,
    color: Color,
) {
    let radius = 4.5;
    let circle_center = Point::new(center.x - 0.3, center.y + 2.75);
    let diagonal = radius * std::f32::consts::FRAC_1_SQRT_2;
    let contact = Point::new(circle_center.x - diagonal, circle_center.y - diagonal);
    let tangent_end = Point::new(contact.x + 8.0, contact.y - 8.0);
    let stroke = canvas::Stroke::default().with_color(color).with_width(1.35);

    frame.stroke(&canvas::Path::circle(circle_center, radius), stroke.clone());
    frame.stroke(&canvas::Path::line(contact, tangent_end), stroke);
}

fn draw_concentric_constraint_glyph(
    frame: &mut canvas::Frame,
    center: Point,
    color: Color,
) {
    let stroke = canvas::Stroke::default().with_color(color).with_width(1.25);
    frame.stroke(&canvas::Path::circle(center, 4.7), stroke.clone());
    frame.stroke(&canvas::Path::circle(center, 2.15), stroke);
}

fn constraint_glyph_box(
    anchor: Point,
    outward: [f32; 2],
    label: &str,
    tangent_offset: f32,
) -> (Point, Size) {
    let size = constraint_glyph_size(label);
    let gap = if is_compact_coincident_glyph(label) {
        1.0
    } else {
        CONSTRAINT_GLYPH_GAP
    };
    let distance = outward[0].abs() * size.width * 0.5
        + outward[1].abs() * size.height * 0.5
        + gap;
    let tangent = [-outward[1], outward[0]];
    (
        Point::new(
            anchor.x + outward[0] * distance + tangent[0] * tangent_offset
                - size.width * 0.5,
            anchor.y + outward[1] * distance + tangent[1] * tangent_offset
                - size.height * 0.5,
        ),
        size,
    )
}

fn constraint_glyph_offsets(glyphs: &[(Point, [f32; 2], String, bool)]) -> Vec<f32> {
    let mut groups: HashMap<[u32; 4], Vec<usize>> = HashMap::new();
    for (index, (anchor, outward, _, _)) in glyphs.iter().enumerate() {
        groups
            .entry([
                anchor.x.to_bits(),
                anchor.y.to_bits(),
                outward[0].to_bits(),
                outward[1].to_bits(),
            ])
            .or_default()
            .push(index);
    }

    let mut offsets = vec![0.0; glyphs.len()];
    for indices in groups.values().filter(|indices| indices.len() > 1) {
        let half_extents: Vec<f32> = indices
            .iter()
            .map(|index| {
                let (_, outward, label, _) = &glyphs[*index];
                let size = constraint_glyph_size(label);
                let tangent = [-outward[1], outward[0]];
                tangent[0].abs() * size.width * 0.5
                    + tangent[1].abs() * size.height * 0.5
            })
            .collect();
        let total = half_extents.iter().sum::<f32>() * 2.0
            + CONSTRAINT_GLYPH_ROW_GAP * (indices.len() - 1) as f32;
        let mut cursor = -total * 0.5;
        for (index, half_extent) in indices.iter().zip(half_extents) {
            offsets[*index] = cursor + half_extent;
            cursor += half_extent * 2.0 + CONSTRAINT_GLYPH_ROW_GAP;
        }
    }
    offsets
}

/// Hit-tests screen point `p` against the same glyph-pill layout `draw`
/// renders — reusing `constraint_glyph_offsets`/`constraint_glyph_box` so
/// the clickable area can never drift from what's actually drawn, including
/// the tangential fan-out applied when several glyphs share one anchor.
/// Returns the index into `glyphs` of the topmost (last-drawn) match.
/// `Scene::constraint_glyph_hit` maps the index back to a constraint id.
pub(crate) fn constraint_glyph_hit_test(
    glyphs: &[(Point, [f32; 2], String, bool)],
    p: Point,
) -> Option<usize> {
    let offsets = constraint_glyph_offsets(glyphs);
    glyphs
        .iter()
        .zip(offsets)
        .enumerate()
        .rev()
        .find_map(|(index, ((anchor, outward, label, _), tangent_offset))| {
            let (top_left, size) = constraint_glyph_box(*anchor, *outward, label, tangent_offset);
            let within = p.x >= top_left.x
                && p.x <= top_left.x + size.width
                && p.y >= top_left.y
                && p.y <= top_left.y + size.height;
            within.then_some(index)
        })
}

/// Convert CURSORSIZE to a screen-space arm length while keeping the original
/// 60 px cursor at the default value and the full-viewport result at 100.
pub(crate) fn crosshair_arm_px(bounds: iced::Rectangle, value: i32) -> f32 {
    let value = value.clamp(1, 100);
    if value <= DEFAULT_CURSOR_SIZE {
        return CROSSHAIR_ARM * value as f32 / DEFAULT_CURSOR_SIZE as f32;
    }

    let full = bounds.width.hypot(bounds.height).max(CROSSHAIR_ARM);
    let scale = (value - DEFAULT_CURSOR_SIZE) as f32 / (100 - DEFAULT_CURSOR_SIZE) as f32;
    CROSSHAIR_ARM + (full - CROSSHAIR_ARM) * scale
}

/// Convert PICKBOX to the visible half-size while retaining the original
/// 15 x 15 px center box at the default value.
pub(crate) fn pick_box_half_px(value: i32) -> f32 {
    let value = value.clamp(0, 50);
    if value <= DEFAULT_PICK_BOX {
        return CROSSHAIR_SQ * value as f32 / DEFAULT_PICK_BOX as f32;
    }

    let scale = (value - DEFAULT_PICK_BOX) as f32 / (50 - DEFAULT_PICK_BOX) as f32;
    CROSSHAIR_SQ + (50.0 - CROSSHAIR_SQ) * scale
}

/// Convert PICKBOX to the real click/hover aperture. A zero setting hides the
/// box but retains the one-pixel minimum needed for direct hits.
pub(crate) fn pick_box_aperture_px(value: i32) -> f32 {
    let value = value.clamp(0, 50);
    let aperture = if value <= DEFAULT_PICK_BOX {
        DEFAULT_PICK_APERTURE * value as f32 / DEFAULT_PICK_BOX as f32
    } else {
        let scale = (value - DEFAULT_PICK_BOX) as f32 / (50 - DEFAULT_PICK_BOX) as f32;
        DEFAULT_PICK_APERTURE + (50.0 - DEFAULT_PICK_APERTURE) * scale
    };
    aperture.max(1.0)
}

#[derive(Clone, Copy)]
pub struct CrosshairOptions {
    pub size_percent: i32,
    pub pick_box: i32,
    pub cursor_type: CursorType,
    pub color: Option<[u8; 3]>,
    pub isometric: bool,
    pub iso_plane: IsoPlane,
    pub snap_angle_deg: f32,
    pub point_mode: bool,
}

/// Rendering style for the viewport grid.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct GridStyle {
    pub opacity: u8,
    pub bg_luminance: f32,
}

impl Default for GridStyle {
    fn default() -> Self {
        Self {
            opacity: 18,
            bg_luminance: 0.15,
        }
    }
}

/// Visual effect options for selection windows, crossings, entity highlights, and grips.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SelectionVisualOptions {
    pub area: bool,
    pub opacity: u8,
    pub window_color: u8,
    pub crossing_color: u8,
    pub highlight_color: u8,
    pub grip_size: f32,
    pub grip_color: u8,
    pub grip_hot: u8,
    pub grip_hover: u8,
}

impl Default for SelectionVisualOptions {
    fn default() -> Self {
        Self {
            area: true,
            opacity: 12,
            window_color: 0,
            crossing_color: 0,
            highlight_color: 0,
            grip_size: 5.0,
            grip_color: 0,
            grip_hot: 0,
            grip_hover: 0,
        }
    }
}

/// Standard CAD crossing selection color (emerald green: `#33B870` / RGB `0.20, 0.72, 0.44`).
pub const DEFAULT_CROSSING_COLOR: Color = Color {
    r: 0.20,
    g: 0.72,
    b: 0.44,
    a: 1.0,
};

/// Standard CAD window selection color (cobalt blue: `#3370B8` / RGB `0.20, 0.44, 0.72`).
pub const DEFAULT_WINDOW_COLOR: Color = Color {
    r: 0.20,
    g: 0.44,
    b: 0.72,
    a: 1.0,
};

/// Returns the curated (crossing_color, window_color) pair tailored for a specific theme.
/// Crossing is always a theme-harmonious green/teal variant, and Window is always a theme-harmonious blue/cyan variant.
pub fn theme_selection_colors(theme: &Theme) -> (Color, Color) {
    match theme {
        Theme::Dark => (
            DEFAULT_CROSSING_COLOR,
            DEFAULT_WINDOW_COLOR,
        ),
        Theme::Light => (
            Color::from_rgb(0.12, 0.52, 0.30), // Engineering Forest Green
            Color::from_rgb(0.13, 0.40, 0.70), // Engineering Blueprint Blue
        ),
        Theme::Oxocarbon => (
            Color::from_rgb(0.26, 0.75, 0.40), // Oxocarbon Green (#42be65)
            Color::from_rgb(0.20, 0.69, 1.00), // Oxocarbon Vibrant Cyan (#33b1ff)
        ),
        Theme::Dracula => (
            Color::from_rgb(0.31, 0.98, 0.48), // Dracula Neon Green (#50fa7b)
            Color::from_rgb(0.54, 0.91, 0.99), // Dracula Vibrant Cyan (#8be9fd)
        ),
        Theme::Nord => (
            Color::from_rgb(0.64, 0.75, 0.55), // Nord Aurora Green (#a3be8c)
            Color::from_rgb(0.53, 0.75, 0.82), // Nord Frost Cyan (#88c0d0)
        ),
        Theme::GruvboxDark => (
            Color::from_rgb(0.72, 0.73, 0.15), // Gruvbox Bright Green (#b8bb26)
            Color::from_rgb(0.51, 0.65, 0.60), // Gruvbox Blue/Aqua (#83a598)
        ),
        Theme::GruvboxLight => (
            Color::from_rgb(0.47, 0.46, 0.05), // Gruvbox Dark Olive Green (#78750d)
            Color::from_rgb(0.03, 0.40, 0.47), // Gruvbox Deep Teal (#076678)
        ),
        Theme::SolarizedDark => (
            Color::from_rgb(0.52, 0.60, 0.00), // Solarized Green (#859900)
            Color::from_rgb(0.15, 0.55, 0.82), // Solarized Blue (#268bd2)
        ),
        Theme::SolarizedLight => (
            Color::from_rgb(0.44, 0.53, 0.00), // Solarized Deep Green (#708700)
            Color::from_rgb(0.12, 0.47, 0.72), // Solarized Deep Blue (#1f78b8)
        ),
        Theme::TokyoNight | Theme::TokyoNightStorm => (
            Color::from_rgb(0.45, 0.85, 0.79), // Tokyo Night Teal Green (#73daca)
            Color::from_rgb(0.48, 0.64, 0.97), // Tokyo Night Electric Blue (#7aa2f7)
        ),
        Theme::TokyoNightLight => (
            Color::from_rgb(0.22, 0.45, 0.37), // Tokyo Night Dark Teal (#38735e)
            Color::from_rgb(0.20, 0.35, 0.60), // Tokyo Night Deep Blue (#335999)
        ),
        Theme::KanagawaWave => (
            Color::from_rgb(0.60, 0.73, 0.42), // Spring Green (#98bb6c)
            Color::from_rgb(0.49, 0.61, 0.85), // Crystal Blue (#7e9cd8)
        ),
        Theme::KanagawaDragon => (
            Color::from_rgb(0.53, 0.66, 0.53), // Dragon Green (#87a987)
            Color::from_rgb(0.40, 0.52, 0.58), // Dragon Blue (#668594)
        ),
        Theme::KanagawaLotus => (
            Color::from_rgb(0.38, 0.49, 0.25), // Lotus Deep Green (#617d40)
            Color::from_rgb(0.24, 0.38, 0.53), // Lotus Deep Blue (#3d6187)
        ),
        Theme::CatppuccinMocha => (
            Color::from_rgb(0.65, 0.89, 0.63), // Mocha Green (#a6e3a1)
            Color::from_rgb(0.54, 0.71, 0.98), // Mocha Sapphire (#89b4fa)
        ),
        Theme::CatppuccinMacchiato => (
            Color::from_rgb(0.65, 0.85, 0.58), // Macchiato Green (#a6da95)
            Color::from_rgb(0.54, 0.68, 0.96), // Macchiato Blue (#8aadf4)
        ),
        Theme::CatppuccinFrappe => (
            Color::from_rgb(0.65, 0.82, 0.54), // Frappe Green (#a6d189)
            Color::from_rgb(0.55, 0.67, 0.93), // Frappe Blue (#8caaee)
        ),
        Theme::CatppuccinLatte => (
            Color::from_rgb(0.25, 0.63, 0.17), // Latte Green (#40a02b)
            Color::from_rgb(0.12, 0.40, 0.96), // Latte Blue (#1e66f5)
        ),
        Theme::Moonfly => (
            Color::from_rgb(0.55, 0.78, 0.37), // Moonfly Lime Green (#8cc85f)
            Color::from_rgb(0.50, 0.63, 1.00), // Moonfly Sky Blue (#80a0ff)
        ),
        Theme::Nightfly => (
            Color::from_rgb(0.13, 0.85, 0.43), // Nightfly Emerald (#21d96e)
            Color::from_rgb(0.51, 0.67, 1.00), // Nightfly Electric Blue (#82aaff)
        ),
        Theme::Ferra => (
            Color::from_rgb(0.69, 0.87, 0.63), // Ferra Sage Green (#b1dda1)
            Color::from_rgb(0.69, 0.84, 0.97), // Ferra Ice Blue (#b1d5f7)
        ),
        _ => (
            DEFAULT_CROSSING_COLOR,
            DEFAULT_WINDOW_COLOR,
        ),
    }
}

/// Selection colors for light surfaces (paper space sheet or user-configured light model space background).
/// Uses deep-contrast pairs for the six light themes and the shared engineering pair (#1F854D / #2166B3)
/// for dark themes rendered on a light canvas.
pub fn light_canvas_color(crossing: bool, theme: &Theme) -> Color {
    let (crossing_color, window_color) = match theme {
        Theme::Light => (
            Color::from_rgb8(0x1F, 0x85, 0x4D), // Engineering Forest Green (#1F854D)
            Color::from_rgb8(0x21, 0x66, 0xB3), // Engineering Blueprint Blue (#2166B3)
        ),
        Theme::GruvboxLight => (
            Color::from_rgb8(0x78, 0x75, 0x0D), // Gruvbox Dark Olive Green (#78750d)
            Color::from_rgb8(0x07, 0x66, 0x78), // Gruvbox Deep Teal (#076678)
        ),
        Theme::SolarizedLight => (
            Color::from_rgb8(0x70, 0x87, 0x00), // Solarized Deep Green (#708700)
            Color::from_rgb8(0x1F, 0x78, 0xB8), // Solarized Deep Blue (#1f78b8)
        ),
        Theme::TokyoNightLight => (
            Color::from_rgb8(0x38, 0x73, 0x5E), // Tokyo Night Dark Teal (#38735e)
            Color::from_rgb8(0x33, 0x59, 0x99), // Tokyo Night Deep Blue (#335999)
        ),
        Theme::KanagawaLotus => (
            Color::from_rgb8(0x61, 0x7D, 0x40), // Lotus Deep Green (#617d40)
            Color::from_rgb8(0x3D, 0x61, 0x87), // Lotus Deep Blue (#3d6187)
        ),
        Theme::CatppuccinLatte => (
            Color::from_rgb8(0x40, 0xA0, 0x2B), // Latte Green (#40a02b)
            Color::from_rgb8(0x1E, 0x66, 0xF5), // Latte Blue (#1e66f5)
        ),
        Theme::Dark
        | Theme::Oxocarbon
        | Theme::Dracula
        | Theme::Nord
        | Theme::GruvboxDark
        | Theme::SolarizedDark
        | Theme::TokyoNight
        | Theme::TokyoNightStorm
        | Theme::KanagawaWave
        | Theme::KanagawaDragon
        | Theme::CatppuccinMocha
        | Theme::CatppuccinMacchiato
        | Theme::CatppuccinFrappe
        | Theme::Moonfly
        | Theme::Nightfly
        | Theme::Ferra
        | Theme::Custom(_) => (
            Color::from_rgb8(0x1F, 0x85, 0x4D), // Shared engineering crossing (#1F854D)
            Color::from_rgb8(0x21, 0x66, 0xB3), // Shared engineering window (#2166B3)
        ),
    };
    if crossing {
        crossing_color
    } else {
        window_color
    }
}

/// Calculates the fill opacity for selection marquees.
/// The 1.35× scale and 0.45 ceiling on light canvases compensate for the reduced
/// perceived contrast of translucent fills on light surfaces, ensuring the fill
/// remains perceptible without washing out underlying drawing geometry.
pub fn selection_fill_alpha(user_opacity_percent: f32, canvas_light: bool) -> f32 {
    let base = (user_opacity_percent / 100.0).clamp(0.0, 1.0);
    if canvas_light {
        (base * 1.35).clamp(0.0, 0.45)
    } else {
        base
    }
}

/// Resolve the base color for selection marquee / polygon.
/// Resolves in this priority order:
/// 1. User ACI override (if custom > 0)
/// 2. Light-canvas palette (if canvas background is light)
/// 3. Theme curated palette (for dark/normal canvas)
pub fn resolve_selection_base_color(
    crossing: bool,
    theme: &Theme,
    visual: &SelectionVisualOptions,
    canvas_bg: [f32; 4],
) -> Color {
    let custom = if crossing {
        visual.crossing_color
    } else {
        visual.window_color
    };
    // ACI 0 (BYBLOCK) and 256 (BYLAYER) are not explicit overrides;
    // the sysvar uses 0 as the unset sentinel; valid user picks are 1..=255.
    if custom > 0 {
        if let Some((r, g, b)) = acadrust::types::aci_table::aci_to_rgb(custom) {
            return Color::from_rgb8(r, g, b);
        }
    }
    if crate::ui::style::common::canvas_is_light(canvas_bg) {
        return light_canvas_color(crossing, theme);
    }
    let (theme_crossing, theme_window) = theme_selection_colors(theme);
    if crossing {
        theme_crossing
    } else {
        theme_window
    }
}

// ── Grip marker data ──────────────────────────────────────────────────────

/// Describes one grip to be drawn in the viewport overlay.
#[derive(Clone, Debug)]
pub struct GripMarker {
    /// Screen-space position (viewport-relative pixels).
    pub pos: Point,
    /// Explicit marker shape.
    pub shape: GripShape,
    /// True → grip is currently being dragged (drawn filled red).
    pub is_hot: bool,
    /// True → pointer is over this grip (drawn with the hover fill).
    pub is_hovered: bool,
    /// Screen-plane direction with positive Y pointing up.
    pub dir: Option<[f32; 2]>,
}

// ── Grid display params ───────────────────────────────────────────────────

/// Passed to the canvas when the GRID display is active.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct GridParams {
    /// Rotation-only view-projection (Camera::view_proj_rte). Grid points are
    /// made relative to `eye` in f64 before projecting, so the grid stays
    /// precise / jitter-free at UTM-scale absolute coordinates.
    pub view_rot: Mat4,
    /// Camera eye in absolute world f64 — subtracted from each grid point.
    pub eye: glam::DVec3,
    pub bounds: iced::Rectangle,
    /// World-space X spacing (GRIDUNIT X, after adaptive scaling).
    /// Rotation does not affect this value, so orbiting cannot rescale the grid.
    pub step_x: f32,
    /// World-space Y spacing (GRIDUNIT Y, after adaptive scaling).
    pub step_y: f32,
    /// Draw every Nth line as a brighter major line. < 2 disables majors.
    pub major_every: u32,
    /// Grid origin in absolute world f64 and the active UCS axis directions.
    /// The grid always lies on the active UCS XY plane. Plain WCS passes
    /// `(ZERO, X, Y, Z)`.
    pub origin: glam::DVec3,
    pub axes: (Vec3, Vec3, Vec3),
    /// WCS XY drawing limits. When present, grid lines stop at this rectangle
    /// instead of extending across the full viewport.
    pub limits: Option<(glam::DVec2, glam::DVec2)>,
}

/// Pure result of grid projection — segments in canvas-local coordinates plus
/// the axis extent (in world units along the active UCS axes) that the wrapper
/// uses to size the coloured UCS axes overlay. Returned from `grid_segments` so
/// the renderer-free geometry construction can be unit-tested and benchmarked
/// without an iced `Renderer` (Mission #1, 2026-08-26 bench-first plan).
#[doc(hidden)]
pub struct GridGeometry {
    pub segments: Vec<(Point, Point)>,
    /// Brighter every-Nth lines (major grid). Stroked separately in `draw_grid`.
    pub major_segments: Vec<(Point, Point)>,
    pub axis_extent: f32,
}

impl GridGeometry {
    /// Empty geometry — no segments drawn, axes suppressed. Returned by the
    /// early-exit branches of `grid_segments` (zero-sized bounds, no visible
    /// samples, non-finite step) so the caller never needs to special-case
    /// the `None` path.
    #[doc(hidden)]
    pub fn empty() -> Self {
        Self { segments: Vec::new(), major_segments: Vec::new(), axis_extent: 0.0 }
    }
}

/// Cache key for the grid overlay. Identical `GridParams` for every pane plus
/// identical overlay `bounds` ⇒ byte-identical grid geometry; that is the
/// invariant the key encodes.
///
/// Bounds are part of the key, not the only key: a tile layout can pan/zoom
/// inside a single bounds rect, so bounds-only reuse (iced's
/// `geometry::Cache`) would serve a stale grid. The full per-pane
/// `GridParams` set is required for correctness.
///
/// Added 2026-08-26 by Mission #1 (grid overlay cache, Tier 1 #1).
#[doc(hidden)]
#[derive(Clone, Debug, PartialEq)]
pub struct GridKey {
    pub grids: Vec<GridParams>,
    pub bounds: iced::Rectangle,
    pub style: GridStyle,
}

impl GridKey {
    /// Build a key from the per-pane `GridParams`, overlay bounds, and grid style.
    #[doc(hidden)]
    pub fn from_grids(grids: &[GridParams], bounds: iced::Rectangle, style: GridStyle) -> Self {
        Self { grids: grids.to_vec(), bounds, style }
    }
}

/// Cache hit decision: `true` iff `cached` is `Some` and structurally equal to
/// `new`. Reference-based to avoid moving the (potentially large) `Vec` of
/// per-pane params; the caller borrows from `RefCell<Option<GridKey>>` on
/// both sides.
#[doc(hidden)]
pub fn should_reuse(cached: Option<&GridKey>, new: &GridKey) -> bool {
    match cached {
        Some(old) => old == new,
        None => false,
    }
}

/// `Program::State` for `GridCanvas`. Stores the `GridKey` of the geometry
/// currently in the cache and the `canvas::Cache` itself.
///
/// `RefCell<Option<GridKey>>` because `Program::draw` takes `&self`; the key
/// is updated on every frame regardless of hit/miss. The `canvas::Cache`
/// provides an Arc-clone hit path when the iced-level bounds match, and we
/// use `clear()` on a params-key miss to force a real rebuild even if the
/// bounds happen to be unchanged (e.g. a pan within the same canvas size).
///
/// Added 2026-08-26 by Mission #1 (grid overlay cache, Tier 1 #1).
#[doc(hidden)]
#[derive(Default)]
pub struct GridCanvasState {
    pub key: RefCell<Option<GridKey>>,
    pub cache: canvas::Cache<iced::Renderer>,
}

/// Compute the adaptive grid step size (world units) from camera zoom.
///
/// Returns the smallest power-of-5 multiple of 1.0 that places grid lines at
/// least `MIN_GRID_PX` pixels apart at the camera pivot. Both orthographic and
/// perspective cameras have the same vertical scale there. Camera rotation is
/// intentionally absent so orbiting cannot rescale the visible grid or snap.
/// Clip the screen segment `p0`→`p1` to `bounds` (Liang–Barsky), returning the
/// visible part, or `None` when it misses entirely.
///
/// Use this before stroking anything **dashed**. A dash pattern is measured in
/// pixels, so the tessellator emits a quad every few pixels and a path's cost
/// scales with its screen length. Guides are built from projected world points,
/// which land millions of pixels away for a far or huge entity — millions of
/// quads, gigabytes, and the process dies (#406). It is tempting to assume the
/// canvas clips this for us; it does not — clipping happens after tessellation,
/// so the quads are all built first. Clip up front instead.
///
/// The box is padded by one dash period's worth so a guide still visibly runs
/// off the edge rather than stopping flush against it.
fn clip_seg(p0: Point, p1: Point, bounds: iced::Rectangle) -> Option<(Point, Point)> {
    const PAD: f32 = 16.0;
    let (xmin, ymin) = (-PAD, -PAD);
    let (xmax, ymax) = (bounds.width + PAD, bounds.height + PAD);
    let (dx, dy) = (p1.x - p0.x, p1.y - p0.y);
    let (mut t0, mut t1) = (0.0f32, 1.0f32);
    for (p, q) in [(-dx, p0.x - xmin), (dx, xmax - p0.x), (-dy, p0.y - ymin), (dy, ymax - p0.y)] {
        if p == 0.0 {
            // Parallel to this edge: outside it means the whole segment is out.
            if q < 0.0 {
                return None;
            }
            continue;
        }
        let r = q / p;
        if p < 0.0 {
            if r > t1 {
                return None;
            }
            t0 = t0.max(r);
        } else {
            if r < t0 {
                return None;
            }
            t1 = t1.min(r);
        }
    }
    Some((
        Point::new(p0.x + t0 * dx, p0.y + t0 * dy),
        Point::new(p0.x + t1 * dx, p0.y + t1 * dy),
    ))
}

pub fn compute_grid_step(distance: f32, fov_y: f32, bounds: iced::Rectangle) -> f32 {
    compute_grid_steps(1.0, 1.0, distance, fov_y, bounds, true).0
}

/// Adaptive world-space grid spacing for non-uniform GRIDUNIT X/Y.
///
/// BUG FIX: the old `compute_grid_step` hardcoded a 1.0 base, so the
/// Drafting Settings grid spacing had no effect on the display. The base now
/// comes from the user's GRIDUNIT setting. With `adaptive == true`, each axis
/// is scaled up by powers of 5 until neighbouring lines are at least
/// `MIN_GRID_PX` apart; with `adaptive == false` the raw base is returned so
/// the grid resizes exactly as typed.
pub fn compute_grid_steps(
    base_x: f32,
    base_y: f32,
    distance: f32,
    fov_y: f32,
    bounds: iced::Rectangle,
    adaptive: bool,
) -> (f32, f32) {
    let sanitize = |b: f32| {
        if b.is_finite() && b > 0.0 && b <= 1e9 {
            b
        } else {
            1.0
        }
    };
    let bx = sanitize(base_x);
    let by = sanitize(base_y);
    if !adaptive {
        return (bx, by);
    }
    let half_height = distance * (fov_y * 0.5).tan();
    if !half_height.is_finite() || half_height <= 1e-9 || bounds.height <= 0.0 {
        return (bx, by);
    }
    let px_per_unit = bounds.height / (2.0 * half_height);
    if !px_per_unit.is_finite() || px_per_unit <= 0.0 {
        return (bx, by);
    }
    let adapt = |mut s: f32, base: f32| {
        // Grow-only: shrinking below the user's base would silently change the
        // requested GRIDUNIT when zoomed in. Guard the loop so a degenerate
        // px_per_unit can never spin forever. The overflow fallback returns
        // this axis's own base (returning the other axis's base mixed X/Y).
        let mut guard = 0;
        while s * px_per_unit < MIN_GRID_PX && guard < 32 {
            s *= 5.0;
            guard += 1;
            if !s.is_finite() || s > 1e9 {
                return base;
            }
        }
        s
    };
    (adapt(bx, bx), adapt(by, by))
}

/// Parameters for the screen-space UCS icon drawn in the viewport corner.
pub struct UcsIconParams {
    /// View-projection matrix used to project world axis directions to screen.
    pub view_proj: Mat4,
    /// Viewport bounds (used for NDC → pixel conversion).
    pub bounds: iced::Rectangle,
    /// The active UCS axis directions in world space (X, Y, Z). Plain WCS is
    /// `(Vec3::X, Vec3::Y, Vec3::Z)`; a UCS rotates the tripod to match.
    pub axes: (Vec3, Vec3, Vec3),
    /// Absolute screen position of the UCS origin, when the icon should track
    /// it (UCSICON ORigin). `None` → pin to the corner. The tripod still snaps
    /// back to the corner if this point falls outside the viewport bounds.
    pub origin_screen: Option<Point>,
    /// Cursor is over the icon — brighten the tripod (hover affordance).
    pub hover: bool,
    /// Icon is selected — draw draggable grip squares at the origin and tips.
    pub selected: bool,
}

// ── Selection overlay ───────────────────────────────────────────────────

/// An acquired OST tracking point with its screen position.
#[derive(Clone, Debug)]
pub struct OstTrackPoint {
    pub screen: Point,
}

pub fn grid_overlay<'a>(
    grid: Vec<GridParams>,
    style: GridStyle,
) -> Element<'a, Message> {
    canvas(GridCanvas { grid, style })
        .width(Length::Fill)
        .height(Length::Fill)
        .into()
}

struct GridCanvas {
    grid: Vec<GridParams>,
    style: GridStyle,
}

impl canvas::Program<Message> for GridCanvas {
    type State = GridCanvasState;

    fn draw(
        &self,
        state: &GridCanvasState,
        renderer: &iced::Renderer,
        _theme: &Theme,
        bounds: iced::Rectangle,
        _cursor: mouse::Cursor,
    ) -> Vec<canvas::Geometry> {
        let key = GridKey::from_grids(&self.grid, bounds, self.style);

        // Hit check: same params, same bounds, same style ⇒ the cached geometry is still
        // valid. The key includes bounds and style, so a `should_reuse` match implies
        // both are equal, and the fork's `draw_with_bounds` will return the
        // cached `Arc` clone (essentially free).
        let hit = should_reuse(state.key.borrow().as_ref(), &key);

        let geometry = if hit {
            // No-op closure: the fork short-circuits on bounds match and
            // returns the cached geometry without invoking the closure.
            state.cache.draw_with_bounds(renderer, bounds, |_frame| {})
        } else {
            // Params, style, or bounds changed. Clear so the closure runs even when
            // bounds happen to match the previously-cached frame.
            state.cache.clear();
            state.cache.draw_with_bounds(renderer, bounds, |frame| {
                for g in &self.grid {
                    let gb = g.bounds;
                    let cx0 = gb.x.max(0.0);
                    let cy0 = gb.y.max(0.0);
                    let cx1 = (gb.x + gb.width).min(bounds.width);
                    let cy1 = (gb.y + gb.height).min(bounds.height);
                    if cx1 <= cx0 || cy1 <= cy0 {
                        continue;
                    }
                    let clip = iced::Rectangle {
                        x: cx0,
                        y: cy0,
                        width: cx1 - cx0,
                        height: cy1 - cy0,
                    };
                    frame.with_clip(clip, |f| {
                        draw_grid(
                            f,
                            g.view_rot,
                            g.eye,
                            gb,
                            g.step_x,
                            g.step_y,
                            g.major_every,
                            g.origin,
                            g.axes,
                            g.limits,
                            self.style,
                        )
                    });
                }
            })
        };

        // Update the stored key.
        *state.key.borrow_mut() = Some(key);

        vec![geometry]
    }
}

pub fn selection_overlay<'a>(
    selection: Arc<RefCell<SelectionState>>,
    snap: Option<(Point, SnapType)>,
    snap_ext_base: Option<Point>,
    snap_ext_base2: Option<Point>,
    grips: Vec<GripMarker>,
    control_polygon: Option<(Vec<Point>, bool)>,
    grip_clip: Option<iced::Rectangle>,
    ucs_icons: Vec<UcsIconParams>,
    ost_points: Vec<OstTrackPoint>,
    otrack_line: Option<(Point, Point)>,
    parallel_ref_marker: Option<Point>,
    show_viewcube: bool,
    dividers: Vec<iced::Rectangle>,
    pane_move_rect: Option<iced::Rectangle>,
    pane_drop_rect: Option<iced::Rectangle>,
    pan_mode: bool,
    suppressed: bool,
    hover_locked: bool,
    crosshair_bg: [f32; 4],
    crosshair: CrosshairOptions,
    selection_visual: SelectionVisualOptions,
    constraint_glyphs: Vec<(Point, [f32; 2], String, bool, bool, Vec<Point>)>,
    constraint_glyph_tooltip: Option<String>,
    constraint_cursor_badge: Option<String>,
) -> Element<'a, Message> {
    canvas(SelectionCanvas {
        selection,
        snap,
        snap_ext_base,
        snap_ext_base2,
        grips,
        control_polygon,
        grip_clip,
        ucs_icons,
        ost_points,
        otrack_line,
        parallel_ref_marker,
        show_viewcube,
        dividers,
        pane_move_rect,
        pane_drop_rect,
        pan_mode,
        suppressed,
        hover_locked,
        crosshair_bg,
        crosshair,
        selection_visual,
        constraint_glyphs,
        constraint_glyph_tooltip,
        constraint_cursor_badge,
    })
    .width(Length::Fill)
    .height(Length::Fill)
    .into()
}

struct SelectionCanvas {
    selection: Arc<RefCell<SelectionState>>,
    snap: Option<(Point, SnapType)>,
    /// Screen position of the endpoint an active Extension snap extends from,
    /// so the dashed extension guide line can be drawn back to it. (#238)
    snap_ext_base: Option<Point>,
    /// Second extension-guide base, present only for an extended intersection so
    /// both crossing extensions stay drawn when the crossing is caught. (#247, #259)
    snap_ext_base2: Option<Point>,
    grips: Vec<GripMarker>,
    /// Selected spline control polygon and closed state.
    control_polygon: Option<(Vec<Point>, bool)>,
    /// Active 3D pane / floating viewport rectangle. Grip markers are clipped
    /// here so orbiting cannot leak them into paper space or adjacent panes.
    grip_clip: Option<iced::Rectangle>,
    /// One UCS icon per Model pane (each viewport shows its own at its origin);
    /// a single entry for paper / floating-viewport. Only the active pane's
    /// entry carries hover/selected (grips).
    ucs_icons: Vec<UcsIconParams>,
    ost_points: Vec<OstTrackPoint>,
    /// Active OTRACK alignment: (acquired tracking point, locked cursor), both
    /// in screen space. Drawn as a dashed guide extended a little past the
    /// cursor so the extension / tracking line the user snapped to is visible.
    /// (#219)
    otrack_line: Option<(Point, Point)>,
    /// The acquired Parallel-snap reference point (screen), marked with a small
    /// ∥ glyph so the user sees which line is the parallel reference. (#277)
    parallel_ref_marker: Option<Point>,
    show_viewcube: bool,
    /// Divider bars (pixel rects, canvas-relative) between Model panes — drawn
    /// as filled lines and used to suppress the crosshair over a divider.
    dividers: Vec<iced::Rectangle>,
    /// When a pane move is armed (drag handle pressed), the source pane's rect
    /// (px) — dimmed, with a ghost card dragged along under the cursor.
    pane_move_rect: Option<iced::Rectangle>,
    /// The pane under the cursor during a pane move (drop target), highlighted.
    pane_drop_rect: Option<iced::Rectangle>,
    /// Interactive PAN mode: the crosshair is hidden and the cursor becomes a
    /// hand so the viewport reads as a draggable surface.
    pan_mode: bool,
    /// A ribbon dropdown (or similar overlay) is open over the viewport. The
    /// crosshair is not drawn and the OS cursor is shown normally so the panel
    /// is usable instead of the cursor vanishing over it. (#227)
    suppressed: bool,
    /// The entity under the crosshair is on a locked layer — draw a small lock
    /// badge by the cursor so the user knows it can't be edited.
    hover_locked: bool,
    /// Background of the active drawing space. Crosshair contrast follows this
    /// rather than the UI theme, which may be light over a dark model viewport.
    crosshair_bg: [f32; 4],
    crosshair: CrosshairOptions,
    selection_visual: SelectionVisualOptions,
    /// Constraint glyph anchor, outward screen direction, label, conflict
    /// state, whether the pill itself is the current click-to-select target,
    /// and the points to mark while the pill is hovered.
    constraint_glyphs: Vec<(Point, [f32; 2], String, bool, bool, Vec<Point>)>,
    /// Localized kind name made visible after the app-level hover dwell.
    constraint_glyph_tooltip: Option<String>,
    /// Symbol shown beside the cursor while it targets an entity that already
    /// participates in an enabled geometric constraint.
    constraint_cursor_badge: Option<String>,
}

fn draw_grip_marker(
    frame: &mut canvas::Frame,
    grip: &GripMarker,
    theme: &Theme,
    visual: &SelectionVisualOptions,
) {
    let sp = grip.pos;
    let h = visual.grip_size.clamp(1.0, 25.0);
    let path = match grip.shape {
        GripShape::Square => canvas::Path::rectangle(
            Point::new(sp.x - h, sp.y - h),
            Size::new(h * 2.0, h * 2.0),
        ),
        GripShape::Rectangle => {
            // Mid-segment stretch handle: small box, longer along the segment
            // direction so the affordance reads as "stretch perpendicular".
            let half_long = h * 1.4;
            let half_short = h * 0.7;
            let (cos_t, sin_t) = match grip.dir {
                Some([dx, dy]) if (dx * dx + dy * dy) > 1e-12 => {
                    let n = (dx * dx + dy * dy).sqrt();
                    (dx / n, -dy / n)
                }
                _ => (1.0, 0.0),
            };
            let ax = (cos_t * half_long, sin_t * half_long);
            let ay = (-sin_t * half_short, cos_t * half_short);
            canvas::Path::new(|b| {
                b.move_to(Point::new(sp.x + ax.0 + ay.0, sp.y + ax.1 + ay.1));
                b.line_to(Point::new(sp.x + ax.0 - ay.0, sp.y + ax.1 - ay.1));
                b.line_to(Point::new(sp.x - ax.0 - ay.0, sp.y - ax.1 - ay.1));
                b.line_to(Point::new(sp.x - ax.0 + ay.0, sp.y - ax.1 + ay.1));
                b.close();
            })
        }
        GripShape::Triangle => canvas::Path::new(|b| {
            let (forward_x, forward_y) = match grip.dir {
                Some([dx, dy]) if (dx * dx + dy * dy) > 1e-12 => {
                    let length = (dx * dx + dy * dy).sqrt();
                    (dx / length, -dy / length)
                }
                _ => (0.0, -1.0),
            };
            let side_x = -forward_y;
            let side_y = forward_x;
            let tip = Point::new(sp.x + forward_x * h, sp.y + forward_y * h);
            let base = Point::new(sp.x - forward_x * h, sp.y - forward_y * h);
            b.move_to(tip);
            b.line_to(Point::new(base.x + side_x * h, base.y + side_y * h));
            b.line_to(Point::new(base.x - side_x * h, base.y - side_y * h));
            b.close();
        }),
        GripShape::Circle => canvas::Path::circle(Point::new(sp.x, sp.y), h),
        GripShape::Dropdown | GripShape::DropdownAdjacent => canvas::Path::new(|b| {
            b.move_to(Point::new(sp.x - h, sp.y - h * 0.5));
            b.line_to(Point::new(sp.x + h, sp.y - h * 0.5));
            b.line_to(Point::new(sp.x, sp.y + h));
            b.close();
        }),
    };

    if grip.is_hot {
        let hot_color = if visual.grip_hot > 0 {
            if let Some((r, g, b)) = acadrust::types::aci_table::aci_to_rgb(visual.grip_hot) {
                Color::from_rgb8(r, g, b)
            } else {
                theme.palette().danger.base.color
            }
        } else {
            theme.palette().danger.base.color
        };
        frame.fill(&path, hot_color);
    } else if grip.is_hovered {
        let pair = theme.palette().primary.strong;
        let hover_color = if visual.grip_hover > 0 {
            if let Some((r, g, b)) = acadrust::types::aci_table::aci_to_rgb(visual.grip_hover) {
                Color::from_rgb8(r, g, b)
            } else {
                pair.color
            }
        } else {
            pair.color
        };
        frame.fill(&path, hover_color);
        frame.stroke(
            &path,
            canvas::Stroke {
                width: 1.5,
                style: canvas::Style::Solid(pair.text),
                ..Default::default()
            },
        );
    } else {
        let palette = theme.palette();
        let color = if visual.grip_color > 0 {
            if let Some((r, g, b)) = acadrust::types::aci_table::aci_to_rgb(visual.grip_color) {
                Color::from_rgb8(r, g, b)
            } else {
                palette.primary.base.color
            }
        } else {
            palette.primary.base.color
        };
        let fill = if matches!(
            grip.shape,
            GripShape::Dropdown | GripShape::DropdownAdjacent
        ) {
            color
        } else {
            palette.background.base.color.scale_alpha(0.7)
        };
        frame.fill(&path, fill);
        frame.stroke(
            &path,
            canvas::Stroke {
                width: 1.5,
                style: canvas::Style::Solid(color),
                ..Default::default()
            },
        );
    }
}

impl SelectionCanvas {
    /// True when the cursor sits on a Model-pane divider (within a few px), so
    /// `draw` can suppress the CAD crosshair there. The resize cursor itself is
    /// supplied by the input pane_grid layered above.
    fn divider_under(&self, cursor: mouse::Cursor, bounds: iced::Rectangle) -> bool {
        const TOL_PX: f32 = 3.0;
        let Some(pos) = cursor.position_in(bounds) else {
            return false;
        };
        self.dividers.iter().any(|d| {
            pos.x >= d.x - TOL_PX
                && pos.x <= d.x + d.width + TOL_PX
                && pos.y >= d.y - TOL_PX
                && pos.y <= d.y + d.height + TOL_PX
        })
    }
}

impl canvas::Program<Message> for SelectionCanvas {
    type State = ();

    fn mouse_interaction(
        &self,
        _state: &(),
        bounds: iced::Rectangle,
        cursor: mouse::Cursor,
    ) -> mouse::Interaction {
        // A dropdown/overlay is open over the viewport — show the normal OS
        // cursor over the whole canvas instead of hiding it for the crosshair,
        // so the cursor doesn't vanish while using the panel. (#227)
        if self.suppressed {
            return mouse::Interaction::default();
        }
        // PAN mode owns the whole viewport: an open hand when hovering, a
        // closed hand while dragging.
        if self.pan_mode && cursor.is_over(bounds) {
            return if self.selection.borrow().middle_down {
                mouse::Interaction::Grabbing
            } else {
                mouse::Interaction::Grab
            };
        }
        if self.show_viewcube {
            if let Some(pos) = cursor.position_in(bounds) {
                use crate::scene::{VIEWCUBE_PAD, VIEWCUBE_REGION_PX};
                let vc_x = bounds.width - VIEWCUBE_REGION_PX - VIEWCUBE_PAD;
                let vc_y = VIEWCUBE_PAD;
                if pos.x >= vc_x
                    && pos.x <= vc_x + VIEWCUBE_REGION_PX
                    && pos.y >= vc_y
                    && pos.y <= vc_y + VIEWCUBE_REGION_PX
                {
                    return mouse::Interaction::None;
                }
            }
        }
        if let Some(pos) = cursor.position_in(bounds) {
            let glyphs: Vec<_> = self
                .constraint_glyphs
                .iter()
                .map(|(anchor, outward, label, conflict, _, _)| {
                    (*anchor, *outward, label.clone(), *conflict)
                })
                .collect();
            if constraint_glyph_hit_test(&glyphs, pos).is_some() {
                return mouse::Interaction::Pointer;
            }
        }
        // The resize cursor over a divider is supplied by the input pane_grid
        // layered above this overlay; `draw` only suppresses the CAD crosshair
        // there (see `divider_under`).
        // Over the viewport (no divider, no viewcube): hide the system
        // cursor entirely. `Interaction::None` would let the stack fall
        // through to a sibling — `Hidden` is the explicit "no cursor"
        // signal that actually suppresses the OS arrow.
        if cursor.is_over(bounds) && self.crosshair.cursor_type == CursorType::Crosshair {
            mouse::Interaction::Hidden
        } else {
            mouse::Interaction::default()
        }
    }

    fn draw(
        &self,
        _state: &(),
        renderer: &iced::Renderer,
        theme: &Theme,
        bounds: iced::Rectangle,
        cursor: mouse::Cursor,
    ) -> Vec<canvas::Geometry> {
        let mut frame = canvas::Frame::new(renderer, bounds.size());

        // ── Pane dividers (Model-space tiled layout) ──────────────────────
        // Filled bars in the pane_grid spacing gaps, so adjacent panes read as
        // distinct viewports. Drawn first so all other overlays sit on top.
        if !self.dividers.is_empty() {
            let divider = theme.palette().background.neutral.color;
            for d in &self.dividers {
                let bar = canvas::Path::rectangle(
                    Point::new(d.x, d.y),
                    iced::Size::new(d.width.max(1.0), d.height.max(1.0)),
                );
                frame.fill(&bar, divider);
            }
        }

        // ── Pane move (drag-to-swap) ──────────────────────────────────────
        // While armed: dim the lifted source pane, highlight the drop target
        // under the cursor, and drag a translucent ghost card along the cursor
        // so the pane is visibly "moving".
        if let Some(src) = self.pane_move_rect {
            let accent = theme.palette().primary.base.color;
            // Source pane: dimmed + dashed-feel outline (it has been lifted).
            let src_path =
                canvas::Path::rectangle(Point::new(src.x, src.y), iced::Size::new(src.width, src.height));
            frame.fill(
                &src_path,
                theme.palette().background.strong.color.scale_alpha(0.28),
            );
            frame.stroke(
                &src_path,
                canvas::Stroke {
                    width: 1.5,
                    style: canvas::Style::Solid(Color { a: 0.6, ..accent }),
                    ..Default::default()
                },
            );
            // Drop target pane: bright fill + outline.
            if let Some(dst) = self.pane_drop_rect {
                let dst_path = canvas::Path::rectangle(
                    Point::new(dst.x, dst.y),
                    iced::Size::new(dst.width, dst.height),
                );
                frame.fill(&dst_path, Color { a: 0.16, ..accent });
                frame.stroke(
                    &dst_path,
                    canvas::Stroke {
                        width: 2.5,
                        style: canvas::Style::Solid(accent),
                        ..Default::default()
                    },
                );
            }
            // Ghost card dragged under the cursor — a 0.32× preview of the
            // source pane, centred on the cursor.
            if let Some(c) = self.selection.borrow().last_move_pos {
                let gw = (src.width * 0.32).clamp(60.0, 280.0);
                let gh = (src.height * 0.32).clamp(40.0, 200.0);
                let g = canvas::Path::rectangle(
                    Point::new(c.x - gw * 0.5, c.y - gh * 0.5),
                    iced::Size::new(gw, gh),
                );
                frame.fill(&g, Color { a: 0.30, ..accent });
                frame.stroke(
                    &g,
                    canvas::Stroke {
                        width: 2.0,
                        style: canvas::Style::Solid(Color { a: 0.95, ..accent }),
                        ..Default::default()
                    },
                );
            }
        }


        // Draw a selection marquee (green crossing / blue window) as a filled,
        // stroked rectangle between two canvas points. Shared by the live
        // box-selection and the preview-only window marquee (#291).
        fn draw_marquee(
            frame: &mut canvas::Frame,
            a: Point,
            b: Point,
            crossing: bool,
            theme: &Theme,
            visual: &SelectionVisualOptions,
            canvas_bg: [f32; 4],
        ) {
            let base = resolve_selection_base_color(crossing, theme, visual, canvas_bg);
            let canvas_light = crate::ui::style::common::canvas_is_light(canvas_bg);
            // Desk-spanning marquee edge case: deliberate limitation to avoid mid-drag rectangle color splits when dragged past sheet onto desk.
            let x0 = a.x.min(b.x);
            let y0 = a.y.min(b.y);
            let w = (a.x - b.x).abs();
            let h = (a.y - b.y).abs();
            let rect = canvas::Path::rectangle(Point::new(x0, y0), Size::new(w, h));
            if visual.area && visual.opacity > 0 {
                let alpha = selection_fill_alpha(visual.opacity as f32, canvas_light);
                let fill = base.scale_alpha(alpha);
                frame.fill(&rect, fill);
            }
            let stroke_alpha = if canvas_light { 0.95 } else { 0.90 };
            let stroke = base.scale_alpha(stroke_alpha);
            frame.stroke(
                &rect,
                canvas::Stroke {
                    width: 1.0,
                    style: canvas::Style::Solid(stroke),
                    line_dash: if crossing {
                        canvas::LineDash {
                            segments: &[4.0, 4.0],
                            offset: 0,
                        }
                    } else {
                        canvas::LineDash::default()
                    },
                    ..Default::default()
                },
            );
        }

        if let (Some(a), Some(b)) = (self.selection.borrow().box_anchor, self.selection.borrow().box_current) {
            draw_marquee(&mut frame, a, b, self.selection.borrow().box_crossing, theme, &self.selection_visual, self.crosshair_bg);
        }
        // Preview marquee for point-picked windows (STRETCH) — same look, no pick.
        if let Some((a, b, crossing)) = self.selection.borrow().preview_box {
            draw_marquee(&mut frame, a, b, crossing, theme, &self.selection_visual, self.crosshair_bg);
        }

        if self.selection.borrow().poly_active && self.selection.borrow().poly_points.len() > 1 {
            let crossing = self.selection.borrow().poly_crossing;
            let base = resolve_selection_base_color(crossing, theme, &self.selection_visual, self.crosshair_bg);
            let canvas_light = crate::ui::style::common::canvas_is_light(self.crosshair_bg);
            if self.selection_visual.area && self.selection_visual.opacity > 0 {
                let alpha = selection_fill_alpha(self.selection_visual.opacity as f32, canvas_light);
                let fill = base.scale_alpha(alpha);
                if let Some(cur) = self.selection.borrow().last_move_pos {
                    let start = self.selection.borrow().poly_points[0];
                    let fill_path = canvas::Path::new(|p| {
                        p.move_to(start);
                        for pt in &self.selection.borrow().poly_points[1..] {
                            p.line_to(*pt);
                        }
                        p.line_to(cur);
                        p.line_to(start);
                    });
                    frame.fill(&fill_path, fill);
                }
            }
            let stroke_alpha = if canvas_light { 0.95 } else { 0.90 };
            let stroke = base.scale_alpha(stroke_alpha);
            let path = canvas::Path::new(|p| {
                p.move_to(self.selection.borrow().poly_points[0]);
                for pt in &self.selection.borrow().poly_points[1..] {
                    p.line_to(*pt);
                }
            });
            let stroke_style = canvas::Stroke {
                width: 1.0,
                style: canvas::Style::Solid(stroke),
                line_dash: if crossing {
                    canvas::LineDash {
                        segments: &[4.0, 4.0],
                        offset: 0,
                    }
                } else {
                    canvas::LineDash::default()
                },
                ..Default::default()
            };
            frame.stroke(&path, stroke_style.clone());
            if let Some(cur) = self.selection.borrow().last_move_pos {
                let start = self.selection.borrow().poly_points[0];
                let last = *self.selection.borrow().poly_points.last().unwrap();
                let preview = canvas::Path::new(|p| {
                    p.move_to(last);
                    p.line_to(cur);
                    p.line_to(start);
                });
                frame.stroke(&preview, stroke_style);
            }
        }

        // ── Grip markers ──────────────────────────────────────────────────
        let grip_bounds = self.grip_clip.unwrap_or(bounds);
        let grip_x0 = grip_bounds.x.max(0.0);
        let grip_y0 = grip_bounds.y.max(0.0);
        let grip_x1 = (grip_bounds.x + grip_bounds.width).min(bounds.width);
        let grip_y1 = (grip_bounds.y + grip_bounds.height).min(bounds.height);
        if grip_x1 > grip_x0 && grip_y1 > grip_y0 {
            let grip_clip = iced::Rectangle {
                x: grip_x0,
                y: grip_y0,
                width: grip_x1 - grip_x0,
                height: grip_y1 - grip_y0,
            };
            frame.with_clip(grip_clip, |frame| {
                if let Some((points, closed)) = &self.control_polygon {
                    if points.len() >= 2 {
                        let polygon = canvas::Path::new(|builder| {
                            builder.move_to(points[0]);
                            for point in points.iter().skip(1) {
                                builder.line_to(*point);
                            }
                            if *closed {
                                builder.line_to(points[0]);
                            }
                        });
                        frame.stroke(
                            &polygon,
                            canvas::Stroke {
                                width: 1.0,
                                style: canvas::Style::Solid(Color::from_rgb(0.72, 0.32, 0.15)),
                                line_dash: canvas::LineDash {
                                    segments: &[4.0, 4.0],
                                    offset: 0,
                                },
                                ..Default::default()
                            },
                        );
                    }
                }
                for grip in &self.grips {
                    draw_grip_marker(frame, grip, theme, &self.selection_visual);
                }
            });
        }

        // ── Snap marker ───────────────────────────────────────────────────
        if let Some((sp, snap_type)) = self.snap {
            let (r, g, b) = if snap_type == SnapType::ObjectPick {
                (0.95_f32, 0.50, 0.08) // orange object-snap marker
            } else {
                (1.0, 0.9, 0.1) // classic yellow OSNAP
            };
            let marker = Color { r, g, b, a: 1.0 };
            let stroke = canvas::Stroke {
                width: if snap_type == SnapType::ObjectPick { 2.0 } else { 1.5 },
                style: canvas::Style::Solid(marker),
                ..Default::default()
            };
            match snap_type {
                SnapType::ObjectPick => {
                    // Target box + center dot (object-acquisition glyph).
                    let h = 7.0_f32;
                    let rect = canvas::Path::rectangle(
                        Point::new(sp.x - h, sp.y - h),
                        Size::new(h * 2.0, h * 2.0),
                    );
                    frame.stroke(&rect, stroke.clone());
                    let r = 3.0_f32;
                    frame.fill(
                        &canvas::Path::circle(sp, r),
                        Color {
                            r: 0.95,
                            g: 0.50,
                            b: 0.08,
                            a: 0.85,
                        },
                    );
                }
                SnapType::Endpoint => {
                    let h = 5.0_f32;
                    let rect = canvas::Path::rectangle(
                        Point::new(sp.x - h, sp.y - h),
                        Size::new(h * 2.0, h * 2.0),
                    );
                    frame.stroke(&rect, stroke);
                }
                SnapType::Midpoint => {
                    let r = 6.0_f32;
                    let path = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x, sp.y - r));
                        b.line_to(Point::new(sp.x + r * 0.866, sp.y + r * 0.5));
                        b.line_to(Point::new(sp.x - r * 0.866, sp.y + r * 0.5));
                        b.close();
                    });
                    frame.stroke(&path, stroke);
                }
                SnapType::Center => {
                    let r = 5.5_f32;
                    let path = canvas::Path::circle(sp, r);
                    frame.stroke(&path, stroke);
                }
                SnapType::Node => {
                    // Circle with an inscribed X.
                    let r = 5.5_f32;
                    let cpath = canvas::Path::circle(sp, r);
                    frame.stroke(&cpath, stroke.clone());
                    let d = r * std::f32::consts::FRAC_1_SQRT_2;
                    let x1 = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - d, sp.y - d));
                        b.line_to(Point::new(sp.x + d, sp.y + d));
                    });
                    let x2 = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - d, sp.y + d));
                        b.line_to(Point::new(sp.x + d, sp.y - d));
                    });
                    frame.stroke(&x1, stroke.clone());
                    frame.stroke(&x2, stroke);
                }
                SnapType::Quadrant => {
                    let r = 6.0_f32;
                    let path = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x, sp.y - r));
                        b.line_to(Point::new(sp.x + r, sp.y));
                        b.line_to(Point::new(sp.x, sp.y + r));
                        b.line_to(Point::new(sp.x - r, sp.y));
                        b.close();
                    });
                    frame.stroke(&path, stroke);
                }
                SnapType::Intersection => {
                    // An extended intersection sets one or two extension bases;
                    // draw a dashed guide from each endpoint through the crossing
                    // so both contributing extension paths stay visible. A real
                    // on-segment crossing carries no bases, so nothing draws here.
                    // (#247, #259)
                    for base in [self.snap_ext_base, self.snap_ext_base2]
                        .into_iter()
                        .flatten()
                    {
                        let dx = sp.x - base.x;
                        let dy = sp.y - base.y;
                        let len = (dx * dx + dy * dy).sqrt();
                        if len > 1e-3 {
                            let dash = canvas::Stroke {
                                line_dash: canvas::LineDash {
                                    segments: &[4.0, 4.0],
                                    offset: 0,
                                },
                                ..canvas::Stroke::default().with_color(marker).with_width(1.0)
                            };
                            let tip = Point::new(
                                sp.x + dx / len * 18.0,
                                sp.y + dy / len * 18.0,
                            );
                            // `base` is a projected entity endpoint: clip before
                            // stroking (see `clip_seg`).
                            if let Some((a, b)) = clip_seg(base, tip, bounds) {
                                frame.stroke(&canvas::Path::line(a, b), dash);
                            }
                        }
                    }
                    let r = 5.0_f32;
                    let p1 = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r, sp.y - r));
                        b.line_to(Point::new(sp.x + r, sp.y + r));
                    });
                    let p2 = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r, sp.y + r));
                        b.line_to(Point::new(sp.x + r, sp.y - r));
                    });
                    frame.stroke(&p1, stroke.clone());
                    frame.stroke(&p2, stroke);
                }
                SnapType::ApparentIntersection => {
                    // X like Intersection, framed by a small square so the
                    // two are visually distinguishable.
                    let r = 5.0_f32;
                    let rect = canvas::Path::rectangle(
                        Point::new(sp.x - r, sp.y - r),
                        Size::new(r * 2.0, r * 2.0),
                    );
                    frame.stroke(&rect, stroke.clone());
                    let xr = r - 1.5;
                    let p1 = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - xr, sp.y - xr));
                        b.line_to(Point::new(sp.x + xr, sp.y + xr));
                    });
                    let p2 = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - xr, sp.y + xr));
                        b.line_to(Point::new(sp.x + xr, sp.y - xr));
                    });
                    frame.stroke(&p1, stroke.clone());
                    frame.stroke(&p2, stroke);
                }
                SnapType::Insertion => {
                    // Two overlapping rectangles (a small "tag" glyph).
                    let r = 5.0_f32;
                    let inner = canvas::Path::rectangle(
                        Point::new(sp.x - r * 0.5, sp.y - r),
                        Size::new(r, r * 2.0),
                    );
                    let outer = canvas::Path::rectangle(
                        Point::new(sp.x - r, sp.y - r * 0.5),
                        Size::new(r * 2.0, r),
                    );
                    frame.stroke(&outer, stroke.clone());
                    frame.stroke(&inner, stroke);
                }
                SnapType::Perpendicular => {
                    // Right-angle hook in the lower-left quadrant.
                    let r = 6.0_f32;
                    let p = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r, sp.y - r));
                        b.line_to(Point::new(sp.x - r, sp.y + r));
                        b.line_to(Point::new(sp.x + r, sp.y + r));
                    });
                    let foot = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r, sp.y));
                        b.line_to(Point::new(sp.x, sp.y));
                        b.line_to(Point::new(sp.x, sp.y + r));
                    });
                    frame.stroke(&p, stroke.clone());
                    frame.stroke(&foot, stroke);
                }
                SnapType::Tangent => {
                    // Circle with a tangent bar across the top.
                    let r = 5.5_f32;
                    let c = canvas::Path::circle(sp, r);
                    frame.stroke(&c, stroke.clone());
                    let bar = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r, sp.y - r));
                        b.line_to(Point::new(sp.x + r, sp.y - r));
                    });
                    frame.stroke(&bar, stroke);
                }
                SnapType::Nearest => {
                    // Bowtie / hourglass — two opposed triangles meeting at sp.
                    let r = 5.5_f32;
                    let path = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r, sp.y - r));
                        b.line_to(Point::new(sp.x + r, sp.y - r));
                        b.line_to(Point::new(sp.x - r, sp.y + r));
                        b.line_to(Point::new(sp.x + r, sp.y + r));
                        b.close();
                    });
                    frame.stroke(&path, stroke);
                }
                SnapType::Extension => {
                    // Unit direction from the endpoint the snap extends from
                    // toward the snap point, so the guide line and the three
                    // dots follow the actual extension path (#238).
                    let dir = self.snap_ext_base.and_then(|base| {
                        let dx = sp.x - base.x;
                        let dy = sp.y - base.y;
                        let len = (dx * dx + dy * dy).sqrt();
                        (len > 1e-3).then(|| (base, Point::new(dx / len, dy / len)))
                    });
                    // Dashed guide line from that endpoint, through the snap
                    // point and a little beyond, so the extension path is
                    // visible as the cursor tracks along it.
                    if let Some((base, u)) = dir {
                        let dash = canvas::Stroke {
                            line_dash: canvas::LineDash {
                                segments: &[4.0, 4.0],
                                offset: 0,
                            },
                            ..canvas::Stroke::default().with_color(marker).with_width(1.0)
                        };
                        let tip = Point::new(sp.x + u.x * 18.0, sp.y + u.y * 18.0);
                        // `base` is a projected entity endpoint: clip before
                        // stroking (see `clip_seg`).
                        if let Some((a, b)) = clip_seg(base, tip, bounds) {
                            frame.stroke(&canvas::Path::line(a, b), dash);
                        }
                    }
                    // Three dots at the snap point, strung along the extension
                    // direction (horizontal fallback when the base is unknown).
                    let u = dir.map(|(_, u)| u).unwrap_or(Point::new(1.0, 0.0));
                    let r = 1.4_f32;
                    for k in [-7.0_f32, 0.0, 7.0] {
                        let dot =
                            canvas::Path::circle(Point::new(sp.x + u.x * k, sp.y + u.y * k), r);
                        frame.fill(&dot, marker);
                    }
                }
                SnapType::Parallel => {
                    // Two short parallel diagonal bars.
                    let r = 6.0_f32;
                    let off = 3.0_f32;
                    let b1 = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r - off, sp.y + r));
                        b.line_to(Point::new(sp.x + r - off, sp.y - r));
                    });
                    let b2 = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r + off, sp.y + r));
                        b.line_to(Point::new(sp.x + r + off, sp.y - r));
                    });
                    frame.stroke(&b1, stroke.clone());
                    frame.stroke(&b2, stroke);
                }
                SnapType::Grid => {
                    let arm = 4.0_f32;
                    let h = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - arm, sp.y));
                        b.line_to(Point::new(sp.x + arm, sp.y));
                    });
                    let v = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x, sp.y - arm));
                        b.line_to(Point::new(sp.x, sp.y + arm));
                    });
                    frame.stroke(&h, stroke.clone());
                    frame.stroke(&v, stroke);
                }
                SnapType::Vertex => {
                    // Filled square: the solid rhyme of Endpoint's hollow box.
                    let h = 5.0_f32;
                    frame.fill(
                        &canvas::Path::rectangle(
                            Point::new(sp.x - h, sp.y - h),
                            Size::new(h * 2.0, h * 2.0),
                        ),
                        marker,
                    );
                }
                SnapType::EdgeMidpoint => {
                    // Filled triangle: the solid rhyme of Midpoint's outline.
                    let r = 6.0_f32;
                    let path = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x, sp.y - r));
                        b.line_to(Point::new(sp.x + r * 0.866, sp.y + r * 0.5));
                        b.line_to(Point::new(sp.x - r * 0.866, sp.y + r * 0.5));
                        b.close();
                    });
                    frame.fill(&path, marker);
                }
                SnapType::FaceCenter => {
                    // Filled disc: the solid rhyme of Center's outline.
                    frame.fill(&canvas::Path::circle(sp, 5.5_f32), marker);
                }
                SnapType::Knot => {
                    // Filled diamond: distinct from Quadrant's outline.
                    let r = 5.5_f32;
                    let path = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x, sp.y - r));
                        b.line_to(Point::new(sp.x + r, sp.y));
                        b.line_to(Point::new(sp.x, sp.y + r));
                        b.line_to(Point::new(sp.x - r, sp.y));
                        b.close();
                    });
                    frame.fill(&path, marker);
                }
                SnapType::FacePerpendicular => {
                    // Right-angle hook like the 2D marker, plus a filled foot
                    // dot marking the face contact.
                    let r = 6.0_f32;
                    let p = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r, sp.y - r));
                        b.line_to(Point::new(sp.x - r, sp.y + r));
                        b.line_to(Point::new(sp.x + r, sp.y + r));
                    });
                    frame.stroke(&p, stroke.clone());
                    frame.fill(&canvas::Path::circle(sp, 2.0_f32), marker);
                }
                SnapType::NearestFace => {
                    // Filled bowtie: the solid rhyme of Nearest's outline.
                    let r = 5.5_f32;
                    let path = canvas::Path::new(|b| {
                        b.move_to(Point::new(sp.x - r, sp.y - r));
                        b.line_to(Point::new(sp.x + r, sp.y - r));
                        b.line_to(Point::new(sp.x - r, sp.y + r));
                        b.line_to(Point::new(sp.x + r, sp.y + r));
                        b.close();
                    });
                    frame.fill(&path, marker);
                }
            }
        }

        // ── CAD crosshair cursor ──────────────────────────────────────────────
        let over_viewcube = self.show_viewcube && {
            use crate::scene::{VIEWCUBE_PAD, VIEWCUBE_REGION_PX};
            cursor.position_in(bounds).map_or(false, |pos| {
                let vc_x = bounds.width - VIEWCUBE_REGION_PX - VIEWCUBE_PAD;
                let vc_y = VIEWCUBE_PAD;
                pos.x >= vc_x
                    && pos.x <= vc_x + VIEWCUBE_REGION_PX
                    && pos.y >= vc_y
                    && pos.y <= vc_y + VIEWCUBE_REGION_PX
            })
        };
        // Over a Model-tile divider the OS cursor switches to a resize
        // arrow (see `mouse_interaction`); drawing the CAD crosshair on
        // top of it would double up the visual feedback.
        let over_divider = self.divider_under(cursor, bounds);
        // PAN mode replaces the crosshair with a hand cursor.
        if !over_viewcube
            && !over_divider
            && !self.pan_mode
            && !self.suppressed
            && self.crosshair.cursor_type == CursorType::Crosshair
        {
            if let Some(cp) = self.selection.borrow().last_move_pos {
                let [r, g, b, a] = self.crosshair.color.map_or_else(
                    || {
                        crate::scene::view::render::adapt_to_bg(
                            [1.0, 1.0, 1.0, 0.90],
                            self.crosshair_bg,
                        )
                    },
                    |[r, g, b]| {
                        [
                            r as f32 / 255.0,
                            g as f32 / 255.0,
                            b as f32 / 255.0,
                            0.90,
                        ]
                    },
                );
                let color = Color { r, g, b, a };
                let stroke = canvas::Stroke {
                    width: 1.0,
                    style: canvas::Style::Solid(color),
                    ..Default::default()
                };
                let point_mode = self.crosshair.point_mode;
                let sq = if point_mode {
                    0.0
                } else {
                    pick_box_half_px(self.crosshair.pick_box)
                };
                let arm = crosshair_arm_px(bounds, self.crosshair.size_percent);
                let base_angles: [f64; 2] = if self.crosshair.isometric {
                    self.crosshair.iso_plane.angles()
                } else {
                    [0.0, 90.0]
                };
                for angle in base_angles {
                    let rad = (angle + self.crosshair.snap_angle_deg as f64).to_radians();
                    let dir = Point::new(rad.cos() as f32, -rad.sin() as f32);
                    let gap = if point_mode {
                        9.0
                    } else if sq > 0.0 {
                        sq / dir.x.abs().max(dir.y.abs()).max(1e-6)
                    } else {
                        0.0
                    };
                    let arms = canvas::Path::new(|path| {
                        path.move_to(Point::new(cp.x + dir.x * gap, cp.y + dir.y * gap));
                        path.line_to(Point::new(cp.x + dir.x * arm, cp.y + dir.y * arm));
                        path.move_to(Point::new(cp.x - dir.x * gap, cp.y - dir.y * gap));
                        path.line_to(Point::new(cp.x - dir.x * arm, cp.y - dir.y * arm));
                    });
                    frame.stroke(&arms, stroke.clone());
                }
                if point_mode {
                    let dot = canvas::Path::circle(cp, 1.75);
                    frame.fill(&dot, color);
                } else if sq > 0.0 {
                    let square = canvas::Path::rectangle(
                        Point::new(cp.x - sq, cp.y - sq),
                        Size::new(sq * 2.0, sq * 2.0),
                    );
                    frame.stroke(&square, stroke);
                }

                // Locked-layer badge: a small padlock beside the crosshair when
                // the hovered object sits on a locked layer (issue: locked
                // objects are visible, snappable and selectable but not editable).
                if self.hover_locked {
                    let warning = theme.palette().warning.base;
                    let amber = warning.color.scale_alpha(0.98);
                    let dark = warning.text;
                    let bx = cp.x + sq + 7.0;
                    let by = cp.y - sq - 13.0;
                    // Lock body (filled).
                    let body = canvas::Path::rectangle(
                        Point::new(bx, by + 6.0),
                        Size::new(12.0, 9.0),
                    );
                    frame.fill(&body, amber);
                    // Shackle: an inverted-U above the body (squared so the
                    // shape is unambiguous regardless of arc winding).
                    let shackle = canvas::Path::new(|b| {
                        b.move_to(Point::new(bx + 2.5, by + 6.0));
                        b.line_to(Point::new(bx + 2.5, by + 2.5));
                        b.line_to(Point::new(bx + 9.5, by + 2.5));
                        b.line_to(Point::new(bx + 9.5, by + 6.0));
                    });
                    frame.stroke(
                        &shackle,
                        canvas::Stroke {
                            width: 1.8,
                            style: canvas::Style::Solid(amber),
                            line_join: canvas::LineJoin::Round,
                            ..Default::default()
                        },
                    );
                    // Keyhole.
                    let hole = canvas::Path::circle(Point::new(bx + 6.0, by + 10.5), 1.4);
                    frame.fill(&hole, dark);
                }
                if let Some(label) = &self.constraint_cursor_badge {
                    let center = Point::new(cp.x + sq + if self.hover_locked { 30.0 } else { 12.0 }, cp.y - sq - 7.0);
                    let blue = Color::from_rgb8(35, 145, 230);
                    let badge = canvas::Path::circle(center, 8.5);
                    frame.fill(&badge, blue);
                    if label == "◎" {
                        draw_concentric_constraint_glyph(&mut frame, center, Color::WHITE);
                    } else if label == "T" {
                        draw_tangent_constraint_glyph(&mut frame, center, Color::WHITE);
                    } else {
                        frame.fill_text(canvas::Text {
                            content: label.clone(),
                            position: center,
                            color: Color::WHITE,
                            size: iced::Pixels(11.0),
                            align_x: iced::alignment::Horizontal::Center.into(),
                            align_y: iced::alignment::Vertical::Center,
                            shaping: iced::advanced::text::Shaping::Advanced,
                            ..Default::default()
                        });
                    }
                }
            }
        } // end !over_viewcube

        // ── UCS icon (one per Model pane) ─────────────────────────────────
        for ucs in &self.ucs_icons {
            draw_ucs_icon(
                &mut frame,
                ucs.view_proj,
                ucs.bounds,
                ucs.axes,
                ucs.origin_screen,
                ucs.hover,
                ucs.selected,
                self.crosshair_bg,
            );
        }

        // ── Object Snap Tracking ─────────────────────────────────────────────
        let track_color = theme.palette().primary.base.color.scale_alpha(0.7);
        // The alignment line the cursor is currently locked to — drawn at its
        // real angle from the acquired point through the lock and a little
        // beyond, dashed so it reads as a construction guide. This covers the
        // ortho (0°/90°), polar, and edge-extension cases uniformly (#219).
        if let Some((base, tip)) = self.otrack_line {
            let dx = tip.x - base.x;
            let dy = tip.y - base.y;
            let len = (dx * dx + dy * dy).sqrt();
            if len > 1e-3 {
                // Extend the alignment path well past both ends along its
                // direction so it reads as a full construction line through the
                // acquired point, not a stub between the corner and the cursor
                // (#219), then clip it to the viewport ourselves: the canvas
                // clips only after tessellating, which is too late for a dash
                // pattern (see `clip_seg`).
                let (ux, uy) = (dx / len, dy / len);
                const L: f32 = 5000.0;
                let p0 = Point::new(base.x - ux * L, base.y - uy * L);
                let p1 = Point::new(tip.x + ux * L, tip.y + uy * L);
                let dash = canvas::Stroke {
                    line_dash: canvas::LineDash {
                        segments: &[6.0, 4.0],
                        offset: 0,
                    },
                    ..canvas::Stroke::default()
                        .with_color(track_color)
                        .with_width(1.0)
                };
                if let Some((a, b)) = clip_seg(p0, p1, bounds) {
                    frame.stroke(&canvas::Path::line(a, b), dash);
                }
            }
        }
        // The acquired Parallel-snap reference — a small ∥ glyph on its line so
        // the user sees which line the parallel is measured from. (#277)
        if let Some(m) = self.parallel_ref_marker {
            let stroke = canvas::Stroke::default()
                .with_color(track_color)
                .with_width(1.5);
            let r = 6.0_f32;
            let off = 3.0_f32;
            let b1 = canvas::Path::new(|b| {
                b.move_to(Point::new(m.x - r - off, m.y + r));
                b.line_to(Point::new(m.x + r - off, m.y - r));
            });
            let b2 = canvas::Path::new(|b| {
                b.move_to(Point::new(m.x - r + off, m.y + r));
                b.line_to(Point::new(m.x + r + off, m.y - r));
            });
            frame.stroke(&b1, stroke.clone());
            frame.stroke(&b2, stroke);
        }
        // Hit testing shares this layout math with the scene projection.
        if !self.constraint_glyphs.is_empty() {
            // `constraint_glyph_offsets` only needs the anchor/outward/label/
            // conflict quadruple it was written against; project away the
            // trailing display fields rather than widen its signature.
            let glyphs_for_offsets: Vec<(Point, [f32; 2], String, bool)> = self
                .constraint_glyphs
                .iter()
                .map(|(anchor, outward, label, is_conflicting, _, _)| {
                    (*anchor, *outward, label.clone(), *is_conflicting)
                })
                .collect();
            let offsets = constraint_glyph_offsets(&glyphs_for_offsets);
            let hovered = cursor
                .position_in(bounds)
                .and_then(|point| constraint_glyph_hit_test(&glyphs_for_offsets, point));
            let normal_bg = Color::from_rgb8(103, 109, 118);
            let normal_fg = Color::WHITE;
            // A redundant or conflicting constraint gets the danger palette
            // instead of the
            // ordinary primary one — same information a resolver panel
            // would show, surfaced right on the geometry.
            let conflict_bg = theme.palette().danger.base.color;
            let conflict_fg = theme.palette().danger.base.text;
            let selected_ring = theme.palette().primary.strong.color;
            let coincident_bg = Color::from_rgb8(35, 145, 230);
            for ((anchor, outward, label, is_conflicting, is_selected, _), tangent_offset) in
                self.constraint_glyphs.iter().zip(offsets.iter().copied())
            {
                if !anchor.x.is_finite() || !anchor.y.is_finite() {
                    continue;
                }
                let compact_coincident = is_compact_coincident_glyph(label);
                let (bg, fg) = if *is_conflicting {
                    (conflict_bg, conflict_fg)
                } else if compact_coincident {
                    (coincident_bg, normal_fg)
                } else {
                    (normal_bg, normal_fg)
                };
                let (top_left, size) =
                    constraint_glyph_box(*anchor, *outward, label, tangent_offset);
                let pill = canvas::Path::rounded_rectangle(
                    top_left,
                    size,
                    (if compact_coincident {
                        1.0
                    } else {
                        size.height * 0.5
                    })
                    .into(),
                );
                frame.fill(&pill, bg);
                if *is_selected {
                    frame.stroke(
                        &pill,
                        canvas::Stroke::default().with_color(selected_ring).with_width(2.0),
                    );
                }
                if !compact_coincident {
                    let glyph_center = Point::new(
                        top_left.x + size.width * 0.5,
                        top_left.y + size.height * 0.5,
                    );
                    if label == "T" {
                        draw_tangent_constraint_glyph(&mut frame, glyph_center, fg);
                    } else if label == "G²" {
                        draw_smooth_constraint_glyph(&mut frame, glyph_center, fg);
                    } else if label == "◎" {
                        draw_concentric_constraint_glyph(&mut frame, glyph_center, fg);
                    } else {
                        frame.fill_text(canvas::Text {
                            content: label.clone(),
                            position: glyph_center,
                            color: fg,
                            size: iced::Pixels(CONSTRAINT_GLYPH_SIZE),
                            align_x: iced::alignment::Horizontal::Center.into(),
                            align_y: iced::alignment::Vertical::Center,
                            shaping: iced::advanced::text::Shaping::Advanced,
                            ..Default::default()
                        });
                    }
                }
            }
            if let Some(index) = hovered {
                let red = Color::from_rgb(1.0, 0.0, 0.0);
                let stroke = canvas::Stroke::default().with_color(red).with_width(1.5);
                for point in &self.constraint_glyphs[index].5 {
                    let first = canvas::Path::line(
                        Point::new(
                            point.x - CONSTRAINT_HOVER_MARKER_RADIUS,
                            point.y - CONSTRAINT_HOVER_MARKER_RADIUS,
                        ),
                        Point::new(
                            point.x + CONSTRAINT_HOVER_MARKER_RADIUS,
                            point.y + CONSTRAINT_HOVER_MARKER_RADIUS,
                        ),
                    );
                    let second = canvas::Path::line(
                        Point::new(
                            point.x - CONSTRAINT_HOVER_MARKER_RADIUS,
                            point.y + CONSTRAINT_HOVER_MARKER_RADIUS,
                        ),
                        Point::new(
                            point.x + CONSTRAINT_HOVER_MARKER_RADIUS,
                            point.y - CONSTRAINT_HOVER_MARKER_RADIUS,
                        ),
                    );
                    frame.stroke(&first, stroke.clone());
                    frame.stroke(&second, stroke.clone());
                }
                if let Some(label) = &self.constraint_glyph_tooltip {
                    let (glyph_top_left, glyph_size) = constraint_glyph_box(
                        self.constraint_glyphs[index].0,
                        self.constraint_glyphs[index].1,
                        &self.constraint_glyphs[index].2,
                        offsets[index],
                    );
                    let width = (label.chars().count() as f32 * 7.0 + 14.0).max(54.0);
                    let height = 24.0;
                    let left = glyph_top_left.x.clamp(2.0, (bounds.width - width - 2.0).max(2.0));
                    let top = (glyph_top_left.y + glyph_size.height + 4.0)
                        .clamp(2.0, (bounds.height - height - 2.0).max(2.0));
                    let tooltip = canvas::Path::rounded_rectangle(
                        Point::new(left, top),
                        Size::new(width, height),
                        4.0.into(),
                    );
                    frame.fill(&tooltip, theme.palette().background.strong.color);
                    frame.stroke(
                        &tooltip,
                        canvas::Stroke::default()
                            .with_color(theme.palette().background.strong.text)
                            .with_width(1.0),
                    );
                    frame.fill_text(canvas::Text {
                        content: label.clone(),
                        position: Point::new(left + width * 0.5, top + height * 0.5),
                        color: theme.palette().background.strong.text,
                        size: iced::Pixels(12.0),
                        align_x: iced::alignment::Horizontal::Center.into(),
                        align_y: iced::alignment::Vertical::Center,
                        shaping: iced::advanced::text::Shaping::Advanced,
                        ..Default::default()
                    });
                }
            }
        }
        // Small cross at each acquired tracking point.
        for ost in &self.ost_points {
            let tp = ost.screen;
            let stroke = canvas::Stroke::default()
                .with_color(track_color)
                .with_width(1.0);
            let sz = 5.0_f32;
            let h = canvas::Path::line(
                Point {
                    x: tp.x - sz,
                    y: tp.y,
                },
                Point {
                    x: tp.x + sz,
                    y: tp.y,
                },
            );
            let v = canvas::Path::line(
                Point {
                    x: tp.x,
                    y: tp.y - sz,
                },
                Point {
                    x: tp.x,
                    y: tp.y + sz,
                },
            );
            frame.stroke(&h, stroke.clone());
            frame.stroke(&v, stroke);
        }

        vec![frame.into_geometry()]
    }
}

// ── Grid line drawing ─────────────────────────────────────────────────────

/// Minimum pixel gap between adjacent grid lines before stepping up to next spacing.
const MIN_GRID_PX: f32 = 20.0;
/// Stop an infinite perspective grid before adjacent lines merge at the horizon.
const MIN_HORIZON_GRID_PX: f32 = 5.0;

#[allow(clippy::too_many_arguments)]
fn draw_grid(
    frame: &mut canvas::Frame,
    view_rot: Mat4,
    eye: glam::DVec3,
    bounds: iced::Rectangle,
    step_x: f32,
    step_y: f32,
    major_every: u32,
    grid_origin: glam::DVec3,
    grid_axes: (Vec3, Vec3, Vec3),
    limits: Option<(glam::DVec2, glam::DVec2)>,
    style: GridStyle,
) {
    let alpha = (style.opacity as f32 / 100.0).clamp(0.02, 1.0);
    // Major lines stay subtle: ~1.5x the minor alpha with a slightly heavier
    // stroke, matching the reference hierarchy without glaring.
    let major_alpha = (alpha * 1.5).clamp(0.03, 1.0);
    let (r, g, b) = if style.bg_luminance > 0.5 {
        (0.10, 0.10, 0.10)
    } else {
        (0.80, 0.80, 0.80)
    };
    let minor_stroke = canvas::Stroke {
        width: 0.5,
        style: canvas::Style::Solid(Color { r, g, b, a: alpha }),
        ..Default::default()
    };
    let major_stroke = canvas::Stroke {
        width: 0.75,
        style: canvas::Style::Solid(Color { r, g, b, a: major_alpha }),
        ..Default::default()
    };
    let geometry =
        grid_segments(view_rot, eye, bounds, step_x, step_y, major_every, grid_origin, grid_axes, limits);
    if !geometry.segments.is_empty() {
        let path = canvas::Path::new(|builder| {
            for (p0, p1) in &geometry.segments {
                builder.move_to(*p0);
                builder.line_to(*p1);
            }
        });
        frame.stroke(&path, minor_stroke);
    }
    if !geometry.major_segments.is_empty() {
        let path = canvas::Path::new(|builder| {
            for (p0, p1) in &geometry.major_segments {
                builder.move_to(*p0);
                builder.line_to(*p1);
            }
        });
        frame.stroke(&path, major_stroke);
    }
    if geometry.axis_extent > 0.0 {
        let (gx, gy, gz) = grid_axes;
        let extent = (geometry.axis_extent + step_x.max(step_y)) * 1.5;
        draw_axes(frame, view_rot, eye, bounds, extent.max(10.0), grid_origin, (gx, gy, gz), style.bg_luminance);
    }
}

/// Pure, renderer-free projection of the grid for one pane. Returns canvas-local
/// `(Point, Point)` segments plus the axis extent (in world units along the
/// active UCS axes) used by `draw_grid` to size the coloured UCS axes overlay.
///
/// Extracted from `draw_grid` (2026-08-26, Mission #1 step 1) so the geometry
/// construction can be unit-tested and benchmarked without an iced
/// `Renderer`. Behaviour is identical to the inlined version that preceded it.
#[doc(hidden)]
#[allow(clippy::too_many_arguments)]
pub fn grid_segments(
    view_rot: Mat4,
    eye: glam::DVec3,
    bounds: iced::Rectangle,
    step_x: f32,
    step_y: f32,
    major_every: u32,
    grid_origin: glam::DVec3,
    grid_axes: (Vec3, Vec3, Vec3),
    limits: Option<(glam::DVec2, glam::DVec2)>,
) -> GridGeometry {
    if bounds.width <= 0.0 || bounds.height <= 0.0 {
        return GridGeometry::empty();
    }

    // World → viewport-local screen via relative-to-eye: subtract the f64 eye
    // first so grid points near the camera stay precise at UTM-scale coords.
    // Reject points on/behind the perspective eye plane before dividing by W.
    let project = |world: glam::DVec3| -> Option<Point> {
        let rel = (world - eye).as_vec3();
        let clip = view_rot * rel.extend(1.0);
        if !clip.is_finite() || clip.w <= 1e-7 {
            return None;
        }
        let ndc = clip.truncate() / clip.w;
        let screen = Point::new(
            (ndc.x + 1.0) * 0.5 * bounds.width,
            (1.0 - ndc.y) * 0.5 * bounds.height,
        );
        (screen.x.is_finite() && screen.y.is_finite()).then_some(screen)
    };

    // Grid is intentionally restricted to the active UCS XY plane.
    let (gx, gy, gz) = grid_axes;
    let axis1 = gx.normalize_or(Vec3::X);
    let axis2 = gy.normalize_or(Vec3::Y);
    let inv = view_rot.inverse();
    let plane_normal = axis1.cross(axis2).normalize_or(Vec3::Z);
    let plane_rel = (grid_origin - eye).as_vec3();

    // Intersect a viewport-local screen ray with the real XY plane. Unlike the
    // old mid-depth approximation, this covers the complete viewport after an
    // orbit and also tells us when a ray crosses the perspective horizon.
    let unproject = |sx: f32, sy: f32| -> Option<glam::DVec3> {
        let ndc_x = (sx / bounds.width) * 2.0 - 1.0;
        let ndc_y = 1.0 - (sy / bounds.height) * 2.0;
        let near = inv.project_point3(Vec3::new(ndc_x, ndc_y, 0.0));
        let far = inv.project_point3(Vec3::new(ndc_x, ndc_y, 1.0));
        let ray = far - near;
        let denom = ray.dot(plane_normal);
        if !near.is_finite()
            || !far.is_finite()
            || !denom.is_finite()
            || denom.abs() < 1e-7
        {
            return None;
        }
        let t = (plane_rel - near).dot(plane_normal) / denom;
        // `far` defines only the unprojection line direction. Its parameter
        // sign is not a reliable front/behind test after the WGPU depth
        // conversion and was cutting the near side during zoom/orbit. The
        // homogeneous clip-W check in `project` is the canonical eye-plane
        // test and also keeps the infinite grid independent of near/far depth.
        if !t.is_finite() {
            return None;
        }
        let hit = near + ray * t;
        if !hit.is_finite() {
            return None;
        }
        let world = eye + hit.as_dvec3();
        project(world).map(|_| world)
    };

    // Perpendicular screen gap between the two neighbouring lines of each
    // family at a point on the grid. Measuring the perpendicular component,
    // rather than point-to-point distance, remains correct for a skewed
    // perspective grid.
    let grid_gaps = |world: glam::DVec3, sx: f32, sy: f32| -> Option<(f32, f32)> {
        let p = project(world)?;
        let projected_deltas = |axis: Vec3, amount: f32| {
            [amount, -amount].map(|signed_step| {
                project(world + (axis * signed_step).as_dvec3())
                    .map(|next| glam::Vec2::new(next.x - p.x, next.y - p.y))
            })
        };
        let neighbours1 = projected_deltas(axis1, sx);
        let neighbours2 = projected_deltas(axis2, sy);
        // A full grid step is needed to measure adjacent-line distance, but it
        // is too large for the line's local tangent near the eye. A small
        // derivative keeps the tangent measurable without crossing the eye.
        // BUG FIX: the tangent used a single shared step for both families, so
        // a non-square GRIDUNIT (sx != sy) measured the wrong local direction.
        // Each family now uses its own derivative.
        let tangents1 = projected_deltas(axis1, (sx * 0.01).max(1e-4));
        let tangents2 = projected_deltas(axis2, (sy * 0.01).max(1e-4));

        // At the near side of a perspective plane a large +step neighbour may
        // cross behind the eye while the -step neighbour remains perfectly
        // visible (or vice versa). Requiring only +X/+Y cut away that entire
        // near side after zoom-out. Use whichever visible neighbour gives the
        // readable separation for each line family.
        let mut gap1 = 0.0_f32;
        let mut gap2 = 0.0_f32;
        for neighbour in neighbours1.into_iter().flatten() {
            for tangent in tangents2.into_iter().flatten() {
                let tangent_len = tangent.length();
                if tangent_len > 1e-6 {
                    let area =
                        (neighbour.x * tangent.y - neighbour.y * tangent.x).abs();
                    gap1 = gap1.max(area / tangent_len);
                }
            }
        }
        for neighbour in neighbours2.into_iter().flatten() {
            for tangent in tangents1.into_iter().flatten() {
                let tangent_len = tangent.length();
                if tangent_len > 1e-6 {
                    let area =
                        (neighbour.x * tangent.y - neighbour.y * tangent.x).abs();
                    gap2 = gap2.max(area / tangent_len);
                }
            }
        }
        (gap1.is_finite() && gap2.is_finite()).then_some((gap1, gap2))
    };

    // Use several interior points because the UCS origin may be off-screen or
    // arbitrarily close to the perspective horizon.
    const SAMPLE_FRACTIONS: [f32; 5] = [0.02, 0.25, 0.5, 0.75, 0.98];
    let mut samples = Vec::with_capacity(SAMPLE_FRACTIONS.len().pow(2));
    for fy in SAMPLE_FRACTIONS {
        for fx in SAMPLE_FRACTIONS {
            let screen = glam::Vec2::new(bounds.width * fx, bounds.height * fy);
            if let Some(world) = unproject(screen.x, screen.y) {
                samples.push((screen, world));
            }
        }
    }
    if samples.is_empty() {
        return GridGeometry::empty();
    };

    // Step follows camera zoom only. The previous visible-sample calculation
    // changed depth while orbiting and made the grid jump 1 → 5 → 25.
    // BUG FIX: a single shared step forced square grids; X and Y are now
    // validated independently so GRIDUNIT X/Y resize each family.
    if !step_x.is_finite() || step_x <= 0.0 || !step_y.is_finite() || step_y <= 0.0 {
        return GridGeometry::empty();
    }
    let (sx, sy) = (step_x, step_y);
    let is_major = |index: i32| {
        major_every >= 2 && (index.rem_euclid(major_every as i32) == 0)
    };

    // Trace a family-specific visible region around the viewport perimeter.
    // When a boundary ray points through the horizon, binary-search back toward
    // a readable anchor and stop where neighbouring lines reach the minimum gap.
    let collect_extent = |
        family: usize,
        anchor_screen: glam::Vec2,
        anchor_world: glam::DVec3,
    | -> Vec<glam::DVec3> {
        let visible_at = |screen: glam::Vec2| -> Option<glam::DVec3> {
            let world = unproject(screen.x, screen.y)?;
            let gaps = grid_gaps(world, sx, sy)?;
            let gap = if family == 0 { gaps.0 } else { gaps.1 };
            (gap >= MIN_HORIZON_GRID_PX).then_some(world)
        };

        const EDGE_STEPS: usize = 12;
        const SEARCH_STEPS: usize = 16;
        let mut hits = vec![anchor_world];
        for i in 0..=EDGE_STEPS {
            let f = i as f32 / EDGE_STEPS as f32;
            let targets = [
                glam::Vec2::new(bounds.width * f, 0.0),
                glam::Vec2::new(bounds.width * f, bounds.height),
                glam::Vec2::new(0.0, bounds.height * f),
                glam::Vec2::new(bounds.width, bounds.height * f),
            ];
            for target in targets {
                if let Some(world) = visible_at(target) {
                    hits.push(world);
                    continue;
                }
                let mut near_screen = anchor_screen;
                let mut far_screen = target;
                let mut near_world = anchor_world;
                for _ in 0..SEARCH_STEPS {
                    let middle = (near_screen + far_screen) * 0.5;
                    if let Some(world) = visible_at(middle) {
                        near_screen = middle;
                        near_world = world;
                    } else {
                        far_screen = middle;
                    }
                }
                hits.push(near_world);
            }
        }
        hits
    };

    let best_anchor = |family: usize| -> Option<(glam::Vec2, glam::DVec3, f32)> {
        let mut best = None;
        for (screen, world) in &samples {
            let Some(gaps) = grid_gaps(*world, sx, sy) else {
                continue;
            };
            let gap = if family == 0 { gaps.0 } else { gaps.1 };
            if best.map_or(true, |(_, _, best_gap)| gap > best_gap) {
                best = Some((*screen, *world, gap));
            }
        }
        best
    };
    let axis_range = |hits: &[glam::DVec3], axis: Vec3| -> Option<(f32, f32)> {
        let mut min = f32::INFINITY;
        let mut max = f32::NEG_INFINITY;
        for world in hits {
            let value = (*world - grid_origin).as_vec3().dot(axis);
            if value.is_finite() {
                min = min.min(value);
                max = max.max(value);
            }
        }
        (min <= max).then_some((min, max))
    };
    let line_range = |min: f32, max: f32, anchor: f32, step: f32| -> (i32, i32) {
        let mut start = (min / step).floor() as i32;
        let mut end = (max / step).ceil() as i32;
        // The pixel-gap cut-off naturally bounds this by viewport resolution. Keep
        // malformed projection data from creating an unbounded CPU loop.
        let limit = ((bounds.width + bounds.height).ceil() as i32 + 64).max(128);
        let center = (anchor / step).round() as i32;
        start = start.max(center.saturating_sub(limit));
        end = end.min(center.saturating_add(limit));
        (start, end)
    };
    // Project an infinite world-grid line to its exact screen-space line and
    // intersect it with the viewport rectangle. This remains valid across the
    // perspective horizon; projecting a finite world-space bounding rectangle
    // is only correct for the perpendicular/top view.
    let grid_clip_origin = view_rot * (grid_origin - eye).as_vec3().extend(1.0);
    let grid_clip_axis1 = view_rot * axis1.extend(0.0);
    let grid_clip_axis2 = view_rot * axis2.extend(0.0);
    let project_line = |family: usize, value: f32| -> Option<(glam::Vec2, glam::Vec2)> {
        let (base, direction) = if family == 0 {
            (
                grid_clip_origin + grid_clip_axis1 * value,
                grid_clip_axis2,
            )
        } else {
            (
                grid_clip_origin + grid_clip_axis2 * value,
                grid_clip_axis1,
            )
        };
        let screen_h = |clip: glam::Vec4| {
            glam::Vec3::new(
                (clip.x + clip.w) * 0.5 * bounds.width,
                (-clip.y + clip.w) * 0.5 * bounds.height,
                clip.w,
            )
        };
        let line = screen_h(base).cross(screen_h(base + direction));
        if !line.is_finite() || line.x.abs() + line.y.abs() < 1e-8 {
            return None;
        }

        const EDGE_EPS: f32 = 0.5;
        let mut points = Vec::with_capacity(4);
        let mut add_point = |point: glam::Vec2| {
            if !point.is_finite()
                || point.x < -EDGE_EPS
                || point.x > bounds.width + EDGE_EPS
                || point.y < -EDGE_EPS
                || point.y > bounds.height + EDGE_EPS
            {
                return;
            }
            let point = glam::Vec2::new(
                point.x.clamp(0.0, bounds.width),
                point.y.clamp(0.0, bounds.height),
            );
            if points.iter().all(|p: &glam::Vec2| p.distance_squared(point) > 1e-4) {
                points.push(point);
            }
        };
        if line.y.abs() > 1e-8 {
            add_point(glam::Vec2::new(0.0, -line.z / line.y));
            add_point(glam::Vec2::new(
                bounds.width,
                -(line.x * bounds.width + line.z) / line.y,
            ));
        }
        if line.x.abs() > 1e-8 {
            add_point(glam::Vec2::new(-line.z / line.x, 0.0));
            add_point(glam::Vec2::new(
                -(line.y * bounds.height + line.z) / line.x,
                bounds.height,
            ));
        }
        if points.len() < 2 {
            return None;
        }

        let mut best = (points[0], points[1]);
        let mut best_distance = best.0.distance_squared(best.1);
        for i in 0..points.len() {
            for j in i + 1..points.len() {
                let distance = points[i].distance_squared(points[j]);
                if distance > best_distance {
                    best = (points[i], points[j]);
                    best_distance = distance;
                }
            }
        }
        Some(best)
    };

    // Keep only the parts of one projected line where its neighbouring line is
    // at least the configured physical-pixel gap away. The visible interval is found in screen
    // space, so oblique/trapezoidal views no longer inherit rectangular world
    // bounds from the top view.
    let trim_line = |
        family: usize,
        p0: glam::Vec2,
        p1: glam::Vec2,
    | -> Vec<(Point, Point)> {
        let visible = |t: f32| {
            let screen = p0.lerp(p1, t);
            let Some(world) = unproject(screen.x, screen.y) else {
                return false;
            };
            let Some(gaps) = grid_gaps(world, sx, sy) else {
                return false;
            };
            let gap = if family == 0 { gaps.0 } else { gaps.1 };
            gap >= MIN_HORIZON_GRID_PX
        };
        let find_transition = |mut low: f32, mut high: f32, low_visible: bool| {
            for _ in 0..14 {
                let middle = (low + high) * 0.5;
                if visible(middle) == low_visible {
                    low = middle;
                } else {
                    high = middle;
                }
            }
            (low + high) * 0.5
        };

        const LINE_SAMPLES: usize = 16;
        let mut result = Vec::with_capacity(2);
        let mut previous_t = 0.0_f32;
        let mut previous_visible = visible(previous_t);
        let mut run_start = previous_visible.then_some(previous_t);
        for i in 1..=LINE_SAMPLES {
            let t = i as f32 / LINE_SAMPLES as f32;
            let is_visible = visible(t);
            if is_visible != previous_visible {
                let boundary = find_transition(previous_t, t, previous_visible);
                if is_visible {
                    run_start = Some(boundary);
                } else if let Some(start) = run_start.take() {
                    let a = p0.lerp(p1, start);
                    let b = p0.lerp(p1, boundary);
                    result.push((
                        Point::new(a.x + bounds.x, a.y + bounds.y),
                        Point::new(b.x + bounds.x, b.y + bounds.y),
                    ));
                }
            }
            previous_t = t;
            previous_visible = is_visible;
        }
        if let Some(start) = run_start {
            let a = p0.lerp(p1, start);
            result.push((
                Point::new(a.x + bounds.x, a.y + bounds.y),
                Point::new(p1.x + bounds.x, p1.y + bounds.y),
            ));
        }
        result
    };

    let mut all_segments: Vec<(Point, Point)> = Vec::new();
    let mut axis_extent = 0.0_f32;

    // A finite LIMITS rectangle replaces the usual viewport/horizon extent.
    // Clip each UCS grid line analytically against the WCS XY rectangle, then
    // project only that finite segment. This keeps the grid bounded even when
    // the active UCS is rotated.
    if let Some((limit_min, limit_max)) = limits {
        let corners = [
            glam::DVec3::new(limit_min.x, limit_min.y, grid_origin.z),
            glam::DVec3::new(limit_max.x, limit_min.y, grid_origin.z),
            glam::DVec3::new(limit_max.x, limit_max.y, grid_origin.z),
            glam::DVec3::new(limit_min.x, limit_max.y, grid_origin.z),
        ];
        let coordinate_range = |axis: Vec3| {
            corners
                .iter()
                .fold((f32::INFINITY, f32::NEG_INFINITY), |(min, max), corner| {
                    let value = (*corner - grid_origin).as_vec3().dot(axis);
                    (min.min(value), max.max(value))
                })
        };
        let clip_world_line = |family: usize, value: f32| -> Option<(Point, Point)> {
            let (base, direction) = if family == 0 {
                (grid_origin + (axis1 * value).as_dvec3(), axis2.as_dvec3())
            } else {
                (grid_origin + (axis2 * value).as_dvec3(), axis1.as_dvec3())
            };
            let (mut t0, mut t1) = (f64::NEG_INFINITY, f64::INFINITY);
            let mut clip_axis = |origin: f64, delta: f64, low: f64, high: f64| {
                if delta.abs() < 1e-12 {
                    return origin >= low && origin <= high;
                }
                let a = (low - origin) / delta;
                let b = (high - origin) / delta;
                t0 = t0.max(a.min(b));
                t1 = t1.min(a.max(b));
                t0 <= t1
            };
            if !clip_axis(base.x, direction.x, limit_min.x, limit_max.x)
                || !clip_axis(base.y, direction.y, limit_min.y, limit_max.y)
                || !t0.is_finite()
                || !t1.is_finite()
            {
                return None;
            }
            let p0 = project(base + direction * t0)?;
            let p1 = project(base + direction * t1)?;
            let local_bounds = iced::Rectangle {
                x: 0.0,
                y: 0.0,
                width: bounds.width,
                height: bounds.height,
            };
            clip_seg(p0, p1, local_bounds).map(|(p0, p1)| {
                (
                    Point::new(p0.x + bounds.x, p0.y + bounds.y),
                    Point::new(p1.x + bounds.x, p1.y + bounds.y),
                )
            })
        };

        let (min1, max1) = coordinate_range(axis1);
        let (min2, max2) = coordinate_range(axis2);
        let mut minor = Vec::new();
        let mut major = Vec::new();
        if let Some((_, anchor_world, gap)) = best_anchor(0) {
            if gap >= MIN_HORIZON_GRID_PX {
                let anchor = (anchor_world - grid_origin).as_vec3().dot(axis1);
                let (start, end) = line_range(min1, max1, anchor, sx);
                for index in start..=end {
                    if let Some(segment) = clip_world_line(0, index as f32 * sx) {
                        if is_major(index) { major.push(segment); } else { minor.push(segment); }
                    }
                }
            }
        }
        if let Some((_, anchor_world, gap)) = best_anchor(1) {
            if gap >= MIN_HORIZON_GRID_PX {
                let anchor = (anchor_world - grid_origin).as_vec3().dot(axis2);
                let (start, end) = line_range(min2, max2, anchor, sy);
                for index in start..=end {
                    if let Some(segment) = clip_world_line(1, index as f32 * sy) {
                        if is_major(index) { major.push(segment); } else { minor.push(segment); }
                    }
                }
            }
        }
        all_segments.extend(minor);
        let all_major: Vec<(Point, Point)> = major;

        // LIMITS bounds the grid, not the UCS axes. Size the axes from the
        // visible grid plane so X/Y/Z still span the viewport even when the
        // finite grid rectangle is small or currently off-screen.
        let limits_extent = samples.iter().fold(0.0_f32, |extent, (_, world)| {
            let delta = (*world - grid_origin).as_vec3();
            extent
                .max(delta.dot(axis1).abs())
                .max(delta.dot(axis2).abs())
        });
        if limits_extent > 0.0 {
            axis_extent = limits_extent;
        }
        return GridGeometry { segments: all_segments, major_segments: all_major, axis_extent };
    }

    let mut all_major: Vec<(Point, Point)> = Vec::new();
    // Lines parallel to axis2 (varying axis1 position).
    if let Some((anchor_screen, anchor_world, gap)) = best_anchor(0) {
        if gap >= MIN_HORIZON_GRID_PX {
            let hits = collect_extent(0, anchor_screen, anchor_world);
            if let (Some((min1, max1)), Some((min2, max2))) =
                (axis_range(&hits, axis1), axis_range(&hits, axis2))
            {
                let anchor1 = (anchor_world - grid_origin).as_vec3().dot(axis1);
                let (start, end) = line_range(min1, max1, anchor1, sx);
                for i in start..=end {
                    let value = i as f32 * sx;
                    if let Some((p0, p1)) = project_line(0, value) {
                        let segs = trim_line(0, p0, p1);
                        if is_major(i) { all_major.extend(segs); } else { all_segments.extend(segs); }
                    }
                }
                axis_extent =
                    axis_extent.max(min1.abs().max(max1.abs()).max(min2.abs()).max(max2.abs()));
            }
        }
    }

    // Lines parallel to axis1 (varying axis2 position).
    if let Some((anchor_screen, anchor_world, gap)) = best_anchor(1) {
        if gap >= MIN_HORIZON_GRID_PX {
            let hits = collect_extent(1, anchor_screen, anchor_world);
            if let (Some((min1, max1)), Some((min2, max2))) =
                (axis_range(&hits, axis1), axis_range(&hits, axis2))
            {
                let anchor2 = (anchor_world - grid_origin).as_vec3().dot(axis2);
                let (start, end) = line_range(min2, max2, anchor2, sy);
                for i in start..=end {
                    let value = i as f32 * sy;
                    if let Some((p0, p1)) = project_line(1, value) {
                        let segs = trim_line(1, p0, p1);
                        if is_major(i) { all_major.extend(segs); } else { all_segments.extend(segs); }
                    }
                }
                axis_extent =
                    axis_extent.max(min1.abs().max(max1.abs()).max(min2.abs()).max(max2.abs()));
            }
        }
    }

    let _ = gz; // gz unused after move; retained for symmetry with `draw_axes` call sites.
    GridGeometry { segments: all_segments, major_segments: all_major, axis_extent }
}

// ── Coloured UCS axes ──────────────────────────────────────────────────────

#[allow(clippy::too_many_arguments)]
fn draw_axes(
    frame: &mut canvas::Frame,
    view_rot: Mat4,
    eye: glam::DVec3,
    bounds: iced::Rectangle,
    extent: f32,
    origin: glam::DVec3,
    axes: (Vec3, Vec3, Vec3),
    bg_luminance: f32,
) {
    let w2s = |world: glam::DVec3| -> Point {
        let ndc = view_rot.project_point3((world - eye).as_vec3());
        Point::new(
            bounds.x + (ndc.x + 1.0) * 0.5 * bounds.width,
            bounds.y + (1.0 - ndc.y) * 0.5 * bounds.height,
        )
    };
    let e = extent;
    let (ax, ay, az) = axes;
    let axis_stroke = |r: f32, g: f32, b: f32| canvas::Stroke {
        width: 1.5,
        style: canvas::Style::Solid(Color { r, g, b, a: 0.85 }),
        ..Default::default()
    };
    // Axes run through the UCS origin along the UCS axis directions.
    let mut line = |dir: Vec3, r: f32, g: f32, b: f32| {
        frame.stroke(
            &canvas::Path::new(|p| {
                p.move_to(w2s(origin - (dir * e).as_dvec3()));
                p.line_to(w2s(origin + (dir * e).as_dvec3()));
            }),
            axis_stroke(r, g, b),
        );
    };
    let y_green = if bg_luminance > 0.5 { 0.60 } else { 0.85 };
    line(ax, 0.90, 0.20, 0.20); // X — red
    line(ay, 0.20, y_green, 0.20); // Y — green
    line(az, 0.20, 0.40, 0.90); // Z — blue
}

// ── UCS icon ──────────────────────────────────────────────────────────────
//
// Draws a small X/Y/Z axis tripod in the bottom-left corner of the viewport.
// The axis directions are projected from world space so the icon rotates with
// the camera. Axis lengths are proportional (foreshortening preserved), depth
// ordering is computed from NDC Z, and axes going away from the viewer are
// drawn as outlined circles with reduced opacity.

const UCS_ICON_MARGIN: f32 = 50.0;
const UCS_ICON_LEN: f32 = 38.0; // longest axis arm in screen pixels
const UCS_ICON_TIP: f32 = 7.0; // arrowhead size in pixels
const UCS_GRIP_BOX: f32 = 7.0; // selected-grip square size in pixels

/// One projected UCS axis arm: scaled screen delta from the anchor plus its
/// depth (for back-to-front draw order).
struct IconAxis {
    dx: f32,
    dy: f32,
    sc_len: f32,
    depth: f32,
}

/// Screen positions of the UCS icon grips, present only when the tripod is
/// anchored at the on-screen UCS origin (i.e. draggable). `tips` is X, Y, Z.
pub struct UcsIconHit {
    pub origin: Point,
    pub tips: [Point; 3],
}

/// Shared icon geometry used by both the renderer and the grip hit-test, so the
/// two never drift. Projects the UCS axis directions to screen, picks the
/// anchor (on-screen origin when available, else the corner) and returns each
/// axis's scaled screen delta. The bool is `at_origin` — true when anchored at
/// the projected origin, which is the only state where grips are live.
fn ucs_icon_geometry(
    vp: Mat4,
    bounds: iced::Rectangle,
    axes: (Vec3, Vec3, Vec3),
    origin_screen: Option<Point>,
) -> Option<(Point, bool, [IconAxis; 3])> {
    if bounds.width < 10.0 || bounds.height < 10.0 {
        return None;
    }

    // Transform directions directly. Projecting a point at the eye origin is
    // undefined in perspective views.
    let axis_screen = |axis: Vec3| -> Option<(f32, f32, f32, f32)> {
        let clip = vp * axis.extend(0.0);
        if !clip.x.is_finite() || !clip.y.is_finite() || !clip.z.is_finite() {
            return None;
        }
        let dx = clip.x * 0.5 * bounds.width;
        let dy = -clip.y * 0.5 * bounds.height;
        Some((dx, dy, (dx * dx + dy * dy).sqrt(), clip.z))
    };

    let (ax, ay, az) = axes;
    let (xdx, xdy, xlen, xdepth) = axis_screen(ax)?;
    let (ydx, ydy, ylen, ydepth) = axis_screen(ay)?;
    let (zdx, zdy, zlen, zdepth) = axis_screen(az)?;
    let corner = Point::new(
        bounds.x + UCS_ICON_MARGIN,
        bounds.y + (bounds.height - UCS_ICON_MARGIN).max(UCS_ICON_MARGIN),
    );
    // Snap the tripod to the projected UCS origin when it is on-screen
    // (UCSICON ORigin); otherwise keep it in the corner.
    let (icon_origin, at_origin) = match origin_screen {
        Some(p)
            if p.x >= bounds.x
                && p.x <= bounds.x + bounds.width
                && p.y >= bounds.y
                && p.y <= bounds.y + bounds.height =>
        {
            (p, true)
        }
        _ => (corner, false),
    };

    // Scale so the longest projected axis fills UCS_ICON_LEN; shorter axes
    // stay proportionally shorter (this IS the foreshortening effect).
    let max_len = xlen.max(ylen).max(zlen).max(1e-4);
    let sc = UCS_ICON_LEN / max_len;

    let mk = |dx: f32, dy: f32, len: f32, depth: f32| IconAxis {
        dx: dx * sc,
        dy: dy * sc,
        sc_len: len * sc,
        depth,
    };
    Some((
        icon_origin,
        at_origin,
        [
            mk(xdx, xdy, xlen, xdepth),
            mk(ydx, ydy, ylen, ydepth),
            mk(zdx, zdy, zlen, zdepth),
        ],
    ))
}

/// Screen grip targets for the UCS icon, or `None` when it is pinned to the
/// corner (origin off-screen) and therefore not draggable.
pub fn ucs_icon_hit(
    vp: Mat4,
    bounds: iced::Rectangle,
    axes: (Vec3, Vec3, Vec3),
    origin_screen: Option<Point>,
) -> Option<UcsIconHit> {
    // Grips are available wherever the icon is drawn — including parked in the
    // corner (origin off-screen), where dragging the origin grip relocates it.
    let (o, _at_origin, g) = ucs_icon_geometry(vp, bounds, axes, origin_screen)?;
    Some(UcsIconHit {
        origin: o,
        tips: [
            Point::new(o.x + g[0].dx, o.y + g[0].dy),
            Point::new(o.x + g[1].dx, o.y + g[1].dy),
            Point::new(o.x + g[2].dx, o.y + g[2].dy),
        ],
    })
}

#[allow(clippy::too_many_arguments)]
fn draw_ucs_icon(
    frame: &mut canvas::Frame,
    vp: Mat4,
    bounds: iced::Rectangle,
    axes: (Vec3, Vec3, Vec3),
    origin_screen: Option<Point>,
    hover: bool,
    selected: bool,
    crosshair_bg: [f32; 4],
) {
    let Some((icon_origin, at_origin, geom)) =
        ucs_icon_geometry(vp, bounds, axes, origin_screen)
    else {
        return;
    };

    // The icon is interactive wherever it is drawn (including parked in the
    // corner), so hover/selection highlight applies there too.
    let _ = at_origin;
    let highlight = hover || selected;
    let is_light_bg = 0.299 * crosshair_bg[0] + 0.587 * crosshair_bg[1] + 0.114 * crosshair_bg[2] > 0.5;
    let y_green = if is_light_bg { 0.60 } else { 0.85 };

    struct AxisInfo {
        dx: f32,
        dy: f32,
        sc_len: f32,
        depth: f32,
        r: f32,
        g: f32,
        b: f32,
        label: &'static str,
    }
    let mut axes = [
        AxisInfo {
            dx: geom[0].dx,
            dy: geom[0].dy,
            sc_len: geom[0].sc_len,
            depth: geom[0].depth,
            r: 0.90,
            g: 0.22,
            b: 0.22,
            label: "X",
        },
        AxisInfo {
            dx: geom[1].dx,
            dy: geom[1].dy,
            sc_len: geom[1].sc_len,
            depth: geom[1].depth,
            r: 0.22,
            g: y_green,
            b: 0.22,
            label: "Y",
        },
        AxisInfo {
            dx: geom[2].dx,
            dy: geom[2].dy,
            sc_len: geom[2].sc_len,
            depth: geom[2].depth,
            r: 0.22,
            g: 0.45,
            b: 0.90,
            label: "Z",
        },
    ];
    // Back-to-front: draw axis farthest from viewer first.
    axes.sort_by(|a, b| {
        b.depth
            .partial_cmp(&a.depth)
            .unwrap_or(std::cmp::Ordering::Equal)
    });

    for ax in &axes {
        // On highlight, lerp the axis colour toward white and thicken the shaft
        // so the whole tripod reads as "live".
        let mix = if highlight { 0.45 } else { 0.0 };
        let col = Color {
            r: ax.r + (1.0 - ax.r) * mix,
            g: ax.g + (1.0 - ax.g) * mix,
            b: ax.b + (1.0 - ax.b) * mix,
            a: 1.0,
        };
        let tip = Point::new(icon_origin.x + ax.dx, icon_origin.y + ax.dy);

        // Shaft
        if ax.sc_len > 1.0 {
            let path = canvas::Path::new(|p| {
                p.move_to(icon_origin);
                p.line_to(tip);
            });
            frame.stroke(
                &path,
                canvas::Stroke {
                    width: if highlight { 3.0 } else { 2.0 },
                    style: canvas::Style::Solid(col),
                    line_cap: canvas::LineCap::Butt,
                    ..Default::default()
                },
            );
        }

        // Filled arrowhead at tip.
        if ax.sc_len > 3.0 {
            let (nx, ny) = if ax.sc_len > 1e-3 {
                (ax.dx / ax.sc_len, ax.dy / ax.sc_len)
            } else {
                (1.0, 0.0)
            };
            let px = -ny;
            let py = nx;
            let tl = Point::new(
                tip.x - nx * UCS_ICON_TIP + px * (UCS_ICON_TIP * 0.45),
                tip.y - ny * UCS_ICON_TIP + py * (UCS_ICON_TIP * 0.45),
            );
            let tr = Point::new(
                tip.x - nx * UCS_ICON_TIP - px * (UCS_ICON_TIP * 0.45),
                tip.y - ny * UCS_ICON_TIP - py * (UCS_ICON_TIP * 0.45),
            );
            let arrow = canvas::Path::new(|p| {
                p.move_to(tip);
                p.line_to(tl);
                p.line_to(tr);
                p.close();
            });
            frame.fill(&arrow, col);
        }

        // Axis label (X / Y / Z) beyond the tip.
        if ax.sc_len > 4.0 {
            let (nx, ny) = if ax.sc_len > 1e-3 {
                (ax.dx / ax.sc_len, ax.dy / ax.sc_len)
            } else {
                (1.0, 0.0)
            };
            frame.fill_text(canvas::Text {
                content: ax.label.to_string(),
                // Offset beyond tip along the axis direction; subtract ~half glyph
                // size to visually center the single character on the axis line.
                position: Point::new(tip.x + nx * 8.0 - 3.5, tip.y + ny * 8.0 - 5.0),
                color: col,
                size: iced::Pixels(10.0),
                shaping: iced::advanced::text::Shaping::Advanced,
                ..Default::default()
            });
        }
    }

    // Origin dot.
    let circle = canvas::Path::circle(icon_origin, 3.5);
    let dot_lum = 0.299 * crosshair_bg[0] + 0.587 * crosshair_bg[1] + 0.114 * crosshair_bg[2];
    let dot_color = if dot_lum > 0.5 {
        Color {
            r: 0.15,
            g: 0.15,
            b: 0.15,
            a: 0.95,
        }
    } else {
        Color {
            r: 0.9,
            g: 0.9,
            b: 0.9,
            a: 0.95,
        }
    };
    frame.fill(&circle, dot_color);

    // Draggable grips when selected: a square at the origin and at the X / Y
    // tips. Warm grip colour with a light border, like an entity grip.
    if selected {
        let x_tip = Point::new(icon_origin.x + geom[0].dx, icon_origin.y + geom[0].dy);
        let y_tip = Point::new(icon_origin.x + geom[1].dx, icon_origin.y + geom[1].dy);
        let fill = Color {
            r: 0.20,
            g: 0.85,
            b: 0.95,
            a: 1.0,
        };
        let border = Color {
            r: 1.0,
            g: 1.0,
            b: 1.0,
            a: 0.9,
        };
        for c in [icon_origin, x_tip, y_tip] {
            let h = UCS_GRIP_BOX / 2.0;
            let sq = canvas::Path::rectangle(
                Point::new(c.x - h, c.y - h),
                iced::Size::new(UCS_GRIP_BOX, UCS_GRIP_BOX),
            );
            frame.fill(&sq, fill);
            frame.stroke(
                &sq,
                canvas::Stroke {
                    width: 1.0,
                    style: canvas::Style::Solid(border),
                    ..Default::default()
                },
            );
        }
    }
}

// ── Dynamic Input overlay ─────────────────────────────────────────────────

use crate::command::{DynGuide, DynRole};

const DYN_OFFSET_X: f32 = 14.0;
const DYN_PAD: f32 = 4.0;
const DYN_GAP: f32 = 6.0;
const DYN_FONT: f32 = 11.0;
const DYN_CHAR_W: f32 = DYN_FONT * 0.62;
const DYN_BOX_H: f32 = DYN_FONT + DYN_PAD * 2.0;

/// One value box in the dynamic-input overlay. Its `role` drives both the
/// label and where the box is placed relative to the step's guide geometry.
#[derive(Clone)]
pub struct DynBox {
    pub label: String,
    pub value: String,
    /// TAB-focused box — keystrokes edit this one.
    pub active: bool,
    /// User has typed a value (the box no longer tracks the cursor).
    pub locked: bool,
    pub role: DynRole,
    /// Optional exact viewport position, used by rotated rectangle dimensions.
    pub center: Option<Point>,
}

pub fn dynamic_input_overlay<'a>(
    cursor_screen: Point,
    base_screen: Option<Point>,
    ref_screen: Option<Point>,
    label_screen: Option<Point>,
    guide: DynGuide,
    boxes: Vec<DynBox>,
    prompt: String,
    tracking_hint: Option<String>,
) -> Element<'a, Message> {
    canvas(DynInputCanvas {
        cursor_screen,
        base_screen,
        ref_screen,
        label_screen,
        guide,
        boxes,
        prompt,
        tracking_hint,
    })
    .width(Length::Fill)
    .height(Length::Fill)
    .into()
}

struct DynInputCanvas {
    cursor_screen: Point,
    /// Step anchor in viewport pixels (projected `dyn_anchor`). Guided layouts
    /// (polar / radius / axis-delta) need it; `None` falls back to a cursor row.
    base_screen: Option<Point>,
    /// Far end of the reference line (projected `dyn_ref`) — for `Perp`.
    ref_screen: Option<Point>,
    /// Command-supplied world-space label point projected by the active camera.
    label_screen: Option<Point>,
    guide: DynGuide,
    boxes: Vec<DynBox>,
    /// The active command's current prompt, drawn just above the boxes.
    prompt: String,
    /// Active tracking-reference label.
    tracking_hint: Option<String>,
}

impl DynInputCanvas {
    fn dotted(theme: &Theme) -> canvas::Stroke<'static> {
        canvas::Stroke {
            width: 1.0,
            style: canvas::Style::Solid(
                theme.palette().background.neutral.color.scale_alpha(0.9)
            ),
            line_dash: canvas::LineDash { segments: &[2.0, 3.0], offset: 0 },
            ..Default::default()
        }
    }

    fn box_content(b: &DynBox) -> String {
        match b.role {
            // Formatted live values already carry their unit marker; typed
            // buffers stay unadorned while they are being edited.
            DynRole::Angle => b.value.clone(),
            _ if b.label.is_empty() => b.value.clone(),
            _ => format!("{}{}", b.label, b.value),
        }
    }

    fn box_width(b: &DynBox) -> f32 {
        (Self::box_content(b).len() as f32 * DYN_CHAR_W) + DYN_PAD * 2.0
    }

    /// Draw a value box centred at `center`, clamped inside `bounds`.
    fn draw_box(
        frame: &mut canvas::Frame,
        b: &DynBox,
        center: Point,
        bounds: iced::Rectangle,
        theme: &Theme,
    ) {
        let content = Self::box_content(b);
        let w = Self::box_width(b);
        let x = (center.x - w * 0.5).clamp(0.0, (bounds.width - w).max(0.0));
        let y = (center.y - DYN_BOX_H * 0.5).clamp(0.0, (bounds.height - DYN_BOX_H).max(0.0));
        let rect = canvas::Path::rectangle(Point { x, y }, Size { width: w, height: DYN_BOX_H });
        let (fill, border, text) = Self::box_colors(b, theme);
        frame.fill(&rect, fill);
        frame.stroke(
            &rect,
            canvas::Stroke::default()
                .with_color(border)
                .with_width(if b.active { 1.6 } else { 1.0 }),
        );
        frame.fill_text(canvas::Text {
            content,
            position: Point { x: x + DYN_PAD, y: y + DYN_PAD },
            color: text,
            size: iced::Pixels(DYN_FONT),
            // Force Advanced shaping: the default `Auto` uses Basic shaping for
            // ASCII-only strings, which the web (wgpu/webgl) backend fails to
            // render — so all-digit value boxes came up blank while the angle
            // box (containing the non-ASCII `°`) rendered. (#117)
            shaping: iced::advanced::text::Shaping::Advanced,
            ..Default::default()
        });
    }

    fn box_colors(b: &DynBox, theme: &Theme) -> (Color, Color, Color) {
        let palette = theme.palette();
        if b.active {
            (
                palette.primary.weak.color,
                palette.primary.base.color,
                palette.primary.weak.text,
            )
        } else if b.locked {
            (
                palette.warning.weak.color,
                palette.warning.base.color,
                palette.warning.weak.text,
            )
        } else {
            (
                palette.background.weak.color,
                palette.background.neutral.color,
                palette.background.weak.text,
            )
        }
    }

    /// Prompt pill at `pos`.
    fn draw_prompt(&self, frame: &mut canvas::Frame, pos: Point, theme: &Theme) {
        if self.prompt.is_empty() {
            return;
        }
        let palette = theme.palette();
        let pw = (self.prompt.len() as f32 * DYN_CHAR_W) + DYN_PAD * 2.0;
        let rect = canvas::Path::rectangle(pos, Size { width: pw, height: DYN_BOX_H });
        frame.fill(&rect, palette.background.strong.color);
        frame.stroke(
            &rect,
            canvas::Stroke::default()
                .with_color(palette.primary.base.color.scale_alpha(0.9))
                .with_width(1.0),
        );
        frame.fill_text(canvas::Text {
            content: self.prompt.clone(),
            position: Point { x: pos.x + DYN_PAD, y: pos.y + DYN_PAD },
            color: palette.background.strong.text,
            size: iced::Pixels(DYN_FONT),
            shaping: iced::advanced::text::Shaping::Advanced,
            ..Default::default()
        });
    }

    fn draw_tracking_hint(
        &self,
        frame: &mut canvas::Frame,
        pos: Point,
        theme: &Theme,
    ) {
        let Some(text) = self.tracking_hint.as_deref() else {
            return;
        };

        let palette = theme.palette();
        let pw = (text.len() as f32 * DYN_CHAR_W) + DYN_PAD * 2.0;

        let rect = canvas::Path::rectangle(
            pos,
            Size {
                width: pw,
                height: DYN_BOX_H,
            },
        );

        frame.fill(&rect, palette.background.strong.color);

        frame.stroke(
            &rect,
            canvas::Stroke::default()
                .with_color(palette.primary.base.color.scale_alpha(0.9))
                .with_width(1.0),
        );

        frame.fill_text(canvas::Text {
            content: text.to_string(),
            position: Point {
                x: pos.x + DYN_PAD,
                y: pos.y + DYN_PAD,
            },
            color: palette.background.strong.text,
            size: iced::Pixels(DYN_FONT),
            shaping: iced::advanced::text::Shaping::Advanced,
            ..Default::default()
        });
    }

    /// Guided layout: draw the guide geometry anchored at `base`, then place
    /// each box according to its role.
    fn draw_guided(
        &self,
        frame: &mut canvas::Frame,
        bounds: iced::Rectangle,
        base: Point,
        theme: &Theme,
    ) {
        let cursor_raw = self.cursor_screen;
        let (vx, vy) = (cursor_raw.x - base.x, cursor_raw.y - base.y);
        let raw_len = (vx * vx + vy * vy).sqrt().max(1.0);
        let (dx, dy) = (vx / raw_len, vy / raw_len);
        // Clamp the drawn length to just past the viewport.
        //
        // These guides are dotted, and a dash pattern is measured in PIXELS: the
        // tessellator emits a quad every few pixels, so the cost scales with a
        // guide's screen length, not with what it represents. Typing a large
        // distance (5000000 into the value box) projects the cursor millions of
        // pixels away — millions of quads, gigabytes of them — and the process
        // dies building a frame whose content is off-screen anyway (#406).
        //
        // Everything past the viewport edge is invisible, so dropping it costs
        // nothing: `dx`/`dy` keep the true direction, the angle and every
        // read-out are computed from `raw_len` above, and only the tail nobody
        // can see is cut. Clamping `cursor` here bounds every guide below —
        // they all derive from it.
        let len = raw_len.min(bounds.width.hypot(bounds.height) * 1.5);
        let cursor = Point {
            x: base.x + dx * len,
            y: base.y + dy * len,
        };
        // Perpendicular pointing to the lower half so labels sit under the line.
        let (mut nx, mut ny) = (-dy, dx);
        if ny < 0.0 {
            nx = -nx;
            ny = -ny;
        }
        // Polar arc reference direction: a supplied reference point (e.g. the
        // ROTATE reference), else the +X axis. The arc sweeps the short way
        // from that reference to the cursor.
        let a_cur = dy.atan2(dx);
        let a_ref = self
            .ref_screen
            .map(|r| (r.y - base.y).atan2(r.x - base.x))
            .unwrap_or(0.0);
        let mut sweep = a_cur - a_ref;
        while sweep > std::f32::consts::PI {
            sweep -= std::f32::consts::TAU;
        }
        while sweep <= -std::f32::consts::PI {
            sweep += std::f32::consts::TAU;
        }
        let corner = Point { x: cursor.x, y: base.y }; // axis-delta elbow

        // Perp / PerpDim: perpendicular direction to the reference line, the
        // measured endpoint along it (`end`), and an offset dimension segment
        // (`off_base`→`off_end`) drawn clear of the edge for PerpDim.
        let perp_info = self.ref_screen.map(|r| {
            let (ax, ay) = (r.x - base.x, r.y - base.y);
            let al = (ax * ax + ay * ay).sqrt().max(1.0);
            let (ux, uy) = (ax / al, ay / al); // axis unit (base → ref)
            let (px, py) = (-uy, ux); // perpendicular unit
            let signed = (cursor.x - base.x) * px + (cursor.y - base.y) * py;
            let end = Point { x: base.x + px * signed, y: base.y + py * signed };
            const OFF: f32 = 16.0; // dimension offset, away from the reference
            let off_base = Point { x: base.x - ux * OFF, y: base.y - uy * OFF };
            let off_end = Point { x: end.x - ux * OFF, y: end.y - uy * OFF };
            (end, off_base, off_end)
        });

        // ── Guide geometry ──
        match self.guide {
            DynGuide::Polar => {
                // Reference line along `a_ref` (the +X axis, or the supplied
                // reference direction), then the arc from it to the cursor.
                let href = canvas::Path::new(|p| {
                    p.move_to(base);
                    p.line_to(Point {
                        x: base.x + a_ref.cos() * len,
                        y: base.y + a_ref.sin() * len,
                    });
                });
                frame.stroke(&href, Self::dotted(theme));
                let arc = canvas::Path::new(|p| {
                    let steps = 48;
                    for k in 0..=steps {
                        let a = a_ref + sweep * (k as f32 / steps as f32);
                        let pt = Point {
                            x: base.x + a.cos() * len,
                            y: base.y + a.sin() * len,
                        };
                        if k == 0 {
                            p.move_to(pt);
                        } else {
                            p.line_to(pt);
                        }
                    }
                });
                frame.stroke(&arc, Self::dotted(theme));
            }
            DynGuide::Radius => {
                let line = canvas::Path::new(|p| {
                    p.move_to(base);
                    p.line_to(cursor);
                });
                frame.stroke(&line, Self::dotted(theme));
            }
            DynGuide::Perp => {
                if let Some((end, _, _)) = perp_info {
                    // The measured semi-axis: anchor → perpendicular endpoint.
                    let line = canvas::Path::new(|p| {
                        p.move_to(base);
                        p.line_to(end);
                    });
                    frame.stroke(&line, Self::dotted(theme));
                }
            }
            DynGuide::PerpDim => {
                if let Some((end, ob, oe)) = perp_info {
                    // Dimension segment offset off the edge, with extension
                    // lines back to the two measured corners.
                    let dim = canvas::Path::new(|p| {
                        p.move_to(ob);
                        p.line_to(oe);
                    });
                    frame.stroke(&dim, Self::dotted(theme));
                    let ext = canvas::Path::new(|p| {
                        p.move_to(base);
                        p.line_to(ob);
                        p.move_to(end);
                        p.line_to(oe);
                    });
                    frame.stroke(&ext, Self::dotted(theme));
                }
            }
            DynGuide::AxisDelta | DynGuide::RectSides => {
                // Dotted legs from the anchor along its axes to the cursor.
                let legs = canvas::Path::new(|p| {
                    p.move_to(base);
                    p.line_to(corner);
                    p.line_to(cursor);
                });
                frame.stroke(&legs, Self::dotted(theme));
                if self.guide == DynGuide::RectSides {
                    // Close the rectangle so both side pairs read as a box.
                    let rest = canvas::Path::new(|p| {
                        p.move_to(base);
                        p.line_to(Point { x: base.x, y: cursor.y });
                        p.line_to(cursor);
                    });
                    frame.stroke(&rest, Self::dotted(theme));
                }
            }
            DynGuide::None => {}
        }

        // ── Box placement by role ──
        for b in &self.boxes {
            let center = b.center.unwrap_or_else(|| match b.role {
                DynRole::Angle => self.label_screen.unwrap_or_else(|| {
                    let a_mid = a_ref + sweep * 0.5;
                    let r = (len - DYN_BOX_H * 2.0).max(len * 0.5);
                    Point {
                        x: base.x + a_mid.cos() * r - nx * 18.0,
                        y: base.y + a_mid.sin() * r - ny * 18.0,
                    }
                }),
                DynRole::X | DynRole::Width => Point {
                    x: (base.x + cursor.x) * 0.5,
                    y: if self.guide == DynGuide::RectSides {
                        base.y - (cursor.y - base.y).signum() * 14.0
                    } else {
                        base.y + 14.0
                    },
                },
                DynRole::Y | DynRole::Height => Point {
                    x: if self.guide == DynGuide::RectSides {
                        corner.x + (cursor.x - base.x).signum() * 18.0
                    } else {
                        corner.x + 18.0
                    },
                    y: (base.y + cursor.y) * 0.5,
                },
                // Perpendicular measure: on the measured segment / dim line.
                _ if matches!(self.guide, DynGuide::Perp | DynGuide::PerpDim)
                    && perp_info.is_some() =>
                {
                    let (end, ob, oe) = perp_info.unwrap();
                    if self.guide == DynGuide::PerpDim {
                        Point { x: (ob.x + oe.x) * 0.5 + 8.0, y: (ob.y + oe.y) * 0.5 }
                    } else {
                        Point { x: (base.x + end.x) * 0.5 + 8.0, y: (base.y + end.y) * 0.5 }
                    }
                }
                // Distance / Radius / Diameter and anything else ride the line.
                _ => Point {
                    x: base.x + dx * len * 0.5 + nx * 16.0,
                    y: base.y + dy * len * 0.5 + ny * 16.0,
                },
            });
            Self::draw_box(frame, b, center, bounds, theme);
        }
        // Keep the tracking hint near the crosshair in guided layouts.
        if let Some(text) = self.tracking_hint.as_deref() {
            let hw = (text.len() as f32 * DYN_CHAR_W) + DYN_PAD * 2.0;

            let mut hx = self.cursor_screen.x + DYN_OFFSET_X;
            let mut hy = self.cursor_screen.y + DYN_OFFSET_X;

            if hx + hw > bounds.width {
                hx = (self.cursor_screen.x - hw - 4.0).max(0.0);
            }

            if hy + DYN_BOX_H > bounds.height {
                hy = (self.cursor_screen.y - DYN_BOX_H - 4.0).max(0.0);
            }

            self.draw_tracking_hint(
                frame,
                Point {
                    x: hx,
                    y: hy,
                },
                theme,
            );
        }
    }

    /// Fallback row layout near the cursor (no anchor / `None` guide).
    fn draw_row(&self, frame: &mut canvas::Frame, bounds: iced::Rectangle, theme: &Theme) {
        let texts: Vec<String> = self
            .boxes
            .iter()
            .map(|b| {
                if b.label.is_empty() {
                    b.value.clone()
                } else {
                    format!("{}:{}", b.label, b.value)
                }
            })
            .collect();
        let widths: Vec<f32> = texts
            .iter()
            .map(|t| (t.len() as f32 * DYN_CHAR_W) + DYN_PAD * 2.0)
            .collect();
        let total_w: f32 =
            widths.iter().sum::<f32>() + DYN_GAP * (self.boxes.len() as f32 - 1.0);

        // Offset the block off the crosshair by the same gap horizontally and
        // vertically; the prompt sits a gap below the horizontal axis and the
        // value boxes a further gap below the prompt.
        let pad = DYN_OFFSET_X;
        let has_prompt = !self.prompt.is_empty();
        let prompt_w = (self.prompt.len() as f32 * DYN_CHAR_W) + DYN_PAD * 2.0;
        let block_w = total_w.max(if has_prompt { prompt_w } else { 0.0 });
        let mut bx = self.cursor_screen.x + pad;
        let mut py = self.cursor_screen.y + pad;
        let mut by = if has_prompt { py + DYN_BOX_H + pad } else { py };
        if bx + block_w > bounds.width {
            bx = (self.cursor_screen.x - block_w - 4.0).max(0.0);
        }
        if by + DYN_BOX_H > bounds.height {
            // Flip the block above the cursor, keeping the same gaps.
            by = (self.cursor_screen.y - pad - DYN_BOX_H).max(0.0);
            py = (by - pad - DYN_BOX_H).max(0.0);
        }
        if has_prompt {
            self.draw_prompt(frame, Point { x: bx, y: py }, theme);
        }

        let mut x = bx;
        for (i, b) in self.boxes.iter().enumerate() {
            let w = widths[i];
            if b.role == DynRole::Angle {
                if let Some(center) = self.label_screen {
                    Self::draw_box(frame, b, center, bounds, theme);
                    x += w + DYN_GAP;
                    continue;
                }
            }
            let rect =
                canvas::Path::rectangle(Point { x, y: by }, Size { width: w, height: DYN_BOX_H });
            let (fill, border, text) = Self::box_colors(b, theme);
            frame.fill(&rect, fill);
            frame.stroke(
                &rect,
                canvas::Stroke::default()
                    .with_color(border)
                    .with_width(if b.active { 1.6 } else { 1.0 }),
            );
            frame.fill_text(canvas::Text {
                content: texts[i].clone(),
                position: Point { x: x + DYN_PAD, y: by + DYN_PAD },
                color: text,
                size: iced::Pixels(DYN_FONT),
                shaping: iced::advanced::text::Shaping::Advanced,
                ..Default::default()
            });
            x += w + DYN_GAP;
        }
        // Place the tracking hint below the value row.
        if self.tracking_hint.is_some() {
            let mut hy = by + DYN_BOX_H + 3.0;

            // Move above when bottom space is insufficient.
            if hy + DYN_BOX_H > bounds.height {
                hy = (py - DYN_BOX_H - 3.0).max(0.0);
            }

            self.draw_tracking_hint(
                frame,
                Point {
                    x: bx,
                    y: hy,
                },
                theme,
            );
        }
    }
}

impl canvas::Program<Message> for DynInputCanvas {
    type State = ();

    fn mouse_interaction(
        &self,
        _state: &(),
        _bounds: iced::Rectangle,
        _cursor: mouse::Cursor,
    ) -> mouse::Interaction {
        mouse::Interaction::None
    }

    fn draw(
        &self,
        _state: &(),
        renderer: &iced::Renderer,
        theme: &Theme,
        bounds: iced::Rectangle,
        _cursor: mouse::Cursor,
    ) -> Vec<canvas::Geometry> {
        let mut frame = canvas::Frame::new(renderer, bounds.size());

        // No boxes — just the prompt pill near the cursor.
        if self.boxes.is_empty() {
            if !self.prompt.is_empty() {
                let pw = (self.prompt.len() as f32 * DYN_CHAR_W) + DYN_PAD * 2.0;
                let mut px = self.cursor_screen.x + DYN_OFFSET_X;
                let mut py = self.cursor_screen.y + DYN_OFFSET_X;
                if px + pw > bounds.width {
                    px = (self.cursor_screen.x - pw - 4.0).max(0.0);
                }
                if py + DYN_BOX_H > bounds.height {
                    py = (self.cursor_screen.y - DYN_BOX_H - 4.0).max(0.0);
                }
                self.draw_prompt(&mut frame, Point { x: px, y: py }, theme);

                if self.tracking_hint.is_some() {
                    let hint_y = py + DYN_BOX_H + 3.0;

                    self.draw_tracking_hint(
                        &mut frame,
                        Point {
                            x: px,
                            y: hint_y,
                        },
                        theme,
                    );
                }
            }
            return vec![frame.into_geometry()];
        }

        // Guided layouts need the anchor; without it fall back to a cursor row.
        match (self.guide, self.base_screen) {
            (DynGuide::None, _) | (_, None) => self.draw_row(&mut frame, bounds, theme),
            (_, Some(base)) => self.draw_guided(&mut frame, bounds, base, theme),
        }
        vec![frame.into_geometry()]
    }
}

#[cfg(test)]
mod clip_tests {
    use super::*;

    fn b() -> iced::Rectangle {
        iced::Rectangle { x: 0.0, y: 0.0, width: 800.0, height: 600.0 }
    }

    /// The #406 shape: a guide from a point projected millions of pixels away,
    /// back to the cursor. Must survive, keep its direction, and come back short.
    #[test]
    fn clips_a_far_guide_to_a_drawable_length() {
        let far = Point::new(-5_000_000.0, -1_500_000.0);
        let cur = Point::new(400.0, 300.0);
        let (a, c) = clip_seg(far, cur, b()).expect("crosses the viewport");
        let len = ((c.x - a.x).powi(2) + (c.y - a.y).powi(2)).sqrt();
        assert!(len < 2000.0, "clipped guide still {len} px long");
        // Same direction as the original. Compare unit vectors, not a cross
        // product: at these magnitudes (800 x 1.5e6) an f32 cross carries ~1e2
        // of rounding, so only a scale-free check means anything.
        let unit = |dx: f32, dy: f32| {
            let l = (dx * dx + dy * dy).sqrt();
            (dx / l, dy / l)
        };
        let (ux, uy) = unit(cur.x - far.x, cur.y - far.y);
        let (vx, vy) = unit(c.x - a.x, c.y - a.y);
        assert!(
            (ux - vx).abs() < 1e-3 && (uy - vy).abs() < 1e-3,
            "clip changed the direction"
        );
        // The end inside the viewport is kept as-is.
        assert!((c.x - cur.x).abs() < 0.5 && (c.y - cur.y).abs() < 0.5);
    }

    #[test]
    fn keeps_a_fully_visible_segment_and_drops_a_missing_one() {
        let (a, c) = clip_seg(Point::new(10.0, 10.0), Point::new(700.0, 500.0), b()).unwrap();
        assert!((a.x - 10.0).abs() < 0.01 && (c.x - 700.0).abs() < 0.01);
        assert!(clip_seg(Point::new(-9000.0, -9000.0), Point::new(-8000.0, -8000.0), b()).is_none());
    }
}

#[cfg(test)]
mod constraint_glyph_tests {
    use super::*;

    #[test]
    fn enlarged_glyph_box_stays_clear_of_its_geometry_anchor() {
        let anchor = Point::new(100.0, 80.0);
        let (right, size) = constraint_glyph_box(anchor, [1.0, 0.0], "⊥", 0.0);
        assert_eq!(size.height, 22.0);
        assert!((right.x - anchor.x - CONSTRAINT_GLYPH_GAP).abs() < 1e-6);

        let (above, size) = constraint_glyph_box(anchor, [0.0, -1.0], "↔ 25.00", 0.0);
        assert!((anchor.y - (above.y + size.height) - CONSTRAINT_GLYPH_GAP).abs() < 1e-6);
    }

    #[test]
    fn coincident_glyphs_are_arranged_side_by_side() {
        let anchor = Point::new(100.0, 80.0);
        let glyphs = vec![
            (anchor, [0.0, -1.0], "—".to_string(), false),
            (anchor, [0.0, -1.0], "∥".to_string(), false),
        ];
        let offsets = constraint_glyph_offsets(&glyphs);
        let (left, left_size) =
            constraint_glyph_box(anchor, glyphs[0].1, &glyphs[0].2, offsets[0]);
        let (right, right_size) =
            constraint_glyph_box(anchor, glyphs[1].1, &glyphs[1].2, offsets[1]);

        assert!((left.y - right.y).abs() < 1e-6);
        assert!(
            (right.x - (left.x + left_size.width) - CONSTRAINT_GLYPH_ROW_GAP).abs() < 1e-4
        );
        assert!(
            (anchor.y - (left.y + right_size.height) - CONSTRAINT_GLYPH_GAP).abs() < 1e-6
        );

        let click = Point::new(left.x + left_size.width * 0.5, left.y + left_size.height * 0.5);
        assert_eq!(constraint_glyph_hit_test(&glyphs, click), Some(0));
    }
}

#[cfg(test)]
mod grid_key_tests {
    use super::*;

    /// Reference `GridParams` used as the baseline for key-construction tests.
    /// Mirrors a representative Model pane: identity-ish view, eye ~3.5m back,
    /// step 80 world units, WCS, no limits. Tests mutate one field at a time
    /// off this baseline to assert that `GridKey` invalidates on every input
    /// change.
    fn baseline_params() -> GridParams {
        GridParams {
            view_rot: Mat4::from_rotation_x(0.15) * Mat4::from_rotation_y(0.05),
            eye: glam::DVec3::new(4.0, 3.5, 9.0),
            bounds: iced::Rectangle {
                x: 0.0,
                y: 0.0,
                width: 1280.0,
                height: 720.0,
            },
            step_x: 80.0,
            step_y: 80.0,
            major_every: 5,
            origin: glam::DVec3::new(0.0, 0.0, 0.0),
            axes: (Vec3::X, Vec3::Y, Vec3::Z),
            limits: None,
        }
    }

    /// Same `Vec<GridParams>` + same bounds + same style ⇒ keys compare equal.
    #[test]
    fn grid_key_matches_identical_params() {
        let grids = vec![baseline_params(), baseline_params()];
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 1920.0, height: 720.0 };
        let a = GridKey::from_grids(&grids, bounds, GridStyle::default());
        let b = GridKey::from_grids(&grids, bounds, GridStyle::default());
        assert_eq!(a, b);
    }

    /// One test, one baseline. Every change of any of the inputs must produce
    /// a key that differs from the baseline. This is the entire correctness
    /// contract for cache hit/miss — if any input is ignored, the cache serves
    /// a stale grid.
    #[test]
    fn grid_key_invalidates_on_changed_fields() {
        let baseline_bounds = iced::Rectangle {
            x: 0.0,
            y: 0.0,
            width: 1920.0,
            height: 720.0,
        };
        let baseline_grids = vec![baseline_params()];
        let baseline_key = GridKey::from_grids(&baseline_grids, baseline_bounds, GridStyle::default());

        // view_rot: small extra rotation
        let mut p = baseline_params();
        p.view_rot = Mat4::from_rotation_x(0.15 + 0.01) * Mat4::from_rotation_y(0.05);
        assert_ne!(
            GridKey::from_grids(&[p], baseline_bounds, GridStyle::default()),
            baseline_key,
            "view_rot change must invalidate"
        );

        // eye: shift in z
        let mut p = baseline_params();
        p.eye = glam::DVec3::new(4.0, 3.5, 9.5);
        assert_ne!(
            GridKey::from_grids(&[p], baseline_bounds, GridStyle::default()),
            baseline_key,
            "eye change must invalidate"
        );

        // step_x: zoom in
        let mut p = baseline_params();
        p.step_x = 40.0;
        assert_ne!(
            GridKey::from_grids(&[p], baseline_bounds, GridStyle::default()),
            baseline_key,
            "step_x change must invalidate"
        );

        // step_y: non-square grid resize
        let mut p = baseline_params();
        p.step_y = 40.0;
        assert_ne!(
            GridKey::from_grids(&[p], baseline_bounds, GridStyle::default()),
            baseline_key,
            "step_y change must invalidate"
        );

        // major_every: major-line frequency change
        let mut p = baseline_params();
        p.major_every = 10;
        assert_ne!(
            GridKey::from_grids(&[p], baseline_bounds, GridStyle::default()),
            baseline_key,
            "major_every change must invalidate"
        );

        // origin: translate the UCS origin off-zero
        let mut p = baseline_params();
        p.origin = glam::DVec3::new(100.0, 0.0, 0.0);
        assert_ne!(
            GridKey::from_grids(&[p], baseline_bounds, GridStyle::default()),
            baseline_key,
            "origin change must invalidate"
        );

        // axes: rotate the active UCS
        let mut p = baseline_params();
        p.axes = (Vec3::Y, Vec3::X, Vec3::Z);
        assert_ne!(
            GridKey::from_grids(&[p], baseline_bounds, GridStyle::default()),
            baseline_key,
            "axes change must invalidate"
        );

        // limits: switch from None to Some
        let mut p = baseline_params();
        p.limits = Some((glam::DVec2::new(0.0, 0.0), glam::DVec2::new(100.0, 100.0)));
        assert_ne!(
            GridKey::from_grids(&[p], baseline_bounds, GridStyle::default()),
            baseline_key,
            "limits change must invalidate"
        );

        // bounds: same baseline GridParams but a different overlay bounds
        let other_bounds = iced::Rectangle {
            x: 0.0,
            y: 0.0,
            width: 1280.0,
            height: 720.0,
        };
        assert_ne!(
            GridKey::from_grids(&baseline_grids, other_bounds, GridStyle::default()),
            baseline_key,
            "bounds change must invalidate"
        );

        // style opacity: change opacity
        let mut style = GridStyle::default();
        style.opacity = 50;
        assert_ne!(
            GridKey::from_grids(&baseline_grids, baseline_bounds, style),
            baseline_key,
            "style opacity change must invalidate"
        );

        // style bg_luminance: change luminance (dark to light)
        let mut style = GridStyle::default();
        style.bg_luminance = 0.9;
        assert_ne!(
            GridKey::from_grids(&baseline_grids, baseline_bounds, style),
            baseline_key,
            "style bg_luminance change must invalidate"
        );
    }

    /// In a 2-pane tiled layout, changing the second pane's params (with pane 1
    /// unchanged) must produce a different key — the cache cannot share geometry
    /// when any pane is dirty.
    #[test]
    fn grid_key_invalidates_when_any_pane_changes() {
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 1920.0, height: 720.0 };
        let pane1 = baseline_params();
        let pane2 = baseline_params();
        let both = vec![pane1.clone(), pane2.clone()];
        let baseline = GridKey::from_grids(&both, bounds, GridStyle::default());

        let mut pane2_changed = pane2;
        pane2_changed.step_x = 160.0;
        let dirty = vec![pane1, pane2_changed];
        assert_ne!(
            GridKey::from_grids(&dirty, bounds, GridStyle::default()),
            baseline,
            "second pane change must invalidate"
        );
    }

    /// `should_reuse(None, &key)` ⇒ `false` (no cached key to reuse).
    #[test]
    fn should_reuse_empty() {
        let grids = vec![baseline_params()];
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 1920.0, height: 720.0 };
        let key = GridKey::from_grids(&grids, bounds, GridStyle::default());
        assert!(!should_reuse(None, &key));
    }

    /// `should_reuse(Some(&old), &same)` ⇒ `true` (structural equality).
    #[test]
    fn should_reuse_equal() {
        let grids = vec![baseline_params()];
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 1920.0, height: 720.0 };
        let key = GridKey::from_grids(&grids, bounds, GridStyle::default());
        assert!(should_reuse(Some(&key), &key));
    }

    /// `should_reuse(Some(&old), &new)` with keys built from different inputs
    /// ⇒ `false` (must recompute, not serve stale geometry).
    #[test]
    fn should_reuse_changed() {
        let grids_a = vec![baseline_params()];
        let mut pane2 = baseline_params();
        pane2.step_x = 160.0;
        let grids_b = vec![pane2];
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 1920.0, height: 720.0 };
        let old = GridKey::from_grids(&grids_a, bounds, GridStyle::default());
        let new = GridKey::from_grids(&grids_b, bounds, GridStyle::default());
        assert!(!should_reuse(Some(&old), &new));
    }

    /// Adaptive steps grow from the GRIDUNIT base (the old hardcoded 1.0 base
    /// ignored the DSettings grid spacing). Fixed mode returns the base verbatim.
    #[test]
    fn grid_steps_follow_base_and_adaptive_flag() {
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 1280.0, height: 720.0 };
        // Far zoom: 10-unit base must scale up to stay readable.
        let (sx, sy) = compute_grid_steps(10.0, 10.0, 5000.0, 0.6, bounds, true);
        assert!(sx >= 10.0 && sy >= 10.0);
        assert_eq!((sx, sy), (sx.max(10.0), sy.max(10.0)));
        // Non-uniform bases stay non-uniform.
        let (nx, ny) = compute_grid_steps(10.0, 2.0, 5000.0, 0.6, bounds, true);
        assert!(nx >= 10.0 && ny >= 2.0);
        // Fixed mode returns exactly what was typed.
        assert_eq!(compute_grid_steps(7.5, 2.5, 5000.0, 0.6, bounds, false), (7.5, 2.5));
        // Degenerate input sanitizes to 1.0 instead of emptying the grid.
        assert_eq!(compute_grid_steps(0.0, -3.0, 5000.0, 0.6, bounds, false), (1.0, 1.0));
    }

    /// Overflow fallback keeps each axis on its own base: an extreme zoom-out
    /// that pushes the 5x growth past 1e9 must return (bx, by), never (bx, bx).
    #[test]
    fn grid_steps_overflow_falls_back_per_axis() {
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 1280.0, height: 720.0 };
        assert_eq!(
            compute_grid_steps(10.0, 2.0, 1e15, 0.6, bounds, true),
            (10.0, 2.0)
        );
    }

    /// Non-uniform steps still produce grid geometry on both families.
    #[test]
    fn grid_segments_support_non_square_spacing() {
        // Top-down orthographic-ish view over the origin: deterministic lines.
        let view_rot = glam::camera::rh::proj::directx::orthographic(
            -400.0, 400.0, -300.0, 300.0, 0.1, 2000.0,
        ) * glam::camera::rh::view::look_at_mat4(
            Vec3::new(0.0, 0.0, 500.0),
            Vec3::ZERO,
            Vec3::Y,
        );
        let eye = glam::DVec3::new(0.0, 0.0, 500.0);
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 800.0, height: 600.0 };
        let g = grid_segments(
            view_rot, eye, bounds, 10.0, 2.0, 5,
            glam::DVec3::ZERO, (Vec3::X, Vec3::Y, Vec3::Z), None,
        );
        assert!(!g.segments.is_empty(), "grid lines expected");
    }

    /// Every-Nth line lands in `major_segments`, the rest in `segments`.
    #[test]
    fn grid_segments_partition_major_lines() {
        // Top-down orthographic-ish view over the origin: deterministic lines.
        let view_rot = glam::camera::rh::proj::directx::orthographic(
            -400.0, 400.0, -300.0, 300.0, 0.1, 2000.0,
        ) * glam::camera::rh::view::look_at_mat4(
            Vec3::new(0.0, 0.0, 500.0),
            Vec3::ZERO,
            Vec3::Y,
        );
        let eye = glam::DVec3::new(0.0, 0.0, 500.0);
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 800.0, height: 600.0 };
        let g = grid_segments(
            view_rot, eye, bounds, 10.0, 10.0, 5,
            glam::DVec3::ZERO, (Vec3::X, Vec3::Y, Vec3::Z), None,
        );
        assert!(!g.segments.is_empty(), "minor lines expected");
        assert!(!g.major_segments.is_empty(), "major lines expected");
        // major_every = 1 disables the split: everything is minor.
        let flat = grid_segments(
            view_rot, eye, bounds, 10.0, 10.0, 1,
            glam::DVec3::ZERO, (Vec3::X, Vec3::Y, Vec3::Z), None,
        );
        assert!(flat.major_segments.is_empty());
        assert!(!flat.segments.is_empty());
    }
}

#[cfg(test)]
mod grid_canvas_state_tests {
    use super::*;

    /// A freshly-defaulted `GridCanvasState` must have no cached key — the
    /// first draw of a session always misses. This pins the `Default` impl
    /// to a usable empty state (no need for the wrapper to special-case it).
    #[test]
    fn default_state_has_no_cached_key() {
        let state = GridCanvasState::default();
        assert!(state.key.borrow().is_none());
    }

    /// After manually storing a key in the state (the same way `draw` will
    /// on a miss), `should_reuse` must return `true` for the stored key and
    /// `false` for a key built from different inputs. This exercises the
    /// state → decision wiring end-to-end without a real iced `Renderer`.
    #[test]
    fn stored_key_is_recognized_by_should_reuse() {
        let view_rot = Mat4::from_rotation_x(0.15) * Mat4::from_rotation_y(0.05);
        let eye = glam::DVec3::new(4.0, 3.5, 9.0);
        let bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 1280.0, height: 720.0 };
        let grid_origin = glam::DVec3::new(0.0, 0.0, 0.0);
        let grid_axes = (Vec3::X, Vec3::Y, Vec3::Z);
        let limits: Option<(glam::DVec2, glam::DVec2)> = None;

        let params = GridParams {
            view_rot,
            eye,
            bounds,
            step_x: 80.0,
            step_y: 80.0,
            major_every: 5,
            origin: grid_origin,
            axes: grid_axes,
            limits,
        };
        let key = GridKey::from_grids(&[params], bounds, GridStyle::default());

        let state = GridCanvasState::default();
        *state.key.borrow_mut() = Some(key.clone());

        // Same key in the cache and in the request ⇒ reuse.
        assert!(should_reuse(state.key.borrow().as_ref(), &key));

        // Different bounds on the same params ⇒ different key, do not reuse.
        let other_bounds = iced::Rectangle { x: 0.0, y: 0.0, width: 640.0, height: 480.0 };
        let other_key = GridKey::from_grids(&[params], other_bounds, GridStyle::default());
        assert!(!should_reuse(state.key.borrow().as_ref(), &other_key));
    }
}

#[cfg(test)]
mod selection_visual_color_tests {
    use super::*;

    #[test]
    fn default_selection_colors_match_theme_palette() {
        let visual = SelectionVisualOptions::default();
        let dark_canvas = [0.0, 0.0, 0.0, 1.0];

        // Dark theme uses authentic classic CAD green and blue
        let dark_crossing = resolve_selection_base_color(true, &Theme::Dark, &visual, dark_canvas);
        let dark_window = resolve_selection_base_color(false, &Theme::Dark, &visual, dark_canvas);
        assert_eq!(dark_crossing, DEFAULT_CROSSING_COLOR);
        assert_eq!(dark_window, DEFAULT_WINDOW_COLOR);

        // Oxocarbon uses curated vibrant cyan and green
        let (oxo_crossing, oxo_window) = theme_selection_colors(&Theme::Oxocarbon);
        assert_eq!(oxo_crossing, Color::from_rgb(0.26, 0.75, 0.40));
        assert_eq!(oxo_window, Color::from_rgb(0.20, 0.69, 1.00));

        // Dracula uses iconic neon green and cyan
        let (drac_crossing, drac_window) = theme_selection_colors(&Theme::Dracula);
        assert_eq!(drac_crossing, Color::from_rgb(0.31, 0.98, 0.48));
        assert_eq!(drac_window, Color::from_rgb(0.54, 0.91, 0.99));

        // Nord uses aurora green and frost cyan
        let (nord_crossing, nord_window) = theme_selection_colors(&Theme::Nord);
        assert_eq!(nord_crossing, Color::from_rgb(0.64, 0.75, 0.55));
        assert_eq!(nord_window, Color::from_rgb(0.53, 0.75, 0.82));

        // Gruvbox Dark uses bright green and aqua
        let (gruv_crossing, gruv_window) = theme_selection_colors(&Theme::GruvboxDark);
        assert_eq!(gruv_crossing, Color::from_rgb(0.72, 0.73, 0.15));
        assert_eq!(gruv_window, Color::from_rgb(0.51, 0.65, 0.60));

        // All 22 themes must provide non-zero, full-alpha colors
        for theme in Theme::ALL {
            let (c, w) = theme_selection_colors(theme);
            assert_eq!(c.a, 1.0, "Theme {:?} crossing alpha should be 1.0", theme);
            assert_eq!(w.a, 1.0, "Theme {:?} window alpha should be 1.0", theme);
            assert!(c.g > 0.0, "Theme {:?} crossing should have green component", theme);
            assert!(w.b > 0.0 || w.g > 0.0, "Theme {:?} window should have blue/cyan component", theme);
        }
    }

    #[test]
    fn custom_aci_selection_colors_override_defaults() {
        let mut visual = SelectionVisualOptions::default();
        visual.crossing_color = 1; // Red
        visual.window_color = 5; // Blue
        let dark_canvas = [0.0, 0.0, 0.0, 1.0];
        let light_canvas = [1.0, 1.0, 1.0, 1.0];

        for theme in Theme::ALL {
            let crossing_dark = resolve_selection_base_color(true, theme, &visual, dark_canvas);
            let window_dark = resolve_selection_base_color(false, theme, &visual, dark_canvas);
            assert_eq!(crossing_dark, Color::from_rgb8(255, 0, 0));
            assert_eq!(window_dark, Color::from_rgb8(0, 0, 255));

            let crossing_light = resolve_selection_base_color(true, theme, &visual, light_canvas);
            let window_light = resolve_selection_base_color(false, theme, &visual, light_canvas);
            assert_eq!(crossing_light, Color::from_rgb8(255, 0, 0));
            assert_eq!(window_light, Color::from_rgb8(0, 0, 255));
        }
    }

    #[test]
    fn paper_space_on_dark_themes_uses_light_canvas_palette() {
        let visual = SelectionVisualOptions::default();
        let paper_bg = [1.0, 1.0, 1.0, 1.0];
        for theme in Theme::ALL {
            let crossing = resolve_selection_base_color(true, theme, &visual, paper_bg);
            let window = resolve_selection_base_color(false, theme, &visual, paper_bg);
            let c_lum = crate::ui::style::common::wcag_luminance(crossing);
            let w_lum = crate::ui::style::common::wcag_luminance(window);
            assert!(
                c_lum < 0.5,
                "Theme {:?} crossing on paper ({:.3}) must have luminance < 0.5",
                theme,
                c_lum
            );
            assert!(
                w_lum < 0.5,
                "Theme {:?} window on paper ({:.3}) must have luminance < 0.5",
                theme,
                w_lum
            );
        }
    }

    #[test]
    fn classic_dark_model_bg_resolves_dark_canvas_palette() {
        let visual = SelectionVisualOptions::default();
        let classic_dark = [33.0 / 255.0, 40.0 / 255.0, 48.0 / 255.0, 1.0];
        for theme in Theme::ALL {
            let crossing = resolve_selection_base_color(true, theme, &visual, classic_dark);
            let window = resolve_selection_base_color(false, theme, &visual, classic_dark);
            let (expected_crossing, expected_window) = theme_selection_colors(theme);
            assert_eq!(
                crossing, expected_crossing,
                "Theme {:?} crossing on ClassicDark should match theme pair",
                theme
            );
            assert_eq!(
                window, expected_window,
                "Theme {:?} window on ClassicDark should match theme pair",
                theme
            );
        }
    }

    #[test]
    fn custom_light_background_resolves_light_canvas_palette() {
        let visual = SelectionVisualOptions::default();
        let custom_light = [0.95, 0.95, 0.9, 1.0];
        let crossing = resolve_selection_base_color(true, &Theme::Dark, &visual, custom_light);
        let window = resolve_selection_base_color(false, &Theme::Dark, &visual, custom_light);
        assert_eq!(crossing, light_canvas_color(true, &Theme::Dark));
        assert_eq!(window, light_canvas_color(false, &Theme::Dark));
    }

    #[test]
    fn test_selection_fill_alpha_clamping() {
        // Dark canvas preserves user opacity directly clamped to [0.0, 1.0]
        assert_eq!(selection_fill_alpha(0.0, false), 0.0);
        assert!((selection_fill_alpha(50.0, false) - 0.5).abs() < 1e-5);
        assert_eq!(selection_fill_alpha(100.0, false), 1.0);
        assert_eq!(selection_fill_alpha(150.0, false), 1.0);

        // Light canvas applies 1.35x boost and clamps to [0.0, 0.45]
        assert_eq!(selection_fill_alpha(0.0, true), 0.0);
        assert!((selection_fill_alpha(20.0, true) - 0.27).abs() < 1e-4);
        assert!((selection_fill_alpha(50.0, true) - 0.45).abs() < 1e-5);
        assert!((selection_fill_alpha(100.0, true) - 0.45).abs() < 1e-5);
    }
}