using System;
using InnerSpaceAPI;
using LavishScriptAPI;
using PRModuleInterface;
using ISXWoW;
using PRCoreInterface;

namespace RequiemRogue
{
    public enum MageStates
    {
        SingleMob,
        DoubleMob,
        MultiMob,
        Flee,
        Null
    }

    public enum SingleStates
    {
        Approach,
        Pulling,
        Nuking,
        Counterspelling,
        Null
    }

    public enum DoubleStates
    {
        Approach,
        Sheeping,
        Nuking,
        Counterspelling,
        Null
    }

    public enum MultiStates
    {
        Approach,
        AOE,
        Nuking,
        CrowdControl,
        Null
    }

    public class PRModule : IPlugin
    {
        int i = 0;
        bool JustPulled = false;

        #region State Object and Data Hiding access initiation.
        private MageStates _CurrentState = MageStates.SingleMob;

        private MageStates MageState
        {
            get { return CurrentState; }
        }

        public MageStates CurrentState
        {
            get { return _CurrentState; }
            set { _CurrentState = value; }
        }

        private SingleStates _CurrentSingleState = SingleStates.Pulling;

        private SingleStates SingleState
        {
            get { return CurrentSingleState; }
        }

        public SingleStates CurrentSingleState
        {
            get { return _CurrentSingleState; }
            set { _CurrentSingleState = value; }
        }

        private DoubleStates _CurrentDoubleState = DoubleStates.Sheeping;

        private DoubleStates DoubleState
        {
            get { return CurrentDoubleState; }
        }

        public DoubleStates CurrentDoubleState
        {
            get { return _CurrentDoubleState; }
            set { _CurrentDoubleState = value; }
        }

        private MultiStates _CurrentMultiState = MultiStates.CrowdControl;

        private MultiStates MultiState
        {
            get { return CurrentMultiState; }
        }

        public MultiStates CurrentMultiState
        {
            get { return _CurrentMultiState; }
            set { _CurrentMultiState = value; }
        }
        #endregion
        public double FleeHealth
        {
            get { return 10.00; }
        }

        public double FleeMana
        {
            get { return 10.00; }
        }

        public void Pulse()
        {
            //return;

            CurrentState = GetState();  //Let's get our state and return it via our accessor, storing it via the CurrentState property.
            StateManager();
            i++;
            if (i % 30 == 0)
            {
                Requiem.Kernel.Echo("Number of baddies in list is " + Requiem.Character.PriorityList.Count + " Number of Aggros: " + Requiem.Character.AggroList.Count);
            }
        }

        #region State Management
        public MageStates GetState()
        {
            if (Requiem.Character.PriorityList.Count == 1) //we have 1 target
                return MageStates.SingleMob;
            if (Requiem.Character.PriorityList.Count == 2) //we have 2 targets
                return MageStates.DoubleMob;
            if (Requiem.Character.PriorityList.Count >= 3) //we have 3 or more targets
                return MageStates.MultiMob;
            if (Requiem.Character.HealthPercent < FleeHealth && Requiem.Character.ManaPercent < FleeMana)
                return MageStates.Flee;
            else
                return MageStates.Null;
        }

        private void StateManager()
        {
            switch (CurrentState)
            {

                case MageStates.SingleMob:
                    SingleStateManager();
                    break;
                case MageStates.DoubleMob:
                    DoubleStateManagement();
                    break;
                case MageStates.MultiMob:
                    MultiStateManager();
                    break;
                case MageStates.Flee:
                    FleeHandler();
                    break;
            }
        }
        #endregion

        #region Single State Management
        private void SingleStateManager()
        {

            //TEMP
            //return;
            //TEMP
            CurrentSingleState = GetSingleState();
            if (i % 30 == 0)
            {
                Requiem.Kernel.Echo("Single State Routine Checking in, Getting State, " + CurrentSingleState.ToString());
            }
            switch (CurrentSingleState)
            {
                case SingleStates.Approach:
                    ApproachHandler();
                    JustPulled = false;
                    break;
                case SingleStates.Pulling:
                    PullHandler();
                    break;
                case SingleStates.Nuking:
                    NukeHandler();
                    break;
                case SingleStates.Counterspelling:
                    CounterHandler();
                    break;
                case SingleStates.Null:
                    NullHandler();
                    break;
            }
        }


        public SingleStates GetSingleState()  //broken for now
        {
            if (PrimaryTarget.Distance > 35)
                return SingleStates.Approach;
            if (PrimaryTarget.SpellInCast.IsValid)
                return SingleStates.Counterspelling;
            if (PrimaryTarget.Distance >= 15 && PrimaryTarget.Distance <= 30 && !JustPulled && !Busy && PrimaryTarget.CurrentTarget != WoWActivePlayer.Get())
                return SingleStates.Pulling;
            if (PrimaryTarget.Distance <= 35 && !Busy)
                return SingleStates.Nuking;
            else
                return SingleStates.Null;
        }
        #endregion

