pub mod line_segment;
pub mod polygon;
pub mod polygon_graph;
pub mod rect;
pub mod triangle;
pub mod triangulate;
pub mod vec2;

pub use self::line_segment::*;
pub use self::polygon::*;
pub use self::polygon_graph::*;
pub use self::rect::*;
pub use self::triangle::*;
pub use self::triangulate::*;
pub use self::vec2::*;

use std::cmp::Ordering;

/// Round a floating point number to the nearest step given by the step argument. For instance, if
/// the step is 0.5, then all numbers from 0.0 to 0.24999... will be 0., while all numbers from
/// 0.25 to 0.74999... will be 0.5 and so on.
pub fn round(num: f32, step: f32) -> f32 {
    // Only positive steps will be accepted.
    assert!(step > 0.);

    let lower_bound = ((num / step) as i32) as f32 * step;
    let upper_bound = lower_bound + step;

    // Compare the distances and prefer the smaller. If they are the same, prefer the upper bound.
    if (num - lower_bound) < (upper_bound - num) {
        lower_bound
    } else {
        upper_bound
    }
}

/// Works like `std::cmp::max`, however also allows partial comparisons. It is specifically
/// designed so functions that should be able to use f32 and f64 work, eventhough these do not
/// implement Ord. The downside of this function however is, that its behaviour is undefined when
/// `f32::NaN` for instance were to be passed.
pub(crate) fn partial_max<T>(a: T, b: T) -> T
where
    T: PartialOrd,
{
    match a.partial_cmp(&b) {
        Some(Ordering::Greater) => a,
        _ => b,
    }
}
/// Like `partial_max`, but for minimum values. Comes with the same downside, too.
pub(crate) fn partial_min<T>(a: T, b: T) -> T
where
    T: PartialOrd,
{
    match a.partial_cmp(&b) {
        Some(Ordering::Less) => a,
        _ => b,
    }
}

#[cfg(test)]
mod test {
    #[test]
    fn partial_max() {
        assert_eq!(super::partial_max(0., 0.), 0.);
        assert_eq!(super::partial_max(-1., 1.), 1.);
        assert_eq!(super::partial_max(-2., -1.), -1.);
        assert_eq!(super::partial_max(2., 1.), 2.);
    }

    #[test]
    fn partial_min() {
        assert_eq!(super::partial_min(0., 0.), 0.);
        assert_eq!(super::partial_min(-1., 1.), -1.);
        assert_eq!(super::partial_min(-2., -1.), -2.);
        assert_eq!(super::partial_min(2., 1.), 1.);
    }
}