use crate::*;

mod layout_align; pub use self::layout_align::*;
mod layout_bsp;   pub use self::layout_bsp::*;
mod layout_cond;  pub use self::layout_cond::*;
mod layout_map;   pub use self::layout_map::*;
mod layout_pad;   pub use self::layout_pad::*;
mod layout_move;  pub use self::layout_move::*;
mod layout_size;  pub use self::layout_size::*;
mod layout_stack;  //pub use self::layout_stack::*;

/// Drawable area of display.
pub trait Layout<O: Out> {
    fn x (&self, to: O::Area) -> O::Unit {
        to.x()
    }
    fn y (&self, to: O::Area) -> O::Unit {
        to.y()
    }
    fn min_w (&self, _to: O::Area) -> O::Unit {
        0.into()
    }
    fn max_w (&self, to: O::Area) -> O::Unit {
        to.w()
    }
    fn w (&self, to: O::Area) -> O::Unit {
        to.w().max(self.min_w(to)).min(self.max_w(to))
    }
    fn min_h (&self, _to: O::Area) -> O::Unit {
        0.into()
    }
    fn max_h (&self, to: O::Area) -> O::Unit {
        to.h()
    }
    fn h (&self, to: O::Area) -> O::Unit {
        to.h().max(self.min_h(to)).min(self.max_h(to))
    }
    fn layout (&self, to: O::Area) -> O::Area {
        [self.x(to), self.y(to), self.w(to), self.h(to)].into()
    }
}

impl<O: Out> Layout<O> for () {
    fn x      (&self, a: O::Area) -> O::Unit { a.x() }
    fn y      (&self, a: O::Area) -> O::Unit { a.y() }
    fn w      (&self, _: O::Area) -> O::Unit { 0.into() }
    fn min_w  (&self, _: O::Area) -> O::Unit { 0.into() }
    fn max_w  (&self, _: O::Area) -> O::Unit { 0.into() }
    fn h      (&self, _: O::Area) -> O::Unit { 0.into() }
    fn min_h  (&self, _: O::Area) -> O::Unit { 0.into() }
    fn max_h  (&self, _: O::Area) -> O::Unit { 0.into() }
    fn layout (&self, a: O::Area) -> O::Area { [a.x(), a.y(), 0.into(), 0.into()].into() }
}

impl<O: Out, L: Layout<O>> Layout<O> for &L {
    fn x      (&self, a: O::Area) -> O::Unit { (*self).x(a) }
    fn y      (&self, a: O::Area) -> O::Unit { (*self).y(a) }
    fn w      (&self, a: O::Area) -> O::Unit { (*self).w(a) }
    fn min_w  (&self, a: O::Area) -> O::Unit { (*self).min_w(a) }
    fn max_w  (&self, a: O::Area) -> O::Unit { (*self).max_w(a) }
    fn h      (&self, a: O::Area) -> O::Unit { (*self).h(a) }
    fn min_h  (&self, a: O::Area) -> O::Unit { (*self).min_h(a) }
    fn max_h  (&self, a: O::Area) -> O::Unit { (*self).max_h(a) }
    fn layout (&self, a: O::Area) -> O::Area { (*self).layout(a) }
}

impl<O: Out, L: Layout<O>> Layout<O> for &mut L {
    fn x      (&self, a: O::Area) -> O::Unit { (**self).x(a) }
    fn y      (&self, a: O::Area) -> O::Unit { (**self).y(a) }
    fn w      (&self, a: O::Area) -> O::Unit { (**self).w(a) }
    fn min_w  (&self, a: O::Area) -> O::Unit { (**self).min_w(a) }
    fn max_w  (&self, a: O::Area) -> O::Unit { (**self).max_w(a) }
    fn h      (&self, a: O::Area) -> O::Unit { (**self).h(a) }
    fn min_h  (&self, a: O::Area) -> O::Unit { (**self).min_h(a) }
    fn max_h  (&self, a: O::Area) -> O::Unit { (**self).max_h(a) }
    fn layout (&self, a: O::Area) -> O::Area { (**self).layout(a) }
}

