use std::fmt;
use std::fmt::Formatter;
use rand::Rng;

pub struct DieRoll {
    sides: u32,
    face: u32,
}

impl DieRoll {
    fn new(sides: u32, face: u32) -> Self {
        DieRoll {
            sides,
            face,
        }
    }
}

pub struct RollResult {
    rolls: Vec<DieRoll>,
}

impl RollResult {
    pub fn new() -> Self {
        RollResult {
            rolls: Vec::new(),
        }
    }

    fn add_roll(&mut self, roll: DieRoll) {
        self.rolls.push(roll)
    }

    pub fn total(&self) -> u32 {
        self.rolls.iter().map(|die_roll| die_roll.face).sum()
    }
}

impl fmt::Display for RollResult {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{} ({})", self.total(), self.rolls.iter()
            .map(|dr| dr.face.to_string())
            .collect::<Vec<String>>()
            .join(", "))
    }
}

/// Roll a single die with the specified number of sides.
pub fn roll_die(sides: u32) -> u32 {
    let mut rng = rand::thread_rng();
    rng.gen_range(1..=sides)
}

/// Parse and roll dice from a dice formula (e.g. "4d6+2" or "d12*3").
pub fn roll_formula(formula: &str) -> Option<RollResult> {
    let delimiters = ['d', '+', '-', '*', '/']; // Only d implemented right now.
    let parts: Vec<&str> = formula.split(|c| delimiters.contains(&c)).collect();

    if parts.len() < 2 {
        return None;
    }

    let num_dice = if parts[0].is_empty() {
        1
    } else {
        match parts[0].parse::<u32>() {
            Ok(num) => num,
            Err(_) => return None,
        }
    };

    let sides = match parts[1].parse::<u32>() {
        Ok(num) => num,
        Err(_) => return None,
    };

    let mut roll_result = RollResult::new();

    for _ in 0..num_dice {
        let face = roll_die(sides);
        roll_result.add_roll(DieRoll::new(sides, face));
    }

    Some(roll_result)
}