using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using RPGCreationKit;
using RPGCreationKit.BehaviourTree;
using System.Linq;

namespace RPGCreationKit.AI
{
    /// <summary>
    /// Manages the Behaviour Trees and the interactions with the AI agent from a tree.
    /// </summary>
    public class AIBehaviourTreed : AICombatSystem
    {
        public TreeTickRate tickRate;
        public int xFrames = 5;
        public float xSeconds = 1f;

        public PurposeState purposeState;

        [Space(10)]
        [Header("Behaviour Tree Control")]
        public bool useBT = true;
        public bool pauseBT = false;
        public RPGCK_BT currentBehaviour;
        public bool isUsingPurposeBehaviour = true;

        public RPGCK_BT purposeBehaviourTree;
        public RPGCK_BT combatBehaviourTree;

        [Header("Settings")]
        public bool keepTicking = true;

        public override void Start()
        {
            base.Start();

            if (!isAlive)
                Die();
            else
                if (useBT)
                {
                    purposeBehaviourTree = purposeBehaviourTree.RPGCK_BTCopy(this.gameObject, GetComponent<RckAI>());
                    combatBehaviourTree = combatBehaviourTree.RPGCK_BTCopy(this.gameObject, GetComponent<RckAI>());

                    // Always start with the NormalBehaviourTree
                    SwitchBehaviourTree(false);

                    StartTicking();
                }
        }

        public void StartTicking()
        {
            keepTicking = true;

            StopCoroutine(TickBehaviourTree());
            StartCoroutine(TickBehaviourTree());
        }

        IEnumerator TickBehaviourTree()
        {
            while (keepTicking)
            {
                while (pauseBT)
                    yield return null;

                switch(tickRate)
                {
                    case TreeTickRate.EveryFrame:
                        yield return new WaitForEndOfFrame();
                        break;

                    case TreeTickRate.EveryXFrames:
                        int framesPassed = 0;

                        while(framesPassed <= xFrames)
                        {
                            yield return new WaitForEndOfFrame();
                            framesPassed++;
                        }
                        break;

                    case TreeTickRate.EveryXSeconds_Realtime:
                        yield return new WaitForSecondsRealtime(xSeconds);
                        break;

                    case TreeTickRate.EveryXSeconds_GameTime:
                        yield return new WaitForSeconds(xSeconds);
                        break;
                }

                while (pauseBT || currentBehaviour == null || currentBehaviour.nodes.Count <= 0 || currentBehaviour.nodes[0] == null)
                    yield return null;

                try
                {
                    (currentBehaviour.nodes[0] as BTNode).Execute();
                }catch { }
                
                /*
                if (firstTick == false)
                {

                    // Tick
                    (currentBehaviour.nodes[0] as BTNode).Execute();
                    firstTick = true;
                }
                else
                {
                    // Find all the nodes that are still running and execute them
                    ((currentBehaviour.nodes[0] as BTNode).GetOutputPort("firstNode").Connection.node as BTNode).Execute();
                }
                */

                yield return null;
            }
        }

        public void ChangeTickRate(TreeTickRate newTickRate)
        {
            tickRate = newTickRate;
        }

        protected bool anyWaitForSetRunning = false;
        protected bool anyWaitForSwitchRunning = false;


        public IEnumerator QueueSwitch(bool _combat)
        {
            if (anyWaitForSwitchRunning)
                yield return null;

            SwitchBehaviourTree(_combat);
        }

