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

pub type Cooldown = Option<usize>;

#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum Effect {
    Amplify,
    Banish,
    Block,
    Buff,
    Counter,
    Curse,
    Haste,
    Hybrid,
    Intercept,
    Invert,
    Pure,
    Purge,
    Reflect,
    Restrict,
    Silence,
    Slow,
    Stun,
    Sustain,
    Vulnerable,
    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

    // effects over time
    Triage,
    Triaged, // immunity

    Decay,
    Decayed, // immunity

    Siphon,
    Siphoned, // immunity

    Countered,

    // Regen,
    // 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::Banish => true,

            Effect::Sustain => [
                Skill::Stun,
                Skill::Silence,
                Skill::SilencePlus,
                Skill::SilencePlusPlus,
                Skill::Ruin,
                Skill::RuinPlus,
                Skill::RuinPlusPlus,
                Skill::Restrict,
                Skill::RestrictPlus,
                Skill::RestrictPlusPlus
            ].contains(&skill),

            Effect::Siphoned => [
                Skill::Siphon,
                Skill::SiphonPlus,
                Skill::SiphonPlusPlus,
                Skill::SiphonTick,
            ].contains(&skill),

            Effect::Decayed => [
                Skill::Decay,
                Skill::DecayPlus,
                Skill::DecayPlusPlus,
                Skill::DecayTick,
            ].contains(&skill),

            Effect::Triaged => [
                Skill::Triage,
                Skill::TriagePlus,
                Skill::TriagePlusPlus,
                Skill::TriageTick,
            ].contains(&skill),

            _ => false,
        }
    }

    // hidden effects are used generally for immunities
    // they are not displayed on client
    // and not included in counts
    pub fn hidden(&self) -> bool {
        match self {
            Effect::Siphoned => true,
            Effect::Decayed => true,
            Effect::Triaged => true,
            Effect::Countered => true,
            _ => false,
        }
    }

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

        match self {
            Effect::Stun => 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 {
            // Bases
            Effect::Block => vec![Stat::RedDamageReceived, Stat::BlueDamageReceived],
            Effect::Buff => vec![Stat::BluePower, Stat::RedPower, Stat::Speed],
            Effect::Slow => vec![Stat::Speed],

            // Power changes
            Effect::Absorption => vec![Stat::RedPower, Stat::BluePower],
            Effect::Amplify => vec![Stat::RedPower, Stat::BluePower],
            Effect::Hybrid => vec![Stat::GreenPower],

            // Damage taken changes
            Effect::Curse => vec![Stat::RedDamageReceived, Stat::BlueDamageReceived],
            Effect::Pure => vec![Stat::GreenHealingReceived], // increased green taken
            Effect::Vulnerable => vec![Stat::RedDamageReceived],
            Effect::Wither => vec![Stat::GreenHealingReceived], // reduced green taken

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

            _ => vec![],
        }
    }

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

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

            _ => {
                warn!("{:?} 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::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::Invert => Some(Colour::Green),

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

            Effect::Triaged => None,
            Effect::Decayed => None,
            Effect::Siphoned => None,
            Effect::Countered => None,
            Effect::Ko => None,
        }
    }
}