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

package engine.gameManager;

import engine.Enum.*;
import engine.InterestManagement.HeightMap;
import engine.InterestManagement.WorldGrid;
import engine.db.handlers.dbEffectsBaseHandler;
import engine.db.handlers.dbSkillReqHandler;
import engine.job.AbstractJob;
import engine.job.AbstractScheduleJob;
import engine.job.JobContainer;
import engine.job.JobScheduler;
import engine.jobs.*;
import engine.math.Vector3fImmutable;
import engine.net.ByteBufferWriter;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.client.ClientConnection;
import engine.net.client.msg.*;
import engine.objects.*;
import engine.powers.*;
import engine.powers.effectmodifiers.AbstractEffectModifier;
import engine.powers.poweractions.AbstractPowerAction;
import engine.powers.poweractions.TrackPowerAction;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;

import static engine.math.FastMath.sqr;

public enum PowersManager {

	POWERMANAGER;

	public static HashMap<String, PowersBase> powersBaseByIDString = new HashMap<>();
	public static HashMap<Integer, PowersBase> powersBaseByToken = new HashMap<>();
	public static HashMap<String, EffectsBase> effectsBaseByIDString = new HashMap<>();
	public static HashMap<Integer, EffectsBase> effectsBaseByToken = new HashMap<>();
	public static HashMap<String, AbstractPowerAction> powerActionsByIDString = new HashMap<>();
	public static HashMap<Integer, AbstractPowerAction> powerActionsByID = new HashMap<>();
	public static HashMap<String, Integer> ActionTokenByIDString = new HashMap<>();
	public static HashMap<Integer, AbstractEffectModifier> modifiersByToken = new HashMap<>();
	public static HashMap<String,Integer> AnimationOverrides = new HashMap<>();
	private static JobScheduler js;
	public static HashMap<Integer,HashMap<Integer,Integer>> AllMobPowers = new HashMap<>();

	public static void initPowersManager(boolean fullPowersLoad) {

		if (fullPowersLoad)
			PowersManager.InitializePowers();
		else
			PowersManager.InitializeLoginPowers();

		PowersManager.js = JobScheduler.getInstance();

	}

	private PowersManager() {

	}

	public static PowersBase getPowerByToken(int token) {
		return PowersManager.powersBaseByToken.get(token);
	}

	public static PowersBase getPowerByIDString(String IDString) {
		return PowersManager.powersBaseByIDString.get(IDString);
	}

	public static EffectsBase getEffectByIDString(String IDString) {
		return PowersManager.effectsBaseByIDString.get(IDString);
	}

	public static AbstractPowerAction getPowerActionByID(Integer id) {
		return PowersManager.powerActionsByID.get(id);
	}

	public static AbstractPowerAction getPowerActionByIDString(String IDString) {
		return PowersManager.powerActionsByIDString.get(IDString);
	}

	public static EffectsBase getEffectByToken(int token) {
		return PowersManager.effectsBaseByToken.get(token);
	}

	// This pre-loads only PowersBase for login
	public static void InitializeLoginPowers() {

		// get all PowersBase
		ArrayList<PowersBase> pbList = dbSkillReqHandler.getAllPowersBase();

		for (PowersBase pb : pbList) {
			if (pb.getToken() != 0)
				PowersManager.powersBaseByToken.put(pb.getToken(), pb);
		}
	}

	// This pre-loads all powers and effects
	public static void InitializePowers() {

		// Add EffectsBase
		ArrayList<EffectsBase> ebList = dbEffectsBaseHandler.getAllEffectsBase();

		for (EffectsBase eb : ebList) {
			PowersManager.effectsBaseByToken.put(eb.getToken(), eb);
			PowersManager.effectsBaseByIDString.put(eb.getIDString(), eb);

		}
		
		// Add Fail Conditions
		EffectsBase.getFailConditions(PowersManager.effectsBaseByIDString);

		// Add Modifiers to Effects
		dbEffectsBaseHandler.cacheAllEffectModifiers();

		// Add Source Types to Effects
		PowersManager.addAllSourceTypes();
		PowersManager.addAllAnimationOverrides();

		// Add PowerActions
		AbstractPowerAction.getAllPowerActions(PowersManager.powerActionsByIDString, PowersManager.powerActionsByID, PowersManager.effectsBaseByIDString);

		// Load valid Item Flags
	//	AbstractPowerAction.loadValidItemFlags(PowersManager.powerActionsByIDString);

		// get all PowersBase
		ArrayList<PowersBase> pbList = dbSkillReqHandler.getAllPowersBase();
		for (PowersBase pb : pbList) {
			if (pb.getToken() != 0) {
				PowersManager.powersBaseByIDString.put(pb.getIDString(), pb);
				PowersManager.powersBaseByToken.put(pb.getToken(), pb);
			}
		}
		
		// Add Power Prereqs
		PowerPrereq.getAllPowerPrereqs(PowersManager.powersBaseByIDString);
		// Add Fail Conditions
		dbSkillReqHandler.getFailConditions(PowersManager.powersBaseByIDString);
		// Add Actions Base
		ActionsBase.getActionsBase(PowersManager.powersBaseByIDString,
				PowersManager.powerActionsByIDString);
		
	}

	private static void addAllSourceTypes() {
		PreparedStatementShared ps = null;
		try {
			ps = new PreparedStatementShared("SELECT * FROM static_power_sourcetype");
			ResultSet rs = ps.executeQuery();
			String IDString, source;
			while (rs.next()) {
				IDString = rs.getString("IDString");
				int token = DbManager.hasher.SBStringHash(IDString);
				
				
				source = rs.getString("source").replace("-", "").trim();
				EffectSourceType effectSourceType = EffectSourceType.GetEffectSourceType(source);
				
				if (EffectsBase.effectSourceTypeMap.containsKey(token) == false)
					EffectsBase.effectSourceTypeMap.put(token, new HashSet<>());
				
				EffectsBase.effectSourceTypeMap.get(token).add(effectSourceType);
			}
			rs.close();
		} catch (Exception e) {
			Logger.error( e);
		} finally {
			ps.release();
		}
	}

	private static void addAllAnimationOverrides() {
		PreparedStatementShared ps = null;
		try {
			ps = new PreparedStatementShared("SELECT * FROM static_power_animation_override");
			ResultSet rs = ps.executeQuery();
			String IDString;
			int animation;
			while (rs.next()) {
				IDString = rs.getString("IDString");

				EffectsBase eb = PowersManager.getEffectByIDString(IDString);
				if (eb != null)
					IDString = eb.getIDString();

				animation = rs.getInt("animation");
				PowersManager.AnimationOverrides.put(IDString, animation);

			}
			rs.close();
		} catch (Exception e) {
			Logger.error( e);
		} finally {
			ps.release();
		}
	}

	public static EffectsBase setEffectToken(int ID, int token) {
		for (EffectsBase eb : PowersManager.effectsBaseByIDString.values()) {
			if (eb.getUUID() == ID) {
				eb.setToken(token);
				return eb;
			}
		}
		return null;
	}

	public static void usePower(final PerformActionMsg msg, ClientConnection origin,
			boolean sendCastToSelf) {

		if (usePowerA(msg, origin, sendCastToSelf)) {
			// Cast failed for some reason, reset timer

			RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(msg.getPowerUsedID());
			Dispatch dispatch = Dispatch.borrow(origin.getPlayerCharacter(), recyclePowerMsg);
			DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);

			// Send Fail to cast message
			PlayerCharacter pc = SessionManager
					.getPlayerCharacter(origin);

			if (pc != null) {
				sendPowerMsg(pc, 2, msg);
				if (pc.isCasting()){
					pc.update();
				}
				
				pc.setIsCasting(false);
			}

		}
	}

	public static void useMobPower(Mob caster, AbstractCharacter target, PowersBase pb, int rank) {

		PerformActionMsg msg = createPowerMsg(pb, rank, caster, target);
		msg.setUnknown04(1);

		if (useMobPowerA(msg, caster)) {
			//sendMobPowerMsg(caster,2,msg); //Lol wtf was i thinking sending msg's to mobs... ZZZZ
		}
	}

	public static boolean usePowerA(final PerformActionMsg msg, ClientConnection origin,
			boolean sendCastToSelf) {
		PlayerCharacter playerCharacter = SessionManager.getPlayerCharacter(
				origin);
		if (playerCharacter == null)
			return false;

		boolean CSRCast = false;


		if (MBServerStatics.POWERS_DEBUG) {
			ChatManager.chatSayInfo(
					playerCharacter,
					"Using Power: " + Integer.toHexString(msg.getPowerUsedID())
					+ " (" + msg.getPowerUsedID() + ')');
			Logger.info( "Using Power: "
					+ Integer.toHexString(msg.getPowerUsedID()) + " ("
					+ msg.getPowerUsedID() + ')');
		}

		//Sending recycle message to player if died while casting.
		if (!playerCharacter.isAlive() && msg.getPowerUsedID() != 428589216) { //succor

			RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(msg.getPowerUsedID());
			Dispatch dispatch = Dispatch.borrow(playerCharacter, recyclePowerMsg);
			DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);

			return false;
		}
		
		


		// if (!pc.getPowers().contains(msg.getPowerUsedID())) {
		// sendPowerMsg(pc, 10, msg);
		// return false;
		// }
		// verify recycle timer is not active for power, skip for a CSR
		if (playerCharacter.getRecycleTimers().containsKey(msg.getPowerUsedID()) && !playerCharacter.isCSR()) {
			// ChatManager.chatSayInfo(pc, "Recycle timer not finished!");

			Logger.warn("usePowerA(): Cheat attempted? '" + msg.getPowerUsedID() + "' recycle timer not finished " + playerCharacter.getName());
			return false;
		}

		// get power
		PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerUsedID());
		if (pb == null) {
			ChatManager.chatSayInfo(playerCharacter,
					"This power is not implemented yet.");

			// Logger.error("usePowerA(): Power '" +
			// msg.getPowerUsedID()
			// + "' was not found on powersBaseByToken map.");
			return true;
			// return false;
		}

		if (playerCharacter.getLastPower() != null)
			return true;
		
		//Check if Power Target is allowed to cast.


		// Check powers for normal users
		if (playerCharacter.getPowers() == null || !playerCharacter.getPowers().containsKey(msg.getPowerUsedID()))
			if (!playerCharacter.isCSR()) {
				if (!MBServerStatics.POWERS_DEBUG) {
					//  ChatManager.chatSayInfo(pc, "You may not cast that spell!");

					 Logger.info("usePowerA(): Cheat attempted? '" + msg.getPowerUsedID() + "' was not associated with " + playerCharacter.getName());
					return true;
				}
			} else
				CSRCast = true;

		// get numTrains for power
		int trains = msg.getNumTrains();

		// can't go over the max trains for the power, unless CSR
		if (trains > pb.getMaxTrains() && !playerCharacter.isCSR()) {
			trains = pb.getMaxTrains();
			msg.setNumTrains(trains);
		}

		// can't go over total trains by player
		if (playerCharacter.getPowers() != null && playerCharacter.getPowers().containsKey(msg.getPowerUsedID())) {
			CharacterPower cp = playerCharacter.getPowers().get(msg.getPowerUsedID());
			if (cp != null) {
				int tot = cp.getTotalTrains();
				if (tot == 0 && !playerCharacter.isCSR())
					return false;
				if (trains != tot && !playerCharacter.isCSR()) {
					trains = tot;
					msg.setNumTrains(trains);
				}
			}
		}

		// get recycle time in ms
		int time = pb.getRecycleTime(trains);

		// verify player is in correct mode (combat/nonCombat)
		if (playerCharacter.isCombat()) {
			if (!pb.allowedInCombat())
				// ChatManager.chatPowerError(pc,
				// "This power is not allowed in combat mode.");
				return true;
		} else if (!pb.allowedOutOfCombat())
			// ChatManager.chatPowerError(pc,
			// "You must be in combat mode to use this power.");
			return true;

		// verify player is not stunned or prohibited from casting
		PlayerBonuses bonus = playerCharacter.getBonuses();
