monolith

use crate::geom::Rect;

use crate::plan::{Config, Plan, Strategy, Style, plan, plan_canonical};

use crate::{plan_blocks, validate};

use proptest::prelude::*;

const G: f64 = 10.0;

fn region() -> Rect {

    Rect::new(G, G, 1180.0, 680.0)

}

fn split(rect: Rect, ratios: &[f64], horizontal: bool) -> Vec<Rect> {

    let total: f64 = ratios.iter().sum();

    let len = if horizontal { rect.w } else { rect.h };

    let avail = len - G * (ratios.len() - 1) as f64;

    let mut pos = if horizontal { rect.x } else { rect.y };

    ratios

        .iter()

        .map(|r| {

            let size = avail * r / total;

            let out = if horizontal {

                Rect::new(pos, rect.y, size, rect.h)

            } else {

                Rect::new(rect.x, pos, rect.w, size)

            };

            pos += size + G;

            out

        })

        .collect()

}

fn cols(rect: Rect, n: usize) -> Vec<Rect> {

    split(rect, &vec![1.0; n], true)

}

fn rows(rect: Rect, n: usize) -> Vec<Rect> {

    split(rect, &vec![1.0; n], false)

}

fn cfg(style: Style) -> Config {

    Config {

        style,

        ..Config::default()

    }

}

fn assert_clean(p: &Plan, c: &Config) {

    let v = validate(p, c);

    assert!(v.is_empty(), "violations {v:?} in {p:?}");

    assert!(p.phases() <= 4, "{} phases", p.phases());

    assert!(

        p.groups.iter().all(|g| g.strategy != Strategy::Pinch),

        "fell back to pinch: {p:?}"

    );

}

fn strategy(p: &Plan) -> Strategy {

    p.groups

        .iter()

        .map(|g| g.strategy)

        .find(|s| *s != Strategy::Unchanged)

        .unwrap_or(Strategy::Unchanged)

}

#[test]

fn full_reversal_needs_one_lane_per_window() {

    let c = cfg(Style::Orthogonal);

    let a = cols(region(), 4);

    let b: Vec<Rect> = (0..4).map(|i| a[3 - i]).collect();

    let p = plan(&a, &b, &c);

    assert_clean(&p, &c);

    assert_eq!(strategy(&p), Strategy::Lanes { lanes: 4 });

}

#[test]

fn growing_both_axes_depends_on_style() {

    let grid = |wide: bool| {

        let r = if wide { [7.0, 3.0] } else { [1.0, 1.0] };

        let rs = split(region(), &r, false);

        let mut out = split(rs[0], &r, true);

        out.extend(split(rs[1], &[1.0, 1.0], true));

        out

    };

    let o = cfg(Style::Orthogonal);

    let d = cfg(Style::Direct);

    let po = plan(&grid(false), &grid(true), &o);

    let pd = plan(&grid(false), &grid(true), &d);

    assert_clean(&po, &o);

    assert_clean(&pd, &d);

    assert_eq!((po.phases(), pd.phases()), (2, 1));

}

#[test]

fn insert_and_split_rewinds() {

    let c = cfg(Style::Orthogonal);

    let layout = |on: bool| {

        let n = if on { 4 } else { 3 };

        let ratios: Vec<f64> = (0..n)

            .map(|i| if i == 0 && on { 2.0 } else { 1.0 })

            .collect();

        let cs = split(region(), &ratios, true);

        let (a, mut b, c3) = (cs[0], cs[1], cs[n - 1]);

        let d = if on {

            cs[2]

        } else {

            Rect::new((b.right() + c3.x) / 2.0, b.y, 0.0, b.h)

        };

        let e = if on {

            let s = rows(b, 2);

            b = s[0];

            s[1]

        } else {

            Rect::new(b.x, b.bottom(), b.w, 0.0)

        };

        vec![a, b, c3, d, e]

    };

    let on = plan(&layout(false), &layout(true), &c);

    let off = plan(&layout(true), &layout(false), &c);

    assert_clean(&on, &c);

    assert_clean(&off, &c);

    assert!(on.groups.iter().all(|g| !g.opens_hole));

    let mut rewound = off.keyframes.clone();

    rewound.reverse();

    assert_eq!(on.keyframes, rewound);

}

