/*
===========================================================================
Copyright (C) 2015-2019 Project Meteor Dev Team

This file is part of Project Meteor Server.

Project Meteor Server is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Project Meteor Server is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with Project Meteor Server. If not, see <https:www.gnu.org/licenses/>.
===========================================================================
*/


using Meteor.Common;
using Meteor.Map.actors.chara.player;
using Meteor.Map.actors.group;
using Meteor.Map.Actors.Chara;
using Meteor.Map.DataObjects;
using Meteor.Map.packets.send.actor;
using Meteor.Map.packets.send.actor.inventory;
using Meteor.Map.utils;
using Meteor.Map.actors.chara.ai;
using System;
using System.Collections.Generic;
using Meteor.Map.actors.chara;
using Meteor.Map.packets.send.actor.battle;
using Meteor.Map.actors.chara.ai.state;
using Meteor.Map.actors.chara.ai.utils;
using Meteor.Map.actors.chara.npc;

namespace Meteor.Map.Actors
{
    /// <summary> Which Character types am I friendly with </summary>
    enum CharacterTargetingAllegiance
    {
        /// <summary> Friendly to BattleNpcs </summary>
        BattleNpcs,
        /// <summary> Friendly to Players </summary>
        Player
    }

    enum DamageTakenType
    {
        None,
        Attack,
        Magic,
        Weaponskill,
        Ability
    }

    class Character : Actor
    {
        public const int CLASSID_PUG = 2;
        public const int CLASSID_GLA = 3;
        public const int CLASSID_MRD = 4;
        public const int CLASSID_ARC = 7;
        public const int CLASSID_LNC = 8;
        public const int CLASSID_THM = 22;
        public const int CLASSID_CNJ = 23;

        public const int CLASSID_CRP = 29;
        public const int CLASSID_BSM = 30;
        public const int CLASSID_ARM = 31;
        public const int CLASSID_GSM = 32;
        public const int CLASSID_LTW = 33;
        public const int CLASSID_WVR = 34;
        public const int CLASSID_ALC = 35;
        public const int CLASSID_CUL = 36;

        public const int CLASSID_MIN = 39;
        public const int CLASSID_BTN = 40;
        public const int CLASSID_FSH = 41;

        public const int SIZE = 0;
        public const int COLORINFO = 1;
        public const int FACEINFO = 2;
        public const int HIGHLIGHT_HAIR = 3;
        public const int VOICE = 4;
        public const int MAINHAND = 5;
        public const int OFFHAND = 6;
        public const int SPMAINHAND = 7;
        public const int SPOFFHAND = 8;
        public const int THROWING = 9;
        public const int PACK = 10;
        public const int POUCH = 11;
        public const int HEADGEAR = 12;
        public const int BODYGEAR = 13;
        public const int LEGSGEAR = 14;
        public const int HANDSGEAR = 15;
        public const int FEETGEAR = 16;
        public const int WAISTGEAR = 17;
        public const int NECKGEAR = 18;
        public const int L_EAR = 19;
        public const int R_EAR = 20;
        public const int R_WRIST = 21;
        public const int L_WRIST = 22;
        public const int R_RINGFINGER = 23;
        public const int L_RINGFINGER = 24;
        public const int R_INDEXFINGER = 25;
        public const int L_INDEXFINGER = 26;
        public const int UNKNOWN = 27;

        public bool isStatic = false;

        public bool isMovingToSpawn = false;
        public bool isAutoAttackEnabled = true;

        public uint modelId;
        public uint[] appearanceIds = new uint[28];

        public uint animationId = 0;

        public uint currentTarget = Actor.INVALID_ACTORID;
        public uint currentLockedTarget = Actor.INVALID_ACTORID;

        public uint currentActorIcon = 0;

        public Work work = new Work();
        public CharaWork charaWork = new CharaWork();

        public Group currentParty = null;
        public ContentGroup currentContentGroup = null;
        
        //public DateTime lastAiUpdate;

        public AIContainer aiContainer;
        public StatusEffectContainer statusEffects;

        public CharacterTargetingAllegiance allegiance;

        public Pet pet;

        private Dictionary<Modifier, double> modifiers = new Dictionary<Modifier, double>();

        protected ushort hpBase, hpMaxBase, mpBase, mpMaxBase, tpBase;
        protected BattleTemp baseStats = new BattleTemp();
        public ushort currentJob;
        public ushort newMainState;
        public float spawnX, spawnY, spawnZ;

        //I needed some values I could reuse for random stuff, delete later
        public int extraInt;
        public uint extraUint;
        public float extraFloat;

        protected Dictionary<string, UInt64> tempVars = new Dictionary<string, UInt64>();
        
        //Inventory        
        protected Dictionary<ushort, ItemPackage> itemPackages = new Dictionary<ushort, ItemPackage>();
        protected ReferencedItemPackage equipment;

        public Character(uint actorID)
            : base(actorID)
        {
            //Init timer array to "notimer"
            for (int i = 0; i < charaWork.statusShownTime.Length; i++)
                charaWork.statusShownTime[i] = 0;

            this.statusEffects = new StatusEffectContainer(this);

            // todo: move this somewhere more appropriate
            // todo: base this on equip and shit
            SetMod((uint)Modifier.AttackRange, 3);
            SetMod((uint)Modifier.Delay, (Program.Random.Next(30, 60) * 100));
            SetMod((uint)Modifier.MovementSpeed, (uint)moveSpeeds[2]);

            spawnX = positionX;
            spawnY = positionY;
            spawnZ = positionZ;
        }

