use crate::*;

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

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

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

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

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

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

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

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

/// 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, T, U> Render<T, U> for Box<dyn Fn(&mut T) -> Perhaps<U> + Send + Sync + 'a> {
    fn render (&self, to: &mut T) -> Perhaps<U> {
        (*self)(to)
    }
}