SourceType sourceType = SourceType.GetSourceType(pb.getCategory());
		if (bonus != null && (bonus.getBool(ModType.Stunned,SourceType.None) || bonus.getBool(ModType.CannotCast, SourceType.None) || bonus.getBool(ModType.BlockedPowerType, sourceType)))
			return true;

		// if moving make sure spell valid for movement
		Vector3fImmutable endLoc = playerCharacter.getEndLoc();

		
			if (!pb.canCastWhileMoving())
				if (playerCharacter.isMoving()){

				// if movement left is less then 1 seconds worth then let cast
				// go through.
				float distanceLeftSquared = endLoc.distanceSquared2D(playerCharacter.getLoc());

				if (distanceLeftSquared > sqr(playerCharacter.getSpeed()))
					return true;
			}
		// if flying, make sure spell valid for flying.
		// if (pc.getAltitude() > 0)
		// if (!pb.canCastWhileFlying())
		// return true;

		int targetLiveCounter = -1;

		// get target based on targetType;
		if (pb.targetFromLastTarget() || pb.targetPet()) // use msg's target
			if (pb.isAOE()) {
				if (!pb.usePointBlank()) {
					AbstractWorldObject target = getTarget(msg);
					
					
					
					if (target != null && target.getObjectType() == GameObjectType.Building && !pb.targetBuilding()) {
						PowersManager.sendPowerMsg(playerCharacter, 9, new PerformActionMsg(msg));
						return true;
					}

					if (target == null) {
						if (playerCharacter.getLoc().distanceSquared2D(msg.getTargetLoc()) > sqr(pb
								.getRange()))
							return true;
					} else if (verifyInvalidRange(playerCharacter, target, pb.getRange()))
						// pc.getLoc().distance(target.getLoc()) >
						// pb.getRange())
						return true;


				}
			} else {
				// get target
				AbstractWorldObject target = getTarget(msg);

				if (target == null)
					return true;
				
				if (!target.isAlive() && target.getObjectType().equals(GameObjectType.Building) == false  && msg.getPowerUsedID() != 428589216)
					return true;

				float range = pb.getRange();
				// verify target is in range
			

				if (verifyInvalidRange(playerCharacter, target, range))
					// (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
					// TODO send message that target is out of range
					return true;

				// verify target is valid type
				if (!validateTarget(target, playerCharacter, pb))
					return true;


				if (AbstractWorldObject.IsAbstractCharacter(target))
					targetLiveCounter = ((AbstractCharacter) target).getLiveCounter();
			}

		// verify regular player can cast spell, otherwise authenticate
		if (!pb.regularPlayerCanCast()) {
            Account a = SessionManager.getAccount(playerCharacter);
            if (a.status.equals(AccountStatus.ADMIN) == false) {
                Logger.warn("Player '" + playerCharacter.getName()
                        + "' is attempting to cast a spell outside of their own access level.");
                return true;
            }
        }

		// verify player has proper effects applied to use power
		if (pb.getEffectPrereqs().size() > 0 && playerCharacter.getEffects() != null) {

			boolean passed = false;
			for (PowerPrereq pp : pb.getEffectPrereqs()) {

				EffectsBase eb = PowersManager.getEffectByIDString(pp.getEffect());

				if (playerCharacter.containsEffect(eb.getToken())) {
					passed = true;
					break;
				}
			}

			if (!passed)
				return true;
		}

		//verify player has proper equipment to use power
		if (pb.getEquipPrereqs().size() > 0) {

			boolean passed = false;

			for (PowerPrereq pp : pb.getEquipPrereqs()) {

				int slot = pp.mainHand() ? MBServerStatics.SLOT_MAINHAND : MBServerStatics.SLOT_OFFHAND;

				if (playerCharacter.validEquip(slot, pp.getMessage())) {
					passed = true; //should have item in slot
					break;
				} else if (!pp.isRequired()) {
					passed = true; //should not have item in slot
					break;
				}
			}
			if (!passed)
				return true;
		}

		// TODO if target immune to powers, cancel unless aoe
		// Also make sure No.ImmuneToPowers is false for target
		// if there's a different power waiting to finish, stop here
	

		//get power cost and calculate any power cost modifiers
		float cost = pb.getCost(trains);
		
		if (playerCharacter.isCSR())
			cost = 0;

		if (bonus != null)
			cost *= (1 + bonus.getFloatPercentAll(ModType.PowerCost, SourceType.None));
		
		if (playerCharacter.getAltitude() > 0)
			cost *= 1.5f;

		// Verify player can afford to use power
		//CCR toons dont use cost
		
		if (!playerCharacter.isCSR()){
			if (cost > 0)
				if ((playerCharacter.getObjectTypeMask() & MBServerStatics.MASK_UNDEAD) != 0)
					if (playerCharacter.getHealth() <= cost)
						return true;
					else {
						playerCharacter.modifyHealth(-cost, playerCharacter, true);
						ModifyHealthMsg mhm = new ModifyHealthMsg(playerCharacter, playerCharacter, -cost,
								0f, 0f, 0, null,
								9999, 0);
						mhm.setOmitFromChat(1);
						DispatchMessage.dispatchMsgToInterestArea(playerCharacter, mhm, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
					}
				else if (pb.useMana())
					if (playerCharacter.getMana() < cost)
						return true;
					else
						playerCharacter.modifyMana(-cost, playerCharacter, true);
				else if (pb.useStamina())
					if (playerCharacter.getStamina() < cost)
						return true;
					else
						playerCharacter.modifyStamina(-cost, playerCharacter, true);
				else if (playerCharacter.getHealth() <= cost)
					return true;
				else
					playerCharacter.modifyHealth(-cost, playerCharacter, true);
		}
		

		// Validity checks passed, move on to casting spell
		//get caster's live counter
		int casterLiveCounter = playerCharacter.getLiveCounter();

		// run recycle job for when cast is available again, don't bother adding the timer for CSRs
		if (time > 0) {
			FinishRecycleTimeJob frtj = new FinishRecycleTimeJob(playerCharacter, msg);
			playerCharacter.getRecycleTimers().put(msg.getPowerUsedID(), js.scheduleJob(frtj, time));
		} else {
			// else send recycle message to unlock power
			RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(msg.getPowerUsedID());
			Dispatch dispatch = Dispatch.borrow(playerCharacter, recyclePowerMsg);
			DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
		}

		//what the fuck?
//		// Send cast to other players
//		if ((playerCharacter.getObjectTypeMask() & MBServerStatics.MASK_UNDEAD) != 0)
//			msg.setUnknown04(2); // Vampire Race, use health?
//		else
//			msg.setUnknown04(1); // Regular Race, use mana?
		int tr = msg.getNumTrains();
		DispatchMessage.dispatchMsgToInterestArea(playerCharacter, msg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, sendCastToSelf, false);

		//Make new msg..
		PerformActionMsg copyMsg = new PerformActionMsg(msg);
		copyMsg.setNumTrains(tr);

		// make person casting stand up if spell (unless they're casting a chant which does not make them stand up)
		if (pb.isSpell() && !pb.isChant() && playerCharacter.isSit()) {
			playerCharacter.update();
			playerCharacter.setSit(false);
			UpdateStateMsg updateStateMsg = new UpdateStateMsg(playerCharacter);
			DispatchMessage.dispatchMsgToInterestArea(playerCharacter, updateStateMsg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);

		}

		// update cast (use skill) fail condition
		playerCharacter.cancelOnCast();

		// update castSpell (use spell) fail condition if spell
		if (pb.isSpell())
			playerCharacter.cancelOnSpell();

		// get cast time in ms.
		time = pb.getCastTime(trains);

		// set player is casting for regens

		
			if (time > 100){
				playerCharacter.update();
				playerCharacter.setIsCasting(true);
			}
		
	
		playerCharacter.setLastMovementState(playerCharacter.getMovementState());
		// update used power timer
		playerCharacter.setLastUsedPowerTime();

		// run timer job to end cast
		if (time < 1) // run immediately
			finishUsePower(copyMsg, playerCharacter, casterLiveCounter, targetLiveCounter);
		else {
			UsePowerJob upj = new UsePowerJob(playerCharacter, copyMsg, copyMsg.getPowerUsedID(), pb, casterLiveCounter, targetLiveCounter);
			JobContainer jc = js.scheduleJob(upj, time);

			// make lastPower
			playerCharacter.setLastPower(jc);	
		}

		if (CSRCast)
			Logger.info("CSR " + playerCharacter.getName() + " cast power " + msg.getPowerUsedID() + '.');

		return false;
	}

	public static void testPowers(ByteBufferWriter writer) {
		writer.putInt(powersBaseByToken.size());
		for (int token : powersBaseByToken.keySet()) {
			writer.putInt(token);
			writer.putInt(40);
		}
	}

	public static boolean useMobPowerA(PerformActionMsg msg, Mob caster) {
		if (caster == null)
			return false;


		if (!caster.isAlive() && msg.getPowerUsedID() != 428589216) //succor
			return false;

		// get power
		PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerUsedID());
		if (pb == null)
			return true;

		// Check powers for normal users
		// get numTrains for power
		int trains = msg.getNumTrains();

		// can't go over the max trains for the power, unless CSR
		// can't go over total trains by player
		// get recycle time in ms
		int time = pb.getRecycleTime(trains);

		// verify player is in correct mode (combat/nonCombat)
		// verify player is not stunned or prohibited from casting
		PlayerBonuses bonus = caster.getBonuses();
		SourceType sourceType = SourceType.GetSourceType(pb.getCategory());
		if (bonus != null && (bonus.getBool(ModType.Stunned, SourceType.None) || bonus.getBool(ModType.CannotCast, SourceType.None) || bonus.getBool(ModType.BlockedPowerType, sourceType)))
			return true;

		// if moving make sure spell valid for movement
		// if flying, make sure spell valid for flying.
		// if (pc.getAltitude() > 0)
		// if (!pb.canCastWhileFlying())
		// return true;
		int targetLiveCounter = -1;

		// get target based on targetType;
		if (pb.targetFromLastTarget() || pb.targetPet()) // use msg's target
			if (pb.isAOE()) {
				if (!pb.usePointBlank()) {
					AbstractWorldObject target = getTarget(msg);


					if (target == null) {

						if (caster.getLoc().distanceSquared2D(msg.getTargetLoc()) > sqr(pb
								.getRange()))
							return true;
					} else if (verifyInvalidRange(caster, target, pb.getRange()))
						// pc.getLoc().distance(target.getLoc()) >
						// pb.getRange())
						return true;
				}
			} else {
				// get target
				AbstractWorldObject target = getTarget(msg);

				if (target == null)
					return true;

				// verify target is in range
				if (verifyInvalidRange(caster, target, pb.getRange()))
					// (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
					// TODO send message that target is out of range
					return true;

				// verify target is valid type
				if (AbstractWorldObject.IsAbstractCharacter(target))
					targetLiveCounter = ((AbstractCharacter) target).getLiveCounter();
			}

		// TODO if target immune to powers, cancel unless aoe
		// Also make sure No.ImmuneToPowers is false for target
		// if there's a different power waiting to finish, stop here
		if (caster.getLastMobPowerToken() != 0)
			return true;

		//get power cost and calculate any power cost modifiers
		// Validity checks passed, move on to casting spell
		//get caster's live counter
		int casterLiveCounter = caster.getLiveCounter();

		// run recycle job for when cast is available again, don't bother adding the timer for CSRs
		// Send cast to other players
		if (caster.getObjectTypeMask() == MBServerStatics.MASK_UNDEAD)
			msg.setUnknown05(0); // Regular Race, use mana?
		else
			msg.setUnknown05(0);

		int tr = msg.getNumTrains();

		msg.setNumTrains(9999);

		DispatchMessage.sendToAllInRange(caster, msg);
		DispatchMessage.sendToAllInRange(caster, msg);

		msg.setNumTrains(tr);

		// make person casting stand up if spell (unless they're casting a chant which does not make them stand up)
		// update cast (use skill) fail condition
		caster.cancelOnCast();

		// update castSpell (use spell) fail condition if spell
		if (pb.isSpell())
			caster.cancelOnSpell();

		// get cast time in ms.
		time = pb.getCastTime(trains);

		// set player is casting for regens
		caster.setIsCasting(true);
		caster.setLastMobPowerToken(pb.getToken());

		// run timer job to end cast
		if (time < 1 || pb.getToken() == -1994153779){
			// run immediately
			finishUseMobPower(msg, caster, casterLiveCounter, targetLiveCounter);
			caster.setLastMobPowerToken(0);
		}
			
		else {
			caster.setLastMobPowerToken(pb.getToken());
			caster.setTimeStamp("FinishCast", System.currentTimeMillis() + (pb.getCastTime(trains)));
		}
		//			finishUseMobPower(msg, caster, casterLiveCounter, targetLiveCounter); //			UseMobPowerJob upj = new UseMobPowerJob(caster, msg, msg.getPowerUsedID(), pb, casterLiveCounter, targetLiveCounter);
		//			 JobContainer jc = js.scheduleJob(upj, time);
		//			// make lastPower


		return false;
	}

	// called when a spell finishes casting. perform actions
	public static void finishUsePower(final PerformActionMsg msg, PlayerCharacter playerCharacter, int casterLiveCounter, int targetLiveCounter) {

		PerformActionMsg performActionMsg;
		Dispatch dispatch;

		if (playerCharacter == null || msg == null)
			return;

		if (playerCharacter.isCasting()){
			playerCharacter.update();
			playerCharacter.updateStamRegen(-100);
		}
		
		playerCharacter.resetLastSetLocUpdate();
		playerCharacter.setIsCasting(false);
		// can't go over total trains by player


		if (!playerCharacter.isAlive() || playerCharacter.getLiveCounter() != casterLiveCounter) {
			playerCharacter.clearLastPower();
			finishRecycleTime(msg.getPowerUsedID(), playerCharacter, true);


			// Let's do good OO.  Clone message don't modify it.

			performActionMsg = new PerformActionMsg(msg);
			performActionMsg.setNumTrains(9999);
			performActionMsg.setUnknown04(2);

			dispatch = Dispatch.borrow(playerCharacter, performActionMsg);
			DispatchMessage.dispatchMsgToInterestArea(playerCharacter, performActionMsg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
			return;
		}

		// set player is not casting for regens


		// clear power.
		playerCharacter.clearLastPower();

		PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerUsedID());

		if (pb == null) {
			Logger.error(
					"finishUsePower(): Power '" + msg.getPowerUsedID()
					+ "' was not found on powersBaseByToken map.");
			return;
		}

		int trains = msg.getNumTrains();

		// update used power timer
		playerCharacter.setLastUsedPowerTime();

		// verify player is not stunned or power type is blocked
		PlayerBonuses bonus = playerCharacter.getBonuses();

		if (bonus != null) {
			if (bonus.getBool(ModType.Stunned, SourceType.None))
				return;
			
			SourceType sourceType = SourceType.GetSourceType(pb.getCategory());
			if (bonus.getBool(ModType.BlockedPowerType, sourceType)) {
				finishRecycleTime(msg.getPowerUsedID(), playerCharacter, true);
				return;
			}
		}

		// get target loc
		Vector3fImmutable targetLoc = msg.getTargetLoc();


		if (pb.targetFromLastTarget() || pb.targetPet()) // use msg's target
			if (pb.isAOE()) {
				if (!pb.usePointBlank()) {
					AbstractWorldObject mainTarget = getTarget(msg);

					float speedRange = 0;
					if (AbstractWorldObject.IsAbstractCharacter(mainTarget)) {
						speedRange = ((AbstractCharacter) mainTarget).getSpeed() * (pb.getCastTime(trains) * .001f);
					}

					if (mainTarget != null && mainTarget.getObjectType() == GameObjectType.Building && !pb.targetBuilding()) {
						PowersManager.sendPowerMsg(playerCharacter, 8, new PerformActionMsg(msg));
						return;
					}

					if (mainTarget == null) {

						if (playerCharacter.getLoc().distanceSquared2D(msg.getTargetLoc()) > sqr(pb
								.getRange())) {
							sendPowerMsg(playerCharacter, 8, msg);
							return;
						}
					} else if (verifyInvalidRange(playerCharacter, mainTarget, speedRange + pb.getRange())) {

						sendPowerMsg(playerCharacter, 8, msg);
						return;
					}
				}
			} else {

				// get target
				AbstractWorldObject mainTarget = getTarget(msg);

				if (mainTarget == null)
					return;

				float speedRange = 0;
				if (AbstractWorldObject.IsAbstractCharacter(mainTarget)) {
					speedRange = ((AbstractCharacter) mainTarget).getSpeed() * (pb.getCastTime(trains) * .001f);
				}
				float range = pb.getRange() + speedRange;
				


				if (verifyInvalidRange(playerCharacter, mainTarget, range)) {

					sendPowerMsg(playerCharacter, 8, msg);
					return;
				}
				// (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
				// TODO send message that target is out of range


			}

		if (targetLoc.x == 0f || targetLoc.z == 0f) {
			AbstractWorldObject tar = getTarget(msg);
			if (tar != null)
				targetLoc = tar.getLoc();
		}


		// get list of targets
		HashSet<AbstractWorldObject> allTargets = getAllTargets(
				getTarget(msg), msg.getTargetLoc(), playerCharacter, pb);

		// no targets found. send error message

		if (allTargets.size() == 0) {
			sendPowerMsg(playerCharacter, 9, msg);
			return;
		}

		playerCharacter.setHateValue(pb.getHateValue(trains));

		//Send Cast Message.
//		PerformActionMsg castMsg = new PerformActionMsg(msg);
//		castMsg.setNumTrains(9999);
//		castMsg.setUnknown04(3);
//		DispatchMessage.dispatchMsgToInterestArea(playerCharacter, castMsg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
//		
		boolean msgCasted = false;
		
		for (AbstractWorldObject target : allTargets) {

			if (target == null)
				continue;

			//Hacky Pyschic healing cross heal

			//make sure target hasn't respawned since we began casting
			//skip this if liveCounter = -1 (from aoe)

			if (targetLiveCounter != -1)
				if (AbstractWorldObject.IsAbstractCharacter(target))
					if (targetLiveCounter != ((AbstractCharacter) target).getLiveCounter())
						continue;

			if (!target.isAlive() && target.getObjectType() != GameObjectType.Building && pb.getToken() != 428589216 && pb.getToken() != 429425915)
				continue;

			//make sure mob is awake to respond.
			//if (target instanceof AbstractIntelligenceAgent)
			//((AbstractIntelligenceAgent)target).enableIntelligence();
			// If Hit roll required, test hit

			boolean miss = false;
			if (pb.requiresHitRoll() && !pb.isWeaponPower() && testAttack(playerCharacter, target, pb, msg)) {
				miss = true;
				//aggro mob even on a miss
				if (target.getObjectType() == GameObjectType.Mob) {
					Mob mobTarget = (Mob) target;
					if (pb.isHarmful())
						mobTarget.handleDirectAggro(playerCharacter);
				}
				continue;
			}
			if (target.getObjectType() == GameObjectType.Mob) {
				Mob mobTarget = (Mob) target;
				if (pb.isHarmful())
					mobTarget.handleDirectAggro(playerCharacter);
			}
			//Power is aiding a target, handle aggro if combat target is a Mob.
			if (!pb.isHarmful() && target.getObjectType() == GameObjectType.PlayerCharacter) {
				PlayerCharacter pcTarget = (PlayerCharacter) target;
				if (!pb.isHarmful())
					Mob.HandleAssistedAggro(playerCharacter, pcTarget);
			}

			// update target of used power timer

			if (pb.isHarmful())
				if (target.getObjectType().equals(GameObjectType.PlayerCharacter) && target.getObjectUUID() != playerCharacter.getObjectUUID()) {

					((PlayerCharacter) target).setLastTargetOfUsedPowerTime();
					((PlayerCharacter) target).setTimeStamp("LastCombatPlayer", System.currentTimeMillis());
					playerCharacter.setTimeStamp("LastCombatPlayer", System.currentTimeMillis());
				}


			//Player didn't miss power, send finish cast. Miss cast already sent.
			

			// finally Apply actions
			for (ActionsBase ab : pb.getActions()) {
				// get numTrains for power, skip action if invalid

				if (trains < ab.getMinTrains() || trains > ab.getMaxTrains())
					continue;
				// If something blocks the action, then stop

				if (ab.blocked(target, pb, trains)) {

					PowersManager.sendEffectMsg(playerCharacter, 5, ab, pb);
					continue;
				}

				// TODO handle overwrite stack order here
				String stackType = ab.getStackType();
				stackType = (stackType.equals("IgnoreStack")) ? Integer.toString(ab.getUUID()) : stackType;
				//				if (!stackType.equals("IgnoreStack")) {
				if (target.getEffects().containsKey(stackType)) {
					// remove any existing power that overrides
					Effect ef = target.getEffects().get(stackType);
					AbstractEffectJob effect = null;
					if (ef != null) {
						JobContainer jc = ef.getJobContainer();
						if (jc != null)
							effect = (AbstractEffectJob) jc.getJob();
					}
					ActionsBase overwrite = effect.getAction();
					
					if (overwrite == null) {
						Logger.error("NULL ACTION FOR POWER " + effect.getPowerToken());
						continue;
					}
					
						if (ab.getStackOrder() < overwrite.getStackOrder())
							continue; // not high enough to overwrite
						else if (ab.getStackOrder() > overwrite.getStackOrder()) {
							effect.setNoOverwrite(true);
							removeEffect(target, overwrite, true, false);
						} else if (ab.getStackOrder() == overwrite.getStackOrder())
							if (ab.greaterThanEqual()
									&& (trains >= effect.getTrains())) {
								effect.setNoOverwrite(true);
								removeEffect(target, overwrite, true, false);
							}
					
					 else if (ab.always())
							removeEffect(target, overwrite, true, false);
						else if (ab.greaterThan()
								&& (trains > effect.getTrains())) {
							effect.setNoOverwrite(true);
							removeEffect(target, overwrite, true, false);
						} else if (ab.greaterThan() && pb.getToken() == effect.getPowerToken())
							removeEffect(target, overwrite, true, false);

						else
							continue; // trains not high enough to overwrite
						
					}
					
				//				}
				

				runPowerAction(playerCharacter, target, targetLoc, ab, trains, pb);
				if (!miss && !msgCasted){
					PerformActionMsg castMsg = new PerformActionMsg(msg);
					castMsg.setNumTrains(9999);
					castMsg.setUnknown04(2);
					DispatchMessage.dispatchMsgToInterestArea(playerCharacter, castMsg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
					msgCasted = true;
				}
			}
		}
		
		if ( !msgCasted){
			PerformActionMsg castMsg = new PerformActionMsg(msg);
			castMsg.setNumTrains(9999);
			castMsg.setUnknown04(2);
			DispatchMessage.dispatchMsgToInterestArea(playerCharacter, castMsg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
			msgCasted = true;
		}

		//Handle chant
		if (pb != null && pb.isChant())
			for (ActionsBase ab : pb.getActions()) {
				AbstractPowerAction pa = ab.getPowerAction();
				if (pa != null)
					if (pb.getToken() != 428950414 && pb.getToken() != 428884878)
						pa.handleChant(playerCharacter, playerCharacter, targetLoc, trains, ab, pb);
					else if (PowersManager.getTarget(msg) != null && PowersManager.getTarget(msg).isAlive())
						pa.handleChant(playerCharacter, PowersManager.getTarget(msg), targetLoc, trains, ab, pb);
					else
						pa.handleChant(playerCharacter, null, targetLoc, trains, ab, pb);
			}
		
		

		
		
		//DispatchMessage.dispatchMsgToInterestArea(playerCharacter, msg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);


	}

	public static void finishUseMobPower(PerformActionMsg msg, Mob caster, int casterLiveCounter, int targetLiveCounter) {

		if (caster == null || msg == null)
			return;

		if (!caster.isAlive() || caster.getLiveCounter() != casterLiveCounter)
			return;

		// set player is not casting for regens
		caster.setIsCasting(false);

		
		PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerUsedID());
		// clear power.
				caster.setLastMobPowerToken(0);

		if (pb == null) {
			Logger.error(
					"finishUsePower(): Power '" + msg.getPowerUsedID()
					+ "' was not found on powersBaseByToken map.");
			return;
		}
		
		int trains = msg.getNumTrains();

		// update used power timer
		// verify player is not stunned or power type is blocked
		PlayerBonuses bonus = caster.getBonuses();
		if (bonus != null) {
			if (bonus.getBool(ModType.Stunned,SourceType.None))
				return;
			SourceType sourceType = SourceType.GetSourceType(pb.getCategory());
			if (bonus.getBool(ModType.BlockedPowerType, sourceType))
				return;
		}

		msg.setNumTrains(9999);
		msg.setUnknown04(2);
		DispatchMessage.sendToAllInRange(caster, msg);

		// get target loc
		Vector3fImmutable targetLoc = msg.getTargetLoc();
		if (targetLoc.x == 0f || targetLoc.z == 0f) {
			AbstractWorldObject tar = getTarget(msg);
			if (tar != null)
				targetLoc = tar.getLoc();
		}

		// get list of targets
		HashSet<AbstractWorldObject> allTargets = getAllTargets(
				getTarget(msg), msg.getTargetLoc(), caster, pb);
		for (AbstractWorldObject target : allTargets) {

			if (target == null)
				continue;


			//make sure target hasn't respawned since we began casting
			//skip this if liveCounter = -1 (from aoe)
			if (targetLiveCounter != -1)
				if (AbstractWorldObject.IsAbstractCharacter(target))
					if (targetLiveCounter != ((AbstractCharacter) target).getLiveCounter())
						continue;

			//make sure mob is awake to respond.
			//if (target instanceof AbstractIntelligenceAgent)
			//((AbstractIntelligenceAgent)target).enableIntelligence();
			// If Hit roll required, test hit
			if (pb.requiresHitRoll() && !pb.isWeaponPower() && testAttack(caster, target, pb, msg))
				//aggro mob even on a miss
				continue;

			// update target of used power timer

			if (target.getObjectType().equals(GameObjectType.PlayerCharacter)) {

				((PlayerCharacter) target).setLastTargetOfUsedPowerTime();
				((PlayerCharacter) target).setTimeStamp("LastCombatPlayer", System.currentTimeMillis());
			}


			// finally Apply actions
			for (ActionsBase ab : pb.getActions()) {
				// get numTrains for power, skip action if invalid

				if (trains < ab.getMinTrains() || trains > ab.getMaxTrains())
					continue;
				// If something blocks the action, then stop

				if (ab.blocked(target, pb, trains))
					continue;
				// TODO handle overwrite stack order here
				String stackType = ab.getStackType();
				stackType = (stackType.equals("IgnoreStack")) ? Integer.toString(ab.getUUID()) : stackType;
				//				if (!stackType.equals("IgnoreStack")) {
				if (target.getEffects().containsKey(stackType)) {
					// remove any existing power that overrides
					Effect ef = target.getEffects().get(stackType);
					AbstractEffectJob effect = null;
					if (ef != null) {
						JobContainer jc = ef.getJobContainer();
						if (jc != null)
							effect = (AbstractEffectJob) jc.getJob();
					}
					ActionsBase overwrite = effect.getAction();
					
					if (overwrite == null){
						Logger.error("NULL ACTION FOR EFFECT " + effect.getPowerToken());
						continue;
					}
					if (ab.getStackOrder() < overwrite.getStackOrder())
						continue; // not high enough to overwrite
					else if (ab.getStackOrder() > overwrite.getStackOrder()) {
						effect.setNoOverwrite(true);
						removeEffect(target, overwrite, true, false);
					} else if (ab.getStackOrder() == overwrite.getStackOrder())
						if (ab.greaterThanEqual()
								&& (trains >= effect.getTrains())) {
							effect.setNoOverwrite(true);
							removeEffect(target, overwrite, true, false);
						} else if (ab.always())
							removeEffect(target, overwrite, true, false);
						else if (ab.greaterThan()
								&& (trains > effect.getTrains())) {
							effect.setNoOverwrite(true);
							removeEffect(target, overwrite, true, false);
						} else if (ab.greaterThan() && pb.getToken() == effect.getPowerToken())
							removeEffect(target, overwrite, true, false);

						else
							continue; // trains not high enough to overwrite
				}

				//				}
				runPowerAction(caster, target, targetLoc, ab, trains, pb);
			}
		}

		//Handle chant
		if (pb != null && pb.isChant())
			for (ActionsBase ab : pb.getActions()) {
				AbstractPowerAction pa = ab.getPowerAction();
				if (pa != null)
					pa.handleChant(caster, caster, targetLoc, trains, ab, pb);
			}

		// TODO echo power use to everyone else
		msg.setNumTrains(9999);
		msg.setUnknown04(2);
		DispatchMessage.sendToAllInRange(caster, msg);

	}

	// *** Refactor : Wtf is this mess?

	private static boolean validMonsterType(AbstractWorldObject target, PowersBase pb) {

		if (pb == null || target == null)
			return false;

		String mtp = pb.getMonsterTypePrereq();

		if (mtp.length() == 0)
			return true;

		if (target.getObjectType().equals(GameObjectType.PlayerCharacter)) {

			PlayerCharacter pc = (PlayerCharacter) target;
			int raceID = 0;

			if (pc.getRace() != null)
				raceID = pc.getRace().getRaceRuneID();

			switch (mtp) {
			case "Shade":
				return raceID == 2015 || raceID == 2016;
			case "Elf":
				return raceID == 2008 || raceID == 2009;
			case "Dwarf":
				return raceID == 2006;
			case "Aracoix":
				return raceID == 2002 || raceID == 2003;
			case "Irekei":
				return raceID == 2013 || raceID == 2014;
			case "Vampire":
				return raceID == 2028 || raceID == 2029;
			}
		} else if (target.getObjectType().equals(GameObjectType.Mob)) {
			Mob mob = (Mob) target;

			if (pb.targetMob() && !mob.isMob() && !mob.isSiege())
				return false;
			else if (pb.targetPet() && !mob.isPet() && !mob.isSiege())
				return false;

			switch (mtp) {
			case "Animal":
				if ((mob.getObjectTypeMask() & MBServerStatics.MASK_BEAST) == 0)
					return false;
				break;
			case "NPC":
				if ((mob.getObjectTypeMask() & MBServerStatics.MASK_HUMANOID) == 0)
					return false;
				break;
			case "Rat":
				if ((mob.getObjectTypeMask() & MBServerStatics.MASK_RAT) == 0)
					return false;
				break;
			case "Siege":
				if (!mob.isSiege())
					return false;
				break;
			case "Undead":
				if ((mob.getObjectTypeMask() & MBServerStatics.MASK_UNDEAD) == 0)
					return false;
				break;
			}
			return true;
		} else return target.getObjectType().equals(GameObjectType.Building) && mtp.equals("Siege");
		return false;
	}

	public static void summon(SendSummonsRequestMsg msg, ClientConnection origin) {
		PlayerCharacter pc = SessionManager.getPlayerCharacter(
				origin);
		if (pc == null)
			return;

		PlayerCharacter target = SessionManager
				.getPlayerCharacterByLowerCaseName(msg.getTargetName());
		if (target == null || target.equals(pc) || target.isCombat()) {

			if (target == null) // Player not found. Send not found message
				ChatManager.chatInfoError(pc,
						"Cannot find that player to summon.");
			else if (target.isCombat())
				ChatManager.chatInfoError(pc,
						"Cannot summon player in combat.");
			// else trying to summon self, just fail

			// recycle summon
			sendRecyclePower(msg.getPowerToken(), origin);

			// TODO: client already subtracted 200 mana.. need to correct it
			// end cast
			PerformActionMsg pam = new PerformActionMsg(msg.getPowerToken(),
					msg.getTrains(), msg.getSourceType(), msg.getSourceID(), 0,
					0, 0f, 0f, 0f, 1, 0);
			sendPowerMsg(pc, 2, pam);

			return;
		}

		PerformActionMsg pam = new PerformActionMsg(msg.getPowerToken(), msg
				.getTrains(), msg.getSourceType(), msg.getSourceID(), target
				.getObjectType().ordinal(), target.getObjectUUID(), 0f, 0f, 0f, 1, 0);

		// Client removes 200 mana on summon use.. so don't send message to self
		target.addSummoner(pc.getObjectUUID(), System.currentTimeMillis() + MBServerStatics.FOURTYFIVE_SECONDS);
		usePower(pam, origin, false);
	}

	public static void recvSummon(RecvSummonsRequestMsg msg, ClientConnection origin) {
		PlayerCharacter pc = SessionManager.getPlayerCharacter(origin);
		if (pc == null)
			return;

		PlayerCharacter source = PlayerCharacter.getFromCache(msg.getSourceID());
		if (source == null)
			return;

		long tooLate = pc.getSummoner(source.getObjectUUID());
		if (tooLate < System.currentTimeMillis()) {
			ChatManager.chatInfoError(pc, "You waited too long to " + (msg.accepted() ? "accept" : "decline") + " the summons.");
			pc.removeSummoner(source.getObjectUUID());
			return;
		}

		if (pc.getBonuses() != null && pc.getBonuses().getBool(ModType.BlockedPowerType, SourceType.SUMMON)) {
			ErrorPopupMsg.sendErrorMsg(pc, "You have been blocked from receiving summons!");
			ErrorPopupMsg.sendErrorMsg(source, "Target is blocked from receiving summons!");
			pc.removeSummoner(source.getObjectUUID());
			return;
		}
		pc.removeSummoner(source.getObjectUUID());

		// Handle Accepting or Denying a summons.
		// set timer based on summon type.
		boolean wentThrough = false;
		if (msg.accepted())
			// summons accepted, let's move the player if within time
			if (source.isAlive()) {

				//				//make sure summons handled in time
				ConcurrentHashMap<String, JobContainer> timers = source.getTimers();
				//				if (timers == null || !timers.containsKey("SummonSend")) {
				//					ChatManager.chatInfoError(pc, "You waited too long to " + (msg.accepted() ? "accept" : "decline") + " the summons.");
				//					return;
				//				}

				//				// clear last summons accept timer
				//	timers.get("SummonSend").cancelJob();
				//timers.remove("SummonSend");
				// cancel any other summons waiting
				timers = pc.getTimers();
				if (timers != null && timers.containsKey("Summon"))
					timers.get("Summon").cancelJob();

				// get time to wait before summons goes through
				BaseClass base = source.getBaseClass();
				PromotionClass promo = source.getPromotionClass();
				int duration;


				//determine if in combat with another player


				//comment out this block to disable combat timer
				//				if (lastAttacked < 60000) {
				//					if (pc.inSafeZone()) //player in safe zone, no need for combat timer
				//						combat = false;
				//					else if (source.inSafeZone()) //summoner in safe zone, apply combat timer
				//						combat = true;
				//					else if ((source.getLoc().distance2D(pc.getLoc())) > 6144f)
				//						combat = true; //more than 1.5x width of zone, not tactical summons
				//				}

                if (promo != null && promo.getObjectUUID() == 2519)
					duration = 10000; // Priest summons, 10 seconds
				else if (base != null && base.getObjectUUID() == 2501)
					duration = 15000; // Healer Summons, 15 seconds
				else
					duration = 45000; // Belgosh Summons, 45 seconds


				// Teleport to summoners location
				FinishSummonsJob fsj = new FinishSummonsJob(source, pc);
				JobContainer jc = JobScheduler.getInstance().scheduleJob(fsj,
						duration);
				if (timers != null)
					timers.put("Summon", jc);
				wentThrough = true;
			}

		// Summons failed
		if (!wentThrough)
			// summons refused. Let's be nice and reset recycle timer
			if (source != null) {

				// Send summons refused Message
				ErrorPopupMsg.sendErrorPopup(source, 29);

				// recycle summons power
				//finishRecycleTime(428523680, source, true);
			}
	}

	public static void trackWindow(TrackWindowMsg msg, ClientConnection origin) {

		PlayerCharacter playerCharacter = SessionManager.getPlayerCharacter(
				origin);

		if (playerCharacter == null)
			return;

		if (MBServerStatics.POWERS_DEBUG) {
			ChatManager.chatSayInfo(
					playerCharacter,
					"Using Power: " + Integer.toHexString(msg.getPowerToken())
					+ " (" + msg.getPowerToken() + ')');
			Logger.info( "Using Power: "
					+ Integer.toHexString(msg.getPowerToken()) + " ("
					+ msg.getPowerToken() + ')');
		}

		// get track power used
		PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerToken());

		if (pb == null || !pb.isTrack())
			return;

		//check track threshold timer to prevent spam
		long currentTime = System.currentTimeMillis();
		long timestamp = playerCharacter.getTimeStamp("trackWindow");
		long dif = currentTime - timestamp;
		if (dif < MBServerStatics.TRACK_WINDOW_THRESHOLD)
			return;
		playerCharacter.setTimeStamp("trackWindow", currentTime);

		ArrayList<ActionsBase> ablist = pb.getActions();
		if (ablist == null)
			return;

		TrackPowerAction tpa = null;
		for (ActionsBase ab : ablist) {
			AbstractPowerAction apa = ab.getPowerAction();
			if (apa != null && apa instanceof TrackPowerAction)
				tpa = (TrackPowerAction) apa;
		}
		if (tpa == null)
			return;

		// Check powers for normal users
		if (playerCharacter.getPowers() == null || !playerCharacter.getPowers().containsKey(msg.getPowerToken()))
			if (!playerCharacter.isCSR())
				if (!MBServerStatics.POWERS_DEBUG) {
					//  ChatManager.chatSayInfo(pc, "You may not cast that spell!");
					//  this.logEXPLOIT("usePowerA(): Cheat attempted? '" + msg.getPowerToken() + "' was not associated with " + pc.getName());
					return;
				}

		// Get search mask for track
		int mask = 0;
		if (pb.targetPlayer())
			if (tpa.trackVampire()) // track vampires
				mask = MBServerStatics.MASK_PLAYER | MBServerStatics.MASK_UNDEAD;
			else
				// track all players
				mask = MBServerStatics.MASK_PLAYER;
		else if (pb.targetCorpse()) // track corpses
			mask = MBServerStatics.MASK_CORPSE;
		else if (tpa.trackNPC()) // Track NPCs
			mask = MBServerStatics.MASK_NPC;
		else if (tpa.trackUndead()) // Track Undead
			mask = MBServerStatics.MASK_MOB | MBServerStatics.MASK_UNDEAD;
		else
			// Track All
			mask = MBServerStatics.MASK_MOB | MBServerStatics.MASK_NPC;

		// Find characters in range
		HashSet<AbstractWorldObject> allTargets;
		allTargets = WorldGrid.getObjectsInRangeContains(playerCharacter.getLoc(),
				pb.getRange(), mask);

		//remove anyone who can't be tracked
		Iterator<AbstractWorldObject> it = allTargets.iterator();
		while (it.hasNext()) {
			AbstractWorldObject awo = it.next();
			if (awo == null)
				continue;
			else if (!awo.isAlive())
				it.remove();
			else if (awo.getObjectType().equals(GameObjectType.PlayerCharacter)) {
				PlayerBonuses bonus = ((PlayerCharacter) awo).getBonuses();
				if (bonus != null && bonus.getBool(ModType.CannotTrack, SourceType.None))
					it.remove();
			}
		}

		// get max charcters for window
		int maxTargets = 20;
		PromotionClass promo = playerCharacter.getPromotionClass();
		if (promo != null) {
			int tableID = promo.getObjectUUID();
			if (tableID == 2512 || tableID == 2514 || tableID == 2515)
				maxTargets = 40;
		}

		// create list of characters
		HashSet<AbstractCharacter> trackChars = RangeBasedAwo.getTrackList(
				allTargets, playerCharacter, maxTargets);

		TrackWindowMsg trackWindowMsg = new TrackWindowMsg(msg);

		// send track window
		trackWindowMsg.setSource(playerCharacter);
		trackWindowMsg.setCharacters(trackChars);

		Dispatch dispatch = Dispatch.borrow(playerCharacter, trackWindowMsg);
		DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);

	}

	private static void sendRecyclePower(int token, ClientConnection origin) {
		RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(token);

		Dispatch dispatch = Dispatch.borrow(origin.getPlayerCharacter(), recyclePowerMsg);
		DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);

	}

	public static boolean verifyInvalidRange(AbstractCharacter ac,
			AbstractWorldObject target, float range) {
		Vector3fImmutable sl = ac.getLoc();
		Vector3fImmutable tl = target.getLoc();
		 if (target.getObjectType().equals(GameObjectType.Item)) {

			Item item = (Item) target;
			AbstractGameObject owner = item.getOwner();

			if (owner == null || owner.getObjectType().equals(GameObjectType.Account))
				return true;

			if (owner.getObjectType().equals(GameObjectType.PlayerCharacter) || owner.getObjectType().equals(GameObjectType.Mob)) {
				AbstractCharacter acOwner = (AbstractCharacter) owner;
				CharacterItemManager itemMan = acOwner.getCharItemManager();
				if (itemMan == null)
					return true;
				if (itemMan.inventoryContains(item)) {
					tl = acOwner.getLoc();
					return !(sl.distanceSquared(tl) <= sqr(range));
				}
				return true;
			}
			return true;
		}

		range += (calcHitBox(ac) + calcHitBox(target));


		float distanceToTarget = sl.distanceSquared(tl);//distance to center of target

		return distanceToTarget > range * range;

	}

	public static float calcHitBox(AbstractWorldObject ac) {
		//TODO Figure out how Str Affects HitBox
		float hitBox = 1;
		switch (ac.getObjectType()) {
		case PlayerCharacter:
			PlayerCharacter pc = (PlayerCharacter) ac;
			if (MBServerStatics.COMBAT_TARGET_HITBOX_DEBUG)
                Logger.info( "Hit box radius for " + pc.getFirstName() + " is " + ((int) pc.statStrBase / 200f));
            hitBox = 2f + (int) ((PlayerCharacter) ac).statStrBase / 50f;
			break;

		case Mob:
			Mob mob = (Mob) ac;
			if (MBServerStatics.COMBAT_TARGET_HITBOX_DEBUG)
				Logger.info( "Hit box radius for " + mob.getFirstName()
				+ " is " + ((Mob) ac).getMobBase().getHitBoxRadius());

			hitBox = ((Mob) ac).getMobBase().getHitBoxRadius();
			break;
		case Building:
			Building building = (Building) ac;
			if (building.getBlueprint() == null)
				return 32;
			hitBox = Math.max(building.getBlueprint().getBuildingGroup().getExtents().x,
					building.getBlueprint().getBuildingGroup().getExtents().y);
			if (MBServerStatics.COMBAT_TARGET_HITBOX_DEBUG)
				Logger.info("Hit box radius for " + building.getName() + " is " + hitBox);
			break;

		}
		return hitBox;
	}

	// Apply a power based on it's IDString
	public static void applyPower(AbstractCharacter ac, AbstractWorldObject target,
			Vector3fImmutable targetLoc, String ID, int trains, boolean fromItem) {
		if (ac == null || target == null || !ac.isAlive())
			return;
		PowersBase pb = powersBaseByIDString.get(ID);
		if (pb == null) {
			Logger.error(
					"applyPower(): Got NULL on powersBaseByIDString table lookup for: "
							+ ID);
			return;
		}
		applyPowerA(ac, target, targetLoc, pb, trains, fromItem);
	}

	// Apply a power based on it's Token
	public static void applyPower(AbstractCharacter ac, AbstractWorldObject target,
			Vector3fImmutable targetLoc, int token, int trains, boolean fromItem) {
		if (ac == null || target == null)
			return;

		//Don't apply power if ac is dead, unless death shroud or safe mode
		if (!ac.isAlive())
			if (!(token == -1661758934 || token == 1672601862))
				return;

		PowersBase pb = powersBaseByToken.get(token);
		if (pb == null) {
			Logger.error(
					"applyPower(): Got NULL on powersBaseByToken table lookup for: "
							+ token);
			return;
		}
		applyPowerA(ac, target, targetLoc, pb, trains, fromItem);
	}

	private static void applyPowerA(AbstractCharacter ac, AbstractWorldObject target,
			Vector3fImmutable targetLoc, PowersBase pb, int trains,
			boolean fromItem) {
		int time = pb.getCastTime(trains);
		if (!fromItem)
			finishApplyPowerA(ac, target, targetLoc, pb, trains, false);
		else if (time == 0)
			finishApplyPower(ac, target, targetLoc, pb, trains, ac.getLiveCounter());
		else {

			ac.setItemCasting(true);
			int tarType = (target == null) ? 0 : target.getObjectType().ordinal();
			int tarID = (target == null) ? 0 : target.getObjectUUID();

			// start the action animation
			PerformActionMsg msg = new PerformActionMsg(pb.getToken(),
					trains, ac.getObjectType().ordinal(), ac.getObjectUUID(), tarType, tarID, 0,
					0, 0, 1, 0);
			DispatchMessage.sendToAllInRange(target, msg);


			ConcurrentHashMap<String, JobContainer> timers = ac.getTimers();

			if (timers.containsKey(Integer.toString(pb.getToken()))) {
				JobContainer jc = timers.get(Integer.toString(pb.getToken()));
				if (jc != null)
					jc.cancelJob();
			}

			//				// clear any other items being used
			//				JobContainer jc = ac.getLastItem();
			//				if (jc != null) {
			//					jc.cancelJob();
			//					ac.clearLastItem();
			//				}
			// run timer job to end cast
			UseItemJob uij = new UseItemJob(ac, target, pb, trains, ac.getLiveCounter());
			JobContainer jc = js.scheduleJob(uij, time);

			// make lastItem
			timers.put(Integer.toString(pb.getToken()), jc);
		}
	}

	public static void finishApplyPower(AbstractCharacter ac,
			AbstractWorldObject target, Vector3fImmutable targetLoc,
			PowersBase pb, int trains, int liveCounter) {
		
		if (ac != null)
			ac.setItemCasting(false);
		if (ac == null || target == null || pb == null)
			return;
		
		ac.clearTimer(Integer.toString(pb.getToken()));
		if (liveCounter == ac.getLiveCounter())
			finishApplyPowerA(ac, target, targetLoc, pb, trains, false);
	}

	public static void finishApplyPowerA(AbstractCharacter ac,
			AbstractWorldObject target, Vector3fImmutable targetLoc,
			PowersBase pb, int trains, boolean fromChant) {
		// finally Apply actions
		ArrayList<ActionsBase> actions = pb.getActions();
		for (ActionsBase ab : actions) {
			// get numTrains for power, skip action if invalid
			if (trains < ab.getMinTrains() || trains > ab.getMaxTrains())
				continue;
			// If something blocks the action, then stop
			if (ab.blocked(target, pb, trains))
				// sendPowerMsg(pc, 5, msg);
				continue;
			// TODO handle overwrite stack order here
			String stackType = ab.getStackType();
			stackType = (stackType.equals("IgnoreStack")) ? Integer.toString(ab.getUUID()) : stackType;
			if (target.getEffects().containsKey(stackType)) {
				// remove any existing power that overrides
				Effect ef = target.getEffects().get(stackType);
				AbstractEffectJob effect = null;
				if (ef != null) {
					JobContainer jc = ef.getJobContainer();
					if (jc != null)
						effect = (AbstractEffectJob) jc.getJob();
				}
				ActionsBase overwrite = effect.getAction();
				PowersBase pbOverwrite = effect.getPower();
				if (pbOverwrite != null && pbOverwrite.equals(pb)
						&& (trains >= effect.getTrains()))
					removeEffect(target, overwrite, true, fromChant);
				else if (ab.getStackOrder() < overwrite.getStackOrder())
					continue; // not high enough to overwrite
				else if (ab.getStackOrder() > overwrite.getStackOrder())
					removeEffect(target, overwrite, true, false);
				else if (ab.getStackOrder() == overwrite.getStackOrder())
					if (ab.greaterThanEqual()
							&& (trains >= effect.getTrains()))
						removeEffect(target, overwrite, true, false);
					else if (ab.always())
						removeEffect(target, overwrite, true, false);
					else if (ab.greaterThan()
							&& (trains > effect.getTrains()))
						removeEffect(target, overwrite, true, false);
					else if (ab.greaterThan() && pb.getToken() == effect.getPowerToken())
						removeEffect(target, overwrite, true, false);
					else
						continue; // trains not high enough to overwrite
			}
			if (fromChant)
				targetLoc = Vector3fImmutable.ZERO;
			runPowerAction(ac, target, targetLoc, ab, trains, pb);
		}

		//Handle chant
		if (pb != null && pb.isChant())
			for (ActionsBase ab : pb.getActions()) {
				AbstractPowerAction pa = ab.getPowerAction();
				if (pa != null)
					pa.handleChant(ac, target, targetLoc, trains, ab, pb);
			}

		// for chants, only send the animation if the character is not is not moving or casting
		boolean doAnimation = true;

		if (target.getObjectType().equals(GameObjectType.PlayerCharacter)) {
			PlayerCharacter pc = (PlayerCharacter) target;
			if (pb != null && pb.isChant() && (pc.isMoving() || pc.isCasting()))
				doAnimation = false;
		}

		if (pb.getToken() == 428950414)
			doAnimation = true;

		if (doAnimation) {
			PerformActionMsg msg = new PerformActionMsg(pb.getToken(), 9999, ac
					.getObjectType().ordinal(), ac.getObjectUUID(), target.getObjectType().ordinal(),
					target.getObjectUUID(), 0, 0, 0, 2, 0);

			DispatchMessage.sendToAllInRange(ac, msg);

		}
	}

	public static void runPowerAction(AbstractCharacter source,
			AbstractWorldObject awo, Vector3fImmutable targetLoc,
			ActionsBase ab, int trains, PowersBase pb) {
		AbstractPowerAction pa = ab.getPowerAction();
		if (pa == null) {
			Logger.error(
					"runPowerAction(): PowerAction not found of IDString: "
							+ ab.getEffectID());
			return;
		}
		pa.startAction(source, awo, targetLoc, trains, ab, pb);
	}

	public static void runPowerAction(AbstractCharacter source,
			AbstractWorldObject awo, Vector3fImmutable targetLoc,
			ActionsBase ab, int trains, PowersBase pb, int duration) {
		AbstractPowerAction pa = ab.getPowerAction();
		if (pa == null) {
			Logger.error(
					"runPowerAction(): PowerAction not found of IDString: "
							+ ab.getEffectID());
			return;
		}
		pa.startAction(source, awo, targetLoc, trains, ab, pb, duration);
	}

	public static HashSet<AbstractWorldObject> getAllTargets(
			AbstractWorldObject target, Vector3fImmutable tl,
			PlayerCharacter pc, PowersBase pb) {
		HashSet<AbstractWorldObject> allTargets;
		if (pb.isAOE()) {
			Vector3fImmutable targetLoc = null;
			if (pb.usePointBlank()) {
				targetLoc = pc.getLoc();
			} else {
				if (target != null) {
					targetLoc = target.getLoc();
				} else {
					targetLoc = tl;
					try{
						targetLoc = targetLoc.setY(HeightMap.getWorldHeight(targetLoc)); //on ground
					}catch (Exception e){
						Logger.error(e);
						targetLoc = tl;
					}
				
				}
			}

			if (targetLoc.x == 0f || targetLoc.z == 0f)
				return new HashSet<>(); // invalid loc,
			// return
			// nothing

			//first find targets in range quickly with QTree
			if (pb.targetPlayer() && pb.targetMob())
				// Player and mobs
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), MBServerStatics.MASK_MOBILE);
			else if (pb.targetPlayer())
				// Player only
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), MBServerStatics.MASK_PLAYER);
			else if (pb.targetMob())
				// Mob only
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), MBServerStatics.MASK_MOB
						| MBServerStatics.MASK_PET);
			else if (pb.targetPet())
				//Pet only
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), MBServerStatics.MASK_PET);
			else if (pb.targetNecroPet())
				allTargets = WorldGrid.getObjectsInRangePartialNecroPets(
						targetLoc, pb.getRadius());
			else
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), 0);

			// cleanup self, group and nation targets if needed
			Iterator<AbstractWorldObject> awolist = allTargets.iterator();
			while (awolist.hasNext()) {
				AbstractWorldObject awo = awolist.next();
				if (awo == null) {
					awolist.remove(); // won't hit a null
					continue;
				}

				//see if targets are within 3D range of each other
				Vector3fImmutable tloc = awo.getLoc();

				if (tloc.distanceSquared(targetLoc) > sqr(pb.getRadius())) {
					awolist.remove(); // too far away
					continue;
				}

				if (pb.isCasterFriendly() && pc.equals(awo)) {
					awolist.remove(); // won't hit self
					continue;
				}

				if (!awo.isAlive()) {
					awolist.remove(); // too far away
					continue;
				}

				if (awo.getObjectType().equals(GameObjectType.PlayerCharacter)) {

					PlayerCharacter pcc = (PlayerCharacter) awo;

					if (pb.isGroupFriendly() && GroupManager.getGroup(pc) != null && GroupManager.getGroup(pcc) != null)
						if (GroupManager.getGroup(pc).equals(GroupManager.getGroup(pcc))) {
							awolist.remove(); // Won't hit group members
							continue;
						}
					if (pb.isNationFriendly() && pc.getGuild() != null &&
							pc.getGuild().getNation() != null && pcc.getGuild() != null &&
							pc.getGuild().getNation() != null)
						if (pc.getGuild().getNation().equals(pcc.getGuild().getNation())) {
							awolist.remove(); // Won't hit nation members
							continue;
						}

					// Remove players for non-friendly spells in safe zone
					if (pb.isHarmful() && (pcc.inSafeZone() || pc.inSafeZone())) {
						awolist.remove();
						continue;
					}
				}
			}
			// Trim list down to max size closest targets, limited by max
			// Player/Mob amounts
			allTargets = RangeBasedAwo.getSortedList(allTargets, targetLoc, pb
					.getMaxNumPlayerTargets(), pb.getMaxNumMobTargets());
		} else if (pb.targetGroup()) {

			if (GroupManager.getGroup(pc) != null) {
				allTargets = WorldGrid.getObjectsInRangePartial(pc
						.getLoc(), pb.getRange(), MBServerStatics.MASK_PLAYER);
				Iterator<AbstractWorldObject> awolist = allTargets.iterator();
				while (awolist.hasNext()) {

					AbstractWorldObject awo = awolist.next();

					if (!(awo.getObjectType().equals(GameObjectType.PlayerCharacter))) {
						awolist.remove(); // remove non players if there are any
						continue;
					}
					PlayerCharacter pcc = (PlayerCharacter) awo;

					if (GroupManager.getGroup(pcc) == null)
						awolist.remove(); // remove players not in a group
					else if (!GroupManager.getGroup(pcc).equals(GroupManager.getGroup(pc)))
						awolist.remove(); // remove if not same group

				}
			} else {
				allTargets = new HashSet<>();
				allTargets.add(pc); // no group, use only self
			}
		} else {
			allTargets = new HashSet<>();
			if (pb.targetSelf())
				allTargets.add(pc);
			else if (pb.targetFromLastTarget())
				allTargets.add(target);
			else if (pb.targetFromNearbyMobs())
				allTargets.add(target); // need better way to do this later
			else
				// targetByName
				allTargets.add(target); // need to get name later
			// can't target self if caster friendly
			if (pb.isCasterFriendly() && allTargets.contains(pc))
				allTargets.remove(0);
		}

		Iterator<AbstractWorldObject> awolist = allTargets.iterator();
		while (awolist.hasNext()) {
			AbstractWorldObject awo = awolist.next();

			//See if target is valid type
			if (!validMonsterType(awo, pb)) {
				awolist.remove();
				continue;
			}

			if (awo != null && awo.getObjectType().equals(GameObjectType.PlayerCharacter)) {

				// Remove players who are in safe mode
				PlayerCharacter pcc = (PlayerCharacter) awo;
				PlayerBonuses bonuses = pcc.getBonuses();

				if (bonuses != null && bonuses.getBool(ModType.ImmuneToPowers, SourceType.None)) {
					awolist.remove();
					continue;
				}

				//remove if power is harmful and caster or target is in safe zone
				if (pb.isHarmful() && (pcc.inSafeZone() || pc.inSafeZone())) {
					awolist.remove();
					continue;
				}
			}
		}

		// verify target has proper effects applied to receive power
		if (pb.getTargetEffectPrereqs().size() > 0) {
			Iterator<AbstractWorldObject> it = allTargets.iterator();
			while (it.hasNext()) {
				boolean passed = false;
				AbstractWorldObject awo = it.next();
				if (awo.getEffects() != null) {
					for (PowerPrereq pp : pb.getTargetEffectPrereqs()) {
						EffectsBase eb = PowersManager.getEffectByIDString(pp.getEffect());
						if (awo.containsEffect(eb.getToken())) {
							passed = true;
							break;
						}
					}
					if (!passed)
						it.remove();
				} else
					it.remove(); //awo is missing it's effects list
			}
		}
		return allTargets;
	}

	public static HashSet<AbstractWorldObject> getAllTargets(
			AbstractWorldObject target, Vector3fImmutable tl,
			AbstractCharacter caster, PowersBase pb) {
		HashSet<AbstractWorldObject> allTargets;
		if (pb.isAOE()) {
			Vector3fImmutable targetLoc = tl;
			if (pb.usePointBlank()) {
				targetLoc = caster.getLoc();
			} else {
				if (target != null) {
					targetLoc = target.getLoc();
				} else {
					targetLoc = tl;
					try{
						targetLoc = targetLoc.setY(HeightMap.getWorldHeight(targetLoc)); //on ground
					}catch (Exception e){
						Logger.error(e);
					}
					
				}
			}

			if (targetLoc.x == 0f || targetLoc.z == 0f)
				return new HashSet<>(); // invalid loc,
	
			//first find targets in range quickly with QTree
			if (pb.targetPlayer() && pb.targetMob())
				// Player and mobs
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), MBServerStatics.MASK_MOBILE);
			else if (pb.targetPlayer())
				// Player only
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), MBServerStatics.MASK_PLAYER);
			else if (pb.targetMob())
				// Mob only
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), MBServerStatics.MASK_MOB
						| MBServerStatics.MASK_PET);
			else if (pb.targetPet())
				//Pet only
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), MBServerStatics.MASK_PET);
			else if (pb.targetNecroPet())
				allTargets = WorldGrid.getObjectsInRangePartialNecroPets(
						targetLoc, pb.getRadius());
			else
				allTargets = WorldGrid.getObjectsInRangePartial(
						targetLoc, pb.getRadius(), 0);

			// cleanup self, group and nation targets if needed
			Iterator<AbstractWorldObject> awolist = allTargets.iterator();
			while (awolist.hasNext()) {
				AbstractWorldObject awo = awolist.next();
				if (awo == null) {
					awolist.remove(); // won't hit a null
					continue;
				}

				//see if targets are within 3D range of each other
				Vector3fImmutable tloc = awo.getLoc();

				if (tloc.distanceSquared(targetLoc) > sqr(pb.getRadius())) {
					awolist.remove(); // too far away
					continue;
				}

				if (pb.isCasterFriendly() && caster.equals(awo)) {
					awolist.remove(); // won't hit self
					continue;
				}

				if (awo.getObjectType() == GameObjectType.Mob) {
					awolist.remove(); // Won't hit other mobs.
					continue;
				}
			}
			// Trim list down to max size closest targets, limited by max
			// Player/Mob amounts
			allTargets = RangeBasedAwo.getSortedList(allTargets, targetLoc, pb
					.getMaxNumPlayerTargets(), pb.getMaxNumMobTargets());
		} else if (pb.targetGroup()) {
			allTargets = new HashSet<>();
			allTargets.add(caster); // no group, use only self
		} else {
			allTargets = new HashSet<>();
			if (pb.targetSelf())
				allTargets.add(caster);
			else if (pb.targetFromLastTarget())
				allTargets.add(target);
			else if (pb.targetFromNearbyMobs())
				allTargets.add(target); // need better way to do this later
			else
				// targetByName
				allTargets.add(target); // need to get name later
			// can't target self if caster friendly
			if (pb.isCasterFriendly() && allTargets.contains(caster))
				allTargets.remove(caster);
		}

		Iterator<AbstractWorldObject> awolist = allTargets.iterator();
		while (awolist.hasNext()) {
			AbstractWorldObject awo = awolist.next();

			//See if target is valid type
			if (!validMonsterType(awo, pb)) {
				awolist.remove();
				continue;
			}

			if (awo != null && awo.getObjectType().equals(GameObjectType.PlayerCharacter)) {
				// Remove players who are in safe mode
				PlayerCharacter pcc = (PlayerCharacter) awo;
				PlayerBonuses bonuses = pcc.getBonuses();
				if (bonuses != null && bonuses.getBool(ModType.ImmuneToPowers, SourceType.None)) {
					awolist.remove();
					continue;
				}
			}
		}

		// verify target has proper effects applied to receive power
		if (pb.getTargetEffectPrereqs().size() > 0) {
			Iterator<AbstractWorldObject> it = allTargets.iterator();
			while (it.hasNext()) {
				boolean passed = false;
				AbstractWorldObject awo = it.next();
				if (awo.getEffects() != null) {
					for (PowerPrereq pp : pb.getTargetEffectPrereqs()) {
						EffectsBase eb = PowersManager.getEffectByIDString(pp.getEffect());
						if (awo.containsEffect(eb.getToken())) {
							passed = true;
							break;
						}
					}
					if (!passed)
						it.remove();
				} else
					it.remove(); //awo is missing it's effects list
			}
		}
		return allTargets;
	}

	// removes an effect before time is finished
	public static void removeEffect(AbstractWorldObject awo, ActionsBase toRemove,
			boolean overwrite, boolean fromChant) {
		if (toRemove == null)
			return;

		String stackType = toRemove.getStackType();
		stackType = (stackType.equals("IgnoreStack")) ? Integer
				.toString(toRemove.getUUID()) : stackType;
				if (fromChant) {
					Effect eff = awo.getEffects().get(stackType);
					if (eff != null)
						eff.cancelJob(true);
				} else
					awo.cancelEffect(stackType, overwrite);
	}

	// removes an effect when timer finishes
	public static void finishEffectTime(AbstractWorldObject source,
			AbstractWorldObject awo, ActionsBase toRemove, int trains) {
		if (awo == null || toRemove == null)
			return;

		// remove effect from player
		String stackType = toRemove.getStackType();
		if (stackType.equals("IgnoreStack"))
			stackType = Integer.toString(toRemove.getUUID());
		awo.endEffect(stackType);
	}

	// removes an effect when timer is canceled
	public static void cancelEffectTime(AbstractWorldObject source,
			AbstractWorldObject awo, PowersBase pb, EffectsBase eb,
			ActionsBase toRemove, int trains, AbstractEffectJob efj) {
		if (awo == null || pb == null || eb == null || toRemove == null)
			return;
		eb.endEffect(source, awo, trains, pb, efj);
	}

	// called when cooldown ends letting player cast next spell
	public static void finishCooldownTime(PerformActionMsg msg, PlayerCharacter pc) {
		// clear spell so player can cast again
		// if (pc != null)
		// pc.clearLastPower();
	}

	// called when recycle time ends letting player cast spell again
	public static void finishRecycleTime(PerformActionMsg msg, PlayerCharacter pc,
			boolean canceled) {
		finishRecycleTime(msg.getPowerUsedID(), pc, canceled);
	}

	public static void finishRecycleTime(int token, PlayerCharacter pc,
			boolean canceled) {
		if (pc == null)
			return;

		ConcurrentHashMap<Integer, JobContainer> recycleTimers = pc
				.getRecycleTimers();
		// clear recycle time
		if (recycleTimers != null)
			if (recycleTimers.containsKey(token)) {
				if (canceled) {
					JobContainer jc = recycleTimers.get(token);
					if (jc != null)
						jc.cancelJob();
				}
				recycleTimers.remove(token);
			}

		// send recycle message to unlock power

		RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(token);
		Dispatch dispatch = Dispatch.borrow(pc, recyclePowerMsg);
		DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);

	}

	// Called when a fail condition is met by player
	// such as moving, taking damage, ect.

	public static void cancelUseLastPower(PlayerCharacter pc) {

		if (pc == null)
			return;

		// set player is not casting for regens
		if (pc.isCasting()){
			pc.update();
		}
		pc.setIsCasting(false);

		UsePowerJob lastPower = null;
		JobContainer jc = pc.getLastPower();

		if (jc != null)
			lastPower = ((UsePowerJob) jc.getJob());

		if (lastPower == null)
			return;

		// clear recycle timer
		int token = lastPower.getToken();

		if (pc.getRecycleTimers().contains(token))
			finishRecycleTime(token, pc, true);

		//			pc.getRecycleTimers().remove(token);
		// Cancel power
		js.cancelScheduledJob(lastPower);

		// clear last power
		pc.clearLastPower();

	}

	private static AbstractWorldObject getTarget(PerformActionMsg msg) {

		int type = msg.getTargetType();
		int UUID = msg.getTargetID();

		if (type == -1 || type == 0 || UUID == -1 || UUID == 0)
			return null;

		return (AbstractWorldObject) DbManager.getObject(GameObjectType.values()[type], UUID);
	}

	public static boolean testAttack(PlayerCharacter pc, AbstractWorldObject awo,
			PowersBase pb, PerformActionMsg msg) {
		// Get defense for target
		float atr = CharacterSkill.getATR(pc, pb.getSkillName());
		float defense;

		if (AbstractWorldObject.IsAbstractCharacter(awo)) {
			AbstractCharacter tar = (AbstractCharacter) awo;
			defense = tar.getDefenseRating();
		} else
			defense = 0f;
		// Get hit chance

		if (pc.getDebug(16)) {
			String smsg = "ATR: " + atr + ", Defense: " + defense;
			ChatManager.chatSystemInfo(pc, smsg);
		}

		int chance;

		if (atr > defense || defense == 0)
			chance = 94;
		else {
			float dif = atr / defense;
			if (dif <= 0.8f)
				chance = 4;
			else
				chance = ((int) (450 * (dif - 0.8f)) + 4);
		}

		// calculate hit/miss
		int roll = ThreadLocalRandom.current().nextInt(100);

		boolean disable = true;
		if (roll < chance) {
			// Hit, check if dodge kicked in
			if (awo instanceof AbstractCharacter) {
				AbstractCharacter tarAc = (AbstractCharacter) awo;
				// Handle Dodge passive
				if (testPassive(pc, tarAc, "Dodge")) {
					// Dodge fired, send dodge message
					PerformActionMsg dodgeMsg = new PerformActionMsg(msg);
					dodgeMsg.setTargetType(awo.getObjectType().ordinal());
					dodgeMsg.setTargetID(awo.getObjectUUID());
					sendPowerMsg(pc, 4, dodgeMsg);
					return true;
				}
			}
			return false;
		} else {
			// Miss. Send miss message
			PerformActionMsg missMsg = new PerformActionMsg(msg);

			missMsg.setTargetType(awo.getObjectType().ordinal());
			missMsg.setTargetID(awo.getObjectUUID());
			sendPowerMsg(pc, 3, missMsg);
			return true;
		}
	}

	public static boolean testAttack(Mob caster, AbstractWorldObject awo,
			PowersBase pb, PerformActionMsg msg) {
		// Get defense for target
		float atr = 2000;
		float defense;

		if (AbstractWorldObject.IsAbstractCharacter(awo)) {
			AbstractCharacter tar = (AbstractCharacter) awo;
			defense = tar.getDefenseRating();
		} else
			defense = 0f;
		// Get hit chance

		int chance;

		if (atr > defense || defense == 0)
			chance = 94;
		else {
			float dif = atr / defense;
			if (dif <= 0.8f)
				chance = 4;
			else
				chance = ((int) (450 * (dif - 0.8f)) + 4);
		}

		// calculate hit/miss
		int roll = ThreadLocalRandom.current().nextInt(100);

		if (roll < chance) {
			// Hit, check if dodge kicked in
			if (AbstractWorldObject.IsAbstractCharacter(awo)) {
				AbstractCharacter tarAc = (AbstractCharacter) awo;
				// Handle Dodge passive
				return testPassive(caster, tarAc, "Dodge");
			}
			return false;
		} else
			return true;
	}

	public static void sendPowerMsg(PlayerCharacter playerCharacter, int type, PerformActionMsg msg) {

		if (playerCharacter == null)
			return;

		msg.setUnknown05(type);

		switch (type) {
		case 3:
		case 4:
			msg.setUnknown04(2);
			DispatchMessage.dispatchMsgToInterestArea(playerCharacter, msg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
			break;
		default:
			msg.setUnknown04(1);
			Dispatch dispatch = Dispatch.borrow(playerCharacter, msg);
			DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
		}
	}

	public static void sendEffectMsg(PlayerCharacter pc, int type, ActionsBase ab, PowersBase pb) {

		if (pc == null)
			return;

		try {

			EffectsBase eb = PowersManager.effectsBaseByIDString.get(ab.getEffectID());

			if (eb == null)
				return;

			ApplyEffectMsg aem = new ApplyEffectMsg(pc, pc, 0, eb.getToken(), 9, pb.getToken(), pb.getName());
			aem.setUnknown03(type);
			DispatchMessage.dispatchMsgToInterestArea(pc, aem, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);


		} catch (Exception e) {
			Logger.error( e.getMessage());
		}

	}

	public static void sendEffectMsg(PlayerCharacter pc, int type, EffectsBase eb) {

		if (pc == null)
			return;
		try {

			if (eb == null)
				return;
			ApplyEffectMsg aem = new ApplyEffectMsg(pc, pc, 0, eb.getToken(), 0, eb.getToken(), "");
			aem.setUnknown03(type);
			aem.setUnknown05(1);

			DispatchMessage.dispatchMsgToInterestArea(pc, aem, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);


		} catch (Exception e) {
			Logger.error( e.getMessage());
		}

	}

	public static void sendMobPowerMsg(Mob mob, int type, PerformActionMsg msg) {

		msg.setUnknown05(type);
		switch (type) {
		case 3:
		case 4:
			DispatchMessage.sendToAllInRange(mob, msg);

		}
	}

	private static boolean testPassive(AbstractCharacter source,
			AbstractCharacter target, String type) {

		float chance = target.getPassiveChance(type, source.getLevel(), false);

		if (chance == 0f)
			return false;

		// max 75% chance of passive to fire
		if (chance > 75f)
			chance = 75f;

		int roll = ThreadLocalRandom.current().nextInt(100);
		// Passive fired
		// TODO send message
		// Passive did not fire
		return roll < chance;
	}

	private static boolean validateTarget(AbstractWorldObject target,
			PlayerCharacter pc, PowersBase pb) {

		//group target. uses pbaoe rules
		if (pb.targetGroup())
			return true;

		// target is player
		else if ((target.getObjectTypeMask() & MBServerStatics.MASK_PLAYER) != 0) {
			if (pb.targetPlayer())
				if (pb.isGroupOnly()) { //single target group only power
					PlayerCharacter trg = (PlayerCharacter) target;

					if (GroupManager.getGroup(trg) != null && GroupManager.getGroup(pc) != null)
						if (GroupManager.getGroup(trg).getObjectUUID() == GroupManager.getGroup(pc).getObjectUUID())
							return true; // both in same group, good to go
					return trg != null && pc.getObjectUUID() == trg.getObjectUUID();
				} else
					return true; // can target player, good to go.
			else if (target.getObjectUUID() == pc.getObjectUUID() && pb.targetSelf())
				return true; // can target self, good to go
			else if (pb.targetCorpse()) {
				//target is dead player
				PlayerCharacter trg = (PlayerCharacter) target;
				return !trg.isAlive();
			} else {
				PlayerCharacter trg = (PlayerCharacter) target;

				if (pb.targetGroup())
					if (GroupManager.getGroup(trg) != null && GroupManager.getGroup(pc) != null)
						if (GroupManager.getGroup(trg).getObjectUUID() == GroupManager.getGroup(pc)
						.getObjectUUID())
							return true; // both in same group, good to go
				if (pb.targetGuildLeader())
					if (pc.getGuild() != null)
						if (pc.getGuild().getGuildLeaderUUID() == trg.getObjectUUID())
							return true; // can hit guild leader, good to go
			}
			String outmsg = "Invalid Target";
			ChatManager.chatSystemInfo(pc, outmsg);
			return false; // can't target player, stop here
		} // target is mob
		else if ((target.getObjectTypeMask() & MBServerStatics.MASK_MOB) != 0)
			return pb.targetMob();

		// target is pet
		else if ((target.getObjectTypeMask() & MBServerStatics.MASK_PET) != 0)
			return pb.targetPet();

		// target is Building
		else if ((target.getObjectTypeMask() & MBServerStatics.MASK_BUILDING) != 0)
			return pb.targetBuilding();

		else if (target.getObjectType().equals(GameObjectType.Item)) {
			Item item = (Item) target;
			if (pb.targetItem())
				return true;
			// TODO add these checks later
			else if (pb.targetArmor() && item.getItemBase().getType().equals(ItemType.ARMOR))
				return true;
			else if (pb.targetJewelry() && item.getItemBase().getType().equals(ItemType.JEWELRY))
				return true;
			else return pb.targetWeapon() && item.getItemBase().getType().equals(ItemType.WEAPON);
		} // How did we get here? all valid targets have been covered
		else
			return false;
	}

	/*
	 * Cancel spell upon actions
	 */
	public static void cancelOnAttack(AbstractCharacter ac) {
		ac.cancelTimer("Stuck");
	}

	public static void cancelOnAttackSwing(AbstractCharacter ac) {
	}

	public static void cancelOnCast(AbstractCharacter ac) {

	}

	public static void cancelOnSpell(AbstractCharacter ac) {

		PowersBase power = getLastPower(ac);

		if (power != null && power.cancelOnCastSpell())
			cancelPower(ac, false);
		ac.cancelLastChant();
	}

	public static void cancelOnEquipChange(AbstractCharacter ac) {

	}

	public static void cancelOnLogout(AbstractCharacter ac) {

	}

	public static void cancelOnMove(AbstractCharacter ac) {

		PowersBase power = getLastPower(ac);

		if (power != null && !power.canCastWhileMoving())
			cancelPower(ac, false);

		//cancel items
		cancelItems(ac, true, false);
		ac.cancelTimer("Stuck");
	}
	
	

	public static void cancelOnNewCharm(AbstractCharacter ac) {

	}

	public static void cancelOnSit(AbstractCharacter ac) {
		cancelPower(ac, false); // Always cancel casts on sit
	}

	public static void cancelOnTakeDamage(AbstractCharacter ac) {

		PowersBase power = getLastPower(ac);

		if (power != null && power.cancelOnTakeDamage())
			cancelPower(ac, true);
		cancelItems(ac, false, true);
		ac.cancelTimer("Stuck");
	}

	public static void cancelOnTerritoryClaim(AbstractCharacter ac) {

	}

	public static void cancelOnUnEquip(AbstractCharacter ac) {

	}

	public static void cancelOnStun(AbstractCharacter ac) {

	}

	private static PowersBase getLastPower(AbstractCharacter ac) {
		if (ac == null)
			return null;

		JobContainer jc = ac.getLastPower();

		if (jc == null)
			return null;

		AbstractJob aj = jc.getJob();

		if (aj == null)
			return null;

		if (aj instanceof UsePowerJob) {
			UsePowerJob upj = (UsePowerJob) aj;
			return upj.getPowersBase();
		}
		return null;
	}

	private static PowersBase getLastItem(AbstractCharacter ac) {

		if (ac == null)
			return null;

		JobContainer jc = ac.getLastItem();

		if (jc == null)
			return null;

		AbstractJob aj = jc.getJob();

		if (aj == null)
			return null;

		if (aj instanceof UseItemJob) {
			UseItemJob uij = (UseItemJob) aj;
			return uij.getPowersBase();
		}
		return null;
	}

	//cancels last casted power
	private static void cancelPower(AbstractCharacter ac, boolean cancelCastAnimation) {

		if (ac == null)
			return;

		JobContainer jc = ac.getLastPower();

		if (jc == null)
			return;

		AbstractJob aj = jc.getJob();

		if (aj == null)
			return;

		if (aj instanceof AbstractScheduleJob)
			((AbstractScheduleJob) aj).cancelJob();

		ac.clearLastPower();

		//clear cast animation for everyone in view range
		if (aj instanceof UsePowerJob && cancelCastAnimation) {

			PerformActionMsg pam = ((UsePowerJob) aj).getMsg();

			if (pam != null) {
				pam.setNumTrains(9999);
				pam.setUnknown04(2);
				DispatchMessage.sendToAllInRange(ac, pam);
			}
		}
	}

	public static PerformActionMsg createPowerMsg(PowersBase pb, int trains, AbstractCharacter source, AbstractCharacter target) {
		return new PerformActionMsg(pb.getToken(), trains, source.getObjectType().ordinal(), source.getObjectUUID(), target.getObjectType().ordinal(), target.getObjectUUID(), target.getLoc().x, target.getLoc().y, target.getLoc().z, 0, 0);

	}

	//cancels any casts from using an item

	private static void cancelItems(AbstractCharacter ac, boolean cancelOnMove, boolean cancelOnTakeDamage) {
		JobContainer jc;
		AbstractJob aj;
		ConcurrentHashMap<String, JobContainer> timers;
		UseItemJob uij;
		PowersBase pb;
		AbstractWorldObject target;

		if (ac == null)
			return;

		timers = ac.getTimers();

		if (timers == null)
			return;

		for (String name : timers.keySet()) {

			jc = timers.get(name);

			if (jc == null)
				continue;

			aj = jc.getJob();

			if (aj != null && aj instanceof UseItemJob) {
				uij = (UseItemJob) aj;
				pb = uij.getPowersBase();

				if (pb == null)
					continue;

				if (!pb.canCastWhileMoving() && cancelOnMove) {
					uij.cancelJob();
					timers.remove(name);
					continue;
				}

				if ((pb.cancelOnTakeDamage() == false) &&
						(cancelOnTakeDamage == false))
					continue;

				uij.cancelJob();
				timers.remove(name);

				//clear cast animation for everyone in view range
				target = uij.getTarget();

				if (target != null) {
					PerformActionMsg pam = new PerformActionMsg(pb.getToken(), 9999, ac
							.getObjectType().ordinal(), ac.getObjectUUID(), target.getObjectType().ordinal(),
							target.getObjectUUID(), 0, 0, 0, 2, 0);
					DispatchMessage.sendToAllInRange(ac, pam);

				}
			}
		}
	}
	public static void LoadAllMobPowers(){

		int count = 0;

		for(AbstractGameObject mobBaseAgo :  DbManager.getList(GameObjectType.MobBase)){

			int mobBaseID = ((MobBase) mobBaseAgo).getLoadID();

			HashMap powersList = DbManager.MobBaseQueries.LOAD_STATIC_POWERS(mobBaseID);

			if (powersList.isEmpty())
				continue;;

			AllMobPowers.put(mobBaseID, powersList);
			count ++;
			}

		Logger.info("Powers loaded for " + count + " Mobbases/");
	}
}