blockworx_editor/shape/

block.rs

use crate::theme::Style;
use blockworx_geom::{Pos2, Rect, Vec2, pos2, vec2};
use blockworx_paint::Renderer;

use blockworx_doc::{block_model::Block, id::PinId};

use crate::{
    edit::{
        lower::{accent_from_role, shape_label},
        naming::{Authoring, InterfaceLock},
    },
    grid::{
        GRID_SIZE, PIN_PITCH, PIN_TOP_MARGIN, max_pin_slot, pin_offset_y, pin_slot, px_rect,
        round_to_pitch, snap_block_height, snap_rect,
    },
    path::Structure,
    render::block_title_position,
    shape::{
        BaseShape, PinLocation, ShapeLabel,
        pin::{Pin, PinSide, slot},
    },
    state::{RenderMode, ResizeMode},
    theme::Role,
};

pub fn resize_rect(rect: &Rect, mode: ResizeMode, delta: Vec2) -> Rect {
    match mode {
        ResizeMode::LeftTop => Rect::from_two_pos(rect.left_top() + delta, rect.right_bottom()),
        ResizeMode::RightTop => Rect::from_two_pos(rect.right_top() + delta, rect.left_bottom()),
        ResizeMode::LeftBottom => Rect::from_two_pos(rect.left_bottom() + delta, rect.right_top()),
        ResizeMode::RightBottom => Rect::from_two_pos(rect.right_bottom() + delta, rect.left_top()),
    }
}

/// The corner `mode` moves when resizing `rect`.
pub fn resize_corner(rect: &Rect, mode: ResizeMode) -> Pos2 {
    match mode {
        ResizeMode::LeftTop => rect.left_top(),
        ResizeMode::RightTop => rect.right_top(),
        ResizeMode::LeftBottom => rect.left_bottom(),
        ResizeMode::RightBottom => rect.right_bottom(),
    }
}

/// The corner `mode` keeps fixed while resizing `rect` (opposite
/// [`resize_corner`]).
pub fn fixed_corner(rect: &Rect, mode: ResizeMode) -> Pos2 {
    match mode {
        ResizeMode::LeftTop => rect.right_bottom(),
        ResizeMode::RightTop => rect.left_bottom(),
        ResizeMode::LeftBottom => rect.right_top(),
        ResizeMode::RightBottom => rect.left_top(),
    }
}

/// Snap radius (world units) for the aspect-ratio resize lock, matching the
/// position-alignment magnetism.
pub const ASPECT_SNAP_RADIUS: f32 = 6.0;

/// If the corner-`mode` box `resized` (grown from `bbox`) is within `radius` of
/// the image's intrinsic `aspect` (`intrinsic_w / intrinsic_h`), return the box
/// snapped so `w/h == aspect` exactly — the dragged corner projected onto the
/// aspect diagonal from the fixed corner; else `None`. Every point on that
/// diagonal has `w/h == aspect` by construction.
pub fn snap_resize_aspect(
    bbox: Rect,
    mode: ResizeMode,
    resized: Rect,
    aspect: f32,
    radius: f32,
) -> Option<Rect> {
    let fixed = fixed_corner(&bbox, mode);
    let dragged = resize_corner(&resized, mode);
    let v = dragged - fixed;
    if v.x == 0.0 || v.y == 0.0 {
        return None;
    }
    let dir = vec2(v.x.signum() * aspect, v.y.signum()).normalized();
    let t = v.dot(dir);
    if t <= 0.0 {
        return None;
    }
    let locked = fixed + dir * t;
    ((dragged - locked).length() <= radius).then(|| Rect::from_two_pos(fixed, locked))
}

/// Translate `inner` minimally so it lies within `bounds` — shifting, not
/// shrinking. On an axis where `inner` is larger than `bounds`, it is centered.
/// Used to keep a block's icon inside the block.
pub fn contain_rect(inner: Rect, bounds: Rect) -> Rect {
    let axis = |lo: f32, hi: f32, blo: f32, bhi: f32| -> f32 {
        if hi - lo >= bhi - blo {
            f32::midpoint(blo, bhi) - f32::midpoint(lo, hi) // center it
        } else if lo < blo {
            blo - lo
        } else if hi > bhi {
            bhi - hi
        } else {
            0.0
        }
    };
    inner.translate(vec2(
        axis(inner.min.x, inner.max.x, bounds.min.x, bounds.max.x),
        axis(inner.min.y, inner.max.y, bounds.min.y, bounds.max.y),
    ))
}

