use std::sync::{Arc, Mutex};
use std::thread;

enum Change<T> {
    Small(T),
    Large(T),
}

struct ChangeEmitter<T> {
    listener: Arc<Mutex<Option<Box<Fn(Change<T>) + Send>>>>,
}

impl<T: 'static + Send> ChangeEmitter<T> {
    pub fn new() -> Self {
        let emitter = ChangeEmitter::<T> {
            listener: Arc::new(Mutex::new(None)),
        };

        emitter
    }

    pub fn listen(&mut self, f: Box<Fn(Change<T>) + Send>) {
        let mut listener = self.listener.lock().unwrap();
        *listener = Some(f);
    }

    pub fn run(&self, values: Vec<T>) {
        let thread_listener = self.listener.clone();

        let thread = thread::spawn(move || {
            let locked = thread_listener.lock().unwrap();

            match *locked {
                Some(ref f) => {
                    for value in values {
                        let change = Change::Small(value);
                        f(change);
                    }
                }
                None => {}
            }
        });

        thread.join().expect("thread to exit successfully");
    }
}

fn main() {
    let mut emitter = ChangeEmitter::<i32>::new();

    // Listen to changes
    emitter.listen(Box::new(|change| match change {
        Change::Small(v) => println!("Small change: {}", v),
        Change::Large(v) => println!("Large change: {}", v),
    }));

    emitter.run(vec![5i32, 10i32, 100i32]);
}