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

package engine.mobileAI;

import engine.Enum;
import engine.Enum.DispatchChannel;
import engine.InterestManagement.WorldGrid;
import engine.gameManager.*;
import engine.math.Vector3f;
import engine.math.Vector3fImmutable;
import engine.mobileAI.Threads.MobAIThread;
import engine.mobileAI.utilities.CombatUtilities;
import engine.mobileAI.utilities.MovementUtilities;
import engine.net.DispatchMessage;
import engine.net.client.msg.PerformActionMsg;
import engine.net.client.msg.PowerProjectileMsg;
import engine.objects.*;
import engine.powers.ActionsBase;
import engine.powers.PowersBase;
import engine.powers.RunePowerEntry;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;

import static engine.math.FastMath.sqr;

public class MobAI {


    private static void AttackTarget(Mob mob, AbstractWorldObject target) {

        try {

            if (mob == null)
                return;

            if (target == null || !target.isAlive()) {
                mob.setCombatTarget(null);
                return;
            }

            if (target.getObjectType().equals(Enum.GameObjectType.PlayerCharacter) &&
                    !mob.canSee((AbstractCharacter) target)) {
                mob.setCombatTarget(null);
                return;
            }

            if (target.getObjectType() == Enum.GameObjectType.PlayerCharacter && canCast(mob)) {

                if (MobCast(mob)) {
                    mob.updateLocation();
                    return;
                }

            }

            if (!CombatUtilities.inRangeToAttack(mob, target))
                return;

            switch (target.getObjectType()) {
                case PlayerCharacter:
                    PlayerCharacter targetPlayer = (PlayerCharacter) target;
                    AttackPlayer(mob, targetPlayer);
                    break;
                case Building:
                    Building targetBuilding = (Building) target;
                    AttackBuilding(mob, targetBuilding);
                    break;
                case Mob:
                    Mob targetMob = (Mob) target;
                    AttackMob(mob, targetMob);
                    break;
            }

            mob.updateLocation();

        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
        }
    }

    public static void AttackPlayer(Mob mob, PlayerCharacter target) {

        try {

            if (!mob.canSee(target)) {
                mob.setCombatTarget(null);
                return;
            }

            if (mob.behaviourType.callsForHelp)
                MobCallForHelp(mob);

            if (!MovementUtilities.inRangeDropAggro(mob, target)) {
                mob.setCombatTarget(null);
                return;
            }

            if (CombatUtilities.inRange2D(mob, target, mob.getRange())) {

                //no weapons, default mob attack speed 3 seconds.

                if (System.currentTimeMillis() < mob.getLastAttackTime())
                    return;

                // ranged mobs cant attack while running. skip until they finally stop.

                if (mob.isMoving() && mob.getRange() > 20)
                    return;

                // add timer for last attack.

                ItemBase mainHand = mob.getWeaponItemBase(true);
                ItemBase offHand = mob.getWeaponItemBase(false);

                if (mainHand == null && offHand == null) {
                    CombatUtilities.combatCycle(mob, target, true, null);
                    int delay = 3000;
                    if (mob.isSiege())
                        delay = 11000;
                    mob.setLastAttackTime(System.currentTimeMillis() + delay);
                } else if (mob.getWeaponItemBase(true) != null) {
                    int delay = 3000;
                    if (mob.isSiege())
                        delay = 11000;
                    CombatUtilities.combatCycle(mob, target, true, mob.getWeaponItemBase(true));
                    mob.setLastAttackTime(System.currentTimeMillis() + delay);
                } else if (mob.getWeaponItemBase(false) != null) {
                    int attackDelay = 3000;
                    if (mob.isSiege())
                        attackDelay = 11000;
                    CombatUtilities.combatCycle(mob, target, false, mob.getWeaponItemBase(false));
                    mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
                }
            }

            if (target.getPet() != null)
                if (target.getPet().getCombatTarget() == null && target.getPet().assist == true)
                    target.getPet().setCombatTarget(mob);

        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
        }

    }

