blockworx/document/

auto_route.rs

//! The route data model. [`AutoRoute`] holds a wire's *authored* state —
//! anchors, waypoints, labels, name and accent — as pure data. The solved
//! geometry (edges, resolved endpoints, crossing hops) is derived state,
//! [`crate::presentation::RouteGeometry`], and the routing behaviour that
//! produces it lives in [`crate::widget::auto_route`].

use super::{GridPos, LineAnchor, LinearDistance, Waypoint};
use crate::document::Lock;
use crate::presentation::store::{IdMap, IdMapExt};
use crate::store::{WaypointId, WireLabelId};

/// Whether the wire reverses direction at `cur`: both the `prev → cur` and
/// `cur → next` runs lie on the same axis (a shared row or a shared column) and
/// point in opposite directions. A perpendicular turn (90°) or a straight run
/// (0°, `cur` between its neighbours) is not a reversal.
fn reverses_at(prev: GridPos, cur: GridPos, next: GridPos) -> bool {
    let (ax, ay) = (cur.x - prev.x, cur.y - prev.y);
    let (bx, by) = (next.x - cur.x, next.y - cur.y);
    (ay == 0 && by == 0 && ax != 0 && bx != 0 && (ax > 0) != (bx > 0))
        || (ax == 0 && bx == 0 && ay != 0 && by != 0 && (ay > 0) != (by > 0))
}

/// The waypoints a backtracking prune would drop from the path-ordered `seq`
/// running `start → … → end`, without touching any route. Iterative, because
/// dropping a corner can expose a reversal between its former neighbours. The
/// policy core of [`AutoRoute::remove_backtracking_waypoints`], shared with the
/// drag previews that must compute the prune without applying it.
pub fn backtracking_waypoints(
    mut seq: Vec<(WaypointId, GridPos)>,
    start: GridPos,
    end: GridPos,
) -> Vec<WaypointId> {
    let mut doomed = Vec::new();
    loop {
        let hit = (0..seq.len()).find(|&i| {
            let prev = if i == 0 { start } else { seq[i - 1].1 };
            let next = if i + 1 == seq.len() {
                end
            } else {
                seq[i + 1].1
            };
            reverses_at(prev, seq[i].1, next)
        });
        match hit {
            Some(i) => doomed.push(seq.remove(i).0),
            None => break,
        }
    }
    doomed
}

#[derive(PartialEq, Debug, Clone)]
pub struct AutoRoute {
    pub(crate) start: LineAnchor,
    pub(crate) finish: LineAnchor,
    pub(crate) waypoints: IdMap<WaypointId, Waypoint>,
    pub(crate) labels: IdMap<WireLabelId, LinearDistance>,
    pub(crate) name: String,
    /// Optional accent index (`0..=7`) selecting the wire's stroke color via
    /// [`Role::Accent0`]..[`Role::Accent7`] (see [`crate::theme::accent_role`]);
    /// `None` uses the mode-based default.
    ///
    /// [`Role::Accent0`]: crate::theme::Role::Accent0
    /// [`Role::Accent7`]: crate::theme::Role::Accent7
    pub(crate) role: Option<u8>,
}

/// Pure data accessors and mutators. Anything that needs pixel space, the
/// router, or the painter lives in `AutoRouteExt` (see the module docs).
/// Which end of a route an operation works from.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RouteEnd {
    Start,
    Finish,
}

impl AutoRoute {
    /// A wire's authored state, freshly drawn: no name yet (so a new
    /// label shows its placeholder), no accent.
    pub fn new(
        start: LineAnchor,
        finish: LineAnchor,
        waypoints: IdMap<WaypointId, Waypoint>,
        labels: IdMap<WireLabelId, LinearDistance>,
    ) -> Self {
        Self {
            start,
            finish,
            waypoints,
            labels,
            name: String::new(),
            role: None,
        }
    }

