use std::collections::HashMap;
use std::sync::Mutex;

// vector describing speed in x,y dimensions
pub type Speed = (usize, usize);

pub struct Robo {
    speed: Mutex<Speed>,
}

impl Robo {
    pub fn new() -> Self {
        Self {
            speed: Mutex::new((0, 0)),
        }
    }

    pub fn make_ins(&mut self) -> HashMap<&'static str, Box<dyn FnMut() + '_>> {
        let mut map = HashMap::new();
        let s = &mut self.speed;
        let op_speed = || {
            let mut x =
                s.lock().expect("couldn't get lock on speed");
            *x = (1, 1);
        };
        let op_speed2 = || {
            let mut x =
                s.lock().expect("couldn't get lock on speed");
            *x = (2, 2);
        };
        map.insert("move", Box::new(op_speed) as Box<dyn FnMut()>);
        map.insert("move2", Box::new(op_speed2) as Box<dyn FnMut()>);
        map
    }
}

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

    #[test]
    fn can_run_two() {
        let mut r = Robo::new();
        {
            let hm = &mut r.make_ins();
            let fun = hm.get_mut("move").expect("move should exist");
            fun();
        }
        let s = r.speed.lock().expect("couldn't get lock on speed");
        assert_eq!(*s, (1, 1));
        drop(s);

        {
            let hm = &mut r.make_ins();
            let fun = hm.get_mut("move2").expect("move2 should exist");
            fun();
        }
        let s = r.speed.lock().expect("couldn't get lock on speed");
        assert_eq!(*s, (2, 2));
        drop(s);
    }
}