use construct::{Stat, EffectMeta};
use skill::{Skill};
use util::{IntPct};

pub type Cooldown = Option<u8>;

#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum Effect {
    Amplify,
    Banish,
    Block,
    Buff,
    Sustain,
    Curse,
    Haste,
    Hex,
    Hybrid,
    Invert,
    Counter,
    Purge,
    Reflect,
    Slow,
    Restrict,
    Stun,
    Intercept,
    Vulnerable,
    Silence,
    Wither, // Reduce green dmg (healing) taken

    // electric is the buff that applies
    // electrocute the dmg debuff
    Electric,
    Electrocute,

    // absorbtion is the buff
    // absorb is the increased damage
    Absorb,
    Absorption,

    // magic immunity
    Link,

    // effects over time
    Triage,
    Decay,
    Regen,
    Siphon,

    // Airborne,
    // Boost
    // Bleed,
    // Blind,
    // Deadly,
    // Enslave,
    // Fury,
    // Injured,
    // Leech,
    // Mesmerise,
    // Untouchable,
    // SpeedSiphon,
    // SpeedIncrease,

    Ko,
}

impl Effect {
    pub fn immune(&self, skill: Skill) -> bool {
        match self {
            Effect::Counter => match skill {
                Skill::Attack => true,
                Skill::Stun => true,
                _ => skill.colours().contains(&Colour::Red)
            },
            Effect::Banish => true,
            Effect::Sustain => [
                Skill::Stun,
                Skill::Hex,
                Skill::HexPlus,
                Skill::HexPlusPlus,
                Skill::Silence,
                Skill::SilencePlus,
                Skill::SilencePlusPlus,
                Skill::Ruin,
                Skill::RuinPlus,
                Skill::RuinPlusPlus,
                Skill::Restrict,
                Skill::RestrictPlus,
                Skill::RestrictPlusPlus
            ].contains(&skill),
            _ => false,
        }
    }

    pub fn disables_skill(&self, skill: Skill) -> bool {
        if skill.is_tick() {
            return false;
        }

        match self {
            Effect::Stun => true,
            Effect::Hex => true,
            Effect::Banish => true,
            Effect::Silence => skill.colours().contains(&Colour::Blue),
            Effect::Restrict => skill.colours().contains(&Colour::Red),
            Effect::Purge => skill.colours().contains(&Colour::Green),
            Effect::Ko => skill.ko_castable(),
            _ => false,
        }
    }

    pub fn modifications(&self) -> Vec<Stat> {
        match self {
            Effect::Vulnerable => vec![Stat::RedDamageTaken],
            Effect::Block => vec![Stat::RedDamageTaken],
            Effect::Buff => vec![Stat::RedPower, Stat::Speed],

            Effect::Absorption => vec![Stat::RedPower, Stat::BluePower],

            Effect::Amplify => vec![Stat::RedPower, Stat::BluePower],
            Effect::Curse => vec![Stat::BlueDamageTaken],

            Effect::Hybrid => vec![Stat::GreenPower],
            Effect::Wither => vec![Stat::GreenDamageTaken],

            Effect::Haste => vec![Stat::Speed],
            Effect::Slow => vec![Stat::Speed],

            Effect::Link => vec![Stat::BlueDamageTaken, Stat::GreenDamageTaken, Stat::RedDamageTaken],

            _ => vec![],
        }
    }

    pub fn apply(&self, value: u64, meta: Option<EffectMeta>) -> u64 {
        match self {
            Effect::Amplify |
            Effect::Vulnerable |
            Effect::Block |
            Effect::Buff |
            Effect::Curse |
            Effect::Haste |
            Effect::Slow |
            Effect::Hybrid |
            Effect::Wither  => value.pct(match meta {
                Some(EffectMeta::Multiplier(d)) => d,
                _ => 100,
            }),

            Effect::Link     => value >> 1,

            Effect::Absorption      => value + match meta {
                Some(EffectMeta::AddedDamage(d)) => d,
                _ => panic!("absorb meta not damage"),
            },

            _ => {
                info!("{:?} does not have a mod effect", self);
                return value;
            },
        }
    }

    pub fn colour(&self) -> Option<Colour> {
        match self {
            // physical
            Effect::Stun => Some(Colour::Red),
            Effect::Block => Some(Colour::Green),
            Effect::Buff => Some(Colour::Green),
            Effect::Counter => Some(Colour::Green),
            Effect::Vulnerable => Some(Colour::Red),
            Effect::Restrict => Some(Colour::Red),
            Effect::Sustain => Some(Colour::Green),
            Effect::Intercept => Some(Colour::Green),

            // magic
            Effect::Hex => Some(Colour::Blue),
            Effect::Curse => Some(Colour::Blue),
            Effect::Banish => None,
            // Effect::Banish => rng.gen_bool(0.5),

            Effect::Slow => Some(Colour::Blue),
            Effect::Haste => Some(Colour::Green),
            Effect::Absorption => Some(Colour::Green),
            Effect::Reflect => Some(Colour::Green),
            Effect::Amplify => Some(Colour::Green),
            Effect::Silence => Some(Colour::Blue),
            Effect::Wither => Some(Colour::Blue),
            Effect::Purge => Some(Colour::Blue),

            Effect::Electric => Some(Colour::Green),
            Effect::Electrocute => Some(Colour::Blue),

            Effect::Absorb => Some(Colour::Green),

            // magic
            Effect::Hybrid => Some(Colour::Green),
            Effect::Link => Some(Colour::Green),
            Effect::Invert => Some(Colour::Green),

            // effects over time
            Effect::Triage => Some(Colour::Green),
            Effect::Decay => Some(Colour::Blue),
            Effect::Regen => Some(Colour::Green),
            Effect::Siphon => Some(Colour::Blue),

            Effect::Ko => None,
        }
    }
}

#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum Colour {
    Red,
    Blue,
    Green,
}