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


use dice::Die;
use std::cmp::Eq;
use std::ops::Add;
use std::hash::Hash;
use std::collections::HashMap;
use std::slice::{IterMut,Iter};
use std::fmt::{Display,Formatter,Result};


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


//==================================================================================================
/// A collection of dice.
//==================================================================================================

pub struct DiceCollection<T: Die> {

    /// Internal collection of dice
    dice: Vec<T>,                       
}


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


//==================================================================================================
impl<T: Die> DiceCollection<T> {
//==================================================================================================

    //==============================================================================================
    /// Pseudo-constructor for DiceCollection.
    //----------------------------------------------------------------------------------------------
    /// ##### Return Value
    /// An empty DiceCollection
    //----------------------------------------------------------------------------------------------
    /// # Examples
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{NumericDie,DiceCollection};
    /// # fn main() {
    ///
    /// // Create a new dice collection and add a standard 6-sided die to it
    /// let mut dice = DiceCollection::<NumericDie>::new();
    /// dice.add(NumericDie::new(1, 1, 6, None));
    ///
    /// assert_eq!(dice.size(), 1);
    /// # }
    /// ```
    //==============================================================================================
    
    pub fn new() -> Self {
        DiceCollection { dice: Vec::new() }
    }


    //==============================================================================================
    /// Add a die to the collection.
    ///
    //----------------------------------------------------------------------------------------------
    /// ##### Parameters
    ///
    /// die : die to add to collection
    ///
    //----------------------------------------------------------------------------------------------
    /// ##### Return value
    ///
    /// A mutable reference to the collection
    ///
    //----------------------------------------------------------------------------------------------
    /// # Examples
    ///
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{NumericDie,DiceCollection};
    /// # fn main() {
    ///
    /// let mkdie = || { NumericDie::new(1, 1, 6, None) };
    /// let mut dice = DiceCollection::<NumericDie>::new();
    ///
    /// dice.add(mkdie());
    /// dice.add(mkdie());
    /// dice.add(mkdie());
    ///
    /// assert_eq!(dice.size(), 3);
    /// # }
    /// ```
    ///
    //----------------------------------------------------------------------------------------------
    /// This operation may also be chained:
    ///
    /// ```
    /// # extern crate ezra;
    /// # use ezra::dice::{NumericDie,DiceCollection};
    /// # fn main() {
    /// let mkdie = || { NumericDie::new(1, 1, 6, None) };
    /// let mut dice = DiceCollection::<NumericDie>::new();
    ///
    /// dice.add(mkdie())
    ///     .add(mkdie())
    ///     .add(mkdie());
    ///
    /// assert_eq!(dice.size(), 3);
    /// # }
    /// ```
    //==============================================================================================

    pub fn add(&mut self, die: T) -> &mut Self {
        self.dice.push(die);
        self
    }

    
    //==============================================================================================
    /// Remove all dice from the collection.
    //----------------------------------------------------------------------------------------------
    /// ##### Return value
    /// A mutable reference to the DiceCollection
    //----------------------------------------------------------------------------------------------
    /// # Examples
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{NumericDie,DiceCollection};
    /// # fn main() {
    ///
    /// let mut dice = DiceCollection::<NumericDie>::new();
    /// dice.add(NumericDie::new(1, 1, 6, None));
    ///
    /// assert_eq!(dice.size(), 1);
    ///
    /// dice.clear();
    /// assert!(dice.is_empty());
    /// # }
    /// ```
    //----------------------------------------------------------------------------------------------
    /// This operation may also be chained:
    ///
    /// ```
    /// # extern crate ezra;
    /// # use ezra::dice::{DiceCollection,NumericDie};
    /// # fn main() {
    /// let mut dice = DiceCollection::<NumericDie>::new();
    /// dice.add(NumericDie::new(1, 1, 6, None));
    ///
    /// assert!(dice.clear().is_empty());
    /// # }
    /// ```
    //==============================================================================================

    pub fn clear(&mut self) ->  &mut Self {
        self.dice.clear();
        self
    }


