//##################################################################################################
//******************************************* DEPENDENCIES  ****************************************
//##################################################################################################


extern crate rand;


//--------------------------------------------------------------------------------------------------


use dice::Die;
use rand::Rng;
use std::fmt::{Display,Formatter,Result};


//##################################################################################################
//**************************************** STRUCT DECLARATIONS *************************************
//##################################################################################################


//==================================================================================================
/// A die that has numeric values at fixed intervals from each other (e.g. d6, d20, d4, etc).
//==================================================================================================
pub struct NumericDie {

    /// Lowest value present on die
    min_value: usize,                   
    /// Interval between die values
    value_step: usize,                  
    /// Number of values the die may have
    num_sides: usize,                   
    /// Value last rolled; die is initialized with min_value
    current_value: usize,               
    /// Source of randomness
    rng: Box<Rng>,                      
}


//##################################################################################################
//************************************* STRUCT IMPLEMENTATIONS *************************************
//##################################################################################################


//==================================================================================================
impl NumericDie {
//==================================================================================================    


    //==============================================================================================
    /// Pseudo-constructor for NumericDie object.
    //----------------------------------------------------------------------------------------------
    ///
    /// ##### Parameters
    ///  - min       : minimum value die may have
    ///  - step      : interval between values
    ///  - num_sides : number of possible values
    ///  - rng       : optional RNG; if none, defaults to ThreadRng
    ///
    /// ##### Return value
    /// A NumericDie constructed with the given specifications
    //----------------------------------------------------------------------------------------------
    /// # Examples
    /// ```
    /// # extern crate ezra;
    /// extern crate rand;
    /// use ezra::dice::{Die,NumericDie};
    /// use rand::OsRng;
    /// # fn main() {
    ///
    /// // Create a standard six sided die, using the OS's source of randomness
    /// let rng = OsRng::new().unwrap();
    /// let mut die = NumericDie::new(1, 1, 6, Some(Box::new(rng)));
    /// println!("First die roll has value: {}", die.roll().get_value());
    /// # }
    /// ```
    //----------------------------------------------------------------------------------------------
    /// A die can also be created without specifying an RNG. The constructed die will use its own
    /// thread-local RNG by default.
    ///
    /// ```
    /// # extern crate ezra;
    /// # extern crate rand;
    /// # use ezra::dice::NumericDie;
    /// # fn main() {
    /// let die = NumericDie::new(1, 1, 6, None);
    /// # }
    /// ```
    //==============================================================================================

    pub fn new(min: usize, step: usize, num_sides: usize, rng: Option<Box<Rng>>) -> Self {
    
        NumericDie {
            min_value: min,
            value_step: step,
            num_sides: num_sides,
            current_value: min,
            rng: match rng {
                Some(r) => r,
                None => Box::new(rand::thread_rng()),
            },
        }
    }
}


//==================================================================================================
impl Die for NumericDie {
//==================================================================================================

    
    //==============================================================================================
    type ValueType = usize;
    //----------------------------------------------------------------------------------------------
    // Type of value die will have.
    //==============================================================================================


    //==============================================================================================
    fn roll(&mut self) -> &mut Self {
    //----------------------------------------------------------------------------------------------
    // Randomizes value of the die to one of its `num_sides` possible values, and returns itself.
    //----------------------------------------------------------------------------------------------
    // TAKES:   nothing
    //
    // RETURNS: a mutable reference to itself
    //==============================================================================================

        self.current_value = self.min_value + self.value_step * self.rng.gen_range(0, self.num_sides);
        self
    }


    //==============================================================================================
    fn get_value(&self) -> Self::ValueType {
    //----------------------------------------------------------------------------------------------
    // Obtain the current value of the die.
    //----------------------------------------------------------------------------------------------
    // TAKES:   nothing
    //
    // RETURNS: the current value of the die
    //==============================================================================================
    
        self.current_value
    }


    //==============================================================================================
    fn values(&self) -> Vec<Self::ValueType> {
    //----------------------------------------------------------------------------------------------
    // Obtain a list of all possible values a die may have.
    //----------------------------------------------------------------------------------------------
    // TAKES:   nothing
    //
    // RETURNS: vector containing all possible values the die may have
    //==============================================================================================

        let mut result = Vec::new();
        for i in 0..self.num_sides {
            result.push(self.min_value + self.value_step * i);
        }
        result
    }
}


//==================================================================================================
impl Display for NumericDie {
//==================================================================================================


    //==============================================================================================
    fn fmt(&self, f: &mut Formatter) -> Result {
    //----------------------------------------------------------------------------------------------
    // Print the die using a given formatter.
    //----------------------------------------------------------------------------------------------
    // TAKES:   f -> formatter with which to print the die
    //
    // RETURNS: Ok(())   -> printed the die without error
    //          Err(...) -> something went wrong while attempting to print the die
    //==============================================================================================

        write!(f, "{}", self.current_value)
    }
}