        #region Double State Management
        private void DoubleStateManagement()
        {
            CurrentDoubleState = GetDoubleState();
            switch (CurrentDoubleState)
            {
                case DoubleStates.Approach:
                    ApproachHandler();
                    break;
                case DoubleStates.Sheeping:
                    SheepHandler();
                    break;
                case DoubleStates.Nuking:
                    NukeHandler();
                    break;
                case DoubleStates.Counterspelling:
                    CounterHandler();
                    break;
            }
        }
        public DoubleStates GetDoubleState()  //broken for now
        {
            if (Requiem.Character.InCombat)
                return DoubleStates.Sheeping;
            else
                return DoubleStates.Nuking;
        }
        #endregion

        #region Multi State Management
        private void MultiStateManager()
        {
            CurrentMultiState = GetMultiState();
            switch (CurrentMultiState)
            {
                case MultiStates.Approach:
                    ApproachHandler();
                    break;
                case MultiStates.CrowdControl:
                    CrowdHandler();
                    break;
                case MultiStates.Nuking:
                    NukeHandler();
                    break;
                case MultiStates.AOE:
                    AOEHandler();
                    break;
            }
        }
        public MultiStates GetMultiState()  //broken for now
        {
            if (Requiem.Character.InCombat)
                return MultiStates.AOE;
            else
                return MultiStates.CrowdControl;
        }
        #endregion

        #region Initialization and Destruction

        public void OnLoad()
        {
            GUIs.LoadGUIs();
            if (Requiem.Character.HasSpell("Conjure Water"))
                Requiem.Character.ConjuredItems.AddConjure("Conjure Water", "Conjured Water", 1);
            if (Requiem.Character.HasSpell("Conjure Food"))
                Requiem.Character.ConjuredItems.AddConjure("Conjure Food", "Conjured Muffin", 1);
            if (Requiem.Character.HasSpell("Frost Armor"))
                Requiem.Character.BuffList.AddBuff("Frost Armor");
            if (Requiem.Character.HasSpell("Arcane Intellect"))
                Requiem.Character.BuffList.AddBuff("Arcane Intellect");

        }

        public void OnUnload()
        {
            GUIs.UnloadGUIs();
        }
        #endregion

        #region Combat State Handlers
        private void NullHandler()
        {
            return;
        }

        private void ApproachHandler()
        {
            if (Requiem.Navigation.CurrentState.Equals(NAVIGATION_STATE.NONE))
            {
                Requiem.Navigation.PathTo(PrimaryTarget.X, PrimaryTarget.Y, PrimaryTarget.Z);
            }
            //throw new Exception("The method or operation is not implemented.");
        }

        private void FleeHandler()
        {
            Requiem.Kernel.Echo("We should Flee");
            //throw new Exception("The method or operation is not implemented.");
        }

        private void CrowdHandler()
        {
            //throw new Exception("The method or operation is not implemented.");
        }

        private void AOEHandler()
        {
            //throw new Exception("The method or operation is not implemented.");
        }

        private void CounterHandler()
        {
            //throw new Exception("The method or operation is not implemented.");
        }

        private void SheepHandler()
        {
            //throw new Exception("The method or operation is not implemented.");
        }

        private void NukeHandler()
        {
            Requiem.Navigation.StopPathing();

            PrimaryTarget.Target();
            if (Requiem.Navigation.ShouldFace(PrimaryTarget.Location.X, PrimaryTarget.Location.Y))
            {
                Requiem.Navigation.Face(PrimaryTarget.X, PrimaryTarget.Y);
                return;
            }
            if (!Busy && Requiem.Character.Action("Fireball").Usable)
            {
                Requiem.Character.Cast("Fireball");
                //Requiem.Character.Cast(FireballObj, MyTarget);  //Let's cast a fireball
                JustPulled = false;
                return;
            }
            if (Requiem.Character.Action("Shoot").Usable)
            {
                Requiem.Character.Action("Shoot").Use();
                JustPulled = false;
                return;
            }
            if (!Requiem.Character.Attacking)
                Requiem.Character.Attack();
            return;
        }

        private void PullHandler()
        {
            Requiem.Navigation.StopPathing();
            PrimaryTarget.Target();
            if (Requiem.Navigation.ShouldFace(PrimaryTarget.Location.X, PrimaryTarget.Location.Y))
            {
                Requiem.Kernel.Echo("Facin'");
                Requiem.Navigation.Face(PrimaryTarget.X, PrimaryTarget.Y);
                return;
            }
            if (Requiem.Character.HasSpell("Frostbolt"))
            {
                if (!Busy)
                {
                    Requiem.Character.Cast("Frostbolt");
                    //Requiem.Character.Cast(FrostboltObj, MyTarget);  //Let's cast a frostbolt
                    JustPulled = true;
                }
                return;
            }
            else
            {
                if (!Busy)
                {
                    Requiem.Character.Cast("Fireball");
                    //Requiem.Character.Cast(FireballObj, MyTarget);  //we should do a fireball then.
                    JustPulled = true;
                }
                return;
            }
        }
        #endregion

        #region Internal Implementations of Macros
        private WoWUnit MyTarget
        {
            get { return Requiem.Character.CurrentTarget; }
        }

        private WoWUnit PrimaryTarget
        {
            get { return Requiem.Character.PriorityList.Unit(1); }
        }

        private bool Busy
        {
            get { return Requiem.Character.IsCasting; }
        }
        #endregion
    }
}