    //==============================================================================================
    /// Roll all dice in the collection.
    //----------------------------------------------------------------------------------------------
    /// ##### Return value
    /// A mutable reference to the DiceCollection
    //----------------------------------------------------------------------------------------------
    /// # Examples
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{NumericDie,DiceCollection};
    /// # fn main() {
    /// 
    /// let mkdie = || { NumericDie::new(1, 1, 6, None) };
    /// let mut dice = DiceCollection::<NumericDie>::new();
    ///
    /// dice.add(mkdie())
    ///     .add(mkdie())
    ///     .add(mkdie())
    ///     .roll_all();
    ///
    /// println!("After 1 roll, the sum of the dice is {}", dice.total());
    /// # }
    /// ```
    //----------------------------------------------------------------------------------------------
    /// This operation may also be chained:
    ///
    /// ```
    /// # extern crate ezra;
    /// # use ezra::dice::{NumericDie,DiceCollection};
    /// # fn main() {
    /// let mkdie = || { NumericDie::new(1, 1, 6, None) };
    /// let mut dice = DiceCollection::<NumericDie>::new();
    ///
    /// dice.add(mkdie()).roll_all().roll_all().roll_all();
    /// 
    /// println!("After 3 roll, the sum of the dice is {}", dice.total());
    /// # }
    /// ```
    //==============================================================================================

    pub fn roll_all(&mut self) -> &mut Self {
        for die in self.dice.iter_mut() {
            die.roll();
        }
        self
    }


    //==============================================================================================
    /// Determine if the collection contains dice.
    //----------------------------------------------------------------------------------------------
    /// ##### Return value
    /// - true : no dice are in the collection
    /// - false : the collection contains one or more dice
    //----------------------------------------------------------------------------------------------
    ///
    /// # Examples
    ///
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{NumericDie,DiceCollection};
    /// # fn main() {
    ///
    /// let mut dice = DiceCollection::new();
    /// assert!(dice.is_empty());
    ///
    /// dice.add(NumericDie::new(1, 1, 6, None));
    /// assert!(!dice.is_empty());
    /// # }
    /// ```
    //==============================================================================================

    pub fn is_empty(&self) -> bool {
        self.dice.is_empty()
    }


    //==============================================================================================
    /// Obtain the number of dice in the collection.
    //----------------------------------------------------------------------------------------------
    /// ##### Return value
    /// The number of dice in the collection
    //----------------------------------------------------------------------------------------------
    /// # Examples
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{DiceCollection,NumericDie};
    /// # fn main() {
    ///
    /// let mut dice = DiceCollection::new();
    /// assert_eq!(dice.size(), 0);
    ///
    /// dice.add(NumericDie::new(1, 1, 6, None));
    /// assert_eq!(dice.size(), 1);
    /// # }
    /// ```
    //==============================================================================================

    pub fn size(&self) -> usize {
        self.dice.len()
    }


    //==============================================================================================
    /// Obtain an immutable iterator across all dice in the collection
    //----------------------------------------------------------------------------------------------
    /// ##### Return value
    ///
    /// An immutable iterator across all dice in the collection
    //----------------------------------------------------------------------------------------------
    /// # Exampes
    ///
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{Die,DiceCollection, NumericDie};
    /// # fn main() {
    ///
    /// let mkdie = || { NumericDie::new(1, 1, 6, None) };
    /// let mut dice = DiceCollection::<NumericDie>::new();
    ///
    /// dice.add(mkdie())
    ///     .add(mkdie())
    ///     .add(mkdie());
    ///
    /// for (i,die) in dice.iter().enumerate() {
    ///     println!("Die {} has value {}.", i, die.get_value());
    /// }
    /// # }
    /// ```
    //==============================================================================================

    pub fn iter(&self) -> Iter<T> {
        self.dice.iter()
    }

    
    //==============================================================================================
    /// Obtain a mutable iterator across all dice in the collection.
    //----------------------------------------------------------------------------------------------
    /// ##### Return Value
    /// A mutable iterator across all dice in the collection.
    //----------------------------------------------------------------------------------------------
    /// # Examples
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{Die,DiceCollection,NumericDie};
    /// # fn main() {
    ///
    /// let mkdie = || { NumericDie::new(1, 1, 6, None) };
    /// let mut dice = DiceCollection::<NumericDie>::new();
    ///
    /// dice.add(mkdie())
    ///     .add(mkdie())
    ///     .add(mkdie());
    ///
    /// for die in dice.iter_mut() {
    ///     die.roll();
    /// }
    ///
    /// println!("After rolling each die once, their total is {}", dice.total());
    /// # }
    /// ```
    //==============================================================================================