#[test]

fn tag_rows_swap_rigidly_with_two_lanes() {

    let c = cfg(Style::Orthogonal);

    let layout = |first_top: bool| {

        let rs = rows(region(), 2);

        let (t1, t2) = if first_top {

            (rs[0], rs[1])

        } else {

            (rs[1], rs[0])

        };

        let mut out = cols(t1, 3);

        out.extend(cols(t2, 2));

        out

    };

    let blocks = vec![vec![0, 1, 2], vec![3, 4]];

    let p = plan_blocks(&layout(true), &layout(false), &blocks, &c);

    assert_clean(&p, &c);

    assert_eq!(strategy(&p), Strategy::Lanes { lanes: 2 });

}

#[test]

fn simultaneous_reversals_on_both_axes_use_the_grid() {

    let c = cfg(Style::Orthogonal);

    let halves = cols(region(), 2);

    let (l, r) = (rows(halves[0], 2), rows(halves[1], 2));

    let from = vec![l[0], r[1], r[0], l[1]];

    let left3 = rows(halves[0], 3);

    let to = vec![left3[0], left3[1], left3[2], halves[1]];

    let p = plan(&from, &to, &c);

    assert_clean(&p, &c);

    assert!(matches!(strategy(&p), Strategy::Grid { .. }));

}

struct Rng(u64);

impl Rng {

    fn next(&mut self) -> u64 {

        self.0 ^= self.0 << 13;

        self.0 ^= self.0 >> 7;

        self.0 ^= self.0 << 17;

        self.0

    }

    fn below(&mut self, n: usize) -> usize {

        (self.next() % n as u64) as usize

    }

    fn unit(&mut self) -> f64 {

        (self.next() >> 11) as f64 / (1u64 << 53) as f64

    }

}

fn random_layout(rng: &mut Rng, n: usize) -> Vec<Rect> {

    let mut ids: Vec<usize> = (0..n).collect();

    for i in (1..n).rev() {

        ids.swap(i, rng.below(i + 1));

    }

    let mut out = vec![Rect::default(); n];

    let horizontal = rng.below(2) == 0;

    build(rng, &ids, region(), horizontal, &mut out);

    out

}

fn build(rng: &mut Rng, ids: &[usize], rect: Rect, horizontal: bool, out: &mut [Rect]) {

    if let [only] = ids {

        out[*only] = rect;

        return;

    }

    let k = ids.len().min(2 + rng.below(2));

    let mut cuts = Vec::with_capacity(k);

    let mut rest = ids;

    for i in 0..k {

        let take = if i == k - 1 {

            rest.len()

        } else {

            1 + rng.below(rest.len() - (k - 1 - i))

        };

        let (head, tail) = rest.split_at(take);

        cuts.push(head);

        rest = tail;

    }

    let ratios: Vec<f64> = cuts.iter().map(|_| 0.5 + rng.unit()).collect();

    for (part, ids) in split(rect, &ratios, horizontal).into_iter().zip(cuts) {

        build(rng, ids, part, !horizontal, out);

    }

}

