//! Cross-links: lines between any two nodes, besides the branches of the
//! tree.

use super::ids::NodeId;
use super::look::LineLook;
use super::text::Label;

/// Identifies the link between two nodes. Two nodes have at most one link
/// between them, whichever way it points, so the key is just the pair (the
/// smaller id first).
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct LinkKey {
    low: NodeId,
    high: NodeId,
}

impl LinkKey {
    /// The key for the link between `a` and `b`, or `None` when they're the
    /// same node (a node can't link to itself).
    pub fn new(a: NodeId, b: NodeId) -> Option<LinkKey> {
        if a == b {
            return None;
        }
        Some(LinkKey { low: a.min(b), high: a.max(b) })
    }

    /// Both nodes, the smaller id first.
    pub fn nodes(self) -> (NodeId, NodeId) {
        (self.low, self.high)
    }

    /// Whether `node` is one of the two ends.
    pub fn touches(self, node: NodeId) -> bool {
        self.low == node || self.high == node
    }
}

/// A cross-link between two nodes. It points from its start to its end, which
/// only matters for where the arrowheads go.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Link {
    key: LinkKey,
    /// True when the link points from the higher id to the lower one.
    downward: bool,
    /// Text shown in the middle of the line.
    pub label: Option<Label>,
    /// How the line is drawn.
    pub look: LineLook,
}

impl Link {
    /// A link from `start` to `end` with the theme's look, or `None` when
    /// they're the same node.
    pub fn new(start: NodeId, end: NodeId) -> Option<Link> {
        let key = LinkKey::new(start, end)?;
        Some(Link { key, downward: start > end, label: None, look: LineLook::default() })
    }

    /// The node the link starts from.
    pub fn start(&self) -> NodeId {
        if self.downward { self.key.high } else { self.key.low }
    }

    /// The node the link points to.
    pub fn end(&self) -> NodeId {
        if self.downward { self.key.low } else { self.key.high }
    }

    /// The pair of nodes it joins.
    pub fn key(&self) -> LinkKey {
        self.key
    }

    /// The same link, pointing the other way.
    pub fn reversed(self) -> Link {
        Link { downward: !self.downward, ..self }
    }
}

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

    #[test]
    fn a_link_keeps_its_direction_and_its_key_ignores_it() {
        let (a, b) = (NodeId::new(7), NodeId::new(3));
        let link = Link::new(a, b).unwrap();
        assert_eq!((link.start(), link.end()), (a, b));
        assert_eq!(link.key(), LinkKey::new(b, a).unwrap());
        let back = link.reversed();
        assert_eq!((back.start(), back.end()), (b, a));
        assert!(Link::new(a, a).is_none());
    }
}