        [AIInvokable]
        public void SwitchBehaviourTree(bool _combat)
        {
            if (anyWaitForSwitchRunning)
            {
                StartCoroutine(QueueSwitch(_combat));
                return;
            }

            // Execute OnExit node if present
            if (currentBehaviour != null && currentBehaviour.nodes.Count > 0 && ((currentBehaviour.nodes[0] as BTNode).GetOutputPort("onExitNode").Connection != null && ((currentBehaviour.nodes[0] as BTNode).GetOutputPort("onExitNode").Connection.node != null)))
            {
                anyWaitForSwitchRunning = true;
                // Execute OnExit before changing the tree
                StartCoroutine(SwitchBehaviourTree_WaitForExitNodeTask(_combat));
            }
            else
            {

                if (_combat)
                {
                    currentBehaviour = combatBehaviourTree;
                    isUsingPurposeBehaviour = false;
                }
                else
                {
                    currentBehaviour = purposeBehaviourTree;
                    isUsingPurposeBehaviour = true;
                }
            }
        }

        IEnumerator SwitchBehaviourTree_WaitForExitNodeTask(bool _combat)
        {
            pauseBT = true;
            yield return new WaitForEndOfFrame();

            var node = (((currentBehaviour.nodes[0] as BTNode).GetOutputPort("onExitNode").Connection.node) as BTNode);
            node.ReEvaluate();
            while (node.m_NodeState == NodeState.Null || node.m_NodeState == NodeState.Running)
            {
                node.Execute();
                yield return new WaitForEndOfFrame();
            }

            if (anyWaitForSetRunning)
            {
                yield return new WaitForEndOfFrame();
            }


            if (_combat)
            {
                currentBehaviour = combatBehaviourTree;
                isUsingPurposeBehaviour = false;
            }
            else
            {
                currentBehaviour = purposeBehaviourTree;
                isUsingPurposeBehaviour = true;
            }

            anyWaitForSwitchRunning = false;
            pauseBT = false;
            yield break;
        }


        [AIInvokable]
        public void SwitchBehaviourTreeToAI(string _rckID, bool _combat)
        {
            // Get the RckAI if possible
            RckAI sTo = null;
            CellsSystem.CellInformation.TryToGetAI(_rckID, out sTo);

            if (sTo != null)
            {
                sTo.SwitchBehaviourTree(_combat);
            }
        }

        public override void OnEnterInCombat()
        {
            base.OnEnterInCombat();

            if (combatBehaviourTree.resetVariablesUponStartResume)
                combatBehaviourTree.ResetVariables();

            if (isUsingActionPoint && !leavingActionPoint)
                StopUsingNPCActionPoint();

            SwitchBehaviourTree(true);
        }

        [AIInvokable]
        public override void LeaveCombat()
        {
            base.LeaveCombat();

            if (purposeBehaviourTree.resetVariablesUponStartResume)
                purposeBehaviourTree.ResetVariables();

            // reset ishostile
            isHostile = false;
            isHostileAgainstPC = false;

            SwitchBehaviourTree(false);

            // Reset PurposeState
            if (purposeState.IsAssigned)
            {
                SetTarget(purposeState.Target);
                purposeState.ResumePurpose();
            }
        }

        public override void Damage(DamageContext context)
        {
            if (context.sender != null && !context.sender.CompareTag("Player"))
            {
                // If they're both members of the same factions chances are they didn't meant to attach each other, so ignore
                for (int i = 0; i < belongsToFactions.Count; i++)
                {
                    if ((context.sender as EntityFactionable).GetInFaction(belongsToFactions[i].ID))
                        return;
                }
            }

            base.Damage(context);

            if (aiSounds != null && isAlive)
            {
                if (aiSounds.takeDamageSounds.Length > 0)
                {
                    int n = Random.Range(0, aiSounds.takeDamageSounds.Length);

                    if (aiSounds.takeDamageSounds[n] != null)
                    {
                        audioSource.clip = aiSounds.takeDamageSounds[n];
                        audioSource.Play();
                    }
                }
            }

            if (context.sender != null)
            {
                // If they're both members of the same factions chances are they didn't meant to attach each other, so ignore
                if (isInCombat)
                {
                    for (int i = 0; i < belongsToFactions.Count; i++)
                    {
                        if ((context.sender as EntityFactionable).GetInFaction(belongsToFactions[i].ID))
                            return;
                    }
                }

                if (!enemyTargets.Any(t => t.m_entity == context.sender))
                {
                    if (isInConversation)
                        StopConversation();

                    if (!m_isInCombat)
                        EnterInCombatAgainst(context.sender);

                    enemyTargets.Add(new VisibleEnemy(context.sender, context.sender.GetComponent<EntityAttributes>(), new AggroInfo(50)));
                }
                else // this enemy was already in combat with this agent so just update the aggro
                {
                    var entTarget = enemyTargets.Find(x => x.m_entity == context.sender);
                    entTarget.m_aggro.AlterAggroValue(AggroSettings.Modifier.Damage, context.amount);

                    float weaponAggroModifier = 0.0f;
                    if (context.weaponItem != null)
                        weaponAggroModifier = context.weaponItem.aggroModifier;
                    else if (context.spell != null)
                        weaponAggroModifier = context.spell.aggroModifier;

                    entTarget.m_aggro.AlterAggroValue(AggroSettings.Modifier.Weapon, weaponAggroModifier);
                }
            }
        }