impl<O: Out, L: Layout<O>> Layout<O> for Arc<L> {
    fn x      (&self, a: O::Area) -> O::Unit { (**self).x(a) }
    fn y      (&self, a: O::Area) -> O::Unit { (**self).y(a) }
    fn w      (&self, a: O::Area) -> O::Unit { (**self).w(a) }
    fn min_w  (&self, a: O::Area) -> O::Unit { (**self).min_w(a) }
    fn max_w  (&self, a: O::Area) -> O::Unit { (**self).max_w(a) }
    fn h      (&self, a: O::Area) -> O::Unit { (**self).h(a) }
    fn min_h  (&self, a: O::Area) -> O::Unit { (**self).min_h(a) }
    fn max_h  (&self, a: O::Area) -> O::Unit { (**self).max_h(a) }
    fn layout (&self, a: O::Area) -> O::Area { (**self).layout(a) }
}

impl<O: Out> Layout<O> for Box<dyn Layout<O>> {
    fn x      (&self, a: O::Area) -> O::Unit { (**self).x(a) }
    fn y      (&self, a: O::Area) -> O::Unit { (**self).y(a) }
    fn w      (&self, a: O::Area) -> O::Unit { (**self).w(a) }
    fn min_w  (&self, a: O::Area) -> O::Unit { (**self).min_w(a) }
    fn max_w  (&self, a: O::Area) -> O::Unit { (**self).max_w(a) }
    fn h      (&self, a: O::Area) -> O::Unit { (**self).h(a) }
    fn min_h  (&self, a: O::Area) -> O::Unit { (**self).min_h(a) }
    fn max_h  (&self, a: O::Area) -> O::Unit { (**self).max_h(a) }
    fn layout (&self, a: O::Area) -> O::Area { (**self).layout(a) }
}

impl<O: Out, L: Layout<O>> Layout<O> for RwLock<L> {
    fn x      (&self, a: O::Area) -> O::Unit { self.read().unwrap().x(a) }
    fn y      (&self, a: O::Area) -> O::Unit { self.read().unwrap().y(a) }
    fn w      (&self, a: O::Area) -> O::Unit { self.read().unwrap().w(a) }
    fn min_w  (&self, a: O::Area) -> O::Unit { self.read().unwrap().min_w(a) }
    fn max_w  (&self, a: O::Area) -> O::Unit { self.read().unwrap().max_w(a) }
    fn h      (&self, a: O::Area) -> O::Unit { self.read().unwrap().h(a) }
    fn min_h  (&self, a: O::Area) -> O::Unit { self.read().unwrap().min_h(a) }
    fn max_h  (&self, a: O::Area) -> O::Unit { self.read().unwrap().max_h(a) }
    fn layout (&self, a: O::Area) -> O::Area { self.read().unwrap().layout(a) }
}

impl<O: Out, L: Layout<O>> Layout<O> for Option<L> {
    fn x (&self, to: O::Area) -> O::Unit {
        self.as_ref().map(|c|c.x(to)).unwrap_or(to.x())
    }
    fn y (&self, to: O::Area) -> O::Unit {
        self.as_ref().map(|c|c.y(to)).unwrap_or(to.y())
    }
    fn min_w (&self, to: O::Area) -> O::Unit {
        self.as_ref().map(|c|c.min_w(to)).unwrap_or(0.into())
    }
    fn max_w (&self, to: O::Area) -> O::Unit {
        self.as_ref().map(|c|c.max_w(to)).unwrap_or(0.into())
    }
    fn w (&self, to: O::Area) -> O::Unit {
        self.as_ref().map(|c|c.w(to)).unwrap_or(0.into())
    }
    fn min_h (&self, to: O::Area) -> O::Unit {
        self.as_ref().map(|c|c.min_h(to)).unwrap_or(0.into())
    }
    fn max_h (&self, to: O::Area) -> O::Unit {
        self.as_ref().map(|c|c.max_h(to)).unwrap_or(0.into())
    }
    fn h (&self, to: O::Area) -> O::Unit {
        self.as_ref().map(|c|c.h(to)).unwrap_or(0.into())
    }
    fn layout (&self, to: O::Area) -> O::Area {
        self.as_ref().map(|c|c.layout([self.x(to), self.y(to), self.w(to), self.h(to)].into()))
            .unwrap_or([to.x(), to.y(), 0.into(), 0.into()].into())
    }
}

pub struct Bounded<O: Out, D>(pub O::Area, pub D);

impl<O: Out, D: Content<O>> HasContent<O> for Bounded<O, D> {
    fn content (&self) -> impl Content<O> {
        &self.1
    }
}

impl<O: Out, T: Draw<O>> Draw<O> for Bounded<O, T> {
    fn draw (&self, to: &mut O) {
        let area = to.area();
        *to.area_mut() = self.0;
        self.1.draw(to);
        *to.area_mut() = area;
    }
}