proptest! {

    #![proptest_config(ProptestConfig::with_cases(512))]

    #[test]

    fn random_transitions_plan_cleanly(seed in 1u64.., n in 2usize..9, direct: bool) {

        let mut rng = Rng(seed);

        let c = cfg(if direct { Style::Direct } else { Style::Orthogonal });

        let (a, b) = (random_layout(&mut rng, n), random_layout(&mut rng, n));

        let p = plan(&a, &b, &c);

        assert_clean(&p, &c);

        prop_assert_eq!(&p.keyframes[0], &a);

        prop_assert_eq!(p.keyframes.last().unwrap(), &b);

    }

    #[test]

    fn planning_back_rewinds(seed in 1u64.., n in 2usize..9) {

        let mut rng = Rng(seed);

        let c = cfg(Style::Orthogonal);

        let (a, b) = (random_layout(&mut rng, n), random_layout(&mut rng, n));

        let mut back = plan_canonical(&b, &a, &c).keys;

        back.reverse();

        prop_assert_eq!(plan_canonical(&a, &b, &c).keys, back);

    }

    #[test]

    fn closing_while_spawning_never_pinches(seed in 1u64.., n in 2usize..9, edge in 0usize..3, direct: bool) {

        let mut rng = Rng(seed);

        let c = cfg(if direct { Style::Direct } else { Style::Orthogonal });

        let a = random_layout(&mut rng, n);

        let v = rng.below(n);

        let at = [a[v].x - G / 2.0, a[v].center_x(), a[v].right() + G / 2.0][edge];

        let line = Rect::new(at, a[v].y, 0.0, a[v].h);

        let mut from = a.clone();

        from.push(line);

        let mut to = a.clone();

        to[v] = Rect::new(a[v].center_x(), a[v].y, 0.0, a[v].h);

        to.push(a[v]);

        let p = plan(&from, &to, &c);

        prop_assert!(validate(&p, &c).is_empty(), "{:?}", p);

        prop_assert!(p.groups.iter().all(|g| g.strategy != Strategy::Pinch), "{:?}", p);

    }

    #[test]

    fn interrupts_replan_cleanly(seed in 1u64.., n in 2usize..9, at in 0.0f64..1.0, s in 0.0f64..1.0) {

        let mut rng = Rng(seed);

        let c = cfg(Style::Orthogonal);

        let (a, b, d) = (random_layout(&mut rng, n), random_layout(&mut rng, n), random_layout(&mut rng, n));

        let first = plan(&a, &b, &c);

        if first.phases() == 0 {

            return Ok(());

        }

        let phase = ((at * first.phases() as f64) as usize).min(first.phases() - 1);

        let mid = first.sample(phase, s);

        let second = plan(&mid, &d, &c);

        assert_clean(&second, &c);

        prop_assert_eq!(&second.keyframes[0], &mid);

    }

}

/// A hidden window is a zero-size seed. One sitting inside a visible window

/// used to join its group and make every strategy fail, so the plan pinched.

#[test]

fn hidden_seeds_stay_out_of_the_plan() {

    let c = cfg(Style::Orthogonal);

    let a = cols(region(), 2);

    let seed = |r: Rect| Rect::new(r.center_x(), r.center_y(), 0.0, 0.0);

    let from = vec![a[0], a[1], seed(a[0])];

    let to = vec![a[1], a[0], seed(a[1])];

    let p = plan(&from, &to, &c);

    assert_clean(&p, &c);

    assert!(p.groups.iter().all(|g| !g.members.contains(&2)));

    assert!(p.keyframes.iter().all(|k| k[2] == to[2]));

}

/// A window closes in the slot where another opens. The ghost shrinks to a

/// seed inside its own full rect while the newcomer grows from a seed on the

/// same line, so no single set of phases keeps them apart and every strategy

/// used to fail until the plan pinched the whole output.

#[test]

fn closing_and_spawning_in_one_slot_plan_in_stages() {

    let c = cfg(Style::Orthogonal);

    let t = cols(region(), 3);

    let seed = Rect::new(600.0, 10.0, 0.0, 680.0);

    let from = vec![t[0], t[1], t[2], seed];

    let to = vec![t[0], seed, t[2], t[1]];

    let p = plan(&from, &to, &c);

    assert!(validate(&p, &c).is_empty(), "{p:?}");

    assert!(p.groups.iter().all(|g| g.strategy != Strategy::Pinch));

    assert_eq!(p.phases(), 2);

    assert_eq!(p.keyframes[1], vec![t[0], seed, t[2], seed]);

}