monolith

use crate::geom::Rect;

use crate::plan::{Config, Group, Plan, plan};

/// Plans with each block moving rigidly, for moves whose unit is a whole

/// container such as reordering viewed tags. Blocks must partition the

/// windows, and every window must keep its place inside its block.

pub fn plan_blocks(from: &[Rect], to: &[Rect], blocks: &[Vec<usize>], cfg: &Config) -> Plan {

    let bounds = |l: &[Rect]| -> Vec<Rect> {

        blocks

            .iter()

            .map(|b| Rect::bounding(b.iter().map(|&i| &l[i])))

            .collect()

    };

    let (bf, bt) = (bounds(from), bounds(to));

    let bp = plan(&bf, &bt, cfg);

    let last = bp.keyframes.len() - 1;

    let keyframes = bp

        .keyframes

        .iter()

        .enumerate()

        .map(|(k, key)| match k {

            0 => from.to_vec(),

            k if k == last => to.to_vec(),

            _ => {

                let mut frame = from.to_vec();

                for (b, members) in blocks.iter().enumerate() {

                    for &i in members {

                        frame[i] = reframe(&from[i], &bf[b], &key[b]);

                    }

                }

                frame

            }

        })

        .collect();

    let groups = bp

        .groups

        .into_iter()

        .map(|g| Group {

            members: g

                .members

                .iter()

                .flat_map(|&b| blocks[b].iter().copied())

                .collect(),

            ..g

        })

        .collect();

    Plan { keyframes, groups }

}

fn reframe(r: &Rect, from: &Rect, to: &Rect) -> Rect {

    let scale = |v: f64, len: f64| if len > 0.0 { v / len } else { 0.0 };

    Rect::new(

        to.x + scale(r.x - from.x, from.w) * to.w,

        to.y + scale(r.y - from.y, from.h) * to.h,

        scale(r.w, from.w) * to.w,

        scale(r.h, from.h) * to.h,

    )

}