        public override void Die()
        {
            base.Die();
            attributes.CurHealth = -1;
            attributes.activeEffects.Clear();
            keepTicking = false;
            useBT = false;
            pauseBT = true;
            for (int i = 0; i < inventory.Items.Count; i++) {
                inventory.Items[i].metadata.IsOwnedByNPC = false;
            }
        }

        #region Methods and Functions specifically for Behaviour Trees
        public bool hasARangedWeapon = false;

        [AIInvokable]
        public void HasRangedWeaponCheck()
        {
            WeaponItem weaponItem = null;

            for (int i = 0; i < inventory.subLists[(int)ItemTypes.WeaponItem].Count; i++)
            {
                weaponItem = (WeaponItem)inventory.subLists[(int)ItemTypes.WeaponItem][i].item;

                if (weaponItem.weaponType == WeaponType.Bow || weaponItem.weaponType == WeaponType.Crossbow)
                {
                    if (HasAmmoForWeapon(weaponItem))
                    {
                        hasARangedWeapon = true;
                        break;
                    }
                    else
                    {
                        Debug.Log("don't have ammo for " + weaponItem.ItemID);
                    }
                }
            }
        }

        public bool hasAMeleeWeapon = false;
        [AIInvokable]
        public void HasMeleeWeaponCheck()
        {
            WeaponItem weaponItem = null;

            for (int i = 0; i < inventory.subLists[(int)ItemTypes.WeaponItem].Count; i++)
            {
                weaponItem = (WeaponItem)inventory.subLists[(int)ItemTypes.WeaponItem][i].item;

                if (weaponItem.weaponType == WeaponType.BladeOneHand || weaponItem.weaponType == WeaponType.BluntOneHand ||
                    weaponItem.weaponType == WeaponType.BladeTwoHands || weaponItem.weaponType == WeaponType.BluntTwoHands ||
                    weaponItem.weaponType == WeaponType.DaggerOneHand)
                {
                    hasAMeleeWeapon = true;
                    break;
                }
            }
        }


        public float distanceFromMainTarget;
        [AIInvokable]
        public void GetDistanceFromMainTarget()
        {
            if(mainTarget == null)
            {
                Debug.LogWarning("Called GetDistanceFromMainTarget() but no MainTarget has been set");
                return;
            }

            distanceFromMainTarget = Vector3.Distance(this.transform.position, mainTarget.transform.position);
        }


        [AIInvokable]
        public void Weapon_SwitchToMelee()
        {
            isSwitchingWeapon = true;

            WeaponItem weaponItem = null;

            for (int i = 0; i < inventory.subLists[(int)ItemTypes.WeaponItem].Count; i++)
            {
                weaponItem = (WeaponItem)inventory.subLists[(int)ItemTypes.WeaponItem][i].item;

                if (weaponItem.weaponType == WeaponType.BladeOneHand || weaponItem.weaponType == WeaponType.BluntOneHand ||
                    weaponItem.weaponType == WeaponType.BladeTwoHands || weaponItem.weaponType == WeaponType.BluntTwoHands
                    || weaponItem.weaponType == WeaponType.DaggerOneHand)
                {
                    ChangeWeapon(weaponItem.ItemID);
                    break;
                }
            }
        }

