use std::borrow::Cow;
use std::collections::HashMap;

// note these cow<'a, str> can be serialized and
// deserialized with serde with the same semantics as
// String
pub type AssignmentId<'a> = Cow<'a, str>;
pub type PlayerId<'a> = Cow<'a, str>;
pub type Data<'a> = Cow<'a, str>;

pub fn n<'a>(s: &'a str) -> Cow<'a, str> {
    Cow::Borrowed(s)
}


#[derive(Debug)]
struct MarioWorldDescriptor<'a> {
    assignments: HashMap<AssignmentId<'a>, Data<'a>>,
    player_data: HashMap<PlayerId<'a>, Data<'a>>,
}

#[derive(Debug)]
struct IndexedMarioWorld<'a, 'b: 'a> {
    descriptor: MarioWorldDescriptor<'b>,
    index1: HashMap<PlayerId<'a>, Data<'a>>,
    index2: HashMap<AssignmentId<'a>, Data<'a>>
}


fn index_mario_world<'a, 'b: 'a>(descriptor: MarioWorldDescriptor<'b>) -> IndexedMarioWorld<'a, 'b> {

    let mut index1 = HashMap::new();
    for (key, value) in descriptor.assignments.iter() {
        assert!(index1.insert(key.clone(), value.clone()).is_none());
    }
    let mut index2 = HashMap::new();
    for (key, value) in descriptor.player_data.iter() {
        assert!(index2.insert(key.clone(), value.clone()).is_none());
    }

    IndexedMarioWorld {
        descriptor,
        index1,
        index2
    }
}

fn test_mario() {
    let assignments = {
        let mut a = HashMap::new();
        a.insert(n("role-a"), n("tank"));
        a.insert(n("role-b"), n("healer"));
        a.insert(n("role-c"), n("dps"));
        a
    };

    let player_data = {
        let mut p = HashMap::new();
        p.insert(n("easytacos"), n("role-a"));
        p.insert(n("earlypear"), n("role-b"));
        p.insert(n("ritzyzucchini"), n("role-c"));
        p.insert(n("crazyjalapeno"), n("role-c"));
        p.insert(n("inertpotatosalad"), n("role-c"));

        p
    };

    let descriptor = MarioWorldDescriptor {
        assignments,
        player_data
    };
    println!("{:#?}", descriptor);

    let indexed = index_mario_world(descriptor);

    println!("{:#?}", indexed);
}


fn main() {

 test_mario();
}