use crate::*;

pub struct Group<T>(T);

impl<T> Group<T> {
    pub const fn new () -> Group<()> {
        Group(())
    }
    pub const fn add <U> (self, value: U) -> Group<(T, U)> {
        Group((self.0, value))
    }
}

/// Lazily-evaluated [Draw]able.
pub struct Thunk<E: Out, T: Draw<E>, F: Fn()->T>(
    PhantomData<E>,
    F
);
impl<E: Out, T: Draw<E>, F: Fn()->T> Thunk<E, T, F> {
    pub const fn new (thunk: F) -> Self {
        Self(PhantomData, thunk)
    }
}
impl<E: Out, T: Draw<E> + Layout<E>, F: Fn()->T> Content<E> for Thunk<E, T, F> {
    fn content (&self) -> impl Draw<E> + Layout<E> + '_ {
        (self.1)()
    }
}

pub struct ThunkDraw<E: Out, F: Fn(&mut E)>(PhantomData<E>, F);
impl<E: Out, F: Fn(&mut E)> ThunkDraw<E, F> {
    pub fn new (render: F) -> Self { Self(PhantomData, render) }
}
impl<E: Out, F: Fn(&mut E)> Draw<E> for ThunkDraw<E, F> {
    fn draw (&self, to: &mut E) { (self.1)(to) }
}

#[derive(Debug, Default)] pub struct Memo<T, U> {
    pub value: T,
    pub view: Arc<RwLock<U>>
}

impl<T: PartialEq, U> Memo<T, U> {
    pub fn new (value: T, view: U) -> Self {
        Self { value, view: Arc::new(view.into()) }
    }
    pub fn update <R> (
        &mut self,
        newval: T,
        render: impl Fn(&mut U, &T, &T)->R
    ) -> Option<R> {
        if newval != self.value {
            let result = render(&mut*self.view.write().unwrap(), &newval, &self.value);
            self.value = newval;
            return Some(result);
        }
        None
    }
}

/// Clear a pre-allocated buffer, then write into it.
#[macro_export] macro_rules! rewrite {
    ($buf:ident, $($rest:tt)*) => { |$buf,_,_|{ $buf.clear(); write!($buf, $($rest)*) } }
}