        public SubPacket CreateAppearancePacket()
        {
            SetActorAppearancePacket setappearance = new SetActorAppearancePacket(modelId, appearanceIds);
            return setappearance.BuildPacket(Id);
        }

        public SubPacket CreateInitStatusPacket()
        {
            return (SetActorStatusAllPacket.BuildPacket(Id, charaWork.status));
        }

        public SubPacket CreateSetActorIconPacket()
        {
            return SetActorIconPacket.BuildPacket(Id, currentActorIcon);
        }

        public SubPacket CreateSubStatePacket()
        {
            return SetActorSubStatePacket.BuildPacket(Id, currentSubState);
        }

        public void SetQuestGraphic(Player player, int graphicNum)
        {
            player.QueuePacket(SetActorQuestGraphicPacket.BuildPacket(Id, graphicNum));
        }

        public void SetCurrentContentGroup(ContentGroup group)
        {
            if (group != null)
                charaWork.currentContentGroup = group.GetTypeId();
            else
                charaWork.currentContentGroup = 0;

            currentContentGroup = group;

            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("charaWork/currentContentGroup", this);
            propPacketUtil.AddProperty("charaWork.currentContentGroup");
            CurrentArea.BroadcastPacketsAroundActor(this, propPacketUtil.Done());
        }

        //This logic isn't correct, order of GetStatusEffects() is not necessarily the same as the actual effects in game. Also sending every time at once isn't needed
        public List<SubPacket> GetActorStatusPackets()
        {
            var propPacketUtil = new ActorPropertyPacketUtil("charaWork/status", this);
            var i = 0;
            foreach (var effect in statusEffects.GetStatusEffects())
            {
                if (!effect.GetHidden())
                {
                    propPacketUtil.AddProperty(String.Format("charaWork.statusShownTime[{0}]", i));
                    propPacketUtil.AddProperty(String.Format("charaWork.statusShownTime[{0}]", i));
                    i++;
                }
            }
            return propPacketUtil.Done();
        }
        
        public void PlayAnimation(uint animId, bool onlySelf = false)
        {
            if (onlySelf)
            {
                if (this is Player)
                    ((Player)this).QueuePacket(PlayAnimationOnActorPacket.BuildPacket(Id, animId));
            }
            else
                CurrentArea.BroadcastPacketAroundActor(this, PlayAnimationOnActorPacket.BuildPacket(Id, animId));
        }
        
        public void DoBattleAction(ushort commandId, uint animationId)
        {
            CurrentArea.BroadcastPacketAroundActor(this, CommandResultX00Packet.BuildPacket(Id, animationId, commandId));
        }

        public void DoBattleAction(ushort commandId, uint animationId, CommandResult result)
        {
            CurrentArea.BroadcastPacketAroundActor(this, CommandResultX01Packet.BuildPacket(Id, animationId, commandId, result));
        }

        public void DoBattleAction(ushort commandId, uint animationId, CommandResult[] results)
        {
            int currentIndex = 0;

            while (true)
            {
                if (results.Length - currentIndex >= 10)
                    CurrentArea.BroadcastPacketAroundActor(this, CommandResultX18Packet.BuildPacket(Id, animationId, commandId, results, ref currentIndex));
                else if (results.Length - currentIndex > 1)
                    CurrentArea.BroadcastPacketAroundActor(this, CommandResultX10Packet.BuildPacket(Id, animationId, commandId, results, ref currentIndex));
                else if (results.Length - currentIndex == 1)
                {
                    CurrentArea.BroadcastPacketAroundActor(this, CommandResultX01Packet.BuildPacket(Id, animationId, commandId, results[currentIndex]));
                    currentIndex++;
                }
                else
                    break;
            }
        }

        public void DoBattleAction(ushort commandId, uint animationId, List<CommandResult> results)
        {
            int currentIndex = 0;

            while (true)
            {
                if (results.Count - currentIndex >= 10)
                    CurrentArea.BroadcastPacketAroundActor(this, CommandResultX18Packet.BuildPacket(Id, animationId, commandId, results, ref currentIndex));
                else if (results.Count - currentIndex > 1)
                    CurrentArea.BroadcastPacketAroundActor(this, CommandResultX10Packet.BuildPacket(Id, animationId, commandId, results, ref currentIndex));
                else if (results.Count - currentIndex == 1)
                {
                    CurrentArea.BroadcastPacketAroundActor(this, CommandResultX01Packet.BuildPacket(Id, animationId, commandId, results[currentIndex]));
                    currentIndex++;
                }
                else
                    break;

                //Sending multiple packets at once causes some issues. Setting any combination of these to zero changes what breaks
                //animationId = 0; //If more than one packet is sent out, only send the animation once to avoid double playing.
                //commandId = 0;
                //sourceActorId = 0;
            }            
        }

        #region ai stuff
        public void PathTo(float x, float y, float z, float stepSize = 0.70f, int maxPath = 40, float polyRadius = 0.0f)
        {
            if (aiContainer != null && aiContainer.pathFind != null)
                aiContainer.pathFind.PreparePath(x, y, z, stepSize, maxPath, polyRadius);
        }

        public void FollowTarget(Actor target, float stepSize = 1.2f, int maxPath = 25, float radius = 0.0f)
        {
            if (target != null)
                PathTo(target.positionX, target.positionY, target.positionZ, stepSize, maxPath, radius);
        }