    public static void AttackBuilding(Mob mob, Building target) {

        try {

            if (target.getRank() == -1 || !target.isVulnerable() || BuildingManager.getBuildingFromCache(target.getObjectUUID()) == null) {
                mob.setCombatTarget(null);
                return;
            }

            City playercity = ZoneManager.getCityAtLocation(mob.getLoc());

            if (playercity != null)
                for (Mob guard : playercity.getParent().zoneMobSet)
                    if (guard.agentType.equals(Enum.AIAgentType.GUARDCAPTAIN))
                        if (guard.getCombatTarget() == null && !guard.getGuild().equals(mob.getGuild()))
                            guard.setCombatTarget(mob);

            if (mob.isSiege())
                MovementManager.sendRWSSMsg(mob);

            ItemBase mainHand = mob.getWeaponItemBase(true);
            ItemBase offHand = mob.getWeaponItemBase(false);

            if (mainHand == null && offHand == null) {
                CombatUtilities.combatCycle(mob, target, true, null);
                int delay = 3000;
                if (mob.isSiege())
                    delay = 15000;
                mob.setLastAttackTime(System.currentTimeMillis() + delay);
            } else if (mob.getWeaponItemBase(true) != null) {
                int attackDelay = 3000;
                if (mob.isSiege())
                    attackDelay = 15000;
                CombatUtilities.combatCycle(mob, target, true, mob.getWeaponItemBase(true));
                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
            } else if (mob.getWeaponItemBase(false) != null) {
                int attackDelay = 3000;
                if (mob.isSiege())
                    attackDelay = 15000;
                CombatUtilities.combatCycle(mob, target, false, mob.getWeaponItemBase(false));
                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
            }

            if (mob.isSiege()) {
                PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
                ppm.setRange(50);
                DispatchMessage.dispatchMsgToInterestArea(mob, ppm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
            }

        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackBuilding" + " " + e.getMessage());
        }
    }

    public static void AttackMob(Mob mob, Mob target) {

        try {

            if (mob.getRange() >= 30 && mob.isMoving())
                return;

            //no weapons, default mob attack speed 3 seconds.

            ItemBase mainHand = mob.getWeaponItemBase(true);
            ItemBase offHand = mob.getWeaponItemBase(false);

            if (mainHand == null && offHand == null) {
                CombatUtilities.combatCycle(mob, target, true, null);
                int delay = 3000;
                if (mob.isSiege())
                    delay = 11000;
                mob.setLastAttackTime(System.currentTimeMillis() + delay);
            } else if (mob.getWeaponItemBase(true) != null) {
                int attackDelay = 3000;
                if (mob.isSiege())
                    attackDelay = 11000;
                CombatUtilities.combatCycle(mob, target, true, mob.getWeaponItemBase(true));
                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
            } else if (mob.getWeaponItemBase(false) != null) {
                int attackDelay = 3000;
                if (mob.isSiege())
                    attackDelay = 11000;
                CombatUtilities.combatCycle(mob, target, false, mob.getWeaponItemBase(false));
                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
                if (target.getCombatTarget() == null) {
                    target.setCombatTarget(mob);
                }
            }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackMob" + " " + e.getMessage());
        }
    }

    private static void Patrol(Mob mob) {

        try {

            int patrolDelay = ThreadLocalRandom.current().nextInt((int) (MobAIThread.AI_PATROL_DIVISOR * 0.5f), MobAIThread.AI_PATROL_DIVISOR) + MobAIThread.AI_PATROL_DIVISOR;

            // early exit while waiting to patrol again.
            // Minions are force marched if captain is alive

            boolean forced = mob.agentType.equals(Enum.AIAgentType.GUARDMINION) &&
                    mob.guardCaptain.isAlive();

            if (mob.stopPatrolTime + (patrolDelay * 1000) > System.currentTimeMillis())
                if (!forced)
                    return;

            //guards inherit barracks patrol points dynamically

            if (mob.patrolPoints == null || mob.patrolPoints.isEmpty())
                if (mob.agentType.equals(Enum.AIAgentType.GUARDCAPTAIN) || mob.agentType.equals(Enum.AIAgentType.GUARDMINION)) {

                    Building barracks = mob.building;

                    if (barracks != null && barracks.patrolPoints != null && !barracks.getPatrolPoints().isEmpty()) {
                        mob.patrolPoints = barracks.patrolPoints;
                    } else {
                        randomGuardPatrolPoint(mob);
                        return;
                    }
                }

            if (mob.lastPatrolPointIndex > mob.patrolPoints.size() - 1)
                mob.lastPatrolPointIndex = 0;

            // Minions are given marching orders by the captain if he is alive

            if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION)) {
                Mob captain = (Mob) mob.guardCaptain;
                mob.destination = captain.destination.add(Formation.getOffset(2, mob.guardCaptain.minions.indexOf(mob.getObjectUUID()) + 3));
                mob.lastPatrolPointIndex = captain.lastPatrolPointIndex;
            } else {
                mob.destination = mob.patrolPoints.get(mob.lastPatrolPointIndex);
                mob.lastPatrolPointIndex += 1;
            }

            // Captain orders minions to patrol

            if (mob.agentType.equals(Enum.AIAgentType.GUARDCAPTAIN))
                for (Integer minionUUID : mob.minions) {
                    Mob minion = Mob.getMob(minionUUID);
                    if (minion.isAlive() && minion.combatTarget == null)
                        MobAI.Patrol(minion);
                }

            MovementUtilities.aiMove(mob, mob.destination, true);

        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
        }
    }

    public static boolean canCast(Mob mob) {

        int contractID = 0;

        try {

            // Performs validation to determine if a
            // mobile in the proper state to cast.

            if (mob == null)
                return false;

            if (mob.isPlayerGuard() == true) {

                if(mob.agentType.equals(Enum.AIAgentType.GUARDWALLARCHER))
                    return false; //wall archers don't cast
                if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION))
                    contractID = mob.guardCaptain.contract.getContractID();
                else
                    contractID = mob.contract.getContractID();

                // exception allowing werewolf and werebear guard captains to cast

                if (Enum.MinionType.ContractToMinionMap.get(contractID).isMage() == false && contractID != 980103 && contractID != 980104)
                    return false;
            }

            // Mobile has no powers defined in mobbase or contract..

            if (PowersManager.getPowersForRune(mob.getMobBaseID()).isEmpty() &&
                    PowersManager.getPowersForRune(contractID).isEmpty())
                return false;

            if (mob.nextCastTime == 0)
                mob.nextCastTime = System.currentTimeMillis();

            return mob.nextCastTime <= System.currentTimeMillis();

        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: canCast" + " " + e.getMessage());
        }
        return false;
    }

    public static boolean MobCast(Mob mob) {

        try {
            // Method picks a random spell from a mobile's list of powers
            // and casts it on the current target (or itself).  Validation
            // (including empty lists) is done previously within canCast();

            ArrayList<RunePowerEntry> powerEntries;
            ArrayList<RunePowerEntry> purgeEntries;
            AbstractCharacter target = (AbstractCharacter) mob.getCombatTarget();

            if (mob.behaviourType.callsForHelp)
                MobCallForHelp(mob);

            // Generate a list of tokens from the mob powers for this mobile.

            powerEntries = new ArrayList<>(PowersManager.getPowersForRune(mob.getMobBaseID()));
            purgeEntries = new ArrayList<>();

            // Additional powers may come from the contract ID.  This is to support
            // powers for player guards irrespective of the mobbase used.

            if (mob.isPlayerGuard()) {

                ArrayList<RunePowerEntry> contractEntries = new ArrayList<>();

                if (mob.contract != null)
                    contractEntries = PowersManager.getPowersForRune(mob.contractUUID);

                if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION))
                    contractEntries = PowersManager.getPowersForRune(mob.guardCaptain.contractUUID);

                powerEntries.addAll(contractEntries);

            }

            // If player has this effect on them currently then remove
            // this token from our list.

            for (RunePowerEntry runePowerEntry : powerEntries) {

                PowersBase powerBase = PowersManager.getPowerByToken(runePowerEntry.token);

                for (ActionsBase actionBase : powerBase.getActions()) {

                    String stackType = actionBase.stackType;

                    if (target.getEffects() != null && target.getEffects().containsKey(stackType))
                        purgeEntries.add(runePowerEntry);
                }
            }

            powerEntries.removeAll(purgeEntries);

            // Sanity check

            if (powerEntries.isEmpty())
                return false;

            // Pick random spell from our list of powers

            RunePowerEntry runePowerEntry = powerEntries.get(ThreadLocalRandom.current().nextInt(powerEntries.size()));

            PowersBase mobPower = PowersManager.getPowerByToken(runePowerEntry.token);
            int powerRank = runePowerEntry.rank;

            if (mob.isPlayerGuard())
                powerRank = getGuardPowerRank(mob);

            //check for hit-roll

            if (mobPower.requiresHitRoll)
                if (CombatUtilities.triggerDefense(mob, mob.getCombatTarget()))
                    return false;

            // Cast the spell

            if (CombatUtilities.inRange2D(mob, mob.getCombatTarget(), mobPower.getRange())) {

                PerformActionMsg msg;

                if (!mobPower.isHarmful() || mobPower.targetSelf) {
                    PowersManager.useMobPower(mob, mob, mobPower, powerRank);
                    msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, mob);
                } else {
                    PowersManager.useMobPower(mob, target, mobPower, powerRank);
                    msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, target);
                }

                msg.setUnknown04(2);

                PowersManager.finishUseMobPower(msg, mob, 0, 0);
                long randomCooldown = (long) ((ThreadLocalRandom.current().nextInt(10, 15) * 1000) * MobAIThread.AI_CAST_FREQUENCY);

                mob.nextCastTime = System.currentTimeMillis() + randomCooldown;
                return true;
            }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
        }
        return false;
    }

    public static int getGuardPowerRank(Mob mob) {
        int powerRank = 1;

        switch (mob.getRank()) {
            case 1:
                powerRank = 10;
                break;
            case 2:
                powerRank = 15;
                break;
            case 3:
                powerRank = 20;
                break;
            case 4:
                powerRank = 25;
                break;
            case 5:
                powerRank = 30;
                break;
            case 6:
                powerRank = 35;
                break;
            case 7:
                powerRank = 40;
                break;
        }
        return powerRank;
    }

    public static void MobCallForHelp(Mob mob) {

        try {

            boolean callGotResponse = false;

            if (mob.nextCallForHelp == 0)
                mob.nextCallForHelp = System.currentTimeMillis();

            if (mob.nextCallForHelp < System.currentTimeMillis())
                return;

            //mob sends call for help message

            ChatManager.chatSayInfo(null, mob.getName() + " calls for help!");

            Zone mobCamp = mob.getParentZone();

            for (Mob helper : mobCamp.zoneMobSet) {
                if (helper.behaviourType.respondsToCallForHelp && helper.behaviourType.BehaviourHelperType.equals(mob.behaviourType)) {
                    helper.setCombatTarget(mob.getCombatTarget());
                    callGotResponse = true;
                }
            }

            //wait 60 seconds to call for help again

            if (callGotResponse)
                mob.nextCallForHelp = System.currentTimeMillis() + 60000;

        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCallForHelp" + " " + e.getMessage());
        }
    }

    public static void DetermineAction(Mob mob) {

        try {

            //always check the respawn que, respawn 1 mob max per second to not flood the client

            if (mob == null)
                return;

            if (mob.getTimestamps().containsKey("lastExecution") == false)
                mob.getTimestamps().put("lastExecution", System.currentTimeMillis());

            if (System.currentTimeMillis() < mob.getTimeStamp("lastExecution"))
                return;

            mob.getTimestamps().put("lastExecution", System.currentTimeMillis() + MobAIThread.AI_PULSE_MOB_THRESHOLD);

            //trebuchet spawn handler

            if (mob.despawned && mob.getMobBase().getLoadID() == 13171) {
                CheckForRespawn(mob);
                return;
            }

            //override for guards

            if (mob.despawned && mob.isPlayerGuard()) {

                if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION)) {
                    if (mob.guardCaptain.isAlive() == false || ((Mob) mob.guardCaptain).despawned == true) {

                        //minions don't respawn while guard captain is dead

                        if (mob.isAlive() == false) {
                            mob.deathTime = System.currentTimeMillis();
                            return;
                        }

                    }
                }

                CheckForRespawn(mob);

                //check to send mob home for player guards to prevent exploit of dragging guards away and then teleporting

                if (!mob.agentType.equals(Enum.AIAgentType.PET))
                    CheckToSendMobHome(mob);

                return;
            }

            //no need to continue if mob is dead, check for respawn and move on

            if (!mob.isAlive()) {
                CheckForRespawn(mob);
                return;
            }

            //no players loaded, no need to proceed unless it's a player guard
            boolean bypassLoadedPlayerCheck = false;
            if(mob.isPlayerGuard() || mob.isSiege()) {
                bypassLoadedPlayerCheck = true;
                if(mob.combatTarget != null && mob.combatTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
                    if(mob.combatTarget.loc.distanceSquared(mob.loc) > 10000)
                        mob.setCombatTarget(null);
            }

            if (mob.playerAgroMap.isEmpty() && !bypassLoadedPlayerCheck) {
                if (mob.getCombatTarget() != null)
                    mob.setCombatTarget(null);
                return;
            }


            if (mob.agentType.equals(Enum.AIAgentType.PET) == false)
                CheckToSendMobHome(mob);

            if (mob.getCombatTarget() != null) {

                if (mob.getCombatTarget().isAlive() == false) {
                    mob.setCombatTarget(null);
                    return;
                }

                if (mob.getCombatTarget().getObjectTypeMask() == MBServerStatics.MASK_PLAYER) {

                    PlayerCharacter target = (PlayerCharacter) mob.getCombatTarget();

                    if (mob.playerAgroMap.containsKey(target.getObjectUUID()) == false) {
                        mob.setCombatTarget(null);
                        return;
                    }

                    if (mob.canSee((PlayerCharacter) mob.getCombatTarget()) == false) {
                        mob.setCombatTarget(null);
                        return;
                    }

                }
            }

            switch (mob.behaviourType) {
                case GuardCaptain:
                case GuardMinion:
                case GuardWallArcher:
                    GuardLogic(mob);
                    break;
                case Pet1:
                case SiegeEngine:
                    PetLogic(mob);
                    break;
                case HamletGuard:
                    HamletGuardLogic(mob);
                    break;
                default:
                    DefaultLogic(mob);
                    break;
            }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DetermineAction" + " " + e.getMessage());
        }
    }

    private static void CheckForAggro(Mob aiAgent) {

        try {

            //looks for and sets mobs combatTarget

            if (!aiAgent.isAlive())
                return;

            ConcurrentHashMap<Integer, Float> loadedPlayers = aiAgent.playerAgroMap;

            for (Entry playerEntry : loadedPlayers.entrySet()) {

                int playerID = (int) playerEntry.getKey();
                PlayerCharacter loadedPlayer = PlayerCharacter.getPlayerCharacter(playerID);

                //Player is null, let's remove them from the list.

                if (loadedPlayer == null) {
                    loadedPlayers.remove(playerID);
                    continue;
                }

                //Player is Dead, Mob no longer needs to attempt to aggro. Remove them from aggro map.

                if (!loadedPlayer.isAlive()) {
                    loadedPlayers.remove(playerID);
                    continue;
                }

                //Can't see target, skip aggro.

                if (!aiAgent.canSee(loadedPlayer))
                    continue;

                // No aggro for this race type

                if (aiAgent.notEnemy.size() > 0 && aiAgent.notEnemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()) == true)
                    continue;

                //mob has enemies and this player race is not it

                if (aiAgent.enemy.size() > 0 && aiAgent.enemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()) == false)
                    continue;

                if (MovementUtilities.inRangeToAggro(aiAgent, loadedPlayer)) {
                    aiAgent.setCombatTarget(loadedPlayer);
                    return;
                }
            }

            if (aiAgent.getCombatTarget() == null) {

                //look for pets to aggro if no players found to aggro

                HashSet<AbstractWorldObject> awoList = WorldGrid.getObjectsInRangePartial(aiAgent, MobAIThread.AI_BASE_AGGRO_RANGE, MBServerStatics.MASK_PET);

                for (AbstractWorldObject awoMob : awoList) {

                    // exclude self.

                    if (aiAgent.equals(awoMob))
                        continue;

                    Mob aggroMob = (Mob) awoMob;
                    aiAgent.setCombatTarget(aggroMob);
                    return;
                }
            }
        } catch (Exception e) {
            Logger.info(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForAggro" + " " + e.getMessage());
        }
    }

    private static void CheckMobMovement(Mob mob) {

        try {

            if (!MovementUtilities.canMove(mob))
                return;

            mob.updateLocation();

            switch (mob.behaviourType) {

                case Pet1:

                    if (mob.guardCaptain == null)
                        return;

                    //mob no longer has its owner loaded, translate pet to owner

                    if (!mob.playerAgroMap.containsKey(mob.guardCaptain.getObjectUUID())) {
                        MovementManager.translocate(mob, mob.guardCaptain.getLoc());
                        return;
                    }

                    if (mob.getCombatTarget() == null) {

                        //move back to owner

                        if (CombatUtilities.inRange2D(mob, mob.guardCaptain, 6))
                            return;

                        mob.destination = mob.guardCaptain.getLoc();
                        MovementUtilities.moveToLocation(mob, mob.destination, 5, false);
                    } else
                        chaseTarget(mob);
                    break;
                default:
                    if (mob.getCombatTarget() == null) {

                        if (!mob.isMoving()) {

                            // Minions only patrol on their own if captain is dead.

                            if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION) == false)
                                Patrol(mob);
                            else if (mob.guardCaptain.isAlive() == false)
                                Patrol(mob);
                        } else
                            mob.stopPatrolTime = System.currentTimeMillis();
                    } else {
                        chaseTarget(mob);
                    }
                    break;
            }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckMobMovement" + " " + e.getMessage());
        }
    }

    private static void CheckForRespawn(Mob aiAgent) {

        try {

            if (aiAgent.deathTime == 0) {
                aiAgent.setDeathTime(System.currentTimeMillis());
                return;
            }

            //handles checking for respawn of dead mobs even when no players have mob loaded
            //Despawn Timer with Loot currently in inventory.

            if (!aiAgent.despawned) {

                if (aiAgent.getCharItemManager().getInventoryCount() > 0) {
                    if (System.currentTimeMillis() > aiAgent.deathTime + MBServerStatics.DESPAWN_TIMER_WITH_LOOT) {
                        aiAgent.despawn();
                        aiAgent.deathTime = System.currentTimeMillis();
                        return;
                    }
                    //No items in inventory.
                } else {
                    //Mob's Loot has been looted.
                    if (aiAgent.isHasLoot()) {
                        if (System.currentTimeMillis() > aiAgent.deathTime + MBServerStatics.DESPAWN_TIMER_ONCE_LOOTED) {
                            aiAgent.despawn();
                            aiAgent.deathTime = System.currentTimeMillis();
                            return;
                        }
                        //Mob never had Loot.
                    } else {
                        if (System.currentTimeMillis() > aiAgent.deathTime + MBServerStatics.DESPAWN_TIMER) {
                            aiAgent.despawn();
                            aiAgent.deathTime = System.currentTimeMillis();
                            return;
                        }
                    }
                }
            } else if (System.currentTimeMillis() > (aiAgent.deathTime + (aiAgent.spawnTime * 1000))) {

                if (Zone.respawnQue.contains(aiAgent) == false) {
                    Zone.respawnQue.add(aiAgent);
                }
            }
        } catch (Exception e) {
            Logger.info(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForRespawn" + " " + e.getMessage());
        }
    }

    public static void CheckForAttack(Mob mob) {
        try {

            //checks if mob can attack based on attack timer and range

            if (mob.isAlive() == false)
                return;

            if (mob.getCombatTarget() == null)
                return;

            if (mob.getCombatTarget().getObjectType().equals(Enum.GameObjectType.PlayerCharacter) && MovementUtilities.inRangeDropAggro(mob, (PlayerCharacter) mob.getCombatTarget()) == false &&
                    mob.agentType.equals(Enum.AIAgentType.PET) == false) {

                mob.setCombatTarget(null);
                return;
            }
            if (System.currentTimeMillis() > mob.getLastAttackTime())
                AttackTarget(mob, mob.getCombatTarget());

        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForAttack" + " " + e.getMessage());
        }
    }

    private static void CheckToSendMobHome(Mob mob) {

        try {

            if (mob.getCombatTarget() != null && CombatUtilities.inRange2D(mob, mob.getCombatTarget(), MobAIThread.AI_BASE_AGGRO_RANGE * 0.5f))
                return;

            if (mob.isPlayerGuard() && !mob.despawned) {

                City current = ZoneManager.getCityAtLocation(mob.getLoc());

                if (current == null || current.equals(mob.getGuild().getOwnedCity()) == false) {

                    PowersBase recall = PowersManager.getPowerByToken(-1994153779);
                    PowersManager.useMobPower(mob, mob, recall, 40);
                    mob.setCombatTarget(null);

                    if (mob.agentType.equals(Enum.AIAgentType.GUARDCAPTAIN) && mob.isAlive()) {

                        //guard captain pulls his minions home with him

                        for (Integer minionUUID : mob.minions) {
                            Mob minion = Mob.getMob(minionUUID);

                            PowersManager.useMobPower(minion, minion, recall, 40);
                            minion.setCombatTarget(null);
                        }
                    }
                }
            } else if (MovementUtilities.inRangeOfBindLocation(mob) == false) {

                PowersBase recall = PowersManager.getPowerByToken(-1994153779);
                PowersManager.useMobPower(mob, mob, recall, 40);
                mob.setCombatTarget(null);

                for (Integer playerEntry : mob.playerAgroMap.keySet())
                    mob.playerAgroMap.put(playerEntry, 0f);
            }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckToSendMobHome" + " " + e.getMessage());
        }
    }

    private static void chaseTarget(Mob mob) {

        try {

            if(mob.getTimestamps().containsKey("lastChase") == false)
                mob.getTimestamps().put("lastChase",System.currentTimeMillis());
            else if(System.currentTimeMillis() < mob.getTimestamps().get("lastChase").longValue() + (750 + ThreadLocalRandom.current().nextInt(0,500)))
                    return;

            mob.getTimestamps().put("lastChase",System.currentTimeMillis());

            if (CombatUtilities.inRange2D(mob, mob.getCombatTarget(), mob.getRange()) == false) {
                if (mob.getRange() > 15) {
                    mob.destination = mob.getCombatTarget().getLoc();
                    MovementUtilities.moveToLocation(mob, mob.destination, 0, false);
                } else {

                    //check if building

                    switch (mob.getCombatTarget().getObjectType()) {
                        case PlayerCharacter:
                        case Mob:
                            mob.destination = MovementUtilities.GetDestinationToCharacter(mob, (AbstractCharacter) mob.getCombatTarget());
                            MovementUtilities.moveToLocation(mob, mob.destination, mob.getRange() + 1, false);
                            break;
                        case Building:
                            mob.destination = mob.getCombatTarget().getLoc();
                            MovementUtilities.moveToLocation(mob, mob.getCombatTarget().getLoc(), 0, false);
                            break;
                    }
                }
            }
            mob.updateMovementState();
            mob.updateLocation();
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: chaseTarget" + " " + e.getMessage());
        }
    }

    private static void SafeGuardAggro(Mob mob) {
        try {

            HashSet<AbstractWorldObject> awoList = WorldGrid.getObjectsInRangePartial(mob, 100, MBServerStatics.MASK_MOB);

            for (AbstractWorldObject awoMob : awoList) {

                //dont scan self.

                if (mob.equals(awoMob) || (mob.agentType.equals(Enum.AIAgentType.GUARDCAPTAIN)) == true)
                    continue;

                Mob aggroMob = (Mob) awoMob;

                //don't attack other guards

                if ((aggroMob.agentType.equals(Enum.AIAgentType.GUARDCAPTAIN)))
                    continue;

                if (aggroMob.agentType.equals(Enum.AIAgentType.PET))
                    continue;

                if (mob.getLoc().distanceSquared2D(aggroMob.getLoc()) > sqr(50))
                    continue;

                mob.setCombatTarget(aggroMob);
            }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: SafeGuardAggro" + " " + e.getMessage());
        }
    }

    public static void GuardLogic(Mob mob) {

        try {
            if (mob.getCombatTarget() == null) {
                CheckForPlayerGuardAggro(mob);
            } else {
                //do not need to look to change target if target is already null
                AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);

                if (newTarget != null) {

                    if (newTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
                        if (GuardCanAggro(mob, (PlayerCharacter) newTarget))
                            mob.setCombatTarget(newTarget);
                    } else
                        mob.setCombatTarget(newTarget);
                }
            }

            if(mob.behaviourType.canRoam)
                CheckMobMovement(mob);//all guards that can move check to move

            if(mob.combatTarget != null)
                CheckForAttack(mob); //only check to attack if combat target is not null

        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardLogic" + " " + e.getMessage());
        }
    }

    private static void PetLogic(Mob mob) {

        try {

            if (mob.guardCaptain == null && mob.isNecroPet() == false && mob.isSiege() == false)
                if (ZoneManager.seaFloor.zoneMobSet.contains(mob))
                    mob.killCharacter("no owner");

            if (MovementUtilities.canMove(mob) && mob.behaviourType.canRoam)
                CheckMobMovement(mob);

            CheckForAttack(mob);

            //recover health

            if (mob.getTimestamps().containsKey("HEALTHRECOVERED") == false)
                mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());

            if (mob.isSit() && mob.getTimeStamp("HEALTHRECOVERED") < System.currentTimeMillis() + 3000)
                if (mob.getHealth() < mob.getHealthMax()) {

                    float recoveredHealth = mob.getHealthMax() * ((1 + mob.getBonuses().getFloatPercentAll(Enum.ModType.HealthRecoverRate, Enum.SourceType.None)) * 0.01f);
                    mob.setHealth(mob.getHealth() + recoveredHealth);
                    mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());

                    if (mob.getHealth() > mob.getHealthMax())
                        mob.setHealth(mob.getHealthMax());
                }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: PetLogic" + " " + e.getMessage());
        }
    }

    private static void HamletGuardLogic(Mob mob) {

        try {
            //safehold guard

            if (mob.getCombatTarget() == null)
                SafeGuardAggro(mob);
            else if (mob.getCombatTarget().isAlive() == false)
                SafeGuardAggro(mob);

            CheckForAttack(mob);
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: HamletGuardLogic" + " " + e.getMessage());
        }
    }

    private static void DefaultLogic(Mob mob) {

        try {

            //check for players that can be aggroed if mob is agressive and has no target

            if (mob.getCombatTarget() != null && mob.playerAgroMap.containsKey(mob.getCombatTarget().getObjectUUID()) == false)
                mob.setCombatTarget(null);

            if (mob.behaviourType.isAgressive) {

                AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);

                if (newTarget != null)
                    mob.setCombatTarget(newTarget);
                else {
                    if (mob.getCombatTarget() == null) {
                        if (mob.behaviourType == Enum.MobBehaviourType.HamletGuard)
                            SafeGuardAggro(mob);  //safehold guard
                        else
                            CheckForAggro(mob);   //normal aggro
                    }
                }
            }

            //check if mob can move for patrol or moving to target

            if (mob.behaviourType.canRoam)
                CheckMobMovement(mob);

            //check if mob can attack if it isn't wimpy

            if (!mob.behaviourType.isWimpy && mob.getCombatTarget() != null)
                CheckForAttack(mob);

        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DefaultLogic" + " " + e.getMessage());
        }
    }

    public static void CheckForPlayerGuardAggro(Mob mob) {

        try {

            //looks for and sets mobs combatTarget

            if (!mob.isAlive())
                return;

            // Defer to captain if possible for current target

            if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION) &&
                    mob.guardCaptain.isAlive()
                    && mob.guardCaptain.combatTarget != null) {
                mob.setCombatTarget(mob.guardCaptain.combatTarget);
                return;
            }

            ConcurrentHashMap<Integer, Float> loadedPlayers = mob.playerAgroMap;

            for (Entry playerEntry : loadedPlayers.entrySet()) {

                int playerID = (int) playerEntry.getKey();
                PlayerCharacter loadedPlayer = PlayerCharacter.getPlayerCharacter(playerID);

                //Player is null, let's remove them from the list.

                if (loadedPlayer == null) {
                    loadedPlayers.remove(playerID);
                    continue;
                }

                //Player is Dead, Mob no longer needs to attempt to aggro. Remove them from aggro map.

                if (!loadedPlayer.isAlive()) {
                    loadedPlayers.remove(playerID);
                    continue;
                }

                //Can't see target, skip aggro.

                if (!mob.canSee(loadedPlayer))
                    continue;

                // No aggro for this player

                if (GuardCanAggro(mob, loadedPlayer) == false)
                    continue;

                if (MovementUtilities.inRangeToAggro(mob, loadedPlayer) && mob.getCombatTarget() == null) {
                    mob.setCombatTarget(loadedPlayer);
                    return;
                }
            }
                if (mob.getCombatTarget() == null) {

                    //look for siege equipment to aggro if no players found to aggro

                    HashSet<AbstractWorldObject> awoList = WorldGrid.getObjectsInRangePartial(mob, MobAIThread.AI_BASE_AGGRO_RANGE, MBServerStatics.MASK_SIEGE);

                    for (AbstractWorldObject awoMob : awoList) {


                        Mob aggroMob = (Mob) awoMob;
                        if(GuardCanAggro(mob,aggroMob)) {
                            mob.setCombatTarget(aggroMob);
                            return;
                        }
                    }

            }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForPlayerGuardAggro" + e.getMessage());
        }
    }

    public static Boolean GuardCanAggro(Mob mob, AbstractCharacter target) {

        try {

            if (mob.guardedCity.cityOutlaws.contains(target.getObjectUUID()) == true)
                return true;

            if (mob.getGuild().getNation().equals(target.getGuild().getNation()))
                return false;

            //first check condemn list for aggro allowed (allies button is checked)

            if (ZoneManager.getCityAtLocation(mob.getLoc()).getTOL().reverseKOS) {
                for (Entry<Integer, Condemned> entry : ZoneManager.getCityAtLocation(mob.getLoc()).getTOL().getCondemned().entrySet()) {

                    //target is listed individually

                    if (entry.getValue().playerUID == target.getObjectUUID() && entry.getValue().active)
                        return false;

                    //target's guild is listed

                    if (Guild.getGuild(entry.getValue().guildUID) == target.getGuild())
                        return false;

                    //target's nation is listed

                    if (Guild.getGuild(entry.getValue().guildUID) == target.getGuild().getNation())
                        return false;
                }
                return true;
            } else {

                //allies button is not checked

                for (Entry<Integer, Condemned> entry : ZoneManager.getCityAtLocation(mob.getLoc()).getTOL().getCondemned().entrySet()) {

                    //target is listed individually

                    if (entry.getValue().playerUID == target.getObjectUUID() && entry.getValue().active)
                        return true;

                    //target's guild is listed

                    if (Guild.getGuild(entry.getValue().guildUID) == target.getGuild())
                        return true;

                    //target's nation is listed

                    if (Guild.getGuild(entry.getValue().guildUID) == target.getGuild().getNation())
                        return true;
                }
            }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCanAggro" + " " + e.getMessage());
        }
        return false;
    }

    public static void randomGuardPatrolPoint(Mob mob) {

        try {

            //early exit for a mob who is already moving to a patrol point
            //while mob moving, update lastPatrolTime so that when they stop moving the 10 second timer can begin

            if (mob.isMoving() == true) {
                mob.stopPatrolTime = System.currentTimeMillis();
                return;
            }

            //wait between 10 and 15 seconds after reaching patrol point before moving

            int patrolDelay = ThreadLocalRandom.current().nextInt(10000) + 5000;

            //early exit while waiting to patrol again

            if (mob.stopPatrolTime + patrolDelay > System.currentTimeMillis())
                return;

            float xPoint = ThreadLocalRandom.current().nextInt(400) - 200;
            float zPoint = ThreadLocalRandom.current().nextInt(400) - 200;
            Vector3fImmutable TreePos = mob.getGuild().getOwnedCity().getLoc();
            mob.destination = new Vector3fImmutable(TreePos.x + xPoint, TreePos.y, TreePos.z + zPoint);

            MovementUtilities.aiMove(mob, mob.destination, true);

            if (mob.agentType.equals(Enum.AIAgentType.GUARDCAPTAIN)) {
                for (Integer minionUUID : mob.minions) {

                    Mob minion = Mob.getMob(minionUUID);

                    //make sure mob is out of combat stance

                    if (minion.despawned == false) {
                        if (MovementUtilities.canMove(minion)) {
                            Vector3f minionOffset = Formation.getOffset(2, mob.minions.indexOf(minionUUID) + 3);
                            minion.updateLocation();
                            Vector3fImmutable formationPatrolPoint = new Vector3fImmutable(mob.destination.x + minionOffset.x, mob.destination.y, mob.destination.z + minionOffset.z);
                            MovementUtilities.aiMove(minion, formationPatrolPoint, true);
                        }
                    }
                }
            }
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: randomGuardPatrolPoints" + " " + e);
        }
    }

    public static AbstractWorldObject ChangeTargetFromHateValue(Mob mob) {

        try {

            float CurrentHateValue = 0;

            if (mob.getCombatTarget() != null && mob.getCombatTarget().getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
                CurrentHateValue = mob.playerAgroMap.get(mob.combatTarget.getObjectUUID()).floatValue();

            AbstractWorldObject mostHatedTarget = null;

            for (Entry playerEntry : mob.playerAgroMap.entrySet()) {

                PlayerCharacter potentialTarget = PlayerCharacter.getPlayerCharacter((int) playerEntry.getKey());

                if (potentialTarget.equals(mob.getCombatTarget()))
                    continue;

                if (potentialTarget != null && mob.playerAgroMap.get(potentialTarget.getObjectUUID()).floatValue() > CurrentHateValue && MovementUtilities.inRangeToAggro(mob, potentialTarget)) {
                    CurrentHateValue = mob.playerAgroMap.get(potentialTarget.getObjectUUID()).floatValue();
                    mostHatedTarget = potentialTarget;
                }

            }
            return mostHatedTarget;
        } catch (Exception e) {
            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: ChangeTargetFromMostHated" + " " + e.getMessage());
        }
        return null;
    }
}