use std::collections::HashMap;
use std::collections::VecDeque;
use std::any::Any;

trait Entity {

    fn process(&self, effect: &Effect);

}

struct MyEntity;

impl Entity for MyEntity {

    fn process(&self, effect: &Effect) {

        match effect.as_any().downcast_ref::<MyEffect<&str>>() {

            Some(x) => println!("It's a string: {}", x.data),
            None => match effect.as_any().downcast_ref::<MyEffect<u32>>() {

                Some(y) => println!("It's a u32: {}", y.data),
                None => unreachable!(),

            }

        }

    }

}

struct Environment<'a> {
    name: &'a str,
    entities: Vec<&'a Entity>,
}

impl<'a> Environment<'a> {

    fn join(&mut self, entity: &'a Entity) {
        self.entities.push(entity);
    }

    fn leave(&mut self, entity: &'a Entity) {
        //let index = self.entities.iter().position(|x| *x == entity).unwrap();
        //self.entities.remove(index);
    }

    fn send(&mut self, effect: &'a Effect) {
       for entity in &self.entities {
           entity.process(effect);
       }
    }

}

trait Effect {

    fn as_any(&self) -> &dyn Any;

}

struct MyEffect<T> {
    data: T,
}

impl<T:'static> Effect for MyEffect<T> {

    fn as_any(&self) -> &dyn Any {
        self
    }

}

struct Event<'a> {
    environment: &'a str,
    effect: Effect,
}

struct Supervisor<'a> {
    environments: HashMap<&'a str, Environment<'a>>,
    queue: VecDeque<&'a Event<'a>>,
}

impl<'a> Supervisor<'a> {

    fn new() -> Supervisor<'a> {
        Supervisor{ environments: HashMap::new(), queue: VecDeque::new() }
    }

    fn create_environment(&mut self, name: &'a str) {
        if !self.environments.contains_key(name) {
            let env = Environment{name: name, entities: Vec::new()};
            self.environments.insert(name, env);
        }
    }

    fn join_environment(&mut self, name: &'a str, entity:&'a Entity) {
        self.create_environment(name);
        let env:&mut Environment = self.environments.get_mut(name).unwrap();
        env.join(entity);
    }

    fn leave_environment(&mut self, name: &'a str, entity:&'a Entity) {
        if self.environments.contains_key(name) {
           let env:&mut Environment = self.environments.get_mut(name).unwrap();
           env.leave(entity);
        }
    }

    fn send(&mut self, name: &'a str, effect: &'a Effect) {
        self.create_environment(name);
        let env:&mut Environment = self.environments.get_mut(name).unwrap();
        env.send(effect);
    }

    fn post(&mut self, event: &'a Event) {
        self.queue.push_back(event);
    }

}


fn main() {

    let mut supervisor = Supervisor::new();

    let env = "Test";
    supervisor.join_environment(&env, &MyEntity { });

    let effect = MyEffect{data: "Hello World"};

    supervisor.send(&env, &effect);

    let x:u32 = 999;

    let another_effect = MyEffect{data: x};

    supervisor.send(&env, &another_effect);

}