        public double GetMod(Modifier modifier)
        {
            return GetMod((uint)modifier);
        }

        public double GetMod(uint modifier)
        {
            double res;
            if (modifiers.TryGetValue((Modifier)modifier, out res))
                return res;
            return 0;
        }

        public void SetMod(uint modifier, double val)
        {
            if (modifiers.ContainsKey((Modifier)modifier))
                modifiers[(Modifier)modifier] = val;
            else
                modifiers.Add((Modifier)modifier, val);

            if (modifier >= 3 && modifier <= 35)
                updateFlags |= ActorUpdateFlags.Stats;
        }

        public void AddMod(Modifier modifier, double val)
        {
            AddMod((uint)modifier, val);
        }

        public void AddMod(uint modifier, double val)
        {

            double newVal = GetMod(modifier) + val;
            SetMod(modifier, newVal);
        }

        public void SubtractMod(Modifier modifier, double val)
        {
            AddMod((uint)modifier, val);
        }

        public void SubtractMod(uint modifier, double val)
        {
            double newVal = GetMod(modifier) - val;
            SetMod(modifier, newVal);
        }

        public void MultiplyMod(Modifier modifier, double val)
        {
            MultiplyMod((uint)modifier, val);
        }

        public void MultiplyMod(uint modifier, double val)
        {
            double newVal = GetMod(modifier) * val;
            SetMod(modifier, newVal);
        }

        public void DivideMod(Modifier modifier, double val)
        {
            DivideMod((uint)modifier, val);
        }

        public void DivideMod(uint modifier, double val)
        {
            double newVal = GetMod(modifier) / val;
            SetMod(modifier, newVal);
        }


        public virtual void OnPath(Vector3 point)
        {
            //lua.LuaEngine.CallLuaBattleFunction(this, "onPath", this, point);

            updateFlags |= ActorUpdateFlags.Position;
            this.isAtSpawn = false;
        }

        public override void Update(DateTime tick)
        {

        }

        public override void PostUpdate(DateTime tick, List<SubPacket> packets = null)
        {
            if (updateFlags != ActorUpdateFlags.None)
            {
                packets = packets ?? new List<SubPacket>();

                if ((updateFlags & ActorUpdateFlags.Appearance) != 0)
                {
                    packets.Add(new SetActorAppearancePacket(modelId, appearanceIds).BuildPacket(Id));
                }

                if ((updateFlags & ActorUpdateFlags.State) != 0)
                {
                    packets.Add(SetActorStatePacket.BuildPacket(Id, currentMainState, 0x0));
                    packets.Add(CommandResultX00Packet.BuildPacket(Id, 0x72000062, 0));
                    packets.Add(CommandResultX01Packet.BuildPacket(Id, 0x7C000062, 21001, new CommandResult(Id, 0, 1)));

                    updateFlags &= ~ActorUpdateFlags.State;
                    //DoBattleAction(21001, 0x7C000062, new BattleAction(this.actorId, 0, 1, 0, 0, 1)); //Attack Mode
                }

                if ((updateFlags & ActorUpdateFlags.SubState) != 0)
                {
                    packets.Add(SetActorSubStatePacket.BuildPacket(Id, currentSubState));
                    //packets.Add(CommandResultX00Packet.BuildPacket(actorId, 0x72000062, 0));
                    //packets.Add(CommandResultX01Packet.BuildPacket(actorId, 0x7C000062, 21001, new CommandResult(actorId, 0, 1)));

                    updateFlags &= ~ActorUpdateFlags.SubState;
                    //DoBattleAction(21001, 0x7C000062, new BattleAction(this.actorId, 0, 1, 0, 0, 1)); //Attack Mode
                }

                if ((updateFlags & ActorUpdateFlags.Status) != 0)
                {

                    List<SubPacket> statusPackets = statusEffects.GetStatusPackets();
                    packets.AddRange(statusPackets);
                    statusPackets.Clear();
                    updateFlags &= ~ActorUpdateFlags.Status;
                }

                if ((updateFlags & ActorUpdateFlags.StatusTime) != 0)
                {
                    packets.AddRange(statusEffects.GetStatusTimerPackets());
                    statusEffects.ResetPropPacketUtil();
                    updateFlags &= ~ActorUpdateFlags.StatusTime;
                }

                if ((updateFlags & ActorUpdateFlags.HpTpMp) != 0)
                {
                    var propPacketUtil = new ActorPropertyPacketUtil("charaWork/stateAtQuicklyForAll", this);
                    propPacketUtil.AddProperty("charaWork.parameterSave.hp[0]");
                    propPacketUtil.AddProperty("charaWork.parameterSave.hpMax[0]");
                    propPacketUtil.AddProperty("charaWork.parameterSave.mp");
                    propPacketUtil.AddProperty("charaWork.parameterSave.mpMax");
                    propPacketUtil.AddProperty("charaWork.parameterTemp.tp");
                    packets.AddRange(propPacketUtil.Done());
                }

                base.PostUpdate(tick, packets);
            }
        }

        public virtual bool IsValidTarget(Character target, ValidTarget validTarget)
        {
            return !target.isStatic;
        }

        public virtual bool CanAttack()
        {
            return true;
        }

        public virtual bool CanUse(Character target, BattleCommand skill, CommandResult error = null)
        {
            return false;
        }