/// Where a block's `icon` lands when the block's rect goes from `old` to `new`:
/// it rides the block's center, then is shifted back inside if the block shrank
/// past it. Shared by the resize preview and the commit so the icon doesn't jump
/// when the drag is released.
pub fn icon_rect_after_resize(icon: Rect, old: Rect, new: Rect) -> Rect {
    contain_rect(icon.translate(new.center() - old.center()), new)
}

/// Clamp a corner-resize `delta` so `resize_rect(bbox, mode, delta)` keeps the
/// dragged corner within `bounds` (the fixed corner is assumed already inside),
/// so a resized icon can't grow past its block.
pub fn clamp_resize_within(bbox: Rect, mode: ResizeMode, delta: Vec2, bounds: Rect) -> Vec2 {
    let corner = resize_corner(&bbox, mode);
    let moved = corner + delta;
    let clamped = pos2(
        moved.x.clamp(bounds.min.x, bounds.max.x),
        moved.y.clamp(bounds.min.y, bounds.max.y),
    );
    clamped - corner
}

/// Snap a resized block rect to the grid. When `is_block`, the *height* is
/// further constrained to a valid block height (see [`snap_block_height`]) by
/// moving the dragged edge, so a block resizes in lockstep with its pin-pitch
/// lattice and never falls below the single-slot minimum. Without this the
/// height snaps to `GRID_SIZE` (a quarter pitch), so `max_pin_slot` only steps
/// every fourth grid row and the pins sub-step up and down against the moving edge.
/// The fixed edge stays put, keeping it grid-aligned.
/// Whether a resize also holds the block height to its 4-cell pitch, or just
/// snaps to the grid (ports, areas, images and text boxes have no pitch).
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum ResizeSnap {
    BlockPitch,
    GridOnly,
}

pub fn snap_resized_block(rect: Rect, mode: ResizeMode, snap: ResizeSnap) -> Rect {
    let snapped = snap_rect(rect);
    if snap == ResizeSnap::GridOnly {
        return snapped;
    }
    let h = snap_block_height(snapped.height());
    match mode {
        ResizeMode::LeftTop | ResizeMode::RightTop => {
            Rect::from_min_max(pos2(snapped.min.x, snapped.max.y - h), snapped.max)
        }
        ResizeMode::LeftBottom | ResizeMode::RightBottom => {
            Rect::from_min_max(snapped.min, pos2(snapped.max.x, snapped.min.y + h))
        }
    }
}

/// How many slots every pin shifts up when a block holding pins at `offsets`
/// is resized to `new_height` px, so the lowest pin keeps its bottom clearance
/// instead of blocking the resize. Bounded by the top margin (the smallest pin
/// offset) so the highest pin never rises above slot `0`. Zero when the pins
/// already fit — i.e. only a height that would push the lowest pin out shifts
/// them.
pub fn resize_pin_shift(offsets: impl Iterator<Item = u32>, new_height: f32) -> u32 {
    let mut bounds: Option<(u32, u32)> = None;
    for offset in offsets {
        bounds = Some(bounds.map_or((offset, offset), |(lo, hi)| {
            (lo.min(offset), hi.max(offset))
        }));
    }
    let Some((min_offset, max_offset)) = bounds else {
        return 0;
    };
    max_offset
        .saturating_sub(max_pin_slot(new_height))
        .min(min_offset)
}

/// A block with the pins the caller resolved for it. In the document a pin is
/// its own entity owned by the block, so nothing about a block's boundary can
/// be read off the block alone; the scope that draws it hands the set in, in
/// the order it wants them painted.
pub struct BlockShape<'a> {
    pub block: &'a Block,
    pub pins: Vec<(PinId, &'a Pin)>,
    /// Whether the block holds blocks of its own — [`crate::path::structure`],
    /// resolved by the scope that built the shape, since a block's interior is
    /// no more readable off the block alone than its pins are.
    pub structure: Structure,
}

