use rand::prelude::*;

use cryp::{Stat};

#[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)]
pub enum Spec {
    SpeedI,

    // Pure redShield has to come first as it applies the base amount
    // that is multiplied
    LifeI,
    RedShieldI,
    BlueShieldI,
    LRSI,
    LBSI,
    RBSI,

    RedDamageI,
    GreenDamageI,
    BlueDamageI,
}

impl Spec {
    pub fn affects(&self) -> Vec<Stat> {
        match *self {
            Spec::RedDamageI    => vec![Stat::RedDamage],
            Spec::GreenDamageI  => vec![Stat::GreenDamage],
            Spec::BlueDamageI   => vec![Stat::BlueDamage],

            Spec::SpeedI        => vec![Stat::Speed],

            Spec::RedShieldI    => vec![Stat::RedShield],
            Spec::BlueShieldI   => vec![Stat::BlueShield],
            Spec::LifeI         => vec![Stat::Hp],
            Spec::LRSI          => vec![Stat::Hp, Stat::RedShield],
            Spec::LBSI          => vec![Stat::Hp, Stat::BlueShield],
            Spec::RBSI          => vec![Stat::BlueShield, Stat::RedShield],

        }
    }

    pub fn apply(&self, modified: u64, base: u64) -> u64 {
        let mut rng = thread_rng();

        let i_min = 32;
        let i_max = 64;

        match *self {
            Spec::RedDamageI        => modified + (base * 5 / 100),
            Spec::GreenDamageI      => modified + (base * 5 / 100),
            Spec::BlueDamageI       => modified + (base * 5 / 100),

            Spec::SpeedI            => modified + (base * 5 / 100),

            Spec::LifeI             => modified + (base * 5 / 100),
            Spec::RedShieldI        => modified + rng.gen_range(i_min, i_max),
            Spec::BlueShieldI       => modified + rng.gen_range(i_min, i_max),
            Spec::LRSI              => modified + (base * 5 / 100),
            Spec::LBSI              => modified + (base * 5 / 100),
            Spec::RBSI              => modified + (base * 5 / 100),
        }
    }

}