        public virtual uint GetAttackDelayMs()
        {
            return (uint)GetMod((uint)Modifier.Delay);
        }

        public virtual uint GetAttackRange()
        {
            return (uint)(GetMod((uint)Modifier.AttackRange) == 0 ? 3 : GetMod((uint)Modifier.AttackRange));
        }

        public virtual bool Engage(uint targid = 0, ushort newMainState = 0xFFFF)
        {
            // todo: attack the things
            /*if (newMainState != 0xFFFF)
            {
                currentMainState = newMainState;// this.newMainState = newMainState;
                updateFlags |= ActorUpdateFlags.State;
            }
            else*/ if (aiContainer.CanChangeState())
            {
                if (targid == 0)
                {
                    if (currentTarget != Actor.INVALID_ACTORID)
                        targid = currentTarget;
                    else if (currentLockedTarget != Actor.INVALID_ACTORID)
                        targid = currentLockedTarget;
                }
                //if (targid != 0)
                {
                    aiContainer.Engage(CurrentArea.FindActorInArea<Character>(targid));
                }
            }

            return false;
        }

        public virtual bool Engage(Character target)
        {
            aiContainer.Engage(target);
            return false;
        }

        public virtual bool Disengage(ushort newMainState = 0xFFFF)
        {
            /*if (newMainState != 0xFFFF)
            {
                currentMainState = newMainState;// this.newMainState = newMainState;
                updateFlags |= ActorUpdateFlags.State;
            }
            else*/ if (IsEngaged())
            {
                aiContainer.Disengage();
                return true;
            }
            return false;
        }
        
        public virtual void Cast(uint spellId, uint targetId = 0)
        {
            if (aiContainer.CanChangeState())
                aiContainer.Cast(CurrentArea.FindActorInArea<Character>(targetId == 0 ? currentTarget : targetId), spellId);
        }

        public virtual void Ability(uint abilityId, uint targetId = 0)
        {
            if (aiContainer.CanChangeState())
                aiContainer.Ability(CurrentArea.FindActorInArea<Character>(targetId == 0 ? currentTarget : targetId), abilityId);
        }

        public virtual void WeaponSkill(uint skillId, uint targetId = 0)
        {
            if (aiContainer.CanChangeState())
                aiContainer.WeaponSkill(CurrentArea.FindActorInArea<Character>(targetId == 0 ? currentTarget : targetId), skillId);
        }

        public virtual void Spawn(DateTime tick)
        {
            aiContainer.Reset();
            // todo: reset hp/mp/tp etc here
            ChangeState(SetActorStatePacket.MAIN_STATE_PASSIVE);
            SetHP((uint) GetMaxHP());
            SetMP((uint) GetMaxMP());
            RecalculateStats();
        }

        //AdditionalActions is the list of actions that EXP/Chain messages are added to
        public virtual void Die(DateTime tick, CommandResultContainer actionContainer = null)
        {
            // todo: actual despawn timer
            aiContainer.InternalDie(tick, 10);
            ChangeSpeed(0.0f, 0.0f, 0.0f, 0.0f);
        }

        public virtual void Despawn(DateTime tick)
        {
            
        }

        public bool IsDead()
        {
            return !IsAlive();
        }

        public bool IsAlive()
        {
            return !aiContainer.IsDead();// && GetHP() > 0;
        }

        public short GetHP()
        {
            // todo: 
            return charaWork.parameterSave.hp[0];
        }

        public short GetMaxHP()
        {
            return charaWork.parameterSave.hpMax[0];
        }

        public short GetMP()
        {
            return charaWork.parameterSave.mp;
        }

        public ushort GetTP()
        {
            return tpBase;
        }

        public short GetMaxMP()
        {
            return charaWork.parameterSave.mpMax;
        }

        public byte GetMPP()
        {
            return (byte)((charaWork.parameterSave.mp / charaWork.parameterSave.mpMax) * 100);
        }

        public byte GetTPP()
        {
            return (byte)((tpBase / 3000) * 100);
        }

        public byte GetHPP()
        {
            return (byte)(charaWork.parameterSave.hp[0] == 0 ? 0 : (charaWork.parameterSave.hp[0] / (float) charaWork.parameterSave.hpMax[0]) * 100);
        }

        public void SetHP(uint hp)
        {
            charaWork.parameterSave.hp[0] = (short)hp;
            if (hp > charaWork.parameterSave.hpMax[0])
                SetMaxHP(hp);

            updateFlags |= ActorUpdateFlags.HpTpMp;
        }

        public void SetMaxHP(uint hp)
        {
            charaWork.parameterSave.hpMax[0] = (short)hp;
            updateFlags |= ActorUpdateFlags.HpTpMp;
        }

        public void SetMP(uint mp)
        {
            charaWork.parameterSave.mp = (short)mp;
            if (mp > charaWork.parameterSave.mpMax)
                SetMaxMP(mp);

            updateFlags |= ActorUpdateFlags.HpTpMp;
        }

        public void SetMaxMP(uint mp)
        {
            charaWork.parameterSave.mp = (short)mp;
            updateFlags |= ActorUpdateFlags.HpTpMp;
        }