impl<'a> BlockShape<'a> {
    pub fn new(block: &'a Block, pins: Vec<(PinId, &'a Pin)>, structure: Structure) -> Self {
        Self {
            block,
            pins,
            structure,
        }
    }

    pub fn rect(&self) -> Rect {
        px_rect(self.block.rect)
    }

    /// The block's [`InterfaceLock`] state, for passing to functions that branch on it.
    pub fn lock(&self) -> InterfaceLock {
        (self.block.locked).into()
    }

    /// The [`Role`] the block's outline strokes with, chosen by its accent
    /// `role` register: `Accent1..=Accent8` →
    /// [`Role::Accent0`]..[`Role::Accent7`], the plain `Accent0` →
    /// [`Role::AccentDefault`].
    pub fn accent_role(&self) -> Role {
        crate::theme::accent_role(accent_from_role(self.block.role)).unwrap_or(Role::AccentDefault)
    }

    fn offsets(&self) -> impl Iterator<Item = u32> + '_ {
        self.pins.iter().map(|(_, pin)| slot(pin).offset)
    }

    pub fn is_pin_location_available(&self, location: PinLocation) -> bool {
        self.is_pin_location_available_excluding(location, None)
    }

    /// Like [`Self::is_pin_location_available`], but ignores the pin `except`
    /// (so a pin being dragged doesn't block its own move).
    pub fn is_pin_location_available_excluding(
        &self,
        location: PinLocation,
        except: Option<PinId>,
    ) -> bool {
        let PinLocation { side, offset } = location;
        let height_px = self.rect().height();
        if offset < 0.0 || offset > height_px {
            return false;
        }
        self.pins
            .iter()
            .filter(|(id, _)| Some(*id) != except)
            .map(|(_, pin)| slot(pin))
            .filter(|l| l.side == side)
            // Slots are PIN_PITCH apart; reject only the exact same slot, allow
            // adjacent slots one pitch away.
            .all(|l| (l.offset as f32 * PIN_PITCH - offset).abs() >= PIN_PITCH * 0.5)
    }

    /// How many slots every pin shifts up when the block is resized to
    /// `new_height` (see the free [`resize_pin_shift`]).
    pub fn resize_pin_shift(&self, new_height: f32) -> u32 {
        resize_pin_shift(self.offsets(), new_height)
    }

    /// Where a pin sitting at (`side`, `offset`) anchors its wire when the
    /// block is drawn at `rect` — the slot-parameterized core of
    /// [`BaseShape::anchor_point_with_rect`], shared with drag previews that
    /// preview a pin at a hypothetical slot without moving it. Applies the same
    /// upward shift the block's render preview uses, so a route re-routed
    /// against a shrunk preview rect tracks where the pin will land; at the
    /// block's real height the shift is zero.
    pub fn pin_anchor_at(&self, rect: Rect, side: PinSide, offset: u32) -> Pos2 {
        let shift = self.resize_pin_shift(rect.height());
        let y = pin_offset_y(rect.top(), offset.saturating_sub(shift));
        match side {
            PinSide::East => pos2(rect.right() + GRID_SIZE, y),
            PinSide::West => pos2(rect.left() - GRID_SIZE, y),
        }
    }

    fn title_label(&self) -> ShapeLabel<'a> {
        shape_label(&self.block.title)
    }

    fn type_label_of(&self) -> ShapeLabel<'a> {
        shape_label(&self.block.type_label)
    }

    /// The grid-committed rect a block renders its frame and pins at for `mode`
    /// (a drag/resize preview snaps to grid on commit). Shared by
    /// [`BaseShape::render_ng`] and [`Self::render_pins_ng`] so the body and pin
    /// passes stay aligned.
    fn committed_rect(&self, mode: RenderMode) -> Rect {
        let bbox = self.rect();
        match mode {
            RenderMode::Moving { delta } => snap_rect(bbox.translate(delta)),
            RenderMode::Resizing { mode, delta } => snap_resized_block(
                resize_rect(&bbox, mode, delta),
                mode,
                ResizeSnap::BlockPitch,
            ),
            _ => bbox,
        }
    }

    /// Draw only the block's pin layer for `mode` — stubs, names, tags, the
    /// selection placeholders, and the drag/resize previews. Split out of
    /// [`BaseShape::render_ng`] so the scene can draw it in a later pass, on top
    /// of a block's icon (see [`crate::widget::DrawingPasses`]).
    pub fn render_pins_ng<R: Renderer>(
        &self,
        accents: crate::presentation::ShapeAccents<'_>,
        mode: RenderMode,
        painter: &mut Style<'_, R>,
    ) {
        let rect = self.committed_rect(mode);
        match mode {
            RenderMode::PinDragged {
                pin,
                delta,
                side,
                candidate,
            } => {
                crate::render::render_pins_with_box(
                    self.pins
                        .iter()
                        .filter(|&&(id, _)| id != pin)
                        .map(|&(id, p)| (id, p)),
                    rect,
                    accents,
                    painter,
                );
                painter.line_segment(
                    [rect.center_top(), rect.center_bottom()],
                    (2.0, Role::PinDragIndicator),
                );
                if let Some(pin_ref) = self.pin(pin) {
                    // A faded ghost at the slot the pin would snap to if released
                    // now, behind the solid pin that follows the cursor.
                    if let Some(candidate_slot) = candidate {
                        let ghost_delta =
                            PIN_PITCH * (candidate_slot as f32 - slot(pin_ref).offset as f32);
                        let ghost_paint = crate::render::PinPaint {
                            delta_y: ghost_delta,
                            side: Some(side),
                            accent: accents.pin(pin),
                        };
                        painter.with_opacity(0.5, |ghost| {
                            crate::render::draw_pin(rect, pin_ref, ghost_paint, ghost);
                        });
                    }
                    let paint = crate::render::PinPaint {
                        delta_y: delta,
                        side: Some(side),
                        accent: accents.pin(pin),
                    };
                    crate::render::draw_pin(rect, pin_ref, paint, painter);
                }
            }
            RenderMode::Selected { authoring } => {
                crate::render::render_pins_with_box(
                    self.pins.iter().copied(),
                    rect,
                    accents,
                    painter,
                );
                if authoring == Authoring::Offered {
                    for (_, pin) in &self.pins {
                        crate::render::draw_pin_placeholders(rect, pin, painter);
                    }
                }
            }
            RenderMode::Resizing { .. } => {
                // Preview the same upward pin shift the drop will commit, so a pin
                // at the lowest slot slides into the top margin instead of spilling
                // below the shrinking block.
                let dy = -(self.resize_pin_shift(rect.height()) as f32 * PIN_PITCH);
                for &(id, pin) in &self.pins {
                    let paint = crate::render::PinPaint {
                        delta_y: dy,
                        side: None,
                        accent: accents.pin(id),
                    };
                    crate::render::draw_pin(rect, pin, paint, painter);
                }
            }
            // Normal, Hidden, Moving, TitleDragged, TypeDragged: pins at rest on
            // the committed rect.
            _ => crate::render::render_pins_with_box(
                self.pins.iter().copied(),
                rect,
                accents,
                painter,
            ),
        }
    }
}

