package core.gameserver.stats.formulas;

import core.commons.util.Rnd;
import core.gameserver.Config;
import core.gameserver.model.Creature;
import core.gameserver.model.Skill;
import core.gameserver.model.base.Element;
import core.gameserver.model.base.SkillTrait;
import core.gameserver.model.items.ItemInstance;
import core.gameserver.mods.balancer.Balancer;
import core.gameserver.stats.Env;
import core.gameserver.stats.Stats;

import java.util.ArrayList;

public class DebuffFormulas
{
    public static boolean calcSkillSuccess(Env env, int spiritshot)
    {
        if((env != null && env.value == -1))
            return true;

        if(env != null && env.target != null && env.target.isNpc() && env.target.isDamageBlocked())
            return false;

        if(env != null && env.target != null && env.target.isDebuffImmune())
            return false;

        if(CommonFormulas.calcIsImmune(env.target, env.skill))
            return false;

        env.value = Math.max(Math.min(env.value, 100), 1);

        final Skill skill = env.skill;

        if(!skill.isOffensive())
            return Rnd.chance(env.value);

        final Creature caster = env.character;
        final Creature target = env.target;

        double activate_rate = env.value;
        double rate = activate_rate;

        //Если offensive скил не имеет trait то и эффект к нему привязанный имеет статический шанс
        if(skill.isActivateRateStatic())
        {
            rate += levelModifierCalculate(skill, caster.getLevel(), target, skill.getMagicLevel());
            showDebuffChance(caster, target, skill, rate);
            return Rnd.chance((int)rate);
        }

        //Делим на модификатор стата, если есть
        if(skill.getSaveVs() != null)
            rate /= skill.getSaveVs().calcBonus(target);

        //Прибавляем левел мод
        rate += levelModifierCalculate(skill, caster.getLevel(), target, skill.getMagicLevel());

        //Умножаем на траит мод, если есть треит
        if(skill.getTraitType() != null || skill.getTraitType() != SkillTrait.NONE)
            rate = debuffResistsModifierCalculate(skill, env, rate);

        //Умножаем на модификатор дебаф резиста
        rate *= debuffResistsRate(target, caster, skill);

        //Умножаем на модификатор атрибута
        rate *= elementModifierCalculate(skill, caster, target);

        //Считаем модификатор из м.атаки и м.дефа и умножаем на него шанс
        double magic_attack_modifier = 1.;
        if(skill.isMagic())
        {
            int magic_defence = Math.max(1, target.getMDef(target, skill));
            double magic_attack;

            if(skill.getCubic() != null)
            {
                magic_attack = skill.getCubic().getPower();
            }
            else
                magic_attack = caster.getMAtk(target, skill);

            if(skill.getCubic() == null)
                magic_attack *= getSSMod(skill, spiritshot);

            magic_attack_modifier = Config.SKILLS_CHANCE_MOD * Math.pow(magic_attack, Config.SKILLS_CHANCE_POW) / magic_defence;

            rate = rate * magic_attack_modifier;
        }

        //Баланс модуль
        rate *= debuffBalanceModifier(caster, skill);
        rate *= balancerIncomeDebuffModifier(caster, target);

        //Применяем капы
        rate = applyCaps(rate);

        //Показываем шанс
        showDebuffChance(caster, target, skill, rate);

        return Rnd.chance((int)rate);
    }

    private static int getSSMod(Skill skill, int spiritshot)
    {
        if(!skill.isSSPossible())
            return 1;

        switch(spiritshot)
        {
            case ItemInstance.CHARGED_BLESSED_SPIRITSHOT:
                return 4;
            case ItemInstance.CHARGED_SPIRITSHOT:
                return 2;
            default:
                return 4;
        }
    }

    private static double debuffResistsModifierCalculate(Skill skill, Env env, double rate)
    {
        double trait_premod, attack_trait_bonus = 1, defence_trait_bonus = 1, trait_mod;
        ArrayList<Double> resists, powers;

        if(skill.isIgnoreResists())
            return rate;

        SkillTrait trait = skill.getTraitType();

        resists = trait.calcVulns(env);

        if(skill.isCubicCastingSkill())
            powers = new ArrayList<>();
        else
            powers = trait.calcProfs(env);

        for(double d : resists)
            defence_trait_bonus *= ((100 + d) / 100);

        for(double d : powers)
            attack_trait_bonus *= ((100 + d) / 100);

        trait_premod = attack_trait_bonus - defence_trait_bonus;
        trait_mod = 1 + trait_premod;

        if(trait_mod < 0.05)
            trait_mod = 0.05;
        else if(trait_mod > 1.95)
            trait_mod = 1.95;

        return rate * trait_mod;
    }

