fn main() {
    let mut e = EventManager::default();
    e.add_listener(&foo);
    e.add_listener(&foo2);
    e.queue_event(Event(0));
    for _ in 0..6 {
        e.update();
    }
}

trait IEventData {
    fn get_timestamp(&self) -> std::time::Duration;
    fn get_name() -> &'static str where Self: Sized;
    fn as_any(&self) -> &dyn std::any::Any;
}

struct Event(i32);
impl IEventData for Event {
    fn get_timestamp(&self) -> std::time::Duration {
        std::time::Duration::from_millis(0)
    }
    fn get_name() -> &'static str {
        "Event"
    }
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

fn foo<'a>(event_manager: &mut EventManager<'a>, e: &Event) {
    println!("Time {:?}", e.get_timestamp());
}

fn foo2<'a>(event_manager: &mut EventManager<'a>, e: &Event) {
    println!("Event2 {}", e.0);
    if e.0 < 5 {
        event_manager.queue_event(Event(e.0 +1));
    }
}

struct Data(&'static str, Box<dyn IEventData>);

#[derive(Default)]
struct EventManager<'a> {
    events: std::collections::VecDeque<Data>,
    listeners: std::collections::HashMap<&'static str, Vec<Box<FnMut(&mut EventManager, &std::any::Any) + 'a>>>
}

impl<'a> EventManager<'a> {
    fn add_listener<E, F>(&mut self, mut f: F) where E: 'static + IEventData + Sized, F: 'a + FnMut(&mut EventManager, &E) {
        let name = E::get_name();
        if let Some(list) = self.listeners.get_mut(name) {
            list.push(Box::new(move |s, e| f(s, e.downcast_ref::<E>().unwrap())));
            return;
        }
        self.listeners.insert(name, vec![Box::new(move |s, e| f(s, e.downcast_ref::<E>().unwrap()))]);
    }

    fn queue_event<E>(&mut self, e: E) where E: 'static + IEventData + Sized {
        self.events.push_back(Data{0: E::get_name(), 1: Box::new(e)});
    }

    fn update(&mut self) {
        let d: Vec<_> = self.events.drain(..).collect();
        for event in d {
            if let Some((key, mut funcs)) = self.listeners.remove_entry(event.0) {
                for func in &mut funcs {
                    func(self, event.1.as_any());
                }
                self.listeners.insert(key, funcs);
            }
        }
    }
}