//! The history graph's lane layout is `oxy_core::lanes`, shared with `oxy

//! log`; this module only adapts hex hashes from views to it.

pub use oxy_core::lanes::{width, Row};

/// `changes` newest first as `(hash hex, deps hex)`.

pub fn layout(changes: &[(String, Vec<String>)]) -> Vec<Row> {

    let parse = |h: &str| oxy_core::hash::ObjectRef::from_hex(h).unwrap_or(oxy_core::hash::ObjectRef([0; 32]));

    let input: Vec<(oxy_core::hash::ChangeHash, Vec<oxy_core::hash::ChangeHash>)> =

        changes.iter().map(|(h, d)| (parse(h), d.iter().map(|x| parse(x)).collect())).collect();

    oxy_core::lanes::layout(&input)

}

/// A card on the swimlane board (hub spec §6.7): one change, placed by its

/// lane (row) and its age (column, oldest on the left).

#[derive(Clone, Debug, PartialEq)]

pub struct Card {

    pub hash: String,

    pub short: String,

    pub title: String,

    pub x: usize,

    pub y: usize,

    pub head: bool,

}

/// The swimlane board: cards and the dependency edges between them.

#[derive(Clone, Debug, PartialEq)]

pub struct Board {

    pub cards: Vec<Card>,

    /// SVG path data, from a change to each change of the board it depends on.

    pub edges: Vec<String>,

    pub width: usize,

    pub height: usize,

    pub lanes: usize,

}

pub const CARD_W: usize = 150;

pub const CARD_H: usize = 34;

const GAP_X: usize = 40;

const GAP_Y: usize = 22;

/// Lay `changes` (newest first, as for [`layout`]) out as swimlanes: each

/// lane a row, time running left to right. Independent work sits in

/// separate lanes; there are no merge nodes, only dependency edges.

pub fn board(changes: &[crate::repos::view::ChangeView]) -> Board {

    let input: Vec<(String, Vec<String>)> = changes.iter().map(|c| (c.hash.clone(), c.deps.clone())).collect();

    let rows = layout(&input);

    let n = changes.len();

    let pos: std::collections::HashMap<&str, (usize, usize)> = changes

        .iter()

        .zip(&rows)

        .enumerate()

        .map(|(i, (c, r))| (c.hash.as_str(), ((n - 1 - i) * (CARD_W + GAP_X) + 10, r.lane * (CARD_H + GAP_Y) + 10)))

        .collect();

    let cards = changes

        .iter()

        .map(|c| {

            let (x, y) = pos[c.hash.as_str()];

            let mut title: String = c.title.chars().take(22).collect();

            if c.title.chars().count() > 22 {

                title.push('…');

            }

            Card { hash: c.hash.clone(), short: c.short.clone(), title, x, y, head: c.head }

        })

        .collect();

    let mut edges = Vec::new();

    for c in changes {

        let (cx, cy) = pos[c.hash.as_str()];

        for d in &c.deps {

            if let Some(&(dx, dy)) = pos.get(d.as_str()) {

                // From the dependency's right edge to the change's left edge.

                let (x1, y1, x2, y2) = (dx + CARD_W, dy + CARD_H / 2, cx, cy + CARD_H / 2);

                let mid = (x1 + x2) / 2;

                edges.push(format!("M{x1} {y1} C{mid} {y1} {mid} {y2} {x2} {y2}"));

            }

        }

    }

    let lanes = width(&rows).max(1);

    Board { cards, edges, width: n.max(1) * (CARD_W + GAP_X) + 20, height: lanes * (CARD_H + GAP_Y) + 20, lanes }

}

#[cfg(test)]

mod board_tests {

    use super::*;

    use crate::repos::view::{AuthorView, ChangeView, SigView};

    fn change(hash: char, title: &str, deps: &[char]) -> ChangeView {

        let h = |c: char| std::iter::repeat_n(c, 64).collect::<String>();

        ChangeView {

            hash: h(hash),

            short: h(hash)[..8].to_string(),

            title: title.into(),

            body: String::new(),

            author: AuthorView { name: String::new(), email: String::new(), key: String::new(), unknown: true, account: None },

            when_ms: 0,

            deps: deps.iter().map(|d| h(*d)).collect(),

            head: false,

            resolution: false,

            signature: SigView::Unsigned,

            labels: vec![],

        }

    }

    #[test]

    fn independent_work_gets_its_own_lane() {

        // Newest first: c depends on a; b is independent of both.

        let changes = vec![change('c', "c on a", &['a']), change('b', "b alone", &[]), change('a', "base", &[])];

        let b = board(&changes);

        assert_eq!(b.cards.len(), 3);

        let card = |h: char| b.cards.iter().find(|c| c.hash.starts_with(h)).unwrap().clone();

        assert!(card('a').x < card('b').x && card('b').x < card('c').x, "oldest on the left");

        assert_eq!(card('a').y, card('c').y, "a chain stays in one lane");

        assert_ne!(card('b').y, card('a').y, "independent work in its own lane");

        assert_eq!(b.edges.len(), 1, "one dependency, no merge nodes");

        assert!(b.lanes >= 2);

        let long = board(&[change('d', "a title far longer than the card can hold", &[])]);

        assert!(long.cards[0].title.ends_with('…') && long.cards[0].title.chars().count() == 23);

    }

}