monolith

use crate::geom::{Change, Rect};

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum Violation {

    /// Windows `a` and `b` overlap at some point during `phase`.

    Overlap { phase: usize, a: usize, b: usize },

    /// In orthogonal style, `window` changes both axes during `phase`.

    TwoAxes { phase: usize, window: usize },

}

/// Exact check of a plan under linear interpolation. Every window in a phase

/// shares one curve, so overlap depends only on the keyframes, not the easing.

pub fn validate(plan: &Plan, cfg: &Config) -> Vec<Violation> {

    let mut out = Vec::new();

    for (phase, pair) in plan.keyframes.windows(2).enumerate() {

        let (a, b) = (&pair[0], &pair[1]);

        for i in 0..a.len() {

            if cfg.style == Style::Orthogonal && Change::between(&a[i], &b[i]).both() {

                out.push(Violation::TwoAxes { phase, window: i });

            }

            for j in i + 1..a.len() {

                if overlaps_during(&a[i], &b[i], &a[j], &b[j], cfg.eps) {

                    out.push(Violation::Overlap { phase, a: i, b: j });

                }

            }

        }

    }

    out

}

/// Whether two linearly moving rectangles share more than `tol` of width and

/// height at any instant. Each condition is linear in time, so the set of

/// instants satisfying all of them is an interval.

fn overlaps_during(a0: &Rect, a1: &Rect, b0: &Rect, b1: &Rect, tol: f64) -> bool {

    let conditions = [

        (a0.w, a1.w),

        (b0.w, b1.w),

        (a0.right() - b0.x, a1.right() - b1.x),

        (b0.right() - a0.x, b1.right() - a1.x),

        (a0.h, a1.h),

        (b0.h, b1.h),

        (a0.bottom() - b0.y, a1.bottom() - b1.y),

        (b0.bottom() - a0.y, b1.bottom() - a1.y),

    ];

    let (mut lo, mut hi) = (0.0f64, 1.0f64);

    for (v0, v1) in conditions {

        let slope = v1 - v0;

        if slope.abs() < 1e-12 {

            if v0 <= tol {

                return false;

            }

            continue;

        }

        let root = (tol - v0) / slope;

        if slope > 0.0 {

            lo = lo.max(root);

        } else {

            hi = hi.min(root);

        }

    }

    lo < hi - 1e-9

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn zero_size_seed_inside_a_window_is_not_an_overlap() {

        let a = Rect::new(0.0, 0.0, 100.0, 100.0);

        let seed = Rect::new(50.0, 0.0, 0.0, 100.0);

        assert!(!overlaps_during(&a, &a, &seed, &seed, 0.5));

    }

}