impl BaseShape for BlockShape<'_> {
    fn title(&self) -> Option<ShapeLabel<'_>> {
        Some(self.title_label())
    }
    fn type_label(&self) -> Option<ShapeLabel<'_>> {
        Some(self.type_label_of())
    }
    fn gui_rect(&self) -> Rect {
        self.rect()
    }
    fn pin(&self, id: PinId) -> Option<&Pin> {
        self.pins
            .iter()
            .find(|&&(pid, _)| pid == id)
            .map(|&(_, pin)| pin)
    }
    fn anchor_point_with_rect(&self, rect: Rect, id: PinId) -> Option<Pos2> {
        let pin = self.pin(id)?;
        let slot = slot(pin);
        Some(self.pin_anchor_at(rect, slot.side, slot.offset))
    }
    fn pin_text_rect<R: Renderer>(&self, id: PinId, painter: &Style<'_, R>) -> Option<Rect> {
        let pin = self.pin(id)?;
        let slot = slot(pin);
        Some(crate::render::estimate_bbox_for_pin_name(
            self.rect(),
            slot.side,
            slot.offset,
            &pin.name,
            painter,
        ))
    }
    fn pin_type_rect<R: Renderer>(&self, id: PinId, painter: &Style<'_, R>) -> Option<Rect> {
        let pin = self.pin(id)?;
        let slot = slot(pin);
        Some(crate::render::estimate_bbox_for_pin_type(
            self.rect(),
            slot.side,
            slot.offset,
            &pin.type_name,
            painter,
        ))
    }
    fn tag_text_rect_for<R: Renderer>(
        &self,
        id: PinId,
        text: &str,
        painter: &Style<'_, R>,
    ) -> Option<Rect> {
        let pin = self.pin(id)?;
        let slot = slot(pin);
        let bbox = self.rect();
        let line_y = pin_offset_y(bbox.top(), slot.offset);
        Some(
            crate::render::TagSlot {
                left: bbox.left(),
                right: bbox.right(),
                side: slot.side,
                line_y,
            }
            .bbox(text, painter),
        )
    }
    fn pin_stub_rect(&self, id: PinId) -> Option<Rect> {
        let pin = self.pin(id)?;
        let slot = slot(pin);
        let bbox = self.rect();
        let line_y = pin_offset_y(bbox.top(), slot.offset);
        Some(crate::render::estimate_bbox_for_pin_stub(
            bbox.left(),
            bbox.right(),
            slot.side,
            line_y,
        ))
    }
    /// The slot a dragged pin would snap to (its grid offset), or `None` if no
    /// free slot is available near the raw drop position. Tries the nearest slot,
    /// then the adjacent slot on the other side of the raw drop position. The
    /// drop's own write ([`crate::edit::geometry::move_pin`]) is handed the slot
    /// this resolved, so the live preview lands exactly where the commit will.
    fn pin_drop_candidate(&self, pin_id: PinId, side: PinSide, raw_offset_px: f32) -> Option<u32> {
        let primary = round_to_pitch(raw_offset_px).max(0.0);
        // The neighbor on the far side of the raw position from `primary`.
        let secondary = if raw_offset_px >= primary {
            primary + PIN_PITCH
        } else {
            (primary - PIN_PITCH).max(0.0)
        };
        [primary, secondary].into_iter().find_map(|cand| {
            self.is_pin_location_available_excluding(
                PinLocation { side, offset: cand },
                Some(pin_id),
            )
            .then(|| pin_slot(cand))
        })
    }
    fn new_pin_locations(&self) -> Vec<PinLocation> {
        let mut locations = Vec::new();
        // One candidate per slot from the top down to `max_pin_slot`, which
        // already reserves two grid cells of clearance above the bottom edge.
        let max_slot = max_pin_slot(self.rect().height());
        for slot in 0..=max_slot {
            let offset = slot as f32 * PIN_PITCH;
            if self.is_pin_location_available((PinSide::West, offset).into()) {
                locations.push(PinLocation {
                    side: PinSide::West,
                    offset,
                });
            }
            if self.is_pin_location_available((PinSide::East, offset).into()) {
                locations.push(PinLocation {
                    side: PinSide::East,
                    offset,
                });
            }
        }
        locations
    }
    fn pin_position(&self, location: PinLocation) -> Option<Pos2> {
        let inner = self.rect();
        let left_top = inner.left_top();
        let offset = location.offset;
        if offset < 0.0 || offset > inner.height() {
            return None;
        }
        // Mirror `pin_offset_y`: a stored slot at px `offset` (= slot*PIN_PITCH)
        // sits a `PIN_TOP_MARGIN` below the top edge, then one pitch per slot.
        Some(match location.side {
            PinSide::West => left_top + vec2(0.0, offset + PIN_TOP_MARGIN),
            PinSide::East => inner.right_top() + vec2(0.0, offset + PIN_TOP_MARGIN),
        })
    }
    fn title_anchor(&self) -> Option<Pos2> {
        let (pos, _) = block_title_position(self.rect(), &self.title_label());
        Some(pos)
    }
    fn type_anchor(&self) -> Option<Pos2> {
        let (pos, _) = crate::render::block_type_position(self.rect(), &self.type_label_of());
        Some(pos)
    }
    fn resizable(&self) -> bool {
        true
    }
    fn render_ng<R: Renderer>(&self, mode: RenderMode, painter: &mut Style<'_, R>) {
        let bbox = self.rect();
        let title = self.title_label();
        let type_label = self.type_label_of();
        let lock = self.lock();
        let structure = self.structure;
        let paint = crate::render::BlockPaint {
            stroke: self.accent_role(),
            lock,
            structure,
        };
        // The committed type label (upper-left). An empty type draws nothing
        // (handled inside the helper).
        let draw_type = |target: Rect, painter: &mut Style<'_, R>| {
            crate::render::draw_block_type(target, &type_label, lock, painter);
        };
        match mode {
            RenderMode::Moving { delta } => {
                let shifted = bbox.translate(delta);
                let predicted = snap_rect(shifted);
                // The block commits to the grid, so draw its body at the snapped
                // position where the route anchors land (its pins follow there in
                // the pin pass); a ghost outline trails the raw cursor to show the
                // un-snapped drag.
                crate::render::draw_box_outline(
                    shifted,
                    Role::Transparent,
                    (1.0, Role::DragPreviewStroke),
                    painter,
                );
                // Draw the landing block with its own accent, exactly as at rest.
                crate::render::draw_block_frame(predicted, &title, paint, painter);
                draw_type(predicted, painter);
            }
            RenderMode::Selected { authoring } => {
                crate::render::draw_block_frame(bbox, &title, paint, painter);
                draw_type(bbox, painter);
                if authoring == Authoring::Offered {
                    crate::render::draw_block_type_placeholder(bbox, &type_label, painter);
                }
                crate::render::draw_selection_frame(bbox, None, painter);
                if lock.is_locked() {
                    crate::render::draw_lock_hint(bbox, painter);
                }
            }
            RenderMode::Resizing { mode, delta } => {
                let resized = resize_rect(&bbox, mode, delta);
                let predicted = snap_resized_block(resized, mode, ResizeSnap::BlockPitch);
                // The block commits to the grid, so draw it and its pins at the
                // snapped position where the route anchors land; a ghost outline
                // trails the raw cursor to show the un-snapped resize.
                crate::render::draw_box_outline(
                    resized,
                    Role::Transparent,
                    (1.0, Role::DragPreviewStroke),
                    painter,
                );
                crate::render::draw_block_boundary(
                    predicted,
                    Role::DragActiveFill,
                    (2.0, Role::DragActiveStroke),
                    structure,
                    painter,
                );
                crate::render::draw_block_title(predicted, &title, lock, painter);
                draw_type(predicted, painter);
                crate::render::draw_selection_frame(predicted, Some(mode), painter);
                crate::render::draw_size_readout(predicted, painter);
            }
            RenderMode::TitleDragged { delta } => {
                let (anchor_pos, _) = block_title_position(bbox, &title);
                let shifted_title = ShapeLabel {
                    side: crate::render::label_side_for_y(bbox, anchor_pos.y + delta.y),
                    offset: title.offset + delta.x,
                    ..title
                };
                crate::render::draw_block_frame(bbox, &shifted_title, paint, painter);
                draw_type(bbox, painter);
                painter.line_segment(
                    [bbox.left_center(), bbox.right_center()],
                    (2.0, Role::PinDragIndicator),
                );
            }
            RenderMode::TypeDragged { delta } => {
                let (anchor_pos, _) = crate::render::block_type_position(bbox, &type_label);
                let shifted_type = ShapeLabel {
                    side: crate::render::label_side_for_y(bbox, anchor_pos.y + delta.y),
                    offset: type_label.offset + delta.x,
                    ..type_label
                };
                crate::render::draw_block_frame(bbox, &title, paint, painter);
                crate::render::draw_block_type(bbox, &shifted_type, lock, painter);
                painter.line_segment(
                    [bbox.left_center(), bbox.right_center()],
                    (2.0, Role::PinDragIndicator),
                );
            }
            // Normal, Hidden, PinDragged draw just the frame and type; the pin
            // layer (including the pin-drag preview) is drawn by
            // [`Self::render_pins_ng`] in a later pass, over any block icon.
            _ => {
                crate::render::draw_block_frame(bbox, &title, paint, painter);
                draw_type(bbox, painter);
            }
        }
    }
}

