use crate::*;

// TODO: Convert to component
// pub enum Align { Center, NW, N, NE, E, SE, S, SW, W, }
pub fn center_box (area: Rect, w: u16, h: u16) -> Rect {
    let width  = w.min(area.width * 3 / 5);
    let height = h.min(area.width * 3 / 5);
    let x = area.x + (area.width  - width)  / 2;
    let y = area.y + (area.height - height) / 2;
    Rect { x, y, width, height }
}

/// Trait for structs that compute drawing area before rendering
pub trait Layout<E: Engine>: Render<E> {
    fn layout (&self, area: E::Area) -> Perhaps<E::Area>;
}
/// Enforce minimum size of drawing area
pub enum Min<U: Number, L> { W(U, L), H(U, L), WH(U, U, L), }
/// Enforce maximum size of drawing area
pub enum Max<U: Number, L> { W(U, L), H(U, L), WH(U, U, L), }
/// Expand drawing area
pub enum Outset<U: Number, L> { W(U, L), H(U, L), WH(U, U, L), }
/// Shrink drawing area
pub enum Inset<U: Number, L> { W(U, L), H(U, L), WH(U, U, L), }
/// Move origin point of drawing area
pub enum Offset<U: Number, L> { X(U, L), Y(U, L), XY(U, U, L), }

impl<E: Engine, L: Layout<E>> Layout<E> for Min<E:: Unit, L> {
    fn layout (&self, area: E::Area) -> Perhaps<E::Area> {
        match self {
            Self::W(w, item) => if area.w() < *w { Ok(None) } else {
                // TODO: axis clamp (subtract from x if width goes out of area
                item.layout([area.x(), area.y(), area.w().max(*w), area.h()].into())
            },
            Self::H(h, item) => if area.w() < *h { Ok(None) } else {
                // TODO: axis clamp (subtract from x if width goes out of area
                item.layout([area.x(), area.y(), area.w(), area.h().max(*h)].into())
            },
            Self::WH(w, h, item) => if area.w() < *w || area.h() < *h { Ok(None) } else {
                item.layout([area.x(), area.y(), area.w().max(*w), area.h().max(*h)].into())
            }
        }
    }
}

impl<E: Engine, L: Layout<E>> Layout<E> for Max<E:: Unit, L> {
    fn layout (&self, area: E::Area) -> Perhaps<E::Area> {
        match self {
            Self::W(w, item) => {
                // TODO: axis clamp (subtract from x if width goes out of area
                item.layout([area.x(), area.y(), area.w().min(*w), area.h()].into())
            },
            Self::H(h, item) => {
                // TODO: axis clamp (subtract from x if width goes out of area
                item.layout([area.x(), area.y(), area.w(), area.h().min(*h)].into())
            },
            Self::WH(w, h, item) => {
                item.layout([area.x(), area.y(), area.w().min(*w), area.h().min(*h)].into())
            }
        }
    }
}

impl<E: Engine, L: Layout<E>> Layout<E> for Outset<E::Unit, L> {
    fn layout (&self, area: E::Area) -> Perhaps<E::Area> {
        match self {
            Self::W(w, item) => if area.x() < *w { Ok(None) } else {
                item.layout([area.x() - *w, area.y(), area.w() + *w, area.h()].into())
            },
            Self::H(h, item) => if area.y() < *h { Ok(None) } else {
                item.layout([area.x(), area.y() - *h, area.w(), area.h() + *h].into())
            },
            Self::WH(w, h, item) => if area.x() < *w || area.y() < *h { Ok(None) } else {
                item.layout([area.x()-*w, area.y() - *h, area.w() + *w, area.h() + *h].into())
            }
        }
    }
}

impl<E: Engine, L: Layout<E>> Layout<E> for Inset<E::Unit, L> {
    fn layout (&self, area: E::Area) -> Perhaps<E::Area> {
        match self {
            Self::W(w, item) => if area.w() < *w { Ok(None) } else {
                item.layout([area.x() + *w, area.y(), area.w() - *w, area.h()].into())
            },
            Self::H(h, item) => if area.h() < *h { Ok(None) } else {
                item.layout([area.x(), area.y() + *h, area.w(), area.h() - *h].into())
            },
            Self::WH(w, h, item) => if area.w() < *w || area.h() < *h { Ok(None) } else {
                item.layout([area.x() - *w, area.y() - *h, area.w() + *w, area.h() + *h].into())
            }
        }
    }
}

impl<E: Engine, L: Layout<E>> Layout<E> for Offset<E::Unit, L> {
    fn layout (&self, area: E::Area) -> Perhaps<E::Area> {
        match self {
            Self::X(x, item) => if area.w() < *x { Ok(None) } else {
                item.layout([area.x() + *x, area.y(), area.w() - *x, area.h()].into())
            },
            Self::Y(y, item) => if area.h() < *y { Ok(None) } else {
                item.layout([area.x(), area.y() + *y, area.w(), area.h() - *y].into())
            },
            Self::XY(x, y, item) => if area.w() < *x || area.h() < *y { Ok(None) } else {
                item.layout([area.x() + *x, area.y() + *y, area.w() - *x, area.h() - *y].into())
            }
        }
    }
}

impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Min<E::Unit, R> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        self.layout(to.area())?
            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
            .map(|to|match self {
                Self::W(_, inner) => inner,
                Self::H(_, inner) => inner,
                Self::WH(_, _, inner) => inner,
            }.render(to))
            .transpose()
            .map(|x|x.flatten())
    }
}

impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Max<E::Unit, R> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        self.layout(to.area())?
            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
            .map(|to|match self {
                Self::W(_, inner) => inner,
                Self::H(_, inner) => inner,
                Self::WH(_, _, inner) => inner,
            }.render(to))
            .transpose()
            .map(|x|x.flatten())
    }
}

impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Inset<E::Unit, R> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        self.layout(to.area())?
            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
            .map(|to|match self {
                Self::W(_, inner) => inner,
                Self::H(_, inner) => inner,
                Self::WH(_, _, inner) => inner,
            }.render(to))
            .transpose()
            .map(|x|x.flatten())
    }
}

impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Outset<E::Unit, R> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        self.layout(to.area())?
            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
            .map(|to|match self {
                Self::W(_, inner) => inner,
                Self::H(_, inner) => inner,
                Self::WH(_, _, inner) => inner,
            }.render(to))
            .transpose()
            .map(|x|x.flatten())
    }
}

impl<E: Engine, R: Render<E> + Layout<E>> Render<E> for Offset<E::Unit, R> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        self.layout(to.area())?
            .map(|area|to.with_area(area.x(), area.y(), area.w(), area.h()))
            .map(|to|match self {
                Self::X(_, inner) => inner,
                Self::Y(_, inner) => inner,
                Self::XY(_, _, inner) => inner,
            }.render(to))
            .transpose()
            .map(|x|x.flatten())
    }
}