monolith

use super::*;

use proptest::prelude::*;

const AREA: Rect = Rect::new(0.0, 0.0, 1000.0, 600.0);

#[derive(Clone, Debug)]

enum Op {

    Add(u8, bool),

    Remove(u8),

    Focus(u8),

    Move(Dir),

    Block(Dir),

    Merge(Dir),

    View(u8),

    ToggleView(u8),

    Retag(u8, u8),

    Float(u8),

    Expand(u8),

    Flip,

    Resize(bool, i8),

    Scratch(u8),

    Summon,

    Unplug,

    Replug,

}

fn dir() -> impl Strategy<Value = Dir> {

    prop_oneof![

        Just(Dir::Left),

        Just(Dir::Right),

        Just(Dir::Up),

        Just(Dir::Down)

    ]

}

fn op() -> impl Strategy<Value = Op> {

    prop_oneof![

        4 => (0u8..4, prop::bool::weighted(0.15)).prop_map(|(t, f)| Op::Add(t, f)),

        1 => any::<u8>().prop_map(Op::Remove),

        3 => any::<u8>().prop_map(Op::Focus),

        4 => dir().prop_map(Op::Move),

        2 => dir().prop_map(Op::Block),

        3 => dir().prop_map(Op::Merge),

        1 => (0u8..4).prop_map(Op::View),

        2 => (0u8..4).prop_map(Op::ToggleView),

        1 => (any::<u8>(), 0u8..4).prop_map(|(w, t)| Op::Retag(w, t)),

        1 => any::<u8>().prop_map(Op::Float),

        1 => (0u8..3).prop_map(Op::Expand),

        1 => Just(Op::Flip),

        1 => (any::<bool>(), any::<i8>()).prop_map(|(a, d)| Op::Resize(a, d)),

        1 => any::<u8>().prop_map(Op::Scratch),

        1 => Just(Op::Summon),

        1 => Just(Op::Unplug),

        1 => Just(Op::Replug),

    ]

}

fn nth(l: &Layout, i: u8) -> Option<WindowId> {

    let ids: Vec<WindowId> = l.windows().map(|(id, _)| id).collect();

    (!ids.is_empty()).then(|| ids[i as usize % ids.len()])

}

fn apply(l: &mut Layout, tags: &[TagId], op: &Op) {

    let active = l.active_output();

    match *op {

        Op::Add(t, f) => {

            let w = l.add_window(

                None,

                Some(tags[t as usize]),

                f.then(|| Rect::new(10.0, 10.0, 200.0, 100.0)),

            );

            if l.visible(w) {

                l.focus(w);

            }

        }

        Op::Remove(i) => nth(l, i).into_iter().for_each(|w| l.remove_window(w)),

        Op::Focus(i) => {

            if let Some(w) = nth(l, i).filter(|&w| l.visible(w)) {

                l.focus(w);

            }

        }

        Op::Move(d) => {

            l.move_window(d);

        }

        Op::Block(d) => {

            l.move_container(d);

        }

        Op::Merge(d) => {

            l.merge_window(d);

        }

        Op::View(t) => active.into_iter().for_each(|o| l.view(o, tags[t as usize])),

        Op::ToggleView(t) => active

            .into_iter()

            .for_each(|o| l.toggle_view(o, tags[t as usize])),

        Op::Retag(i, t) => nth(l, i)

            .into_iter()

            .for_each(|w| l.set_tag(w, tags[t as usize])),

        Op::Float(i) => nth(l, i).into_iter().for_each(|w| l.toggle_floating(w)),

        Op::Expand(s) => {

            l.expand(

                [

                    ExpandScope::Window,

                    ExpandScope::Container,

                    ExpandScope::All,

                ][s as usize],

            );

        }

        Op::Flip => active.into_iter().for_each(|o| l.flip(o)),

        Op::Resize(h, d) => {

            let axis = if h { Axis::Horizontal } else { Axis::Vertical };

            l.resize(axis, f64::from(d) / 200.0);

        }

        Op::Scratch(i) => nth(l, i).into_iter().for_each(|w| l.scratchpad_add(w, "s")),

        Op::Summon => {

            l.summon("s");

        }

        Op::Unplug => {

            let b = l.outputs().find(|(_, out)| out.name == "b").map(|(o, _)| o);

            if let Some(o) = b {

                l.remove_output(o);

            }

        }

        Op::Replug => {

            if !l.outputs().any(|(_, out)| out.name == "b") {

                l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

            }

        }

    }

}

fn check_geometry(l: &Layout) {

    for (o, out) in l.outputs() {

        let arr = l.arrange(o);

        let mut drawn: Vec<WindowId> = arr

            .tiled

            .iter()

            .filter(|p| p.visible)

            .map(|p| p.window)

            .chain(arr.floating.iter().map(|&(w, _)| w))

            .chain(arr.fullscreen)

            .collect();

        drawn.sort();

        drawn.dedup();

        let mut visible: Vec<WindowId> = l

            .windows()

            .filter(|&(w, win)| win.output == Some(o) && l.visible(w))

            .map(|(w, _)| w)

            .collect();

        visible.sort();

        assert_eq!(drawn, visible, "arrangement disagrees with visible()");

        let shown: Vec<Rect> = arr

            .tiled

            .iter()

            .filter(|p| p.visible)

            .map(|p| p.rect)

            .collect();

        for p in arr.tiled.iter().filter(|p| !p.visible) {

            assert!(p.rect.w * p.rect.h <= 1e-6, "hidden {:?} has area", p.rect);

        }

        for r in &shown {

            assert!(r.w >= 0.0 && r.h >= 0.0);

            assert!(r.x >= out.area.x - 1e-6 && r.right() <= out.area.right() + 1e-6);

            assert!(r.y >= out.area.y - 1e-6 && r.bottom() <= out.area.bottom() + 1e-6);

        }

        for (i, a) in shown.iter().enumerate() {

            for b in &shown[i + 1..] {

                let ox = a.right().min(b.right()) - a.x.max(b.x);

                let oy = a.bottom().min(b.bottom()) - a.y.max(b.y);

                assert!(ox <= 1e-6 || oy <= 1e-6, "{a:?} overlaps {b:?}");

            }

        }

    }

}

