use super::Message;
use std::{
    sync::mpsc::{Receiver, Sender},
    thread::spawn,
};

pub struct Router {
    txs: Vec<Sender<Message>>,
    rx: Receiver<Message>,
}

impl Router {
    fn new(senders: Vec<Sender<Message>>, rx: Receiver<Message>) -> Self {
        Self {
            txs: senders,
            rx: rx,
        }
    }

    pub fn start(senders: Vec<Sender<Message>>, rx: Receiver<Message>) {
        spawn(move || {
            let router = Router::new(senders, rx);
            router.listen();
        });
    }

    fn listen(&self) {
        loop {
            let msg = self.rx.recv().unwrap();
            for tx in self.txs.iter() {
                tx.send(msg.clone()).unwrap();
            }
        }
    }
}

#[cfg(test)]
mod messages {
    use std::sync::mpsc::channel;
    use super::super::MsgData;
    use super::{super::test_message::Tester, *};

    #[test]
    fn forward_messages() {
        let (tx, rx) = channel();
        let (tx1, rx1) = channel();
        let (tx2, rx2) = channel();
        let senders = vec![tx1, tx2];
        Router::start(senders, rx);
        let data = Tester::Test1;
        let msg = Message::new(&data);
        tx.send(msg.clone()).unwrap();
        let result1 = rx1.recv().unwrap();
        assert_eq!(result1.get_id(), msg.get_id());
        match result1.get_message() {
            MsgData::Test1 => {}
            _ => unreachable!("Should have been test1."),
        }
        let result2 = rx2.recv().unwrap();
        assert_eq!(result2.get_id(), msg.get_id());
        match result2.get_message() {
            MsgData::Test1 => {}
            _ => unreachable!("Should have been test1."),
        }
    }
}