using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Xml.Serialization;

namespace Astral.Logic.UCC.Actions
{
    public class Spell : Classes.UCCAction
    {
        public override Classes.UCCAction Clone()
        {
            var newSpell = new Spell();
            newSpell.SpellID = SpellID;
            newSpell.CastingTime = CastingTime;
            return BaseClone(newSpell);
        }

        public override bool NeedToRun
        {
            get
            {
                var power = NW.Powers.GetPowerByInternalName(SpellID);
                if (!power.IsValid)
                {
                    return false;
                }
                if (power.UseCharges())
                {
                    if (!power.ChargeAvailable())
                    {
                        return false;
                    }
                }
                if (power.PowerDef.IsDaily && Shortcut.LocalPlayer.Character.AttribsBasic.ActionPoints < 1000)
                {
                    return false;
                }
                if (power.IsOnCooldown())
                {
                    return false;
                }
                if (!power.IsInTray)
                {
                    if (!Classes.ActionsPlayer.combatBLActions.Contains(this))
                        Classes.ActionsPlayer.combatBLActions.Add(this);
                    return false;
                }
                return true;
            }
        }

        [Browsable(false), XmlIgnore()]
        MyNW.Classes.Entity TargetEntity
        {
            get
            {
                switch (Target)
                {
                    case Ressources.Enums.Unit.Player:
                        return Shortcut.LocalPlayer;
                    case Ressources.Enums.Unit.MostInjuredAlly:
                        return Classes.ActionsPlayer.MostInjuredAlly;
                    case Ressources.Enums.Unit.StrongestAdd:
                        return Classes.ActionsPlayer.AnAdd;
                    case Ressources.Enums.Unit.StrongestTeamMember:
                        return Classes.ActionsPlayer.StrongestTeamMember;
                    default:
                        return Core.CurrentTarget;
                }
            }
        }

        static Astral.Classes.Timeout stopMoveDodgeTO = new Astral.Classes.Timeout(0);
        public override bool Run()
        {

            var power = NW.Powers.GetPowerByInternalName(SpellID);
            var powerDef = power.EffectivePowerDef();
            if (Target != Ressources.Enums.Unit.Player)
            {
                switch (Target)
                {
                    case Ressources.Enums.Unit.MostInjuredAlly:
                        Controllers.Movements.SpecificTarget = Classes.ActionsPlayer.MostInjuredAlly;
                        break;
                    case Ressources.Enums.Unit.StrongestTeamMember:
                        Controllers.Movements.SpecificTarget = Classes.ActionsPlayer.StrongestTeamMember;
                        break;
                    case Ressources.Enums.Unit.StrongestAdd:
                        Controllers.Movements.SpecificTarget = Classes.ActionsPlayer.AnAdd;
                        break;
                    default:
                        Controllers.Movements.SpecificTarget = null;
                        break;
                }
                int range = NW.Powers.getEffectiveRange(powerDef);
                if (Range > 0)
                    range = Range;
                if (range > 1)
                {
                    if (range < 7)
                        range = 7;
                    Controllers.Movements.RequireRange = range - 2;
                    while (!Controllers.Movements.RangeIsOk)
                    {
                        if (Core.CurrentTarget.IsDead)
                        {
                            return true;
                        }
                        System.Threading.Thread.Sleep(100);
                        if (stopMoveDodgeTO.IsTimedOut && Astral.Controllers.AOECheck.PlayerIsInAOE)
                        {
                            stopMoveDodgeTO.ChangeTime(3500);
                            return true;
                        }
                    }
                }
            }
            int castTime = 0;
            if (CastingTime > 0)
                castTime = CastingTime;
            else
            {
                castTime = NW.Powers.getEffectiveTimeCharge(powerDef);
            }


            var target = new MyNW.Classes.Entity(TargetEntity.Pointer);
            if (target.ContainerId != Shortcut.LocalPlayer.ContainerId &&
                !target.Location.IsInYawFace)
            {
                target.Location.Face();
                var faceTo = new Astral.Classes.Timeout(750);
                while (!target.Location.IsInYawFace)
                {
                    if (faceTo.IsTimedOut)
                        break;
                    System.Threading.Thread.Sleep(20);
                }
                System.Threading.Thread.Sleep(100);
            }

            var activateTimeTo = NW.Powers.getEffectiveTimeActivate(powerDef) * 1.5;

            var to = new Astral.Classes.Timeout(castTime);
            try
            {
                if (!powerDef.GroundTargeted && !powerDef.Categories.Contains(MyNW.Patchables.Enums.PowerCategory.IgnorePitch))
                {
                    NW.Powers.ExecPower(power, target, true);
                }
                else
                {
                    var aoeLoc = target.Location;
                    aoeLoc.Z += 3;
                    NW.Powers.ExecPower(power, aoeLoc, true);
                }

                while (true)
                {
                    if (power.UseCharges())
                    {
                        if (!power.ChargeAvailable())
                            break;
                    }
                    if (Core.CurrentTarget.IsDead)
                        return true;
                    if (to.IsTimedOut)
                        break;
                    if (power.IsActive)
                        break;
                    System.Threading.Thread.Sleep(20);
                    if (Astral.Controllers.AOECheck.PlayerIsInAOE)
                        break;
                }
            }
            catch { }
            finally
            {
                NW.Powers.ExecPower(power, target, false);
            }
            NW.Powers.WaitPowerActivation(power, (int)activateTimeTo);

            return true;
        }

        [Browsable(false), XmlIgnore]
        public bool Slotted
        {
            get
            {
                var spell = NW.Powers.GetPowerByInternalName(spellID);
                foreach (var pid in Shortcut.LocalPlayer.Character.SlottedPowers)
                {
                    if (spell.PowerId == pid)
                        return true;
                }
                return false;
            }
        }

        public override string ToString()
        {
            if (SpellID.Length > 0)
            {
                var spell = NW.Powers.GetPowerByInternalName(spellID);
                if (spell.IsValid)
                {
                    var txt = string.Empty;
                    if (Slotted)
                        txt += "[Slotted] ";
                    if (spell.EffectivePowerDef().DisplayName.Length > 0)
                        txt += spell.EffectivePowerDef().DisplayName;
                    else
                        txt += spell.EffectivePowerDef().InternalName;
                    txt += " (Spell)";
                    return txt;
                }
                else
                {
                    var spellDef = NW.Powers.GetPowerDefByPowerId(SpellID);
                    if (spellDef.IsValid)
                        return spellDef.DisplayName + " (Unknown Spell)";
                }
            }
            return "Unknow Spell";
        }

        [Browsable(false)]
        public new string ActionName { get; set; }

        public Spell()
        {
            spellID = string.Empty;
            CastingTime = 0;
        }

        string spellID = string.Empty;
        [DisplayName("Spell ID"), Category("Required"), TypeConverter(typeof(Converters.AnSpell))]
        public string SpellID
        {
            get
            {
                return spellID;
            }
            set
            {
                if (value.Length > 0)
                {
                    var power = NW.Powers.GetPowerByDisplayName(value);
                    if (power.IsValid)
                    {
                        spellID = power.PowerDef.InternalName;
                        return;
                    }
                }
                spellID = value;
            }
        }
        [DisplayName("Casting Time (ms)"), Description("0 for automatic"), Category("Advanced (Optionnal)")]
        public int CastingTime { get; set; }
    }

}