        // todo: the following functions are virtuals since we want to check hidden item bonuses etc on player for certain conditions
        public virtual void AddHP(int hp, CommandResultContainer resultContainer = null)
        {
            // dont wanna die ded, don't want to send update if hp isn't actually changed
            if (IsAlive() && hp != 0)
            {
                // todo: +/- hp and die
                // todo: battlenpcs probably have way more hp?
                var addHp = charaWork.parameterSave.hp[0] + hp;
                addHp = addHp.Clamp((short)GetMod((uint)Modifier.MinimumHpLock), charaWork.parameterSave.hpMax[0]);
                charaWork.parameterSave.hp[0] = (short)addHp;

                updateFlags |= ActorUpdateFlags.HpTpMp;

                if (charaWork.parameterSave.hp[0] < 1)
                    Die(Program.Tick, resultContainer);
            }
        }

        public short GetClass()
        {
            return charaWork.parameterSave.state_mainSkill[0];
        }

        public short GetLevel()
        {
            return charaWork.parameterSave.state_mainSkillLevel;
        }

        public void AddMP(int mp)
        {
            if (IsAlive() && mp != 0)
            {
                charaWork.parameterSave.mp = (short)(charaWork.parameterSave.mp + mp).Clamp(ushort.MinValue, charaWork.parameterSave.mpMax);

                // todo: check hidden effects and shit

                updateFlags |= ActorUpdateFlags.HpTpMp;
            }
        }

        public void AddTP(int tp)
        {
            if (IsAlive() && tp != 0)
            {
                var addTp = charaWork.parameterTemp.tp + tp;
                
                addTp = addTp.Clamp((int) GetMod(Modifier.MinimumTpLock), 3000);
                charaWork.parameterTemp.tp = (short) addTp;
                tpBase = (ushort)charaWork.parameterTemp.tp;
                updateFlags |= ActorUpdateFlags.HpTpMp;

                if (tpBase >= 1000)
                    lua.LuaEngine.GetInstance().OnSignal("tpOver1000");
            }
        }

        public void DelHP(int hp, CommandResultContainer resultContainer = null)
        {
            AddHP((short)-hp, resultContainer);
        }

        public void DelMP(int mp)
        {
            AddMP(-mp);
        }

        public void DelTP(int tp)
        {
            AddTP(-tp);
        }

        virtual public void CalculateBaseStats()
        {
            // todo: apply mods and shit here, get race/level/job and shit
            uint hpMod = (uint) GetMod((uint)Modifier.Hp);
            if (hpMod != 0)
            {
                SetMaxHP(hpMod);
                uint hpp = (uint) GetMod((uint) Modifier.HpPercent);
                uint hp = hpMod;
                if(hpp != 0)
                {
                    hp = (uint) Math.Ceiling(((float)hpp / 100.0f) * hpMod);
                }
                SetHP(hp);
            }

            uint mpMod = (uint)GetMod((uint)Modifier.Mp);
            if (mpMod != 0)
            {
                SetMaxMP(mpMod);
                uint mpp = (uint)GetMod((uint)Modifier.MpPercent);
                uint mp = mpMod;
                if (mpp != 0)
                {
                    mp = (uint)Math.Ceiling(((float)mpp / 100.0f) * mpMod);
                }
                SetMP(mp);
            }
            // todo: recalculate stats and crap
            updateFlags |= ActorUpdateFlags.HpTpMp;


            SetMod((uint)Modifier.HitCount, 1);
        }

        public void RecalculateStats()
        {
            //CalculateBaseStats();
        }

        public void SetStat(uint statId, int val)
        {
            charaWork.battleTemp.generalParameter[statId] = (short)val;
        }

        public short GetStat(uint statId)
        {
            return charaWork.battleTemp.generalParameter[statId];
        }

        public virtual float GetSpeed()
        {
            // todo: for battlenpc/player calculate speed
            return (float) GetMod((uint)Modifier.MovementSpeed);
        }

        public virtual void OnAttack(State state, CommandResult action, ref CommandResult error)
        {
            var target = state.GetTarget();
            // todo: change animation based on equipped weapon
            // todo: get hitrate and shit, handle protect effect and whatever
            if (BattleUtils.TryAttack(this, target, action, ref error))
            {
                //var packet = BattleActionX01Packet.BuildPacket(owner.actorId, owner.actorId, target.actorId, (uint)0x19001000, (uint)0x8000604, (ushort)0x765D, (ushort)BattleActionX01PacketCommand.Attack, (ushort)damage, (byte)0x1);
            }

            // todo: call onAttack/onDamageTaken
            //BattleUtils.DamageTarget(this, target, DamageTakenType.Attack, action);
            AddTP(200);
            target.AddTP(100);
        }

        public virtual void OnCast(State state, CommandResult[] actions, BattleCommand spell, ref CommandResult[] errors)
        {
            // damage is handled in script
            var spellCost = spell.CalculateMpCost(this);
            this.DelMP(spellCost); // mpCost can be set in script e.g. if caster has something for free spells

            foreach (CommandResult action in actions)
            {
                if (CurrentArea.FindActorInArea<Character>(action.targetId) is Character)
                {
                    //BattleUtils.HandleHitType(this, chara, action);
                    //BattleUtils.DoAction(this, chara, action, DamageTakenType.Magic);
                }
            }
            lua.LuaEngine.GetInstance().OnSignal("spellUsed");
        }

        public virtual void OnWeaponSkill(State state, CommandResult[] actions, BattleCommand skill, ref CommandResult[] errors)
        {
            // damage is handled in script

            foreach (CommandResult action in actions)
            {
                //Should we just store the character insteado f having to find it again?
                if (CurrentArea.FindActorInArea<Character>(action.targetId) is Character)
                {
                    //BattleUtils.DoAction(this, chara, action, DamageTakenType.Weaponskill);
                }
            }

            this.DelTP(skill.tpCost);
        }

