use crate::*;

pub enum Cond<E: Engine, A: Render<E>, B: Render<E>> {
    _Unused(E),
    When(bool, A),
    Either(bool, A, B)
}

impl<E: Engine, R: Render<E>> LayoutCond<E> for R {}

pub trait LayoutCond<E: Engine>: Render<E> + Sized {
    fn when (self, cond: bool) -> If<E, Self> {
        If(Default::default(), cond, self)
    }
    fn or <B: Render<E>> (self, cond: bool, other: B) -> Either<E, Self, B> {
        Either(Default::default(), cond, self, other)
    }
}

impl<E: Engine> LayoutCondStatic<E> for E {}

pub trait LayoutCondStatic<E: Engine> {
    fn either <A: Render<E>, B: Render<E>> (
        condition: bool,
        a: A,
        b: B,
    ) -> Either<E, A, B> {
        Either(Default::default(), condition, a, b)
    }
}

/// Render widget if predicate is true
pub struct If<E: Engine, A: Render<E>>(PhantomData<E>, bool, A);

impl<E: Engine, A: Render<E>> Render<E> for If<E, A> {
    fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
        if self.1 {
            return self.2.min_size(to)
        }
        Ok(None)
    }
    fn render (&self, to: &mut E::Output) -> Usually<()> {
        if self.1 {
            return self.2.render(to)
        }
        Ok(())
    }
}

/// Render widget A if predicate is true, otherwise widget B
pub struct Either<E: Engine, A: Render<E>, B: Render<E>>(
    PhantomData<E>,
    bool,
    A,
    B,
);

impl<E: Engine, A: Render<E>, B: Render<E>> Render<E> for Either<E, A, B> {
    fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
        if self.1 { self.2.min_size(to) } else { self.3.min_size(to) }
    }
    fn render (&self, to: &mut E::Output) -> Usually<()> {
        if self.1 { self.2.render(to) } else { self.3.render(to) }
    }
}