        [AIInvokable]
        public void Weapon_SwitchToRanged()
        {
            isSwitchingWeapon = true;

            WeaponItem weaponItem = null;

            for (int i = 0; i < inventory.subLists[(int)ItemTypes.WeaponItem].Count; i++)
            {
                weaponItem = (WeaponItem)inventory.subLists[(int)ItemTypes.WeaponItem][i].item;

                if (weaponItem.weaponType == WeaponType.Bow || weaponItem.weaponType == WeaponType.Crossbow)
                {
                    // We got a weapon, check for ammo
                    if (EquipAmmoForWeapon(weaponItem))
                    {
                        ChangeWeapon(weaponItem);
                        break;
                    }
                }
            }
        }

        [AIInvokable]
        public void Weapon_SwitchToDefault()
        {
            ChangeWeapon(defaultWeapon.ItemID);
        }

        public float currentWeaponReach = RCKSettings.DEFAULT_WEAPON_REACH;

        [AIInvokable]
        public void GetWeaponsReach()
        {
            if (equipment.currentWeapon != null)
                currentWeaponReach = equipment.currentWeapon.Reach;
            else
                currentWeaponReach = RCKSettings.DEFAULT_WEAPON_REACH; // 4 is default value
        }


        [AIInvokable]
        public void SpeakToTarget()
        {
            if (mainTarget.CompareTag("Player"))
                RPGCreationKit.Player.RckPlayer.instance.StartDialogue(this.GetComponent<IDialoguable>());
            else
            {
                IDialoguable[] targetDialoguable = new IDialoguable[2];
                targetDialoguable[0] = mainTarget.GetComponent<IDialoguable>();

                if (targetDialoguable == null)
                    targetDialoguable[0] = mainTarget.GetComponentInParent<IDialoguable>();

                // Set us
                targetDialoguable[1] = this;

                if (targetDialoguable[0] != null)
                {
                    DialogueLogic(targetDialoguable, GetCurrentDialogueGraph());
                }
            }
        }

        [AIInvokable]
        public void SetRckAIAsTarget(string _rckID)
        {
            // Get the RckAI if possible
            RckAI sTo = null;
            CellsSystem.CellInformation.TryToGetAI(_rckID, out sTo);

            if (sTo != null)
                SetTarget(sTo.gameObject);
        }

        public override void OnDialogueEnds(GameObject target)
        {
            //// PURPOSE_CALLBACK: ClearOnTeleportToCell \\\\\
            if (purposeState != null && purposeState.IsAssigned && purposeState.clearsOn == PurposeClearTypes.ClearOnFinishTalkingWith)
            {
                if (purposeState.clearsOnData.stringData == speakingTo.GetEntityGameObject().GetComponent<Entity>().entityID)
                {
                    // We did it
                    purposeState.CompletePurpose();
                }
            }

            base.OnDialogueEnds(target);
        }

        /// <summary>
        /// Forces the AI to stop the dialogue
        /// </summary>
        public void StopConversation()
        {
            if (entitiesTalkingWith != null)
            {
                // Copy before destroying entitiesTalkingWith
                List<IDialoguable> dial = new List<IDialoguable>();

                for (int i = 0; i < entitiesTalkingWith.Length; i++)
                    dial.Add(entitiesTalkingWith[i]);

                for (int i = 0; i < dial.Count; i++)
                    dial[i].ForceToStopDialogue();
            }
        }

        bool goingToSpeak = false;