        public virtual void OnAbility(State state, CommandResult[] actions, BattleCommand ability, ref CommandResult[] errors)
        {
            foreach (var action in actions)
            {
                if (CurrentArea.FindActorInArea<Character>(action.targetId) is Character)
                {
                    //BattleUtils.DoAction(this, chara, action, DamageTakenType.Ability);
                }
            }
        }

        public virtual void OnSpawn()
        {

        }

        public virtual void OnDeath()
        {

        }

        public virtual void OnDespawn()
        {

        }

        public virtual void OnDamageDealt(Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
        {
            switch (action.hitType)
            {
                case (HitType.Miss):
                    OnMiss(defender, skill, action, actionContainer);
                    break;
                case (HitType.Crit):
                    OnCrit(defender, skill, action, actionContainer);
                    OnHit(defender, skill, action, actionContainer);
                    break;
                default:
                    OnHit(defender, skill, action, actionContainer);
                    break;
            }

            //TP is only gained from autoattacks and abilities
            if ((action.commandType == CommandType.AutoAttack || action.commandType == CommandType.Ability) && action.hitType != HitType.Miss)
            {
                //TP gained on an attack is usually 100 * delay.
                //Store TP seems to add .1% per point.
                double weaponDelay = GetMod(Modifier.Delay) / 1000.0;
                var storeTPPercent = 1 + (GetMod(Modifier.StoreTp) * 0.001);
                AddTP((int)(weaponDelay * 100 * storeTPPercent));
            }
        }

        public virtual void OnDamageTaken(Character attacker, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
        {
            switch (action.hitType)
            {
                case (HitType.Miss):
                    OnEvade(attacker, skill, action, actionContainer);
                    break;
                case (HitType.Parry):
                    OnParry(attacker, skill, action, actionContainer);
                    break;
                case (HitType.Block):
                    OnBlock(attacker, skill, action, actionContainer);
                    break;
            }

            statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnDamageTaken, "onDamageTaken", attacker, this, skill, action, actionContainer);

            //TP gain formula seems to be something like 5 * e ^ ( -0.667 * [defender's level] ) * damage taken, rounded up
            //This should be completely accurate at level 50, but isn't totally accurate at lower levels.
            //Don't know if store tp impacts this
            double tpModifier = 5 * Math.Pow(Math.E, (-0.0667 * GetLevel()));
            AddTP((int)Math.Ceiling(tpModifier * action.amount));
        }

        public UInt64 GetTempVar(string name)
        {
            UInt64 retVal = 0;
            if (tempVars.TryGetValue(name, out retVal))
                return retVal;
            return 0;
        }

        // cause lua is a dick
        public void SetTempVar(string name, uint val)
        {
            if (tempVars.ContainsKey(name))
                tempVars[name] = val;
        }

        public void SetTempVar(string name, UInt64 val)
        {
            if (tempVars.ContainsKey(name))
                tempVars[name] = val;
        }

        public void ResetTempVars()
        {
            tempVars.Clear();
        }

        #region lua helpers
        public bool IsEngaged()
        {
            return aiContainer.IsEngaged();
        }

        public bool IsPlayer()
        {
            return this is Player;
        }

        public bool IsMonster()
        {
            return this is BattleNpc;
        }

        public bool IsPet()
        {
            return this is Pet;
        }

        public bool IsAlly()
        {
            return this is Ally;
        }

        public bool IsDiscipleOfWar()
        {
            return GetClass() < CLASSID_THM;
        }

        public bool IsDiscipleOfMagic()
        {
            return GetClass() >= CLASSID_THM && currentJob < CLASSID_CRP;
        }

        public bool IsDiscipleOfHand()
        {
            return GetClass() >= CLASSID_CRP && currentJob < CLASSID_MIN;
        }

        public bool IsDiscipleOfLand()
        {
            return GetClass() >= CLASSID_MIN;
        }
        #endregion lua helpers
        #endregion ai stuff

        //Reset procs. Only send packet if any procs were actually reset. 
        //This assumes you can't use weaponskills between getting a proc and using the procced ability
        public void ResetProcs()
        {
            var propPacketUtil = new ActorPropertyPacketUtil("charaWork/timingCommand", this);
            bool shouldSend = false;
            for (int i = 0; i < 4; i++)
            {
                if (charaWork.battleTemp.timingCommandFlag[i])
                {
                    shouldSend = true;
                    charaWork.battleTemp.timingCommandFlag[i] = false;
                    propPacketUtil.AddProperty(String.Format("charaWork.battleTemp.timingCommandFlag[{0}]", i));
                }
            }

            if (shouldSend && this is Player)
                ((Player)this).QueuePackets(propPacketUtil.Done());
        }

        //Set given proc to true and send packet if this is a player
        // todo: hidden status effects for timing when the procs fall off
        public void SetProc(int procId, bool val = true)
        {
            charaWork.battleTemp.timingCommandFlag[procId] = val;
            uint effectId = (uint)StatusEffectId.EvadeProc + (uint)procId;

            //If a proc just occurred, add a hidden effect effect
            if (val)
            {
                StatusEffect procEffect = Server.GetWorldManager().GetStatusEffect(effectId);
                procEffect.SetDuration(5);
                statusEffects.AddStatusEffect(procEffect, this);
            }
            //Otherwise we're reseting a proc, remove the status
            else
            {
                statusEffects.RemoveStatusEffect(statusEffects.GetStatusEffectById((uint)effectId));
            }

            if (this is Player)
            {
                var propPacketUtil = new ActorPropertyPacketUtil("charaWork/timingCommand", this);
                propPacketUtil.AddProperty(String.Format("charaWork.battleTemp.timingCommandFlag[{0}]", procId));
                ((Player)this).QueuePackets(propPacketUtil.Done());
            }
        }

        public HitDirection GetHitDirection(Actor target)
        {
            //Get between taget's position and our position
            double angle = Vector3.GetAngle(target.GetPosAsVector3(), GetPosAsVector3());
            //Add to the target's rotation, mod by 2pi. This is the angle relative to where the target is looking
            //Actor's rotation is 0 degrees on their left side, rotate it by 45 degrees so that quadrants line up with sides
            angle = (angle + target.rotation - (.25 * Math.PI)) % (2 * Math.PI);
            //Make positive
            if (angle < 0)
                angle = angle + (2 * Math.PI);

            //Get the side we're on. 0 is front, 1 is right, 2 is rear, 3 is left
            var side = (int) (angle / (.5 * Math.PI)) % 4;

            return (HitDirection) (1 << side);
        }

        //Called when this character evades attacker's action
        public void OnEvade(Character attacker, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
        {
            SetProc((ushort)HitType.Evade);
            statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnEvade, "onEvade", attacker, this, skill, action, actionContainer);
        }

        //Called when this character blocks attacker's action
        public void OnBlock(Character attacker, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
        {
            SetProc((ushort)HitType.Block);
            statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnBlock, "onBlock", attacker, this, skill, action, actionContainer);
        }

        //Called when this character parries attacker's action
        public void OnParry(Character attacker, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
        {
            SetProc((ushort)HitType.Parry);
            statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnParry, "onParry", attacker, this, skill, action, actionContainer);
        }

        //Called when this character misses
        public void OnMiss(Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
        {
            SetProc((ushort)HitType.Miss);
            statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnMiss, "onMiss", this, defender, skill, action, actionContainer);
        }

        public void OnHit(Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
        {
            statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnHit, "onHit", this, defender, skill, action, actionContainer);
        }

        public void OnCrit(Character defender, BattleCommand skill, CommandResult action, CommandResultContainer actionContainer = null)
        {
            statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnCrit, "onCrit", this, defender, skill, action, actionContainer);
        }

