use std::collections::HashMap;

trait Entity {

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

}

struct MyEntity { }

impl Entity for MyEntity {

    fn process(&self, effect: &Effect) {
        println!("{}", effect.data);
    }

}

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 send(&mut self, effect: &'a Effect) {
       for entity in &self.entities {
           entity.process(effect);
       }
    }

}

trait Effect { }

struct MyEffect<T> {
    data: T,
}

impl<T> Effect for MyEffect<T> { }

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

impl<'a> Supervisor<'a> {

    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 send_effect(&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 main() {


    let mut supervisor = Supervisor {environments: HashMap::new() };

    let mut entity = MyEntity { };

    let env = "Test";
    supervisor.join_environment(&env, &entity);

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

    supervisor.send_effect(&env, &effect);

}