#[cfg(test)]
pub(crate) mod tests {
    use super::*;
    use blockworx_doc::{
        block_model::{Block, Icon, Label, Pin},
        geometry::{FracVal, PinSlot},
        id::BlockId,
        values::{LabelSide, PinDir, Role as DocRole},
    };

    /// A pin at `side`/`slot`, with only the fields the geometry layer
    /// reads set to anything but their zero.
    pub(crate) fn test_pin(side: PinSide, offset: u32) -> Pin {
        Pin {
            slot: PinSlot { side, offset },
            dir: PinDir::InOut,
            ..Pin::default()
        }
    }

    /// A block covering `rect` in world px, snapped to whole cells.
    pub(crate) fn test_block(rect: Rect) -> Block {
        let label = |name: &str, side| Label {
            name: name.into(),
            side,
            offset: FracVal::default(),
            hidden: false,
        };
        Block {
            parent: BlockId::default(),
            rect: crate::grid::grid_rect(rect.min, rect.max),
            locked: false,
            role: DocRole::default(),
            title: label("b", LabelSide::Bottom),
            type_label: label("", LabelSide::Top),
            icon: Icon::default(),
        }
    }

    /// A 300×300 block at the origin, holding `pins` under ids `1..`.
    fn block_300() -> Block {
        test_block(Rect::from_min_max(pos2(0.0, 0.0), pos2(300.0, 300.0)))
    }

