// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
//      Magicbane Emulator Project © 2013 - 2022
//                www.magicbane.com

package engine.gameManager;

import engine.job.JobContainer;
import engine.job.JobScheduler;
import engine.jobs.AttackJob;
import engine.jobs.DeferredPowerJob;
import engine.mbEnums;
import engine.net.DispatchMessage;
import engine.net.client.ClientConnection;
import engine.net.client.msg.TargetedActionMsg;
import engine.net.client.msg.UpdateStateMsg;
import engine.objects.*;
import engine.powers.DamageShield;
import engine.powers.effectmodifiers.AbstractEffectModifier;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;

import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.util.EnumSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;

public enum CombatManager {

    COMBAT_MANAGER;

    public static void combatCycle(AbstractCharacter attacker, AbstractWorldObject target) {

        //early exit checks

        if (attacker == null || target == null || !attacker.isAlive() || !target.isAlive())
            return;

        if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
            if (((Mob) attacker).nextAttackTime > System.currentTimeMillis())
                return;

        switch (target.getObjectType()) {
            case Building:
                if (!((Building) target).isVulnerable())
                    return;
                break;
            case PlayerCharacter:
            case Mob:
                PlayerBonuses bonuses = ((AbstractCharacter) target).getBonuses();
                if (bonuses != null && bonuses.getBool(mbEnums.ModType.ImmuneToAttack, mbEnums.SourceType.None))
                    return;
                break;
            case NPC:
                return;
        }

        Item mainWeapon = attacker.charItemManager.getEquipped().get(mbEnums.EquipSlotType.RHELD);
        Item offWeapon = attacker.charItemManager.getEquipped().get(mbEnums.EquipSlotType.LHELD);

        if (mainWeapon == null && offWeapon == null) {
            //no weapons equipped, punch with both fists
            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
            if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter))
                processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
            return;
        }

        if (mainWeapon != null && offWeapon == null) {
            //swing right hand only
            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
            return;
        }

        if (mainWeapon == null && offWeapon != null && !offWeapon.template.item_skill_required.containsKey("Block")) {
            //swing left hand only
            processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
            return;
        }

        if (mainWeapon == null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block")) {
            //no weapon equipped with a shield, punch with one hand
            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
            return;
        }

        if (mainWeapon != null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block")) {
            //one weapon equipped with a shield, swing with one hand
            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
            return;
        }

        if (mainWeapon != null && offWeapon != null && !offWeapon.template.item_skill_required.containsKey("Block")) {
            //two weapons equipped, swing both hands
            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
            if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter))
                processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
        }
    }

    public static void processAttack(AbstractCharacter attacker, AbstractWorldObject target, mbEnums.EquipSlotType slot) {

        if(attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
            if (!attacker.isCombat())
                return;

            if (attacker.getTimestamps().get("Attack" + slot.name()) != null && attacker.getTimestamps().get("Attack" + slot.name()) < System.currentTimeMillis()) {
                setAutoAttackJob(attacker, slot, 1000);
                return;
            }
        }

        // check if character is in range to attack target

        PlayerBonuses bonus = attacker.getBonuses();

        float rangeMod = 1.0f;
        float attackRange = MBServerStatics.NO_WEAPON_RANGE;

        Item weapon = attacker.charItemManager.getEquipped(slot);

        if (weapon != null) {
            if (bonus != null)
                rangeMod += bonus.getFloatPercentAll(mbEnums.ModType.WeaponRange, mbEnums.SourceType.None);

            attackRange = weapon.template.item_weapon_max_range * rangeMod;
        }

        if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
            if (((Mob) attacker).isSiege())
                attackRange = 300;

        float distanceSquared = attacker.loc.distanceSquared(target.loc);

        boolean inRange = false;
        if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
            attackRange += ((PlayerCharacter) attacker).getCharacterHeight() * 0.5f;
        } else {
            attackRange += attacker.calcHitBox();
        }
        switch (target.getObjectType()) {
            case PlayerCharacter:
                attackRange += ((PlayerCharacter) target).getCharacterHeight() * 0.5f;
                if (distanceSquared < attackRange * attackRange)
                    inRange = true;
                break;
            case Mob:
                attackRange += ((AbstractCharacter) target).calcHitBox();
                if (distanceSquared < attackRange * attackRange)
                    inRange = true;
                break;
            case Building:
                float locX = target.loc.x - target.getBounds().getHalfExtents().x;
                float locZ = target.loc.z - target.getBounds().getHalfExtents().y;
                float sizeX = (target.getBounds().getHalfExtents().x + attackRange) * 2;
                float sizeZ = (target.getBounds().getHalfExtents().y + attackRange) * 2;
                Rectangle2D.Float rect = new Rectangle2D.Float(locX, locZ, sizeX, sizeZ);
                if (rect.contains(new Point2D.Float(attacker.loc.x, attacker.loc.z)))
                    inRange = true;
                break;
        }

        //get delay for the auto attack job
        long delay = 5000;

        if (weapon != null) {

            int wepSpeed = (int) (weapon.template.item_weapon_wepspeed);

            if (weapon.getBonusPercent(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None) != 0f) //add weapon speed bonus
                wepSpeed *= (1 + weapon.getBonus(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None));

            if (attacker.getBonuses() != null && attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None) != 0f) //add effects speed bonus
                wepSpeed *= (1 + attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None));

            if (wepSpeed < 10)
                wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects.

            delay = wepSpeed * 100L;
        }

        if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
            ((Mob) attacker).nextAttackTime = System.currentTimeMillis() + delay;

        if (inRange) {

            //handle retaliate
            if (AbstractCharacter.IsAbstractCharacter(target)) {
                if (((AbstractCharacter) target).combatTarget == null || !((AbstractCharacter) target).combatTarget.isAlive()) {
                    ((AbstractCharacter) target).combatTarget = attacker;
                    if (target.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter) && ((AbstractCharacter) target).isCombat())
                        combatCycle((AbstractCharacter) target, attacker);
                }
            }



            //check if Out of Stamina
            if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
                if (attacker.getStamina() < (weapon.template.item_wt / 3f)) {
                    //set auto attack job
                    setAutoAttackJob(attacker, slot, delay);
                    return;
                }
            }
            // take stamina away from attacker
            if (weapon != null) {
                float stam = weapon.template.item_wt / 3f;
                stam = (stam < 1) ? 1 : stam;
                attacker.modifyStamina(-(stam), attacker, true);
            } else
                attacker.modifyStamina(-0.5f, attacker, true);

            //cancel things that are cancelled by an attack

            attacker.cancelOnAttackSwing();

            //declare relevant variables

            int min = attacker.minDamageHandOne;
            int max = attacker.maxDamageHandOne;
            int atr = attacker.atrHandOne;

            //get the proper stats based on which slot is attacking

            if (slot == mbEnums.EquipSlotType.LHELD) {
                min = attacker.minDamageHandTwo;
                max = attacker.maxDamageHandTwo;
                atr = attacker.atrHandTwo;
            }

            int def = 0;

            if (AbstractCharacter.IsAbstractCharacter(target))
                def = ((AbstractCharacter) target).defenseRating;

            //calculate hit chance based off ATR and DEF

            int hitChance;
            if (def == 0)
                def = 1;
            float dif = atr * 1f / def;

            if (dif <= 0.8f)
                hitChance = 4;
            else
                hitChance = ((int) (450 * (dif - 0.8f)) + 4);

            if (target.getObjectType() == mbEnums.GameObjectType.Building)
                hitChance = 100;

            int passiveAnim = getSwingAnimation(null, null, slot.equals(mbEnums.EquipSlotType.RHELD));
            if (attacker.charItemManager.getEquipped().get(slot) != null) {
                passiveAnim = getSwingAnimation(attacker.charItemManager.getEquipped().get(slot).template, null, true);
            }

            if (ThreadLocalRandom.current().nextInt(100) > hitChance) {
                TargetedActionMsg msg = new TargetedActionMsg(attacker, target, 0f, passiveAnim);

                if (target.getObjectType() == mbEnums.GameObjectType.PlayerCharacter)
                    DispatchMessage.dispatchMsgToInterestArea(target, msg, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
                else
                    DispatchMessage.sendToAllInRange(attacker, msg);

                //set auto attack job
                setAutoAttackJob(attacker, slot, delay);
                return;
            }

            //calculate passive chances only if target is AbstractCharacter

            if (EnumSet.of(mbEnums.GameObjectType.PlayerCharacter, mbEnums.GameObjectType.NPC, mbEnums.GameObjectType.Mob).contains(target.getObjectType())) {
                mbEnums.PassiveType passiveType = mbEnums.PassiveType.None;
                int hitRoll = ThreadLocalRandom.current().nextInt(100);

                float dodgeChance = ((AbstractCharacter) target).getPassiveChance("Dodge", attacker.getLevel(), true);
                float blockChance = ((AbstractCharacter) target).getPassiveChance("Block", attacker.getLevel(), true);
                float parryChance = ((AbstractCharacter) target).getPassiveChance("Parry", attacker.getLevel(), true);

                // Passive chance clamped at 75

                dodgeChance = Math.max(0, Math.min(75, dodgeChance));
                blockChance = Math.max(0, Math.min(75, blockChance));
                parryChance = Math.max(0, Math.min(75, parryChance));

                if (hitRoll < dodgeChance)
                    passiveType = mbEnums.PassiveType.Dodge;
                else if (hitRoll < blockChance)
                    passiveType = mbEnums.PassiveType.Block;
                else if (hitRoll < parryChance)
                    passiveType = mbEnums.PassiveType.Parry;


                if (!passiveType.equals(mbEnums.PassiveType.None)) {
                    TargetedActionMsg msg = new TargetedActionMsg(attacker, passiveAnim, target, passiveType.value);

                    if (target.getObjectType() == mbEnums.GameObjectType.PlayerCharacter)
                        DispatchMessage.dispatchMsgToInterestArea(target, msg, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
                    else
                        DispatchMessage.sendToAllInRange(attacker, msg);

                    //set auto attack job
                    setAutoAttackJob(attacker, slot, delay);
                    return;
                }
            }

            //calculate the base damage
            int damage = ThreadLocalRandom.current().nextInt(min, max + 1);
            if (damage == 0) {
                //set auto attack job
                setAutoAttackJob(attacker, slot, delay);
                return;
            }
            //get the damage type

            mbEnums.DamageType damageType;

            if (attacker.charItemManager.getEquipped().get(slot) == null) {
                damageType = mbEnums.DamageType.CRUSHING;
                if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
                    if (((Mob) attacker).isSiege())
                        damageType = mbEnums.DamageType.SIEGE;
            } else {
                damageType = (mbEnums.DamageType) attacker.charItemManager.getEquipped().get(slot).template.item_weapon_damage.keySet().toArray()[0];
            }

            //get resists

            Resists resists;

            if (!AbstractCharacter.IsAbstractCharacter(target))
                resists = ((Building) target).getResists();            //this is a building
            else
                resists = ((AbstractCharacter) target).getResists();   //this is a character

            if (AbstractCharacter.IsAbstractCharacter(target)) {
                AbstractCharacter absTarget = (AbstractCharacter) target;

                //check damage shields

                PlayerBonuses bonuses = absTarget.getBonuses();

                if (bonuses != null) {

                    ConcurrentHashMap<AbstractEffectModifier, DamageShield> damageShields = bonuses.getDamageShields();
                    float total = 0;

                    for (DamageShield ds : damageShields.values()) {

                        //get amount to damage back

                        float amount;

                        if (ds.usePercent())
                            amount = damage * ds.getAmount() / 100;
                        else
                            amount = ds.getAmount();

                        //get resisted damage for damagetype

                        if (resists != null)
                            amount = resists.getResistedDamage(absTarget, attacker, ds.getDamageType(), amount, 0);
                        total += amount;
                    }

                    if (total > 0) {
                        //apply Damage back
                        attacker.modifyHealth(-total, absTarget, true);
                        TargetedActionMsg cmm = new TargetedActionMsg(attacker, attacker, total, 0);
                        DispatchMessage.sendToAllInRange(target, cmm);
                    }
                }

                if (resists != null) {

                    //check for damage type immunities

                    if (resists.immuneTo(damageType)) {
                        //set auto attack job
                        setAutoAttackJob(attacker, slot, delay);
                        return;
                    }
                    //calculate resisted damage including fortitude

                    damage = (int) resists.getResistedDamage(attacker, (AbstractCharacter) target, damageType, damage, 0);
                }
            }

            //remove damage from target health

            if (damage > 0) {

                if (AbstractCharacter.IsAbstractCharacter(target))
                    ((AbstractCharacter) target).modifyHealth(-damage, attacker, true);
                else
                    ((Building) target).setCurrentHitPoints(target.getCurrentHitpoints() - damage);

                int attackAnim = getSwingAnimation(null, null, slot.equals(mbEnums.EquipSlotType.RHELD));
                if (attacker.charItemManager.getEquipped().get(slot) != null) {
                    if(attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
                        DeferredPowerJob weaponPower = ((PlayerCharacter) attacker).getWeaponPower();
                        attackAnim = getSwingAnimation(attacker.charItemManager.getEquipped().get(slot).template, weaponPower, slot.equals(mbEnums.EquipSlotType.RHELD));
                    }else {
                        attackAnim = getSwingAnimation(attacker.charItemManager.getEquipped().get(slot).template, null, slot.equals(mbEnums.EquipSlotType.RHELD));
                    }
                }
                TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) damage, attackAnim);
                DispatchMessage.sendToAllInRange(target, cmm);
            }
        }

        DeferredPowerJob dpj = null;

        if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {

            dpj = ((PlayerCharacter) attacker).getWeaponPower();

            if (dpj != null) {
                dpj.attack(target, attackRange);

                if (dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518))
                    ((PlayerCharacter) attacker).setWeaponPower(dpj);
            }
        }

        //set auto attack job
        setAutoAttackJob(attacker, slot, delay);

    }

    public static void toggleCombat(boolean toggle, ClientConnection origin) {

        PlayerCharacter playerCharacter = SessionManager.getPlayerCharacter(origin);

        if (playerCharacter == null)
            return;

        playerCharacter.setCombat(toggle);

        if (!toggle) // toggle is move it to false so clear combat target
            playerCharacter.setCombatTarget(null); //clear last combat target

        UpdateStateMsg rwss = new UpdateStateMsg();
        rwss.setPlayer(playerCharacter);
        DispatchMessage.dispatchMsgToInterestArea(playerCharacter, rwss, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
    }

    public static void toggleSit(boolean toggle, ClientConnection origin) {

        PlayerCharacter playerCharacter = SessionManager.getPlayerCharacter(origin);

        if (playerCharacter == null)
            return;

        playerCharacter.setSit(toggle);
        UpdateStateMsg rwss = new UpdateStateMsg();
        rwss.setPlayer(playerCharacter);
        DispatchMessage.dispatchMsgToInterestArea(playerCharacter, rwss, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
    }


    public static void handleRetaliate(AbstractCharacter target, AbstractCharacter attacker) {

        //Called when character takes damage.

        if (attacker == null || target == null)
            return;

        if (attacker.equals(target))
            return;

        if (target.isMoving() && target.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter))
            return;

        if (!target.isAlive() || !attacker.isAlive())
            return;

        boolean isCombat = target.isCombat();

        //If target in combat and has no target, then attack back

        if (isCombat && target.combatTarget == null)
            target.setCombatTarget(attacker);
    }

    public static int getSwingAnimation(ItemTemplate wb, DeferredPowerJob dpj, boolean mainHand) {

        int token;

        if (dpj != null) {

            token = (dpj.getPower() != null) ? dpj.getPower().getToken() : 0;

            if (token == 563721004) //kick animation
                return 79;

            if (wb != null) {
                if (mainHand) {
                    int random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_right.size());
                    int anim = wb.weapon_attack_anim_right.get(random)[0];
                    return anim;
                }else {
                    int random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_left.size());
                    return wb.weapon_attack_anim_left.get(random)[0];
                }
            }
        }

        if (wb == null)
            return 75;

        if (mainHand)
            return wb.weapon_attack_anim_right.get(0)[0];
        else
            return wb.weapon_attack_anim_left.get(0)[0];

    }

    public static void setAutoAttackJob(AbstractCharacter attacker, mbEnums.EquipSlotType slot, long delay) {
        //calculate next allowed attack and update the timestamp
        attacker.getTimestamps().put("Attack" + slot.name(), System.currentTimeMillis() + delay);

        //handle auto attack job creation
        ConcurrentHashMap<String, JobContainer> timers = attacker.getTimers();

        if (timers != null) {
            AttackJob aj = new AttackJob(attacker, slot.ordinal(), true);
            JobContainer job;
            job = JobScheduler.getInstance().scheduleJob(aj, (System.currentTimeMillis() + delay)); // offset 1 millisecond so no overlap issue
            timers.put("Attack" + slot, job);
        } else
            Logger.error("Unable to find Timers for Character " + attacker.getObjectUUID());

    }
}