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


extern crate rand;


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


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


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


//==================================================================================================
/// A die that has values of a fixed type, but no other relationship between the values must exist.
///
/// For example:
///
/// - a die with symbols,
/// - a numeric die without a fixed interval between values
/// - a numeric die with repeated values
//==================================================================================================

pub struct ValueDie<E: Copy> {
    
    /// Collection of all possible values
    values: Vec<E>,                     
    /// Value last rolled; die is initialized to the first item in *values*
    current_value: E,       
    /// Source of randomness
    rng: Box<Rng>,          
}


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


//==================================================================================================
impl<E: Copy> ValueDie<E> {
//==================================================================================================


    //==============================================================================================
    /// Pseudo-constructor for ValueDie.
    //----------------------------------------------------------------------------------------------
    ///
    /// ##### Parameters
    /// - vals : non-empty vector containing all possible die values; may contain duplicates
    /// - rng  : optional RNG; if None, defaults to a ThreadRng
    ///
    //----------------------------------------------------------------------------------------------
    /// ##### Return value
    /// A ValueDie constructed to the given specifications
    ///
    //----------------------------------------------------------------------------------------------
    /// # Examples
    ///
    /// ```
    /// # extern crate ezra;
    /// extern crate rand;
    /// use ezra::dice::{Die,ValueDie};
    /// use rand::OsRng;
    /// # fn main() {
    ///
    /// // Values a die may have
    /// #[derive(Copy,Clone,Debug)]
    /// enum DiceValues {
    ///     Value1,
    ///     Value2,
    ///     Value3,
    /// }
    ///
    /// let values = vec![DiceValues::Value1, DiceValues::Value2, DiceValues::Value3];
    /// let rng = OsRng::new().unwrap();
    /// let mut die = ValueDie::new(values, Some(Box::new(rng)));
    ///
    /// println!("The value {:?} was rolled.", die.roll().get_value()); 
    /// # }
    /// ```
    //----------------------------------------------------------------------------------------------
    /// The die may be constructed without an RNG, defaulting to its own thread-local RNG.
    ///
    /// ```
    /// # extern crate ezra;
    /// # use ezra::dice::{Die,ValueDie};
    /// # fn main() {
    /// // Values a die may have
    /// #[derive(Copy,Clone)]
    /// enum DiceValues {
    ///     Value1,
    ///     Value2,
    ///     Value3,
    /// }
    ///
    /// let values = vec![DiceValues::Value1, DiceValues::Value2, DiceValues::Value3];
    /// let mut die = ValueDie::new(values, None);
    /// # }
    /// ```
    //==============================================================================================

    pub fn new(vals: Vec<E>, rng: Option<Box<Rng>>) -> Self {

        // vals vector must be nonempty
        assert!(!vals.is_empty());
        
        ValueDie {
            current_value: vals[0],
            values: vals,
            // Use RNG if given, otherwise default to a ThreadRng
            rng: match rng {
                Some(r) => r,
                None => Box::new(rand::thread_rng()),
            },
        }
    }
}


//==================================================================================================
impl<E: Copy> Die for ValueDie<E>  {
//==================================================================================================
    

    //==============================================================================================
    type ValueType = E;
    //----------------------------------------------------------------------------------------------
    // Type of value the die may have.
    //==============================================================================================


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

        self.current_value = *self.rng.choose(self.values.as_slice()).unwrap();
        self
    }


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


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

        self.values.clone()
    }
}


//==================================================================================================
impl<E: Display + Copy> Display for ValueDie<E> {
//==================================================================================================


    //==============================================================================================
    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 die without error
    //          Err(...) -> something went wrong while attempting to print the die
    //==============================================================================================

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