use crate::vec3::{Point3};
use crate::ray::{Ray};
use std::mem;

#[derive(Copy, Debug, Clone)]
pub struct Aabb {
    pub minimum: Point3,
    pub maximum: Point3,
}

impl Aabb {
    pub fn min(&self) -> Point3 { self.minimum }
    pub fn max(&self) -> Point3 { self.maximum }
}

impl Default for Aabb {
    fn default() -> Self {
        Aabb {minimum: Point3::default(), maximum: Point3::default() }
    }
}

impl Aabb {
    pub fn hit(&self, ray: &Ray, mut t_min: f64, mut t_max: f64) -> bool {
        for a in 0..3 {
            let inv_d = 1.0 / ray.direction()[a];
            let mut t0 = (self.minimum[a] - ray.origin()[a]) * inv_d;
            let mut t1 = (self.maximum[a] - ray.origin()[a]) * inv_d;
            if inv_d < 0.0 {
                mem::swap(&mut t0, &mut t1);
            }
            t_min = t_min.max(t0);
            t_max = t_max.min(t1);
            if t_max <= t_min {
                return false;
            }
        }
        true
    }
    pub fn surrounding(&self, other: &Aabb) -> Aabb {
        let minimum = Point3::new(
            self.minimum.x().min(other.minimum.x()),
            self.minimum.y().min(other.minimum.y()),
            self.minimum.z().min(other.minimum.z()));
        let maximum = Point3::new(
            self.maximum.x().max(other.maximum.x()),
            self.maximum.y().max(other.maximum.y()),
            self.maximum.z().max(other.maximum.z()));
        Aabb {minimum, maximum}
    }
}