use rand::prelude::*;

use cryp::{Stat, Colours};

#[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,
    GRDI,
    GBDI,
    RBDI,

    RedDamageI,
    GreenDamageI,
    BlueDamageI,
}

pub trait IntPct {
    fn pct(self, pct: u64) -> u64;
}

impl IntPct for u64 {
    fn pct(self, pct: u64) -> u64 {
        self * pct / 100
    }
}

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::GRDI          => vec![Stat::GreenDamage, Stat::RedDamage],
            Spec::GBDI          => vec![Stat::GreenDamage, Stat::BlueDamage],
            Spec::RBDI          => vec![Stat::RedDamage, 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, team_colours: &Colours) -> u64 {
        let mut rng = thread_rng();

        let i_min = 32;
        let i_max = 64;
        
        fn apply_bonus(colours: Vec<u8>, reqs: Vec<u8>, bonuses: Vec<u64>) -> u64 {
            bonuses.iter().enumerate().fold(0, |acc, (i, b)| {
                acc + match (colours.iter().all(|colour| colour >= &reqs[i])) {
                    true => bonuses[i],
                    false => 0
                }
            })
        }

        match *self {
            Spec::RedDamageI        => modified + {
                let mut bonus = base.pct(5);
                bonus + apply_bonus(vec![team_colours.red], vec![5, 10, 20], 
                    vec![base.pct(5), base.pct(10), base.pct(20)])
            },
            Spec::GreenDamageI        => modified + {
                let mut bonus = base.pct(5) as u64;
                bonus + apply_bonus(vec![team_colours.green], vec![5, 10, 20],
                    vec![base.pct(5), base.pct(10), base.pct(20)])
            },
            Spec::BlueDamageI        => modified + {
                let mut bonus = base.pct(5) as u64;
                bonus + apply_bonus(vec![team_colours.blue], vec![5, 10, 20], 
                    vec![base.pct(5), base.pct(10), base.pct(20)])
            },
            Spec::GRDI              => modified + {
                let mut bonus = base.pct(5) as u64;
                bonus + apply_bonus(vec![team_colours.green, team_colours.red], 
                    vec![2, 5, 10], vec![base.pct(5), base.pct(10), base.pct(20)])
            },
            Spec::GBDI              => modified + {
                let mut bonus = base.pct(5) as u64;
                bonus + apply_bonus(vec![team_colours.green, team_colours.blue], 
                    vec![2, 5, 10], vec![base.pct(5), base.pct(10), base.pct(20)])
            },
            Spec::RBDI              => modified + {
                let mut bonus = base.pct(5) as u64;
                bonus + apply_bonus(vec![team_colours.red, team_colours.blue], 
                    vec![2, 5, 10], vec![base.pct(5), base.pct(10), base.pct(20)])
            },

            Spec::SpeedI            => modified + base.pct(5),

            Spec::LifeI             => modified + {
                let mut bonus = 10 * team_colours.green as u64;
                bonus + apply_bonus(vec![team_colours.green], vec![5, 10, 20], vec![bonus, bonus * 2, bonus * 3])
            },
            Spec::RedShieldI        => modified + {
                let mut bonus = 10 * team_colours.red as u64;
                bonus + apply_bonus(vec![team_colours.red], vec![5, 10, 20], vec![bonus, bonus * 2, bonus * 3])
            },
            Spec::BlueShieldI       => modified + {
                let mut bonus = 10 * team_colours.blue as u64;
                bonus + apply_bonus(vec![team_colours.blue], vec![5, 10, 20], vec![bonus, bonus * 2, bonus * 3])
            },            
            Spec::LRSI              => modified + {
                let mut bonus = 5 * (team_colours.green + team_colours.red) as u64;
                bonus + apply_bonus(vec![team_colours.green, team_colours.red], 
                    vec![2, 5, 10], vec![bonus, bonus * 2, bonus * 3])
            },
            Spec::LBSI              => modified + {
                let mut bonus = 5 * (team_colours.green + team_colours.blue) as u64;
                bonus + apply_bonus(vec![team_colours.green, team_colours.blue], 
                    vec![2, 5, 10], vec![bonus, bonus * 2, bonus * 3])
            },
            Spec::RBSI              => modified + {
                let mut bonus = 5 * (team_colours.red + team_colours.blue) as u64;
                bonus + apply_bonus(vec![team_colours.red, team_colours.blue], 
                    vec![2, 5, 10], vec![bonus, bonus * 2, bonus * 3])
            },
        }
    }
}