use crossbeam::channel::{Receiver, Sender};
use std::error::Error;

pub struct Bus<T>
where
    T: Copy,
{
    subscriptions: Vec<(Box<dyn FnMut(T) -> bool + 'static>, Sender<T>)>,
}

impl<T> Bus<T>
where
    T: Copy,
{
    pub fn new() -> Self {
        Bus {
            subscriptions: vec![],
        }
    }

    pub fn send(&mut self, message: T) -> Result<(), crossbeam::channel::SendError<T>> {
        for v in self.subscriptions.iter_mut() {
            if v.0(message) {
                match v.1.send(message) {
                    Ok(()) => (),
                    Err(e) => {
                        return Err(e);
                    }
                }
            }
        }

        return Ok(());
    }

    pub fn subscribe(&mut self, guard: impl FnMut(T) -> bool + 'static) -> Receiver<T> {
        let (sender, receiver) = crossbeam_channel::unbounded();
        self.subscriptions.push((Box::new(guard), sender));
        return receiver;
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn send_message() {
        let mut test_bus: Bus<&[u8]> = Bus::new();
        assert_eq!(test_bus.send("test".as_bytes()), Ok(()));
    }

    #[test]
    fn send_message_and_receive() {
        let mut test_bus: Bus<&[u8]> = Bus::new();
        let receiver = test_bus.subscribe(|x| return x == "test".as_bytes());
        match test_bus.send("test".as_bytes()) {
            Ok(()) => {
                assert_eq!(receiver.recv().unwrap(), "test".as_bytes());
            }
            Err(_) => return,
        }
    }
}