extern crate rayon;

use std::sync::mpsc;
use std::sync::Arc;

#[derive(Debug)]
pub struct Output(u32);

#[derive(Debug)]
pub struct Message(u32);

pub struct Server {
    worker_pool: rayon::ThreadPool,
}

impl Server {
    fn process(&self, tx: &mpsc::Sender<Output>, message: Message) {
        // each task needs its own sender, but this is cheap.
        let tx = tx.clone();

        self.worker_pool.spawn(move || {
            // do something with message here
            tx.send(Output(message.0));
        });
    }
}

fn main() {
    use std::thread;

    let worker_pool = rayon::ThreadPoolBuilder::new().num_threads(4).build().unwrap();
    let (tx, rx) = mpsc::channel();

    let server = Arc::new(Server {
        worker_pool
    });

    // first thread sending messages.
    let s1 = thread::spawn({
        // cheap to clone since Arc.
        let server = server.clone();
        // each thread needs its own clone of tx.
        let tx = tx.clone();

        move || {
            for i in 0u32..1000 {
                server.process(&tx, Message(i));
            }
        }
    });

    // second thread sending messages.
    let s2 = thread::spawn({
        // cheap to clone since Arc.
        let server = server.clone();
        // each thread needs its own clone of tx.
        let tx = tx.clone();

        move || {
            for i in 1000u32..200 {
                server.process(&tx, Message(i));
            }
        }
    });

    while let Ok(output) = rx.recv() {
        println!("output: {:?}", output);
    }

    s1.join().expect("bad thread");
    s2.join().expect("bad thread");
}