// Copyright 2017 Kyle Mayes
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! A dice rolling and statistics library.

#![feature(conservative_impl_trait, i128_type)]

#![warn(missing_copy_implementations, missing_debug_implementations, missing_docs)]

#![cfg_attr(feature="clippy", feature(plugin))]
#![cfg_attr(feature="clippy", plugin(clippy))]
#![cfg_attr(feature="clippy", warn(clippy))]

extern crate rand;

#[macro_use]
mod utility;

mod statistics;

pub mod syntax;

use std::cmp;

use rand::{Rng};

pub use self::statistics::ratio::{Ratio};

/// The result of rolling a die.
pub type DieResult = (u32, Option<u32>);

/// The result of rolling a set of same-sized dice.
pub type DiceResult = (u32, Vec<DieResult>);

//================================================
// Enums
//================================================

// Binary ________________________________________

/// An operation used to combine the results of two dice rolling expressions.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum Binary {
    /// Add the results.
    Add,
    /// Divide the results.
    Divide,
    /// Multiply the results.
    Multiply,
    /// Subtract the results.
    Subtract,
}

impl Binary {
    //- Accessors --------------------------------

    /// Combines the supplied results using this binary operation.
    ///
    /// This method returns `None` if the binary operation fails (e.g., integer overflow).
    pub fn combine(&self, left: i32, right: i32) -> Option<i32> {
        match *self {
            Binary::Add => left.checked_add(right),
            Binary::Divide => left.checked_div(right),
            Binary::Multiply => left.checked_mul(right),
            Binary::Subtract => left.checked_sub(right),
        }
    }
}

// Expression ____________________________________

/// A dice rolling expression.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Expression {
    /// A binary expression.
    Binary(Binary, Box<Expression>, Box<Expression>),
    /// A constant expression.
    Constant(u32),
    /// A die expression.
    Die(Die, Option<Reroll>),
    /// A dice expression.
    Dice(Dice, Option<Reroll>, Fold),
}

impl Expression {
    //- Accessors --------------------------------

    /// Rolls this dice rolling expression and returns the result.
    ///
    /// This method returns `None` if any of the binary operations fail (e.g., integer overflow).
    pub fn roll(&self, rng: &mut Rng) -> Option<i32> {
        match *self {
            Expression::Binary(binary, ref left, ref right) => {
                let left = try_opt!(left.roll(rng));
                let right = try_opt!(right.roll(rng));
                binary.combine(left, right)
            },
            Expression::Constant(constant) => Some(constant as i32),
            Expression::Die(die, reroll) => Some(die.roll(rng, reroll).0 as i32),
            Expression::Dice(dice, reroll, fold) => Some(dice.roll(rng, reroll, fold).0 as i32),
        }
    }
}

// Fold __________________________________________

/// An operation used to combine the results of rolling a set of same-sized dice.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum Fold {
    /// Sum the results after dropping the smallest result.
    DropMinimum,
    /// Sum the results after dropping the largest result.
    DropMaximum,
    /// Take the smallest result.
    Minimum,
    /// Take the largest result.
    Maximum,
    /// Sum the results.
    Sum,
}

impl Fold {
    //- Accessors --------------------------------

    /// Combines the supplied results using this fold operation.
    pub fn combine<R>(&self, results: R) -> u32 where R: Iterator<Item=u32> {
        match *self {
            Fold::DropMinimum => {
                let start = (0, u32::max_value());
                let (sum, minimum) = results.fold(start, |(s, m), r| (s + r, cmp::min(r, m)));
                sum - minimum
            },
            Fold::DropMaximum => {
                let start = (0, u32::min_value());
                let (sum, maximum) = results.fold(start, |(s, m), r| (s + r, cmp::max(r, m)));
                sum - maximum
            },
            Fold::Minimum => results.min().unwrap_or(0),
            Fold::Maximum => results.max().unwrap_or(0),
            Fold::Sum => results.sum(),
        }
    }
}

//================================================
// Structs
//================================================

// Dice __________________________________________

/// A set of same-sized dice.
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
pub struct Dice(u32, Die);

impl Dice {
    //- Constructors -----------------------------

    /// Constructs a new `Dice`.
    ///
    /// # Panics
    ///
    /// * `size` is zero
    pub fn new(size: u32, die: Die) -> Self {
        assert!(size != 0, "`size` is zero");
        Dice(size, die)
    }

    //- Accessors --------------------------------

    /// Returns the size of this set of dice.
    pub fn size(&self) -> u32 {
        self.0
    }

    /// Returns the die used in this set of dice.
    pub fn die(&self) -> Die {
        self.1
    }

    /// Rolls this set of dice and returns the combined result.
    pub fn roll(&self, rng: &mut Rng, reroll: Option<Reroll>, fold: Fold) -> DiceResult {
        let results = (0..self.0).map(|_| self.1.roll(rng, reroll)).collect::<Vec<_>>();
        (fold.combine(results.iter().map(|&(r, _)| r)), results)
    }
}

// Die ___________________________________________

/// A die.
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Die(u32);

impl Die {
    //- Constructors -----------------------------

    /// Constructs a new `Die`.
    ///
    /// # Panics
    ///
    /// * `size` is zero
    pub fn new(size: u32) -> Die {
        assert!(size != 0, "`size` is zero");
        Die(size)
    }

    //- Accessors --------------------------------

    /// Returns the size of this die.
    pub fn size(&self) -> u32 {
        self.0
    }

    /// Rolls this die and returns the result.
    pub fn roll(&self, rng: &mut Rng, reroll: Option<Reroll>) -> DieResult {
        let roll = generate(rng, 1, self.0);
        if reroll.map_or(false, |r| r.reroll(roll, *self)) {
            (generate(rng, 1, self.0), Some(roll))
        } else {
            (roll, None)
        }
    }
}

// Reroll ________________________________________

/// An inclusive upper bound on rolls that should be rerolled once.
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Reroll(u32);

impl Reroll {
    //- Constructors -----------------------------

    /// Constructs a new `Reroll`.
    ///
    /// # Panics
    ///
    /// * `maximum` is zero
    pub fn new(maximum: u32) -> Self {
        assert!(maximum != 0, "`maximum` is zero");
        Reroll(maximum)
    }

    //- Accessors --------------------------------

    /// Returns whether the supplied roll on the supplied die should be rerolled once.
    ///
    /// This method returns `true` only when it would be advantagous to reroll the die. In other
    /// words, this method always returns `false` when supplied with a roll that is above average
    /// for the supplied die.
    pub fn reroll(&self, roll: u32, die: Die) -> bool {
        roll <= (die.size() / 2) && roll <= self.0
    }
}

//================================================
// Functions
//================================================

fn generate(rng: &mut Rng, minimum: u32, maximum: u32) -> u32 {
    assert!(minimum <= maximum);
    let size = (maximum - minimum) + 1;
    let mut number = rng.next_u32();
    while number >= u32::max_value() - (u32::max_value() % size) {
        number = rng.next_u32();
    }
    (number % size) + minimum
}