    private static double debuffResistsRate(Creature target, Creature caster, Skill skill)
    {
        return 1. + (target.calcStat(Stats.DEBUFF_POWER, caster, skill) - target.calcStat(Stats.DEBUFF_RESIST, caster, skill)) / 100;
    }

    private static int levelModifierCalculate(Skill skill, int caster_level, Creature target, int magic_level)
    {
        int skill_level_depend = skill.getLevelModifier();

        if(skill_level_depend == 0)
            return 0;

        int attack_level = magic_level > 0 ? magic_level : caster_level;
        int delta = attack_level - target.getLevel();

        return delta * skill_level_depend;
    }

    private static double elementModifierCalculate(Skill skill, Creature caster, Creature target)
    {
        double element_modifier = 1;
        Element element = skill.getElement();

        if(element != Element.NONE && caster.getActiveWeaponInstance() != null)
        {
            Element attackElement = caster.getActiveWeaponInstance().getAttackElement();
            double debuff_element_power = skill.getElementPower();
            double attack_element_power = caster.calcStat(element.getAttack(), 0);
            double defence_element_power = target.calcStat(element.getDefence(), 0);
            attack_element_power = attackElement != element ? 0 : attack_element_power;
            element_modifier = SimpleFormulas.getElementMod(debuff_element_power + attack_element_power, defence_element_power);
        }

        return element_modifier;
    }

    private static double applyCaps(double rate)
    {
        if(rate < Config.SKILLS_CHANCE_MIN)
            rate = Config.SKILLS_CHANCE_MIN;
        else if(rate > Config.SKILLS_CHANCE_CAP)
            rate = Config.SKILLS_CHANCE_CAP;
        return rate;
    }

    private static void showDebuffChance(Creature caster, Creature target, Skill skill, double rate)
    {
        if(caster != null && caster.getPlayer() != null && (Config.SKILLS_CHANCE_SHOW || caster.getPlayer().isGM()))
            caster.getPlayer().sendMessage(skill.getName() + " chance: " + (int)rate + "%");

        if(target != null && target.getPlayer() != null && (Config.SKILLS_CHANCE_SHOW || target.getPlayer().isGM()))
            target.getPlayer().sendMessage("Enemy " + skill.getName() + " chance: " + (int)rate + "%");
    }

    private static double balancerIncomeDebuffModifier(Creature attacker, Creature target)
    {
        double result = 1.;
        if(attacker.getPlayer() == null || target.getPlayer() == null)
            return result;

        int attacker_class_id = attacker.getPlayer().getClassId().getId();
        int target_class_id = target.getPlayer().getClassId().getId();
        boolean olympiad = target.getOlympiadGame() != null;

        result *= Balancer.incomeDebuffCalculate(attacker_class_id, target_class_id, olympiad);
        result *= Balancer.incomeCommonDebuffCalculate(target_class_id, olympiad);

        return result;
    }

    private static double debuffBalanceModifier(Creature caster, Skill skill)
    {
        if(caster == null || caster.getPlayer() == null)
            return 1.;

        int classId = caster.getPlayer().getClassId().getId();
        boolean isMagic = skill.isMagic();
        boolean hasTrait = skill.getTraitType() != null;

        boolean olympiad = caster.getOlympiadGame() != null;

        if(isMagic && !hasTrait)
            return Balancer.debuffMagicalModifierCalculate(classId, olympiad);
        else if(isMagic && hasTrait)
            return Balancer.debuffTraitMagicalModifierCalculate(classId, olympiad);
        else if(!isMagic && hasTrait)
            return Balancer.debuffTraitPhysicalModifierCalculate(classId, olympiad);
        else
            return Balancer.debuffPhysicalModifierCalculate(classId, olympiad);
    }

    public static void showStepByStepDebug(Skill skill)
    {

    }
}