    fn shape<'a>(block: &'a Block, pins: &'a [Pin]) -> BlockShape<'a> {
        BlockShape::new(
            block,
            pins.iter()
                .enumerate()
                .map(|(i, pin)| (blockworx_doc::fixtures::pin_id(i as u32 + 1), pin))
                .collect(),
            Structure::Leaf,
        )
    }

    #[test]
    fn contain_rect_shifts_into_bounds_without_shrinking() {
        let bounds = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 100.0));
        let outside = Rect::from_min_max(pos2(90.0, 90.0), pos2(130.0, 130.0));
        let contained = contain_rect(outside, bounds);
        assert!(bounds.contains_rect(contained));
        assert_eq!(contained.size(), outside.size(), "shifted, not shrunk");
    }

    #[test]
    fn clamp_resize_within_keeps_the_dragged_corner_in_bounds() {
        let bounds = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 100.0));
        let bbox = Rect::from_min_max(pos2(20.0, 20.0), pos2(60.0, 60.0));
        // Drag the bottom-right corner far past the bounds → clamped to the edge.
        let d = clamp_resize_within(bbox, ResizeMode::RightBottom, vec2(1000.0, 1000.0), bounds);
        let resized = resize_rect(&bbox, ResizeMode::RightBottom, d);
        assert!(
            bounds.contains_rect(resized),
            "resized icon stays within the block"
        );
        assert_eq!(
            resized.max,
            pos2(100.0, 100.0),
            "corner clamped to the edge"
        );
    }

    #[test]
    fn snap_resize_aspect_locks_a_near_ratio_box() {
        // Fixed corner at the origin; the aspect ray for aspect=2 passes through
        // (20,10). A dragged corner 3px off that ray (radius 6) snaps to it.
        let bbox = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
        let perp = vec2(1.0, -2.0).normalized() * 3.0; // perpendicular to (2,1)
        let dragged = pos2(20.0, 10.0) + perp;
        let resized = Rect::from_min_max(pos2(0.0, 0.0), dragged);
        let snapped =
            snap_resize_aspect(bbox, ResizeMode::RightBottom, resized, 2.0, 6.0).expect("snaps");
        assert!(
            (snapped.width() / snapped.height() - 2.0).abs() < 1e-3,
            "w/h locks to the intrinsic aspect"
        );
        assert_eq!(snapped.min, pos2(0.0, 0.0), "the fixed corner stays put");
    }

    #[test]
    fn snap_resize_aspect_ignores_a_far_box() {
        let bbox = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
        // A square box is far from the 2:1 aspect ray.
        let resized = Rect::from_min_max(pos2(0.0, 0.0), pos2(20.0, 20.0));
        assert!(snap_resize_aspect(bbox, ResizeMode::RightBottom, resized, 2.0, 6.0).is_none());
    }

    #[test]
    fn snap_resize_aspect_keeps_the_fixed_corner_for_left_top() {
        // LeftTop drags the top-left; the bottom-right stays fixed.
        let bbox = Rect::from_min_max(pos2(0.0, 0.0), pos2(30.0, 30.0));
        let fixed = bbox.right_bottom();
        // Aspect 2 ray from the fixed corner toward the top-left: dir (-2,-1).
        let perp = vec2(1.0, -2.0).normalized() * 2.0;
        let dragged = fixed + vec2(-20.0, -10.0) + perp;
        let resized = Rect::from_two_pos(dragged, fixed);
        let snapped =
            snap_resize_aspect(bbox, ResizeMode::LeftTop, resized, 2.0, 6.0).expect("snaps");
        assert!((snapped.width() / snapped.height() - 2.0).abs() < 1e-3);
        assert_eq!(
            snapped.max, fixed,
            "the fixed (bottom-right) corner stays put"
        );
    }

    #[test]
    fn pin_drop_candidate_returns_the_nearest_free_slot() {
        let (block, pins) = (block_300(), [test_pin(PinSide::West, 5)]);
        let b = shape(&block, &pins);
        let id = b.pins[0].0;
        assert_eq!(b.pin_drop_candidate(id, PinSide::West, 4.0), Some(0));
    }

    #[test]
    fn pin_drop_candidate_falls_back_to_neighbor_slot() {
        let (block, pins) = (
            block_300(),
            [test_pin(PinSide::West, 1), test_pin(PinSide::West, 5)],
        );
        let b = shape(&block, &pins);
        let mover = b.pins[1].0;
        // Drop exactly on slot 1 (occupied); fallback is the neighbor slot 2.
        assert_eq!(
            b.pin_drop_candidate(mover, PinSide::West, PIN_PITCH),
            Some(2)
        );
    }

    #[test]
    fn pin_drop_candidate_is_none_when_both_neighbors_taken() {
        let (block, pins) = (
            block_300(),
            [
                test_pin(PinSide::West, 1),
                test_pin(PinSide::West, 2),
                test_pin(PinSide::West, 6),
            ],
        );
        let b = shape(&block, &pins);
        let mover = b.pins[2].0;
        // Drop between slots 1 and 2: both candidates occupied.
        assert_eq!(
            b.pin_drop_candidate(mover, PinSide::West, 1.5 * PIN_PITCH),
            None
        );
    }

    #[test]
    fn resize_pin_shift_uses_the_top_margin_to_let_a_block_shrink() {
        // One pin at slot 5 (the max for a 300px-tall block).
        let shift = |height| resize_pin_shift([5].into_iter(), height);
        // No shift while the pin still fits (height unchanged, slot 5 is the max).
        assert_eq!(shift(300.0), 0);
        // A partial shrink slides it up just enough to keep fitting.
        assert_eq!(shift(2.0 * PIN_TOP_MARGIN + 2.0 * PIN_PITCH), 3);
        // Shrinking to the single-pin floor slides the pin all the way to slot 0.
        assert_eq!(shift(2.0 * PIN_TOP_MARGIN), 5);
    }

    #[test]
    fn resize_pin_shift_preserves_a_multi_pin_span() {
        // span = 3; the floor PIN_PITCH*(3+1) shifts both up by the top offset (2),
        // landing the pins at slots 0 and 3 with the span intact.
        assert_eq!(resize_pin_shift([2, 5].into_iter(), 4.0 * PIN_PITCH), 2);
    }

    #[test]
    fn snap_resized_block_quantizes_height_to_a_valid_block_height() {
        // Eight grid cells tall (120px) — grid-aligned, but not a valid block
        // height. Quantization rounds it to the nearest valid one, fixed edge held.
        let top = 2.0 * PIN_TOP_MARGIN;
        let r = Rect::from_min_max(pos2(0.0, top), pos2(60.0, top + 8.0 * GRID_SIZE));
        let is_valid = |h: f32| snap_block_height(h) == h;

        // Bottom-edge drag keeps the top edge put.
        let q = snap_resized_block(r, ResizeMode::RightBottom, ResizeSnap::BlockPitch);
        assert_eq!(q.min.y, top);
        assert!(is_valid(q.height()));

        // Top-edge drag keeps the bottom edge put.
        let q = snap_resized_block(r, ResizeMode::LeftTop, ResizeSnap::BlockPitch);
        assert_eq!(q.max.y, top + 8.0 * GRID_SIZE);
        assert!(is_valid(q.height()));

        // A pinless block keeps its plain grid height.
        let q = snap_resized_block(r, ResizeMode::RightBottom, ResizeSnap::GridOnly);
        assert_eq!(q.height(), 8.0 * GRID_SIZE);
    }

    #[test]
    fn a_block_reads_its_geometry_and_labels_off_its_registers() {
        let (block, pins) = (block_300(), [test_pin(PinSide::East, 1)]);
        let b = shape(&block, &pins);
        assert_eq!(
            b.gui_rect(),
            Rect::from_min_max(pos2(0.0, 0.0), pos2(300.0, 300.0))
        );
        assert_eq!(b.title().expect("a block always has a title").name, "b");
        assert!(!b.title().expect("a title").hidden);
        // The stub anchors one cell outboard of the edge its slot sits on.
        let anchor = b
            .anchor_point_with_rect(b.gui_rect(), b.pins[0].0)
            .expect("the pin is the block's");
        assert_eq!(anchor.x, 300.0 + GRID_SIZE);
        assert_eq!(anchor.y, pin_offset_y(0.0, 1));
    }
}