use rand::{ distributions:: {Distribution, Standard}, Rng };
//use dict::{ Dict, DictIface };
//use std::collections::HashMap;

#[derive(Debug, Hash)]
enum Cls {
    Artificer = 0, 
    Barbarian, 
    Bard, 
    Cleric, 
    Druid, 
    Fighter, 
    Monk, 
    Paladin, 
    Ranger, 
    Rogue, 
    Sorcerer, 
    Warlock, 
    Wizard
}

impl PartialEq for Cls {
    fn eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl Default for Cls {
    fn default() -> Self { Cls::Fighter }
}

impl Distribution<Cls> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Cls {
        match rng.gen_range(0..=12) {
            0 => Cls::Artificer,
            1 => Cls::Barbarian,
            2 => Cls::Bard,
            3 => Cls::Cleric,
            4 => Cls::Druid,
            5 => Cls::Fighter,
            6 => Cls::Monk,
            7 => Cls::Paladin,
            8 => Cls::Ranger,
            9 => Cls::Rogue,
            10 => Cls::Sorcerer,
            11 => Cls::Warlock,
            12 => Cls::Wizard,
            _ => Cls::Fighter
        }
    }
}
            
#[derive(Debug, Default)]
struct Character {
    class: Cls,
    strength: u32,
    dexterity: u32,
    constitution: u32,
    intelligence: u32,
    wisdom: u32,
    charisma: u32,
}

impl Character {
    fn pick_class(&mut self) {
        self.class = rand::random();
    }
    fn gen_stats(&mut self) {
        let associated_stats = vec![
            [3,1,2,5,4,0],
            [],
            [],
            [],
            [],
            [],
            [],
            [],
            [],
            [],
            [],
            [],
            []
        ];
//        println!("{:?}", associated_stats);
        self.strength = roll_stat();
        self.dexterity = roll_stat();
        self.constitution = roll_stat();
        self.intelligence = roll_stat();
        self.wisdom = roll_stat();
        self.charisma = roll_stat();
    }
}

fn roll_stat() -> u32 {
    let mut rolls = Vec::new();
    while rolls.len()<4 {
        let roll = rand::thread_rng().gen_range(1..=6);
        if roll == 1 {
            continue;
        }
        rolls.push(roll);
    }
    rolls.sort_by(|a,b| b.cmp(a));
    rolls.pop();
    rolls.iter().sum()
}

fn main() {
    let mut chr: Character = Default::default();
    chr.pick_class();
    chr.gen_stats();
    println!("{:?}", chr);
    println!("{:?}", chr.class as u32);
}