proptest! {

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

    #[test]

    fn random_commands_keep_the_model_sound(ops in prop::collection::vec(op(), 1..80)) {

        let mut l = Layout::default();

        l.add_output("a", AREA);

        l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

        let tags = [l.homeless(), l.tag("1"), l.tag("2"), l.tag("3")];

        for op in &ops {

            apply(&mut l, &tags, op);

            l.check();

            check_geometry(&l);

        }

    }

    #[test]

    fn replugging_restores_what_unplugging_moved(ops in prop::collection::vec(op(), 1..60)) {

        let mut l = Layout::default();

        l.add_output("a", AREA);

        l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

        let tags = [l.homeless(), l.tag("1"), l.tag("2"), l.tag("3")];

        for op in &ops {

            apply(&mut l, &tags, op);

        }

        let Some(b) = l.outputs().find(|(_, out)| out.name == "b").map(|(o, _)| o) else {

            return Ok(());

        };

        let before = |l: &Layout, o| {

            let out = l.output(o).unwrap();

            (out.tree.windows().collect::<Vec<_>>(), out.floating.clone(), out.viewed.clone())

        };

        let was = before(&l, b);

        l.remove_output(b);

        let b = l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));

        l.check();

        prop_assert_eq!(before(&l, b), was);

    }

}

/// The hidden-slot rules from planner.html, demo 11.

#[test]

fn hidden_windows_keep_their_slots() {

    let (a, b, c, d, e) = (1, 2, 3, 4, 5);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(a);

    t.insert_after(d, a);

    t.insert_after(b, d);

    t.insert_row(c);

    t.insert_after(e, c);

    t.check();

    let hidden = |w: u32| w != d && w != e;

    let all = |_| true;

    let rect = |t: &Tree<u32>, w| {

        t.arrange(AREA, 0.0, all)

            .into_iter()

            .find(|p| p.0 == w)

            .unwrap()

            .1

    };

    assert!(t.move_window(a, Dir::Right, hidden));

    assert!(rect(&t, b).x < rect(&t, d).x && rect(&t, d).x < rect(&t, a).x);

    assert!(t.move_window(c, Dir::Up, hidden));

    t.check();

    assert_eq!(rect(&t, e).w, AREA.w, "E is demoted to a row of its own");

}

/// Moving out of a row toward a lane of hidden windows joins that lane, so

/// they share it when shown again instead of a new lane opening between.

#[test]

fn moving_toward_a_hidden_lane_joins_it() {

    let (a, b, c, d, e) = (1, 2, 3, 4, 5);

    let mut t: Tree<u32> = Tree::default();

    t.insert_row(a);

    t.insert_after(b, a);

    t.insert_after(c, b);

    t.insert_row(d);

    t.insert_after(e, c);

    let tag_two = |w: u32| w != a && w != d;

    assert!(t.move_window(e, Dir::Down, tag_two));

    t.check();

    let all = t.arrange(AREA, 0.0, |_| true);

    let rect = |w| all.iter().find(|p| p.0 == w).unwrap().1;

    assert_eq!(rect(e).y, rect(d).y);

    assert!(rect(d).x < rect(e).x);

    assert!(rect(a).y < rect(d).y);

}

#[test]

fn merging_steps_out_of_a_stack_before_joining_another() {

    let (a, b, c) = (1, 2, 3);

    let stacked = || {

        let mut t: Tree<u32> = Tree::default();

        t.insert_row(a);

        t.insert_after(b, a);

        t.insert_after(c, b);

        assert!(t.merge_window(b, Dir::Left, |_| true));

        t

    };

    let rects = |t: &Tree<u32>| {

        t.check();

        let all = t.arrange(AREA, 0.0, |_| true);

        move |w| all.iter().find(|p: &&(u32, Rect)| p.0 == w).unwrap().1

    };

    let mut t = stacked();

    assert!(t.merge_window(a, Dir::Right, |_| true));

    let rect = rects(&t);

    assert!(rect(b).x < rect(a).x && rect(a).x < rect(c).x);

    assert_eq!(rect(a).h, AREA.h);

    assert!(t.merge_window(a, Dir::Right, |_| true));

    let rect = rects(&t);

    assert_eq!(rect(a).x, rect(c).x);

    let mut t = stacked();

    assert!(t.merge_window(a, Dir::Up, |_| true));

    let rect = rects(&t);

    assert_eq!(rect(a).w, AREA.w);

    assert!(rect(a).bottom() <= rect(b).y && rect(b).y == rect(c).y);

}