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

const DBG_LVL: u32 = 0;

fn dbg_print(msg: &impl Debug, lvl: u32) {
    if lvl <= DBG_LVL {
        println!("{:?}", msg);
    }
}

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

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, Copy, Clone)]
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!(
            [0,4,3,5,1,2], // Artificer
            [5,3,4,0,1,2], // Barbarian
            [0,4,1,3,2,5], // Bard
            [3,0,4,2,5,1], // Cleric
            [1,2,4,3,5,0], // Druid
            [5,3,4,2,1,0], // Fighter
            [2,5,3,1,4,0], // Monk
            [5,1,3,0,2,4], // Paladin
            [3,5,2,1,4,0], // Ranger
            [1,5,2,4,0,3], // Rogue
            [0,1,4,3,2,5], // Sorcerer
            [0,1,4,3,2,5], // Warlock
            [0,1,3,5,4,2]  // Wizard
        );
        let cls = self.class as u32;
        let statblock = associated_stats[cls as usize];
        dbg_print(&statblock, 2);
        let mut rolled_stats = Vec::new();
        while rolled_stats.len() < 6 {
            rolled_stats.push(roll_stat());
        }
        dbg_print(&rolled_stats, 2);
        rolled_stats.sort();
        dbg_print(&rolled_stats, 2);
        self.strength = rolled_stats[statblock[0]];
        self.dexterity = rolled_stats[statblock[1]];
        self.constitution = rolled_stats[statblock[2]];
        self.intelligence = rolled_stats[statblock[3]];
        self.wisdom = rolled_stats[statblock[4]];
        self.charisma = rolled_stats[statblock[5]];
    }
}

fn roll_stat() -> u32 {
    let mut rolls = Vec::new();
    while rolls.len()<4 {
        let mut roll = rand::thread_rng().gen_range(1..=6);
        if roll == 1 {
            roll = rand::thread_rng().gen_range(1..=6);
        }
        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);
    dbg_print(&(chr.class as u32), 2);
}