    pub fn start(&self) -> LineAnchor {
        self.start
    }
    pub fn finish(&self) -> LineAnchor {
        self.finish
    }
    /// Repoint both endpoints. Used by paste, which remaps a cloned route's
    /// anchors onto the freshly assigned shape ids before re-routing.
    pub fn set_anchors(&mut self, start: LineAnchor, finish: LineAnchor) {
        self.start = start;
        self.finish = finish;
    }
    /// Insert a waypoint at position `index` in path order (the corner
    /// sequence), returning its id. Unlike `AutoRouteExt::add_waypoint` this does
    /// no geometry-based reordering — the caller places the corner at a known
    /// position, which is required now that waypoint insertion order *is* the
    /// route's polyline order.
    pub fn insert_waypoint_at(&mut self, index: usize, pos: GridPos, lock: Lock) -> WaypointId {
        self.waypoints.insert_value_at(
            index,
            Waypoint {
                pos,
                locked: lock.is_locked(),
            },
        )
    }
    pub fn lock_waypoint(&mut self, id: WaypointId) {
        if let Some(wp) = self.waypoint_mut(id) {
            wp.locked = true;
        }
    }
    pub fn iter_labels(&self) -> impl Iterator<Item = (WireLabelId, &LinearDistance)> {
        self.labels.iter().map(|(&k, v)| (k, v))
    }
    pub fn label(&self, label_id: WireLabelId) -> Option<&LinearDistance> {
        self.labels.get(&label_id)
    }
    pub fn label_mut(&mut self, label_id: WireLabelId) -> Option<&mut LinearDistance> {
        self.labels.get_mut(&label_id)
    }
    pub fn remove_label(&mut self, label_id: WireLabelId) {
        self.labels.shift_remove(&label_id);
    }
    pub fn waypoint(&self, waypoint_id: WaypointId) -> Option<&Waypoint> {
        self.waypoints.get(&waypoint_id)
    }
    pub fn waypoint_mut(&mut self, waypoint_id: WaypointId) -> Option<&mut Waypoint> {
        self.waypoints.get_mut(&waypoint_id)
    }
    pub fn update_waypoint(&mut self, waypoint_id: WaypointId, update: impl FnOnce(&mut Waypoint)) {
        if let Some(wp) = self.waypoint_mut(waypoint_id) {
            update(wp);
        }
    }
    pub fn iter_waypoints(&self) -> impl Iterator<Item = (WaypointId, &Waypoint)> {
        self.waypoints.iter().map(|(&k, v)| (k, v))
    }
    /// Discard every waypoint, so the next reroute autoroutes the endpoints on
    /// Dijkstra cost alone, with no user-placed corners to route through.
    pub fn clear_waypoints(&mut self) {
        self.waypoints.clear();
    }
    /// The approach waypoints a trim from `end` would drop — up to two unlocked
    /// corners nearest that endpoint, stopping at the first locked, hand-placed
    /// corner so an explicit user bend survives. Pure twin of
    /// [`Self::trim_approach_waypoints`]; drag previews route through the
    /// skeleton minus this set without touching the stored waypoints.
    pub fn approach_waypoint_ids(&self, end: RouteEnd) -> Vec<WaypointId> {
        const APPROACH: usize = 2;
        let ordered: Vec<WaypointId> = if end == RouteEnd::Start {
            self.waypoints.keys().copied().collect()
        } else {
            self.waypoints.keys().rev().copied().collect()
        };
        let mut doomed = Vec::new();
        for id in ordered.into_iter().take(APPROACH) {
            if self.waypoints.get(&id).is_some_and(|wp| wp.locked) {
                break;
            }
            doomed.push(id);
        }
        doomed
    }

    /// Drop up to two approach waypoints nearest a just-moved endpoint so the
    /// next reroute builds a clean approach into the block instead of threading
    /// the stale corners the drag left behind (which used to pin the approach
    /// column and row to the block's old position). The policy — which corners
    /// are doomed — is [`Self::approach_waypoint_ids`].
    pub fn trim_approach_waypoints(&mut self, end: RouteEnd) {
        for id in self.approach_waypoint_ids(end) {
            self.waypoints.shift_remove(&id);
        }
    }
    /// Remove any waypoint the wire doubles back on — a 180° turn *at* the
    /// waypoint, where the run arriving and the run leaving lie on the same axis
    /// in opposite directions. Strict waypoint routing produces these when a
    /// waypoint sits "behind" its neighbours (the wire overshoots to it and comes
    /// straight back); the autorouter itself never introduces a 180° turn, so a
    /// reversal is always a stale corner worth dropping. Applies regardless of
    /// `locked` — an explicit user corner that only makes the wire reverse is
    /// still just a kink. `start`/`end` are the route's resolved endpoints (the
    /// corners flanking the first and last waypoints). Returns whether anything
    /// was removed, so the caller re-routes to erase the reversal geometry.
    ///
    /// Reruns after each removal because dropping a corner can expose a reversal
    /// between the waypoints that were on either side of it.
    pub fn remove_backtracking_waypoints(&mut self, start: GridPos, end: GridPos) -> bool {
        let seq = self.waypoints.iter().map(|(&k, wp)| (k, wp.pos)).collect();
        let doomed = backtracking_waypoints(seq, start, end);
        let removed = !doomed.is_empty();
        for id in doomed {
            self.waypoints.shift_remove(&id);
        }
        removed
    }
    /// Shift every waypoint by `delta` grid cells. Used by paste to keep a
    /// route's manual waypoints aligned with the endpoints when the whole
    /// group is offset (a waypoint is stored in absolute grid space).
    pub fn translate_waypoints(&mut self, delta: super::GridVec) {
        for wp in self.waypoints.values_mut() {
            wp.pos = wp.pos + delta;
        }
    }
    pub fn route_name(&self) -> &str {
        &self.name
    }
    pub fn set_route_name(&mut self, name: String) {
        self.name = name;
    }
    /// The wire's accent index (`Some(0..=7)`), or `None` for the default color.
    pub fn role(&self) -> Option<u8> {
        self.role
    }
    /// Set the wire's accent index (`Some(0..=7)`) or clear it (`None`).
    pub fn set_role(&mut self, role: Option<u8>) {
        self.role = role;
    }
}