    pub fn iter_mut(&mut self) -> IterMut<T> {
        self.dice.iter_mut()
    }
}


//==================================================================================================
impl<V: Add<V,Output=V>, T: Die<ValueType=V>> DiceCollection<T> {
//==================================================================================================


    //==============================================================================================
    /// Calculate the sum of all dice values.
    ///
    /// In order to use this method, the associated ValueType of the dice in the collection must
    /// implement the Add trait.
    //----------------------------------------------------------------------------------------------
    /// ##### Return value
    /// The sum of all dice values
    //----------------------------------------------------------------------------------------------
    /// # Examples
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{NumericDie,DiceCollection};
    /// # fn main() {
    /// 
    /// let mkdie = || { NumericDie::new(1, 1, 6, None) };
    /// let mut dice = DiceCollection::<NumericDie>::new();
    ///
    /// dice.add(mkdie())
    ///     .add(mkdie())
    ///     .add(mkdie())
    ///     .roll_all();
    ///
    /// println!("After 1 roll, the sum of the dice is {}", dice.total());
    /// # }
    /// ```
    //==============================================================================================

    pub fn total(&self) -> V {
        let mut total = self.dice[0].get_value();
        for die in self.dice.iter().skip(1) {
            total = total + die.get_value();
        }
        total
    }
}


//==================================================================================================
impl<V: Eq + Hash, T: Die<ValueType=V>> DiceCollection<T> {
//==================================================================================================

    
    //==============================================================================================
    /// Produce a summary of the state of all dice in the collection.
    ///
    /// The summary is a table of value types and their occurence count within the dice values in
    /// the DiceCollection. In order to use this function, the associated ValueType of the dice in
    /// the collection must implement the Eq and Hash traits.
    //----------------------------------------------------------------------------------------------
    /// ##### Return Value
    /// A HashMap with keys for each possible die value, with values corresponding to the number of
    /// occurrences of that key in the multiset of die values in the collection.
    //----------------------------------------------------------------------------------------------
    /// # Examples
    /// ```
    /// # extern crate ezra;
    /// use ezra::dice::{ValueDie,DiceCollection};
    /// # fn main() {
    ///
    /// // Values a die may have
    /// #[derive(Copy,Clone,Debug,Hash,Eq,PartialEq)]
    /// enum DiceValues {
    ///     Value1,
    ///     Value2,
    ///     Value3,
    /// }
    ///
    /// let values = vec![DiceValues::Value1, DiceValues::Value2, DiceValues::Value3];
    /// let mkdie = || { ValueDie::new(values, None) };
    /// let mut dice = DiceCollection::<ValueDie<DiceValues>>::new();
    /// dice.roll_all();
    ///
    /// let summary = dice.summary();
    /// for key in summary.keys() {
    ///     println!("Value {:?} occured {} time(s)", key, summary.get(key).unwrap()); 
    /// }
    /// # }
    /// ```
    //==============================================================================================
    pub fn summary(&self) -> HashMap<T::ValueType, usize> {
        use std::collections::HashMap;
        let mut result = HashMap::new();
        for die in self.dice.iter() {
            for value in die.values() {
                result.insert(value, 0);
            }
        }
        for die in self.dice.iter() {
            let oldval = *result.get(&die.get_value()).unwrap();
            result.insert(die.get_value(),  oldval + 1);
        }
        result
    }
}


//==================================================================================================
impl<T: Die + Display> Display for DiceCollection<T> {
//==================================================================================================


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

        let mut result = "{".to_string() + &format!("{}", self.dice[0]) ;
        for die in self.dice.iter().skip(1) {
            result = result + &format!(", {}", die);
        }
        write!(f, "{}", result)
    }
}