use crate::*;

/// Render to output.
pub trait Render<E: Engine>: Send + Sync {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered>;
}

impl<E: Engine> Render<E> for () {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        Ok(None)
    }
}

/// Options can be rendered optionally.
impl<R, E: Engine> Render<E> for Option<R> where R: Render<E> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        match self {
            Some(component) => component.render(to),
            None => Ok(None)
        }
    }
}

/// Boxed references can be rendered.
impl<'a, E: Engine> Render<E> for Box<dyn Render<E> + 'a> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        (**self).render(to)
    }
}

/// Immutable references can be rendered.
impl<R, E: Engine> Render<E> for &R where R: Render<E> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        (*self).render(to)
    }
}

/// Mutable references can be rendered.
impl<R, E: Engine> Render<E> for &mut R where R: Render<E> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        (**self).render(to)
    }
}

/// Counted references can be rendered.
impl<R, E: Engine> Render<E> for Arc<R> where R: Render<E> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        self.as_ref().render(to)
    }
}

/// References behind a [Mutex] can be rendered.
impl<R, E: Engine> Render<E> for Mutex<R> where R: Render<E> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        self.lock().unwrap().render(to)
    }
}

/// References behind a [RwLock] can be rendered.
impl<R, E: Engine> Render<E> for RwLock<R> where R: Render<E> {
    fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        self.read().unwrap().render(to)
    }
}

// FIXME: components are now 2 thunks (layout and render).
// maybe this resolves the conflict describe below?
///// Boxed closures can be rendered.
/////
///// Rendering unboxed closures should also be possible;
///// but in practice implementing the trait for an unboxed
///// `Fn` closure causes an impl conflict.
//impl<'a, E: Engine> Render<E> for Box<dyn Fn(&mut E) -> Perhaps<E::Rendered> + Send + Sync + 'a> {
    //fn render (&self, to: &mut E) -> Perhaps<E::Rendered> {
        //(*self)(to)
    //}
//}