use crate::*;
use Direction::*;

/// A split or layer.
pub struct Bsp<Head, Tail>(
    pub(crate) Direction,
    /// First element.
    pub(crate) Head,
    /// Second element.
    pub(crate) Tail,
);

impl<Head, Tail> Bsp<Head, Tail> {
    #[inline] pub const fn n (a: Head, b: Tail) -> Self { Self(North, a, b) }
    #[inline] pub const fn s (a: Head, b: Tail) -> Self { Self(South, a, b) }
    #[inline] pub const fn e (a: Head, b: Tail) -> Self { Self(East,  a, b) }
    #[inline] pub const fn w (a: Head, b: Tail) -> Self { Self(West,  a, b) }
    #[inline] pub const fn a (a: Head, b: Tail) -> Self { Self(Above, a, b) }
    #[inline] pub const fn b (a: Head, b: Tail) -> Self { Self(Below, a, b) }
}

impl<
    O: Out,
    Head: Draw<O> + Layout<O>,
    Tail: Draw<O> + Layout<O>
> Draw<O> for Bsp<Head, Tail> {
    fn draw (&self, to: &mut O) {
        let [a, b, _] = bsp_areas(to.area(), self.0, &self.1, &self.2);
        if self.0 == Below {
            to.place_at(a, &self.1);
            to.place_at(b, &self.2);
        } else {
            to.place_at(b, &self.2);
            to.place_at(a, &self.1);
        }
    }
}

impl<O: Out, Head: Layout<O>, Tail: Layout<O>> Layout<O> for Bsp<Head, Tail> {
    fn layout (&self, area: O::Area) -> O::Area {
        bsp_areas(area, self.0, &self.1, &self.2)[2]
    }
}

fn bsp_areas <O: Out> (
    area: O::Area, direction: Direction, a: &impl Layout<O>, b: &impl Layout<O>,
) -> [O::Area;3] {
    let [x, y, w, h] = area.xywh();
    let [aw, ah] = a.layout(area).wh();
    let [bw, bh] = b.layout(match direction {
        Above | Below => area,
        South => [x, y + ah, w, h.minus(ah)].into(),
        North => [x, y, w, h.minus(ah)].into(),
        East  => [x + aw, y, w.minus(aw), h].into(),
        West  => [x, y, w.minus(aw), h].into(),
    }).wh();
    match direction {
        Above | Below => {
            let [x, y, w, h] = area.center_xy([aw.max(bw), ah.max(bh)]);
            let a = [(x + w/2.into()).minus(aw/2.into()), (y + h/2.into()).minus(ah/2.into()), aw, ah];
            let b = [(x + w/2.into()).minus(bw/2.into()), (y + h/2.into()).minus(bh/2.into()), bw, bh];
            [a.into(), b.into(), [x, y, w, h].into()]
        },
        South => {
            let [x, y, w, h] = area.center_xy([aw.max(bw), ah + bh]);
            let a = [(x + w/2.into()).minus(aw/2.into()), y, aw, ah];
            let b = [(x + w/2.into()).minus(bw/2.into()), y + ah, bw, bh];
           [a.into(), b.into(), [x, y, w, h].into()]
        },
        North => {
            let [x, y, w, h] = area.center_xy([aw.max(bw), ah + bh]);
            let a = [(x + (w/2.into())).minus(aw/2.into()), y + bh, aw, ah];
            let b = [(x + (w/2.into())).minus(bw/2.into()), y, bw, bh];
            [a.into(), b.into(), [x, y, w, h].into()]
        },
        East => {
            let [x, y, w, h] = area.center_xy([aw + bw, ah.max(bh)]);
            let a = [x,      (y + h/2.into()).minus(ah/2.into()), aw, ah];
            let b = [x + aw, (y + h/2.into()).minus(bh/2.into()), bw, bh];
            [a.into(), b.into(), [x, y, w, h].into()]
        },
        West => {
            let [x, y, w, h] = area.center_xy([aw + bw, ah.max(bh)]);
            let a = [x + bw, (y + h/2.into()).minus(ah/2.into()), aw, ah];
            let b = [x,      (y + h/2.into()).minus(bh/2.into()), bw, bh];
            [a.into(), b.into(), [x, y, w, h].into()]
        },
    }
}

/// Stack things on top of each other,
#[macro_export] macro_rules! lay (($($expr:expr),* $(,)?) =>
    {{ let bsp = (); $(let bsp = Bsp::b(bsp, $expr);)*; bsp }});

/// Stack southward.
#[macro_export] macro_rules! col (($($expr:expr),* $(,)?) =>
    {{ let bsp = (); $(let bsp = Bsp::s(bsp, $expr);)*; bsp }});

/// Stack northward.
#[macro_export] macro_rules! col_up (($($expr:expr),* $(,)?) =>
    {{ let bsp = (); $(let bsp = Bsp::n(bsp, $expr);)*; bsp }});

/// Stack eastward.
#[macro_export] macro_rules! row (($($expr:expr),* $(,)?) =>
    {{ let bsp = (); $(let bsp = Bsp::e(bsp, $expr);)*; bsp }});