        //The order of messages that appears after using a command is:

        //1. Cast start messages. (ie "You begin casting... ")
        //2. Messages from buffs that activate before the command actually starts, like Power Surge or Presence of Mind. (This may be wrong and these could be the same as 4.)
        //3. If the command is a multi-hit command, this is where the "You use [command] on [target]" message goes

        //Then, for each hit:
        //4. Buffs that activate before a command hits, like Blindside
        //5. The hit itself. For single hit commands this message is "Your [command] hits [target] for x damage" for multi hits it's "[Target] takes x points of damage"
        //6. Stoneskin falling off
        //6. Buffs that activate after a command hits, like Aegis Boon and Divine Veil

        //After all hits
        //7. If it's a multi-hit command there's a "{numhits]fold attack..." message or if all hits miss an "All attacks missed" message
        //8. Buffs that fall off after the skill ends, like Excruciate

        //For every target defeated:
        //8. Defeat message
        //9. EXP message
        //10. EXP chain message


        //folder is probably temporary until move to cached scripts is complete
        public void DoBattleCommand(BattleCommand command, string folder)
        {
            //List<BattleAction> actions = new List<BattleAction>();
            CommandResultContainer actions = new CommandResultContainer();

            var targets = command.targetFind.GetTargets();
            bool hitTarget = false;

            if (targets.Count > 0)
            {
                statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnCommandStart, "onCommandStart", this, command, actions);

                foreach (var chara in targets)
                {
                    ushort hitCount = 0;
                    ushort totalDamage = 0;
                    for (int hitNum = 1; hitNum <= command.numHits; hitNum++)
                    {
                        var action = new CommandResult(chara.Id, command, (byte)GetHitDirection(chara), (byte) hitNum);
                        
                        //uncached script
                        lua.LuaEngine.CallLuaBattleCommandFunction(this, command, folder, "onSkillFinish", this, chara, command, action, actions);
                        //cached script
                        //skill.CallLuaFunction(owner, "onSkillFinish", this, chara, command, action, actions);
                        if (action.ActionLanded())
                        {
                            hitTarget = true;
                            hitCount++;
                            totalDamage += action.amount;
                        }
                    }

                    if (command.numHits > 1)
                    {
                        //30442: [hitCount]fold Attack! [chara] takes a total of totalDamage points of damage.
                        //30450: All attacks miss!
                        ushort textId = (ushort) (hitTarget ? 30442 : 30450);
                        actions.AddAction(new CommandResult(chara.Id, textId, 0, totalDamage, (byte)hitCount));
                    }
                }

                statusEffects.CallLuaFunctionByFlag((uint)StatusEffectFlags.ActivateOnCommandFinish, "onCommandFinish", this, command, actions);
            }
            else
            {
                actions.AddAction(new CommandResult(Id, 30202, 0));
            }

            DelMP(command.CalculateMpCost(this));
            DelTP(command.CalculateTpCost(this));