        [AIInvokable]
        public void SendAIToSpeakToPlayer(bool run)
        {
            if (goingToSpeak)
                return;

            goingToSpeak = true;

            StopCoroutine(SendAIToSpeakToPlayerTask());

            if ( isReachingActionPoint || isUsingActionPoint)
            {
                ResetActionPointAgentState();
                StopUsingNPCActionPoint(true);
            }

            if (run)
                Movements_SwitchToRun();
            else
                Movements_SwitchToWalk();

            // Set maintarget
            SetTarget(Player.RckPlayer.instance.gameObject);

            // Follow until he reaches it
            StartCoroutine(SendAIToSpeakToPlayerTask());
        }

        public IEnumerator SendAIToSpeakToPlayerTask()
        {
            if (!isLoaded)
            {
                goingToSpeak = false;
                yield break;
            }

            while (Vector3.Distance(this.gameObject.transform.position, Player.RckPlayer.instance.transform.position) > RCKSettings.NPC_TO_NPC_CONVERSATION_DISTANCE || !CanDialogue() ||
                !Player.RckPlayer.instance.CanDialogue() || !WorldManager.instance.isLoading && !Player.RckPlayer.instance.IsControlledByPlayer() || isInOfflineMode || !isLoaded)
                yield return new WaitForEndOfFrame();

            Player.RckPlayer.instance.StartDialogue(this);

            goingToSpeak = false;
            yield break;
        }

        [AIInvokable]
        public void AssignPurpose(RckAI _AI, GameObject _target, PurposeClearTypes _clearsOn, PurposeStateClearsOnData _clearOnData, string _nextPurposeBehaviourTree = null)
        {
            purposeState.AssignPurpose(_AI, _target, _clearsOn, _clearOnData, _nextPurposeBehaviourTree);
        }

        [AIInvokable]
        public void Purpose_AssignToFollowCurrentPath()
        {
            if(aiPath != null && aiPath.gameObject != null)
                purposeState.AssignPurpose(GetComponent<RckAI>(), aiPath.gameObject, PurposeClearTypes.ClearOnDeath, null, null);
        }

        [AIInvokable]
        public void Magic_SwitchToHealingSpell()
        {
            // Check if the AI already has an healing spell
            if (spellsKnowledge.spellInUse != null && spellsKnowledge.spellInUse.tag == SpellTag.RestoreHealth)
                return;

            for(int i = 0; i < spellsKnowledge.Spells.Count; i++)
            {
                if(spellsKnowledge.Spells[i].tag == SpellTag.RestoreHealth)
                {
                    spellsKnowledge.spellInUse = spellsKnowledge.Spells[i];
                    return;
                }
            }
        }

        [AIInvokable]
        public void Magic_SwitchToDamageSpell()
        {
            // Check if the AI already has an healing spell
            if (spellsKnowledge.spellInUse != null && spellsKnowledge.spellInUse.tag == SpellTag.DamageProjectile || spellsKnowledge.spellInUse.tag == SpellTag.DamageTouch)
                return;

            for (int i = 0; i < spellsKnowledge.Spells.Count; i++)
            {
                if (spellsKnowledge.Spells[i].tag == SpellTag.DamageProjectile || spellsKnowledge.Spells[i].tag == SpellTag.DamageTouch)
                {
                    spellsKnowledge.spellInUse = spellsKnowledge.Spells[i];
                    return;
                }
            }
        }

        [AIInvokable]
        public void Magic_SetSpell(string _spellIDToSet)
        {
            Spell _spellToSet = SpellsDatabase.GetSpell(_spellIDToSet);

            if (_spellToSet != null)
                spellsKnowledge.spellInUse = _spellToSet;
        }


        [AIInvokable]
        public void Magic_AddSpellToKnowledge(string _spellIDToAdd)
        {
            Spell _spellToAdd = SpellsDatabase.GetSpell(_spellIDToAdd);

            if (_spellToAdd != null)
                spellsKnowledge.Spells.Add(_spellToAdd);
        }
        #endregion
    }
}