            //Now that we know if we hit the target we can check if the combo continues
            if (this is Player)
            {
                if (command.isCombo && hitTarget)
                    ((Player)this).SetCombos(command.comboNextCommandId);
                //Only reset combo if the command is a spell or weaponskill, since abilities can be used between combo skills
                else if (command.commandType == CommandType.Spell || command.commandType == CommandType.WeaponSkill)
                    ((Player)this).SetCombos();
            }


            actions.CombineLists();
            DoBattleAction(command.id, command.battleAnimation, actions.GetList());
        }

        public List<Character> GetPartyMembersInRange(uint range)
        {
            TargetFind targetFind = new TargetFind(this);
            targetFind.SetAOEType(ValidTarget.Party, TargetFindAOEType.Circle, TargetFindAOETarget.Self, range, 0, 10, 0, 0);
            targetFind.FindWithinArea(this, ValidTarget.Party, TargetFindAOETarget.Self);
            return targetFind.GetTargets();
        }

        #region Inventory
        public void SendItemPackage(Player player, uint id)
        {
            if (!itemPackages.ContainsKey((ushort)id))
                return;

            player.QueuePacket(InventoryBeginChangePacket.BuildPacket(Id, true));
            itemPackages[(ushort)id].SendFullPackage(player);
            player.QueuePacket(InventoryEndChangePacket.BuildPacket(Id));
        }

        public void AddItem(uint catalogID)
        {
            AddItem(catalogID, 1);
        }

        public void AddItem(uint catalogID, int quantity)
        {
            AddItem(catalogID, quantity, 1);
        }

        public void AddItem(uint catalogID, int quantity, byte quality)
        {
            ushort itemPackage = GetPackageForItem(catalogID);
            if (itemPackages.ContainsKey(itemPackage))
            {
                itemPackages[itemPackage].AddItem(catalogID, quantity, quality);
            }
        }

        public void AddItem(InventoryItem item)
        {
            ushort itemPackage = GetPackageForItem(item.GetItemData().catalogID);
            if (itemPackages.ContainsKey(itemPackage))
            {
                itemPackages[itemPackage].AddItem(item);
            }
        }

        public void MoveItem(InventoryItem item, ushort destinationPackage)
        {
            ushort sourcePackage = item.itemPackage;

            if (!itemPackages.ContainsKey(sourcePackage) && !itemPackages.ContainsKey(destinationPackage))
                return;
            
            itemPackages[sourcePackage].MoveItem(item, itemPackages[destinationPackage]);
        }

        public void RemoveItem(uint catalogID)
        {
            RemoveItem(catalogID, 1);
        }

        public void RemoveItem(uint catalogID, int quantity)
        {
            RemoveItem(catalogID, quantity, 1);
        }

        public void RemoveItem(uint catalogID, int quantity, byte quality)
        {
            ushort itemPackage = GetPackageForItem(catalogID);
            if (itemPackages.ContainsKey(itemPackage))
            {
                itemPackages[itemPackage].RemoveItem(catalogID, quantity, quality);
            }
        }

        public void RemoveItemAtSlot(ushort itemPackage, ushort slot)
        {
            if (itemPackages.ContainsKey(itemPackage))
            {
                itemPackages[itemPackage].RemoveItemAtSlot(slot);
            }
        }

        public void RemoveItem(InventoryItem item)
        {
            itemPackages[item.itemPackage].RemoveItem(item);
        }

        public bool HasItem(uint catalogID)
        {
            return HasItem(catalogID, 1);
        }

        public bool HasItem(uint catalogID, int minQuantity)
        {
            return HasItem(catalogID, minQuantity, 1);
        }

        public bool HasItem(uint catalogID, int minQuantity, byte quality)
        {
            ushort itemPackage = GetPackageForItem(catalogID);
            if (itemPackages.ContainsKey(itemPackage))
            {
                return itemPackages[itemPackage].HasItem(catalogID, minQuantity, quality);
            }
            return false;
        }

        public bool HasItem(InventoryItem item)
        {
            ushort itemPackage = GetPackageForItem(item.GetItemData().catalogID);
            if (itemPackages.ContainsKey(itemPackage))
            {
                //return itemPackages[itemPackage].HasItem(item);
                return false; //TODO FIX
            }
            else
                return false;
        }

        public InventoryItem GetItem(LuaUtils.ItemRefParam reference)
        {
            if (reference.actorId != Id)
                return null;
            if (itemPackages.ContainsKey(reference.itemPackage))
            {
                return itemPackages[reference.itemPackage].GetItemAtSlot(reference.slot);
            }
            return null;
        }

        public ItemPackage GetItemPackage(ushort package)
        {
            if (itemPackages.ContainsKey(package))
                return itemPackages[package];
            else
                return null;
        }

        public ushort GetPackageForItem(uint catalogID)
        {
            ItemData data = Server.GetItemGamedata(catalogID);

            if (data == null)
                return ItemPackage.NORMAL;
            else
            {
                if (data.IsMoney())
                    return ItemPackage.CURRENCY_CRYSTALS;
                else if (data.IsImportant())
                    return ItemPackage.KEYITEMS;
                else
                    return ItemPackage.NORMAL;
            }
        }

        //public void removeItem(byUniqueId)
        //public void removeItem(byUniqueId, quantity)
        //public void removeItem(slot)
        //public void removeItem(slot, quantity)

        #endregion

    }
}