using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

public class AIMeleeCombatSystemBrain : MonoBehaviour
{
    [Header ("Main Settings")]
    [Space]

    public bool combatSystemEnabled = true;

    public bool makeFullCombos;
    public bool useWaitTimeBetweenFullCombos;
    public float minRandomTimeBetweenFullCombos;
    public float maxRandomTimeBetweenFullCombos;

    public bool keepWeaponsIfNotTargetsToAttack;

    [Space]
    [Header ("Attack Enabled Settings")]
    [Space]

    public bool attackEnabled;

    [Space]
    [Header ("Attack Settings")]
    [Space]

    public bool useRandomAttack;
    public bool useAlwaysSameAttackType;
    public string sameAttackTypeName;
    public bool alternateAttackTypes;

    [Space]

    public bool checkToForceAttackIfNotUsedLongTimeAgo;

    public float maxWaitTimeToForceAttackIfNotUsedLongTimeAgo = 10;

    [Space]
    [Header ("Random Time Attack Settings")]
    [Space]

    public bool useRandomTimeBetweenAttacks;
    public float minRandomTimeBetweenAttacks;
    public float maxRandomTimeBetweenAttacks;

    public float minTimeBetweenAttacks;

    [Space]
    [Header ("Attack Types Settings")]
    [Space]

    public List<string> meleeAttackTypes = new List<string> ();

    public List<int> meleeAttackTypesAmount = new List<int> ();

    [Space]
    [Header ("Drop Weapon Settings")]
    [Space]

    public bool canDropWeaponExternallyEnabled = true;

    public bool drawRandomWeaponOnWeaponDrop;

    [Space]
    [Header ("Block Attack Settings")]
    [Space]

    public bool blockEnabled;

    public Vector2 randomBlockWaitTime;
    public Vector2 randomBlockDuration;

    [Space]
    [Header ("Roll/Dodge Settings")]
    [Space]

    public bool rollEnabled;

    public Vector2 randomRollWaitTime;

    public float minWaitTimeAfterRollActive = 1.3f;

    public List<Vector2> rollMovementDirectionList = new List<Vector2> ();

    [Space]
    [Header ("Random Walk Settings")]
    [Space]

    public bool randomWalkEnabled;

    public Vector2 randomWalkWaitTime;
    public Vector2 randomWalkDuration;
    public Vector2 randomWalkRadius;

    [Space]

    public bool ignoreRandomWalkInFrontDirectionEnabled = true;

    [Space]
    [Header ("Jump To Target Settings")]
    [Space]

    public bool jumpToTargetOnRangeDistance;
    public Vector2 rangeDistanceToJumpToTarget;
    public bool avoidAttackOnAir = true;
    public float minTimeToJumpAgain = 4;
    public bool useJumpProbability;
    [Range (0, 100)] public float jumpProbability;

    [Space]

    public bool setNewJumpForce;
    public float newJumpForce;
    public bool setNewJumpForceMinDistance;
    public float newJumpForceMinDistance;

    [Space]
    [Header ("Melee Weapon At Distance Settings")]
    [Space]

    public float meleeAttackAtDistanceRate;
    public UnityEvent eventToStartAimMeleeWeapon;
    public UnityEvent eventToStopAimMeleeWeapon;

    public UnityEvent eventToMeleeAttackAtDistance;

    public float minWaitTimeToAimMeleeWeaponAfterDraw = 2;

    public bool useMeleeAttackAtDistanceIfTargetCantBeReached;

    [Space]
    [Header ("Other Settings")]
    [Space]

    public bool checkIfAttackInProcessBeforeCallingNextAttack = true;

    public bool changeWaitToActivateAttackEnabled = true;

    public bool activateRandomWalkIfWaitToActivateAttackActive;

    public bool checkInitialWeaponsOnCharacterSpawnEnabled = true;

    public bool useWaitToActivateAttackActiveCounter;

    [Space]

    public bool checkVerticalDistanceToTarget;
    public float maxVerticalDistanceToTarget;

    [Space]
    [Header ("Check Target State Settings")]
    [Space]

    public bool checkCurrentTargetState;

    public bool activateBlockIfTargetAttack;
    [Range (0, 100)] public float probabilityToActiveBlockIfTargetAttack = 100;
    public float reactionTimeToActiveBlockIfTargetAttack;
    public Vector2 randomBlockDurationIfTargetAttack;
    public Vector2 randomWaitTimeToActivateBlockIfTargetAttack;

    public float minTimToCheckToBlockFromAttackAfterFail = 1.8f;

    public float maxTimeToResetBlockFromAttackFail = 5;

    [Space]

    public bool useEventToCancelAttackToActivateAutoBlock;
    public UnityEvent eventToCancelAttackToActivateBlock;

    [Space]

    public bool activateParryCounterOnPerfectBlock;
    public UnityEvent eventToActivateParryCounterOnPerfectBlock;

    [Space]

    public bool useProbablityToActivateParryCounterOnPerfectBlock;
    [Range (0, 100)] public float probablityToActivateParryCounterOnPerfectBlock;

    public bool useDelayToActivateParryCounterOnPerfectBlock;
    public float delayToActivateParryCounterOnPerfectBlock;

    [Space]
    [Header ("Search Weapons On Scene Settings")]
    [Space]

    public bool searchWeaponsPickupsOnLevelIfNoWeaponsAvailable;

    public bool useMaxDistanceToGetPickupWeapon;
    public float maxDistanceToGetPickupWeapon;

    [Space]

    public bool useEventOnNoWeaponToPickFromScene;
    public UnityEvent eventOnNoWeaponToPickFromScene;

    [Space]

    public bool useEventsOnNoWeaponsAvailable;
    public bool useEventsOnNoWeaponsAvailableAfterCheckWeaponsOnScene;
    public UnityEvent eventOnNoWeaponsAvailable;

    [Space]
    [Header ("Steal Weapons From Targets Settings")]
    [Space]

    public bool stealWeaponFromCurrentTarget;

    [Range (0, 100)] public float probabilityToStealWeapon = 0;

    public bool stealWeaponOnlyIfNotPickupsLocated;

    public bool useMaxDistanceToStealWeapon;
    public float maxDistanceToGetStealWeapon;

    [Space]

    public bool useEventOnSteal;
    public UnityEvent eventOnStealWeapon;

    [Space]
    [Header ("Debug")]
    [Space]

    public bool showDebugPrint;

    public bool showAttackDebugPrint;

    public bool showCheckAttackStateDebugPrint;

    [Space]

    public bool weaponEquiped;

    public bool combatSystemActive;

    public bool canDoAttack;

    public bool waitingForAttackActive;
    float currentRandomTimeToAttack;

    public bool waitingForFullComboComplete;
    float currentRandomTimeToFullCombo;

    [Space]

    public bool canUseAttackActive;

    public bool attackStatePaused;

    public bool insideMinDistanceToAttack;

    public int currentActionPriority = 1;

    public bool currentMeleeWeaponAtDistance;

    public bool aimingMeleeWeapon;

    public bool characterHasWeapons;

    public bool waitToActivateAttackActive;

    public int waitToActivateAttackActiveCounter = 0;

    public GameObject currentWeaponToGet;

    [Space]
    [Space]

    public bool walkActive;
    public bool waitingWalkActive;

    public bool blockActive;
    public bool waitingBlockActive;

    public bool waitingRollActive;

    public bool rollPaused;

    public bool currentTargetAssigned;

    public bool behaviorStatesPaused;

    public string currentComboNameSelected;

    public bool searchingWeapon;

    public bool turnBasedCombatActionActive;

    public bool ignoreOtherActionsToForceAttackActive;

    [Space]
    [Header ("Events Settings")]
    [Space]

    public bool useEventsOnCombatActive;
    public UnityEvent eventOnCombatActive;
    public UnityEvent eventOnCombatDeactivate;

    [Space]

    public bool useEventIfTargetCantBeReachedButVisible;
    public UnityEvent eventIfTargetCantBeReachedButVisible;

    public float minWaitTimeIfTargetCantBeReached = 1;

    [Space]

    public eventParameters.eventToCallWithString eventToChangeAttackMode;

    [Space]
    [Header ("Components")]
    [Space]

    public grabbedObjectMeleeAttackSystem mainGrabbedObjectMeleeAttackSystem;
    public dashSystem mainDashSystem;
    public findObjectivesSystem mainFindObjectivesSystem;
    public meleeWeaponsGrabbedManager mainMeleeWeaponsGrabbedManager;

    public AINavMesh mainAINavmeshManager;


    float lastTimeAttack;

    int currentAttackTypeIndex;

    bool weaponInfoStored;

    int currentAttackIndex;

    int currentAttackTypeToAlternateIndex;


    float lastTimeBlockActive;

    float currentBlockWaitTime;

    float currentBlockDuration;

    float lastTimeBlockWaitActive;


    float lastTimeRollActive;

    float lastTimeWaitRollActive;

    float currentRollWaitTime;


    float lastTimeWaitWalkActive;
    float currentWalkTime;
    float lastTimeWalkActive;

    float currentWalkDuration;
    float currentWalkRadius;

    GameObject currentTarget;
    GameObject previousTarget;

    grabbedObjectMeleeAttackSystem targetGrabbedObjectMeleeAttackSystem;

    bool targetCurrentlyAttacking;
    bool targetPreviouslAttacking;

    float lastTimeAttackDetectedOnTarget;

    bool waitingToActivateBlockFromAttack;
    float lastTimeWaitingToActivateBlockFromAttack;

    float currentWaitTimeToActivateBlockIfTargetAttack;

    float lastTimeBlockActiveFromAttack;

    bool rollCoolDownActive;

    float currentPauseAttackStateDuration;
    float lastTimeAttackPauseWithDuration;

    bool checkIfDrawMeleeWeaponActive;

    float randomWaitTime;

    float lastTimeMeleeAttackAtDistance;

    bool checkIfSearchWeapon;

    bool originalRandomWalkEnabled;

    float lastTimeWeaponPicked = 0;

    string currentWeaponNameToPick;

    float lastTimeJump;

    bool eventIfTargetCantBeReachedButVisibleActivated;

    float lastTimeTryingToBlockFromAttackProbabilityFailed;


    void Start ()
    {
        originalRandomWalkEnabled = randomWalkEnabled;
    }


    public void updateAI ()
    {
        if (combatSystemActive) {
            if (!weaponInfoStored) {
                if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
                    meleeAttackTypesAmount = mainGrabbedObjectMeleeAttackSystem.getMeleeAttackTypesAmount ();

                    weaponInfoStored = true;

                    weaponEquiped = true;

                    if (showDebugPrint) {
                        print ("obtaining melee weapon attacks type");
                    }
                }
            }

            if (walkActive) {
                if (Time.time > lastTimeWalkActive + 1) {
                    if (Time.time > lastTimeWalkActive + currentWalkDuration ||
                        mainFindObjectivesSystem.getRemainingPathDistanceToTarget () < 0.5f ||
                        mainFindObjectivesSystem.getCurrentDistanceToTarget () < 0.5f) {
                        resetRandomWalkState ();
                    }
                }
            }

            if (searchingWeapon) {
                bool weaponReached = false;

                if (currentWeaponToGet != null) {
                    if (GKC_Utils.distance (mainAINavmeshManager.transform.position, currentWeaponToGet.transform.position) < 1) {
                        meleeWeaponPickup currentWeaponPickup = currentWeaponToGet.GetComponent<meleeWeaponPickup> ();

                        if (currentWeaponPickup != null) {
                            simpleActionButton currentSimpleActionButton = currentWeaponToGet.GetComponentInChildren<simpleActionButton> ();

                            if (currentSimpleActionButton != null) {
                                mainFindObjectivesSystem.takeObject (currentSimpleActionButton.gameObject);
                            }

                            weaponReached = true;
                        } else {
                            grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem =
                                currentWeaponToGet.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();

                            if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
                                GKC_Utils.grabPhysicalObjectExternally (mainFindObjectivesSystem.gameObject, currentWeaponToGet);

                                weaponReached = true;
                            }
                        }
                    }
                } else {
                    weaponReached = true;
                }

                if (weaponReached) {
                    characterHasWeapons = mainGrabbedObjectMeleeAttackSystem.getCurrentNumberOfWeaponsAvailable () > 0;

                    mainFindObjectivesSystem.setSearchigWeaponState (false);

                    searchingWeapon = false;

                    checkIfSearchWeapon = false;

                    currentWeaponToGet = null;

                    mainFindObjectivesSystem.setIgnoreVisionRangeActiveState (true);

                    mainFindObjectivesSystem.resetAITargets ();

                    mainFindObjectivesSystem.setIgnoreVisionRangeActiveState (false);

                    mainGrabbedObjectMeleeAttackSystem.repairObjectFully (currentWeaponNameToPick);

                    lastTimeWeaponPicked = Time.time;

                    if (showDebugPrint) {
                        print ("Weapon picked, resuming state on AI");
                    }
                }
            }

            if (!turnBasedCombatActionActive) {
                if (checkCurrentTargetState) {
                    if (!currentTargetAssigned || currentTarget != previousTarget) {
                        currentTarget = mainFindObjectivesSystem.getCurrentTargetToAttack ();

                        if (currentTarget != null) {
                            previousTarget = currentTarget;

                            playerComponentsManager currentPlayerComponentsManager = currentTarget.GetComponent<playerComponentsManager> ();

                            if (currentPlayerComponentsManager != null) {
                                targetGrabbedObjectMeleeAttackSystem = currentPlayerComponentsManager.getGrabbedObjectMeleeAttackSystem ();

                                currentTargetAssigned = true;
                            }

                        } else {
                            currentTargetAssigned = false;
                            previousTarget = null;
                        }
                    }

                    if (currentTargetAssigned) {
                        targetCurrentlyAttacking = targetGrabbedObjectMeleeAttackSystem.isAttackInProcess ();

                        if (activateBlockIfTargetAttack) {
                            //wait to check if block from attack made by target until the target attack stops
                            if (lastTimeTryingToBlockFromAttackProbabilityFailed != 0) {
                                if (targetCurrentlyAttacking && targetPreviouslAttacking) {
                                    lastTimeTryingToBlockFromAttackProbabilityFailed = Time.time;
                                }

                                if (!targetPreviouslAttacking) {
                                    lastTimeTryingToBlockFromAttackProbabilityFailed = 0;

                                    if (showDebugPrint) {
                                        print ("can block from attack again after a failed block");
                                    }
                                }

                                if (Time.time > lastTimeAttackDetectedOnTarget + maxTimeToResetBlockFromAttackFail) {
                                    lastTimeTryingToBlockFromAttackProbabilityFailed = 0;
                                }
                            }

                            if (targetCurrentlyAttacking != targetPreviouslAttacking) {
                                targetPreviouslAttacking = targetCurrentlyAttacking;

                                lastTimeAttackDetectedOnTarget = Time.time;
                            }

                            //wait x time to allow to block again
                            if (currentWaitTimeToActivateBlockIfTargetAttack > 0) {
                                if (Time.time > lastTimeBlockActiveFromAttack + currentWaitTimeToActivateBlockIfTargetAttack &&
                                    Time.time > lastTimeBlockActive + currentBlockDuration) {
                                    waitingToActivateBlockFromAttack = false;

                                    currentWaitTimeToActivateBlockIfTargetAttack = 0;

                                    if (showDebugPrint) {
                                        print ("can block again");
                                    }

                                    lastTimeWaitingToActivateBlockFromAttack = 0;
                                }
                            }

                            //if the current target is attacking, then
                            if (targetCurrentlyAttacking) {
                                bool canCheckForBlockFromAttackProbabilityResult = false;

                                //check if a failed block was made recently, to avoid to block again
                                if (lastTimeTryingToBlockFromAttackProbabilityFailed == 0 ||
                                    (Time.time > lastTimeTryingToBlockFromAttackProbabilityFailed + minTimToCheckToBlockFromAttackAfterFail)) {
                                    if (currentWaitTimeToActivateBlockIfTargetAttack == 0 && lastTimeWaitingToActivateBlockFromAttack == 0) {

                                        canCheckForBlockFromAttackProbabilityResult = true;
                                    }
                                }

                                //if there is no block fail or it can be activated, check for the probability
                                if (canCheckForBlockFromAttackProbabilityResult) {
                                    float probablityToActivateBlock = Random.Range (0, 100);

                                    if (probabilityToActiveBlockIfTargetAttack >= probablityToActivateBlock) {
                                        waitingToActivateBlockFromAttack = true;
                                        lastTimeWaitingToActivateBlockFromAttack = Time.time;

                                        lastTimeBlockActiveFromAttack = 0;

                                        lastTimeTryingToBlockFromAttackProbabilityFailed = 0;
                                    } else {
                                        lastTimeTryingToBlockFromAttackProbabilityFailed = Time.time;
                                    }

                                    if (showDebugPrint) {
                                        print ("target attacking, probability to block is " + probablityToActivateBlock);
                                    }
                                }
                            }

                            if (blockActive) {
                                if (waitingToActivateBlockFromAttack) {
                                    currentWaitTimeToActivateBlockIfTargetAttack = 0;

                                    lastTimeWaitingToActivateBlockFromAttack = 0;

                                    waitingToActivateBlockFromAttack = false;
                                }
                            }

                            //if the block can be done, wait for x time to activate it
                            if (waitingToActivateBlockFromAttack) {
                                if (Time.time > reactionTimeToActiveBlockIfTargetAttack + lastTimeWaitingToActivateBlockFromAttack) {
                                    if (showDebugPrint) {
                                        print ("check to activate block");
                                    }

                                    bool canActivateBlock = true;

                                    if (rollEnabled) {
                                        if (Time.time < lastTimeRollActive + 1) {
                                            canActivateBlock = false;

                                            if (showDebugPrint) {
                                                print ("1");
                                            }
                                        }
                                    }

                                    if (lastTimeAttack > 0 && Time.time < lastTimeAttack + 0.2f) {
                                        if (useEventToCancelAttackToActivateAutoBlock) {
                                            if (showDebugPrint) {
                                                print ("cancel attack to activate auto block");
                                            }

                                            eventToCancelAttackToActivateBlock.Invoke ();
                                        } else {
                                            canActivateBlock = false;

                                            if (showDebugPrint) {
                                                print ("2");
                                            }
                                        }
                                    }

                                    if (!targetCurrentlyAttacking) {
                                        canActivateBlock = false;

                                        if (showDebugPrint) {
                                            print ("3");
                                        }
                                    }

                                    if (!insideMinDistanceToAttack) {
                                        if (mainFindObjectivesSystem.getDistanceToTarget () > 4) {
                                            canActivateBlock = false;

                                            if (showDebugPrint) {
                                                print ("4");
                                            }
                                        }
                                    }

                                    if (canActivateBlock) {
                                        if (showDebugPrint) {
                                            print ("block can be activated");
                                        }

                                        if (mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ()) {
                                            if (useEventToCancelAttackToActivateAutoBlock) {
                                                if (showDebugPrint) {
                                                    print ("cancel attack to activate auto block");
                                                }

                                                eventToCancelAttackToActivateBlock.Invoke ();
                                            }
                                        }

                                        resetStates ();

                                        currentBlockDuration = Random.Range (randomBlockDurationIfTargetAttack.x, randomBlockDurationIfTargetAttack.y);

                                        blockActive = true;

                                        mainGrabbedObjectMeleeAttackSystem.inputActivateBlock ();

                                        lastTimeBlockActiveFromAttack = Time.time;

                                        lastTimeBlockActive = Time.time;

                                        waitingBlockActive = true;

                                        currentWaitTimeToActivateBlockIfTargetAttack = Random.Range (randomWaitTimeToActivateBlockIfTargetAttack.x, randomWaitTimeToActivateBlockIfTargetAttack.y);
                                    } else {
                                        if (showDebugPrint) {
                                            print ("block can't be activated");
                                        }

                                        currentWaitTimeToActivateBlockIfTargetAttack = 0;

                                        lastTimeWaitingToActivateBlockFromAttack = 0;
                                    }

                                    waitingToActivateBlockFromAttack = false;
                                }
                            }

                            if (!blockEnabled && blockActive) {
                                updateBlockState ();
                            }
                        }

                        if (targetGrabbedObjectMeleeAttackSystem.isBlockActive ()) {

                        }
                    }
                }

                if (!insideMinDistanceToAttack) {
                    if (!currentMeleeWeaponAtDistance) {
                        if (mainFindObjectivesSystem.isOnSpotted ()) {
                            if (!mainFindObjectivesSystem.getCanReachCurrentTargetValue ()) {
                                bool checkIfTargetVisible = mainFindObjectivesSystem.checkIfTargetVisible (0);

                                if (checkIfTargetVisible) {
                                    if (lastTimeTargetNotReachable == 0) {
                                        lastTimeTargetNotReachable = Time.time;
                                    }

                                    if (Time.time > lastTimeTargetNotReachable + minWaitTimeIfTargetCantBeReached) {
                                        if (showDebugPrint) {
                                            print ("target is visible but can't be reached");
                                        }

                                        bool checkEventOnTargetCantBeReachedResult = false;

                                        if (useMeleeAttackAtDistanceIfTargetCantBeReached) {
                                            if (mainGrabbedObjectMeleeAttackSystem.mainMeleeWeaponsGrabbedManager.isThereAnyBowMeleeWeaponTypeAvailable ()) {
                                                mainGrabbedObjectMeleeAttackSystem.mainMeleeWeaponsGrabbedManager.selectAndDrawFirstBowMeleeWeaponTypeAvailable ();
                                            } else {
                                                checkEventOnTargetCantBeReachedResult = true;
                                            }
                                        }

                                        if (checkEventOnTargetCantBeReachedResult) {
                                            if (useEventIfTargetCantBeReachedButVisible) {
                                                if (!eventIfTargetCantBeReachedButVisibleActivated) {
                                                    eventIfTargetCantBeReachedButVisible.Invoke ();

                                                    eventIfTargetCantBeReachedButVisibleActivated = true;
                                                }
                                            }
                                        }
                                    }
                                }
                            } else {
                                lastTimeTargetNotReachable = 0;
                            }
                        }
                    }
                }
            }

            if (jumpToTargetOnRangeDistance) {
                checkJumpState ();
            }
        }
    }

    float lastTimeTargetNotReachable = 0;

    void checkJumpState ()
    {
        if (mainFindObjectivesSystem.isActionActive ()) {
            return;
        }

        if (!insideMinDistanceToAttack &&
            !searchingWeapon &&
            mainFindObjectivesSystem.isAIOnGround () &&
            mainFindObjectivesSystem.isOnSpotted () &&
            (lastTimeJump == 0 || Time.time > minTimeToJumpAgain + lastTimeJump)) {

            float distanceToTarget = mainFindObjectivesSystem.getDistanceToTarget ();

            if (distanceToTarget > rangeDistanceToJumpToTarget.x && distanceToTarget < rangeDistanceToJumpToTarget.y) {
                bool activateJumpResult = true;

                if (useJumpProbability) {
                    float currentProbability = Random.Range (0, 100);

                    if (currentProbability > jumpProbability) {
                        useJumpProbability = false;
                    }
                }

                if (activateJumpResult) {
                    bool setNewJumpForceResult = setNewJumpForce;

                    if (setNewJumpForceMinDistance) {
                        if (distanceToTarget < newJumpForceMinDistance) {
                            setNewJumpForceResult = false;
                        }
                    }

                    if (setNewJumpForceResult) {
                        mainFindObjectivesSystem.setJumpPower (newJumpForce);

                        mainFindObjectivesSystem.activateJumpExternally (0);
                    } else {
                        mainFindObjectivesSystem.setOriginalJumpPower ();

                        mainFindObjectivesSystem.activateJumpExternally (distanceToTarget);
                    }
                }

                lastTimeJump = Time.time;
            }
        }
    }

    public void resetRandomWalkState ()
    {
        mainFindObjectivesSystem.setRandomWalkPositionState (0);

        waitingWalkActive = false;

        walkActive = false;

        lastTimeWalkActive = Time.time;
    }

    public void resetBlockState ()
    {
        waitingBlockActive = false;

        if (blockActive) {
            mainGrabbedObjectMeleeAttackSystem.inputDeactivateBlock ();
        }

        blockActive = false;

        lastTimeBlockActive = Time.time;
    }

    public void resetRollState ()
    {
        waitingRollActive = false;

        lastTimeRollActive = Time.time;
    }

    public void dropWeapon ()
    {
        if (!combatSystemActive) {
            return;
        }

        if (!weaponEquiped) {
            return;
        }

        if (mainFindObjectivesSystem.isAIPaused ()) {
            return;
        }

        if (behaviorStatesPaused) {
            return;
        }

        if (turnBasedCombatActionActive) {
            return;
        }

        if (!canDropWeaponExternallyEnabled) {
            return;
        }

        if (mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ()) {
            return;
        }

        if (mainGrabbedObjectMeleeAttackSystem.isActionActive ()) {
            return;
        }


        string previousWeaponName = mainGrabbedObjectMeleeAttackSystem.getCurrentMeleeWeaponName ();

        if (mainGrabbedObjectMeleeAttackSystem.dropMeleeWeaponsExternally ()) {

            if (aimingMeleeWeapon) {
                setAimMeleeWeaponState (false);
            }

            resetAttackState ();

            updateWeaponsAvailableState ();

            weaponEquiped = characterHasWeapons;

            weaponInfoStored = false;

            if (characterHasWeapons) {
                if (drawRandomWeaponOnWeaponDrop) {
                    mainGrabbedObjectMeleeAttackSystem.drawRandomWeaponFromPrefabList (previousWeaponName);
                } else {
                    mainGrabbedObjectMeleeAttackSystem.drawNextWeaponAvailable ();
                }
            }
        }
    }

    public void resetAttackState ()
    {

    }

    public void resetStates ()
    {
        resetRandomWalkState ();

        resetBlockState ();

        resetRollState ();

        resetAttackState ();

        currentActionPriority = Random.Range (1, 3);
    }

    public void checkIfResetStatsOnRandomWalk ()
    {
        if (walkActive) {
            resetStates ();
        }
    }

    public void checkBlockState ()
    {
        if (ignoreOtherActionsToForceAttackActive) {
            return;
        }

        if (blockEnabled) {
            updateBlockState ();
        }
    }

    public void updateBlockState ()
    {
        if (rollEnabled) {
            if (Time.time < lastTimeRollActive + 1) {
                return;
            }
        }

        if (walkActive) {
            return;
        }

        //		print (mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ());

        if (mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ()) {
            return;
        }

        if (waitingRollActive) {
            return;
        }

        if (!insideMinDistanceToAttack) {
            if (blockActive) {
                resetBlockState ();

                lastTimeBlockActive = 0;
            }

            return;
        }

        if (waitingBlockActive) {
            if (blockActive) {
                if (Time.time > lastTimeBlockActive + currentBlockDuration) {
                    resetBlockState ();
                }
            } else {
                if (Time.time > lastTimeBlockWaitActive + currentBlockWaitTime) {
                    blockActive = true;

                    mainGrabbedObjectMeleeAttackSystem.inputActivateBlock ();

                    lastTimeBlockActive = Time.time;
                }
            }
        } else {
            if (Time.time > lastTimeBlockActive + randomWaitTime && currentActionPriority == 1) {
                currentBlockWaitTime = Random.Range (randomBlockWaitTime.x, randomBlockWaitTime.y);

                currentBlockDuration = Random.Range (randomBlockDuration.x, randomBlockDuration.y);

                lastTimeBlockWaitActive = Time.time;

                waitingBlockActive = true;

                blockActive = false;

                randomWaitTime = Random.Range (0.1f, 0.5f);

                currentActionPriority = Random.Range (1, 3);
            }
        }
    }

    public void checkRollState ()
    {
        if (ignoreOtherActionsToForceAttackActive) {
            return;
        }

        if (rollEnabled) {

            if (blockActive) {
                return;
            }

            if (walkActive) {
                return;
            }

            if (mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ()) {
                return;
            }

            if (waitingBlockActive) {
                return;
            }

            if (!insideMinDistanceToAttack) {
                resetRollState ();

                lastTimeRollActive = 0;

                return;
            }

            if (waitingRollActive) {
                if (Time.time > lastTimeWaitRollActive + currentRollWaitTime) {

                    int randomRollMovementDirection = Random.Range (0, rollMovementDirectionList.Count);

                    Vector3 dashDirection = rollMovementDirectionList [randomRollMovementDirection];

                    if (mainFindObjectivesSystem.isLocked2_5dModeActive ()) {
                        randomRollMovementDirection = Random.Range (0, 2);

                        if (randomRollMovementDirection == 0) {
                            dashDirection = Vector3.forward;
                        } else {
                            dashDirection = -Vector3.forward;
                        }
                    }

                    mainDashSystem.activateDashStateWithCustomDirection (dashDirection);

                    resetRollState ();
                }
            } else {
                if (Time.time > lastTimeRollActive + randomWaitTime && currentActionPriority == 2) {
                    currentRollWaitTime = Random.Range (randomRollWaitTime.x, randomRollWaitTime.y);

                    lastTimeWaitRollActive = Time.time;

                    waitingRollActive = true;

                    randomWaitTime = Random.Range (0.1f, 0.5f);

                    currentActionPriority = Random.Range (1, 3);
                }
            }
        }
    }

    public void checkWalkState ()
    {
        if (ignoreOtherActionsToForceAttackActive) {
            return;
        }

        if (randomWalkEnabled) {

            if (blockActive) {
                return;
            }

            if (mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ()) {
                return;
            }

            rollCoolDownActive = Time.time < lastTimeRollActive + 0.7f;

            if (rollCoolDownActive) {
                return;
            }

            if (waitingWalkActive) {
                if (!walkActive) {

                    if (Time.time > lastTimeWaitWalkActive + currentWalkTime) {
                        mainFindObjectivesSystem.setignoreRandomWalkInFrontDirectionEnabledState (ignoreRandomWalkInFrontDirectionEnabled);

                        mainFindObjectivesSystem.setRandomWalkPositionState (currentWalkRadius);

                        mainFindObjectivesSystem.setStrafeModeActive (true);

                        lastTimeWalkActive = Time.time;

                        walkActive = true;
                    }
                }
            } else {
                currentWalkTime = Random.Range (randomWalkWaitTime.x, randomWalkWaitTime.y);

                lastTimeWaitWalkActive = Time.time;

                waitingWalkActive = true;

                currentWalkDuration = Random.Range (randomWalkDuration.x, randomWalkDuration.y);

                currentWalkRadius = Random.Range (randomWalkRadius.x, randomWalkRadius.y);

                walkActive = false;
            }
        }
    }

    public void updateInsideMinDistance (bool newInsideMinDistanceToAttack)
    {
        insideMinDistanceToAttack = newInsideMinDistanceToAttack;

        if (insideMinDistanceToAttack) {
            if (checkIfDrawMeleeWeaponActive) {
                if (!mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
                    mainGrabbedObjectMeleeAttackSystem.drawOrKeepMeleeWeapon ();

                    weaponEquiped = true;

                    weaponInfoStored = false;
                }

                checkIfDrawMeleeWeaponActive = false;
            }
        } else {
            if (currentMeleeWeaponAtDistance) {
                if (aimingMeleeWeapon && !mainFindObjectivesSystem.isAttackTargetDirectlyActive ()) {
                    setAimMeleeWeaponState (false);
                }
            }
        }
    }

    public void updateMainMeleeBehavior ()
    {
        if (!combatSystemActive) {
            return;
        }

        if (behaviorStatesPaused) {
            return;
        }

        if (mainFindObjectivesSystem.isAIPaused ()) {
            return;
        }

        if (turnBasedCombatActionActive) {
            return;
        }

        if (checkToForceAttackIfNotUsedLongTimeAgo) {
            if (lastTimeAttack > 0 && !ignoreOtherActionsToForceAttackActive) {
                if (Time.time > maxWaitTimeToForceAttackIfNotUsedLongTimeAgo + lastTimeAttack) {
                    ignoreOtherActionsToForceAttackActive = true;

                    resetRandomWalkState ();

                    resetRollState ();

                    resetBlockState ();

                    if (showDebugPrint) {
                        print ("too much time since last attack active, reseting other states" +
                        " to force an attack");
                    }
                }
            }
        }

        checkWalkState ();

        if (walkActive) {
            return;
        } else {
            if (randomWalkEnabled) {
                if (lastTimeWalkActive != 0) {
                    if (Time.time < lastTimeWalkActive + 0.2f) {
                        return;
                    }
                }
            }
        }

        checkBlockState ();

        if (blockEnabled) {
            if (rollEnabled) {
                if (Time.time < lastTimeRollActive + 0.3f) {
                    return;
                }
            }
        }

        if (blockActive) {
            return;
        }

        if (blockEnabled) {
            if (rollEnabled) {
                if (Time.time < lastTimeBlockActive + 0.3f) {
                    return;
                }
            }
        }

        checkRollState ();

        if (rollEnabled) {
            if (Time.time < lastTimeRollActive + minWaitTimeAfterRollActive) {
                return;
            }
        }

        if (!canUseAttackActive) {
            if (currentMeleeWeaponAtDistance) {
                if (!mainFindObjectivesSystem.isAttackTargetDirectlyActive ()) {
                    return;
                }
            } else {
                return;
            }
        }

        if (!insideMinDistanceToAttack) {
            if (currentMeleeWeaponAtDistance) {
                if (!mainFindObjectivesSystem.isAttackTargetDirectlyActive ()) {
                    return;
                }
            } else {
                return;
            }
        }

        if (checkVerticalDistanceToTarget && !currentMeleeWeaponAtDistance) {
            float verticalDistanceToCurrentEnemyPosition = mainFindObjectivesSystem.getVerticalDistanceToCurrentEnemyPosition ();

            if (verticalDistanceToCurrentEnemyPosition != 0) {
                if (verticalDistanceToCurrentEnemyPosition > maxVerticalDistanceToTarget) {
                    return;
                }
            }
        }

        if (currentPauseAttackStateDuration > 0) {
            if (Time.time > currentPauseAttackStateDuration + lastTimeAttackPauseWithDuration) {

                attackStatePaused = false;

                currentPauseAttackStateDuration = 0;
            } else {
                return;
            }
        }

        if (jumpToTargetOnRangeDistance && avoidAttackOnAir) {
            if (!mainFindObjectivesSystem.isAIOnGround ()) {
                return;
            }
        }

        if (characterHasWeapons) {

            if (waitToActivateAttackActive) {
                if (activateRandomWalkIfWaitToActivateAttackActive) {
                    if (!walkActive) {
                        currentWalkTime = Random.Range (randomWalkWaitTime.x, randomWalkWaitTime.y);

                        currentWalkDuration = Random.Range (randomWalkDuration.x, randomWalkDuration.y);

                        currentWalkRadius = Random.Range (randomWalkRadius.x, randomWalkRadius.y);

                        mainFindObjectivesSystem.setignoreRandomWalkInFrontDirectionEnabledState (ignoreRandomWalkInFrontDirectionEnabled);

                        mainFindObjectivesSystem.setRandomWalkPositionState (currentWalkRadius);

                        mainFindObjectivesSystem.setStrafeModeActive (true);

                        lastTimeWalkActive = Time.time;

                        walkActive = true;
                    }
                }

                if (showCheckAttackStateDebugPrint) {
                    print ("waitToActivateAttackActive");
                }

                return;
            }

            checkAttackState ();
        } else {
            checkNoMeleeWeaponsAvailableState ();
        }
    }

    public void checkNoMeleeWeaponsAvailableState ()
    {
        if (!combatSystemActive) {
            return;
        }

        if (!searchingWeapon && !checkIfSearchWeapon) {
            if (lastTimeWeaponPicked > 0) {
                if (Time.time < lastTimeWeaponPicked + 0.75f) {
                    if (showDebugPrint) {
                        print ("NO; WAITING TO WEAPON PICKED\n\n");
                    }

                    return;
                } else {
                    lastTimeWeaponPicked = 0;
                }
            }

            characterHasWeapons = mainGrabbedObjectMeleeAttackSystem.getCurrentNumberOfWeaponsAvailable () > 0;

            //seach for the closest weapon
            if (!characterHasWeapons) {

                if (!stealWeaponOnlyIfNotPickupsLocated) {
                    if (checkIfStealWeaponFromCurrentTarget ()) {
                        return;
                    }
                }

                if (!useEventsOnNoWeaponsAvailableAfterCheckWeaponsOnScene) {
                    checkEventOnNoWeaponsAvailable ();
                }

                bool weaponFound = false;

                if (searchWeaponsPickupsOnLevelIfNoWeaponsAvailable) {
                    checkIfSearchWeapon = true;

                    if (showDebugPrint) {
                        print ("checking if weapons found on scene");
                    }

                    meleeWeaponPickup [] weaponPickupList = FindObjectsOfType (typeof (meleeWeaponPickup)) as meleeWeaponPickup [];

                    List<GameObject> weaponObjectsDetected = new List<GameObject> ();

                    if (weaponPickupList.Length > 0) {
                        for (int i = 0; i < weaponPickupList.Length; i++) {
                            bool checkObjectResult = true;

                            if (useMaxDistanceToGetPickupWeapon) {
                                float distance = GKC_Utils.distance (weaponPickupList [i].transform.position, mainAINavmeshManager.transform.position);

                                if (distance > maxDistanceToGetPickupWeapon) {
                                    checkObjectResult = false;
                                }
                            }

                            if (checkObjectResult) {
                                if (weaponPickupList [i].gameObject.activeSelf && weaponPickupList [i].gameObject.activeInHierarchy) {
                                    weaponObjectsDetected.Add (weaponPickupList [i].gameObject);
                                }
                            }
                        }
                    }

                    if (weaponObjectsDetected.Count == 0) {
                        if (showDebugPrint) {
                            print ("no pickups detected, searching for physical objects");
                        }

                        grabPhysicalObjectMeleeAttackSystem [] grabPhysicalObjectMeleeAttackSystemList = FindObjectsOfType (typeof (grabPhysicalObjectMeleeAttackSystem)) as grabPhysicalObjectMeleeAttackSystem [];

                        for (int i = 0; i < grabPhysicalObjectMeleeAttackSystemList.Length; i++) {
                            bool checkObjectResult = true;

                            if (useMaxDistanceToGetPickupWeapon) {
                                float distance = GKC_Utils.distance (grabPhysicalObjectMeleeAttackSystemList [i].transform.position, mainAINavmeshManager.transform.position);

                                if (distance > maxDistanceToGetPickupWeapon) {
                                    checkObjectResult = false;
                                }
                            }

                            if (checkObjectResult) {
                                if (!grabPhysicalObjectMeleeAttackSystemList [i].isWeaponCarriedByCharacter () &&
                                    grabPhysicalObjectMeleeAttackSystemList [i].gameObject.activeSelf &&
                                    grabPhysicalObjectMeleeAttackSystemList [i].gameObject.activeInHierarchy) {

                                    float lastTimeWeaponDropped = grabPhysicalObjectMeleeAttackSystemList [i].getLastTimeWeaponDropped ();

                                    if (lastTimeWeaponDropped == 0 || Time.time > lastTimeWeaponDropped + 1) {
                                        weaponObjectsDetected.Add (grabPhysicalObjectMeleeAttackSystemList [i].gameObject);
                                    }
                                }
                            }
                        }
                    }

                    if (weaponObjectsDetected.Count > 0) {
                        if (showDebugPrint) {
                            print ("weapons found on scene");
                        }

                        string currentWeaponName = "";

                        for (int i = 0; i < weaponObjectsDetected.Count; i++) {
                            if (!weaponFound) {
                                currentWeaponName = "";

                                meleeWeaponPickup currentWeaponPickup = weaponObjectsDetected [i].GetComponent<meleeWeaponPickup> ();

                                if (currentWeaponPickup != null) {
                                    currentWeaponName = currentWeaponPickup.weaponName;
                                } else {
                                    grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem =
                                        weaponObjectsDetected [i].GetComponent<grabPhysicalObjectMeleeAttackSystem> ();

                                    if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
                                        currentWeaponName = currentGrabPhysicalObjectMeleeAttackSystem.getWeaponName ();
                                    }
                                }

                                currentWeaponNameToPick = currentWeaponName;

                                if (showDebugPrint) {
                                    print ("checking if weapon with name " + currentWeaponName + " can be used");
                                }

                                if (mainGrabbedObjectMeleeAttackSystem.checkIfCanUseMeleeWeaponPrefabByName (currentWeaponName)) {
                                    if (mainAINavmeshManager.updateCurrentNavMeshPath (weaponObjectsDetected [i].transform.position)) {
                                        mainFindObjectivesSystem.setSearchigWeaponState (true);

                                        currentWeaponToGet = weaponObjectsDetected [i];

                                        mainAINavmeshManager.setTarget (weaponObjectsDetected [i].transform);

                                        mainAINavmeshManager.setTargetType (false, true);

                                        weaponFound = true;

                                        mainAINavmeshManager.lookAtTaget (false);

                                        if (showDebugPrint) {
                                            print ("weapon to use located " + currentWeaponName + ", setting searching weapon state on AI");
                                        }

                                        searchingWeapon = true;
                                    } else {
                                        if (showDebugPrint) {
                                            print ("weapon to use located " + currentWeaponName + ", but can't be reached");
                                        }
                                    }
                                } else {
                                    if (showDebugPrint) {
                                        print ("weapon " + currentWeaponName + " can't be used");
                                    }
                                }
                            }
                        }
                    } else {
                        if (showDebugPrint) {
                            print ("no pickups or physical objects found");
                        }
                    }

                    if (!weaponFound) {
                        if (stealWeaponOnlyIfNotPickupsLocated) {
                            if (checkIfStealWeaponFromCurrentTarget ()) {
                                return;
                            }
                        }

                        if (useEventOnNoWeaponToPickFromScene) {
                            eventOnNoWeaponToPickFromScene.Invoke ();
                        }
                    }
                }

                if (!weaponFound) {
                    if (stealWeaponOnlyIfNotPickupsLocated) {
                        if (checkIfStealWeaponFromCurrentTarget ()) {
                            return;
                        }
                    }

                    if (showDebugPrint) {
                        print ("no weapons located or out of range, activating no weapons detected mode");
                    }

                    if (useEventsOnNoWeaponsAvailableAfterCheckWeaponsOnScene) {
                        checkEventOnNoWeaponsAvailable ();
                    }
                }

                //it will need to check if the weapon can be seen by the character and if it is can be reached by the navmesh
            }

            mainFindObjectivesSystem.setLookingAtTargetPositionState (false);
        }
    }

    void checkEventOnNoWeaponsAvailable ()
    {
        if (useEventsOnNoWeaponsAvailable) {
            eventOnNoWeaponsAvailable.Invoke ();
        }
    }

    bool checkIfStealWeaponFromCurrentTarget ()
    {
        if (stealWeaponFromCurrentTarget) {
            if (showDebugPrint) {
                print ("Checking probability to steal weapon");
            }

            float currentProbability = Random.Range (0, 100);

            if (currentProbability < probabilityToStealWeapon) {
                if (showDebugPrint) {
                    print ("AI can check if steal object, checking target state");
                }

                GameObject currentTarget = mainFindObjectivesSystem.getCurrentTargetToAttack ();

                if (currentTarget != null) {
                    if (useMaxDistanceToStealWeapon) {
                        float distance = GKC_Utils.distance (currentTarget.transform.position, mainAINavmeshManager.transform.position);

                        if (distance > maxDistanceToGetStealWeapon) {
                            return false;
                        }
                    }

                    playerComponentsManager currentPlayerComponentsManager = currentTarget.GetComponent<playerComponentsManager> ();

                    if (currentPlayerComponentsManager != null) {
                        playerController currentPlayerController = currentPlayerComponentsManager.getPlayerController ();

                        if (currentPlayerController.isPlayerUsingMeleeWeapons ()) {
                            if (showDebugPrint) {
                                print ("target is using melee weapons, checking weapon it self");
                            }

                            grabbedObjectMeleeAttackSystem currentGrabbedObjectMeleeAttackSystem = currentPlayerComponentsManager.getGrabbedObjectMeleeAttackSystem ();

                            if (currentGrabbedObjectMeleeAttackSystem.canWeaponsBeStolenFromCharacter ()) {
                                string currentWeaponName = currentGrabbedObjectMeleeAttackSystem.getCurrentMeleeWeaponName ();

                                if (mainGrabbedObjectMeleeAttackSystem.checkIfCanUseMeleeWeaponPrefabByName (currentWeaponName)) {
                                    if (currentPlayerController.isCharacterUsedByAI ()) {
                                        currentGrabbedObjectMeleeAttackSystem.dropMeleeWeaponsExternallyWithoutResultAndDestroyIt ();
                                    } else {
                                        inventoryManager currentInventoryManager = currentPlayerComponentsManager.getInventoryManager ();

                                        if (currentInventoryManager != null) {
                                            currentInventoryManager.removeObjectAmountFromInventoryByName (currentWeaponName, 1);
                                        }
                                    }

                                    mainGrabbedObjectMeleeAttackSystem.mainMeleeWeaponsGrabbedManager.checkMeleeWeaponToUse (currentWeaponName, false);

                                    currentGrabbedObjectMeleeAttackSystem.mainMeleeWeaponsGrabbedManager.checkEventOnWeaponStolen ();

                                    if (showDebugPrint) {
                                        print ("weapon stolen from target");
                                    }

                                    if (useEventOnSteal) {
                                        eventOnStealWeapon.Invoke ();
                                    }

                                    return true;
                                } else {
                                    if (showDebugPrint) {
                                        print ("AI can't use weapon from target");
                                    }
                                }
                            }
                        } else {
                            if (showDebugPrint) {
                                print ("target is not using melee weapons");
                            }
                        }
                    }
                }
            }
        }

        return false;
    }

    public void checkAttackState ()
    {
        if (!attackEnabled) {
            return;
        }

        if (showCheckAttackStateDebugPrint) {
            print ("checkAttackState");
        }

        if (currentMeleeWeaponAtDistance) {
            if (!aimingMeleeWeapon) {
                float lastTimeDrawMeleeWeapon = mainGrabbedObjectMeleeAttackSystem.getLastTimeDrawMeleeWeapon ();

                if (showDebugPrint) {
                    print ("checking to aim melee weapon");
                }

                if (lastTimeDrawMeleeWeapon > -1 && Time.time > lastTimeDrawMeleeWeapon + minWaitTimeToAimMeleeWeaponAfterDraw) {
                    if (showDebugPrint) {
                        print ("AIM AFTER DRAW");
                    }

                    setAimMeleeWeaponState (true);
                }
            }

            if (Time.time > meleeAttackAtDistanceRate + lastTimeMeleeAttackAtDistance) {
                eventToMeleeAttackAtDistance.Invoke ();

                lastTimeMeleeAttackAtDistance = Time.time;
            }


            return;
        }

        if (currentRandomTimeToFullCombo > 0) {
            if (Time.time < currentRandomTimeToFullCombo + lastTimeAttack) {
                return;
            } else {
                currentRandomTimeToFullCombo = 0;
            }
        }

        canDoAttack = false;

        if (useRandomTimeBetweenAttacks) {
            if (!waitingForAttackActive) {
                currentRandomTimeToAttack = Random.Range (minRandomTimeBetweenAttacks, maxRandomTimeBetweenAttacks);

                waitingForAttackActive = true;
            }
        } else {
            currentRandomTimeToAttack = minTimeBetweenAttacks;
        }

        if (Time.time > currentRandomTimeToAttack + lastTimeAttack) {
            canDoAttack = true;
        }

        if (makeFullCombos) {
            if (!waitingForFullComboComplete) {
                waitingForFullComboComplete = true;

                currentAttackTypeIndex = -1;

                if (useAlwaysSameAttackType) {
                    currentAttackTypeIndex = meleeAttackTypes.IndexOf (sameAttackTypeName);
                }

                if (currentAttackTypeIndex == -1) {
                    currentAttackTypeIndex = Random.Range (0, meleeAttackTypes.Count);

                    if (currentAttackTypeIndex >= meleeAttackTypesAmount.Count) {
                        currentAttackTypeIndex = meleeAttackTypesAmount.Count - 1;

                        if (showDebugPrint) {
                            print ("currentAttackTypeIndex out of index on the default melee attack types amount" +
                            " reducing the index to get a proper list element");
                        }
                    }
                }

                currentComboNameSelected = meleeAttackTypes [currentAttackTypeIndex];

                currentAttackIndex = 0;
            }
        }

        if (canDoAttack) {
            if (weaponEquiped) {
                if (!mainGrabbedObjectMeleeAttackSystem.isCarryingObject () && !mainFindObjectivesSystem.isActionActive ()) {
                    mainGrabbedObjectMeleeAttackSystem.drawOrKeepMeleeWeapon ();

                    weaponEquiped = true;

                    weaponInfoStored = false;

                    lastTimeAttack = Time.time;

                    ignoreOtherActionsToForceAttackActive = false;

                    return;
                }
            }

            if (checkIfAttackInProcessBeforeCallingNextAttack) {
                if (!mainGrabbedObjectMeleeAttackSystem.canActivateAttack ()) {
                    if (showAttackDebugPrint) {
                        print ("attack in process, cancelling check of attack");
                    }

                    return;
                }
            }

            if (waitingForFullComboComplete) {
                if (currentAttackIndex >= meleeAttackTypesAmount [currentAttackTypeIndex]) {
                    waitingForFullComboComplete = false;

                    if (useWaitTimeBetweenFullCombos) {
                        currentRandomTimeToFullCombo = Random.Range (minRandomTimeBetweenFullCombos, maxRandomTimeBetweenFullCombos);
                    }
                } else if (!mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ()) {
                    useAttack (currentComboNameSelected);

                    currentAttackIndex++;

                    lastTimeAttack = Time.time;

                    ignoreOtherActionsToForceAttackActive = false;
                }
            } else {
                if (!mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ()) {
                    if (useRandomAttack) {
                        useAttack (meleeAttackTypes [Random.Range (0, meleeAttackTypes.Count)]);

                        lastTimeAttack = Time.time;

                        ignoreOtherActionsToForceAttackActive = false;
                    } else if (useAlwaysSameAttackType) {
                        useAttack (sameAttackTypeName);

                        lastTimeAttack = Time.time;

                        ignoreOtherActionsToForceAttackActive = false;

                    } else if (alternateAttackTypes) {
                        useAttack (meleeAttackTypes [currentAttackTypeToAlternateIndex]);

                        currentAttackTypeToAlternateIndex++;

                        if (currentAttackTypeToAlternateIndex == meleeAttackTypes.Count) {
                            currentAttackTypeToAlternateIndex = 0;
                        }

                        lastTimeAttack = Time.time;

                        ignoreOtherActionsToForceAttackActive = false;
                    }
                }
            }

            if (useRandomTimeBetweenAttacks) {
                waitingForAttackActive = false;
            }
        }
    }

    public void useAttack (string attackType)
    {
        if (showAttackDebugPrint) {
            print ("use attack" + attackType);
        }

        mainGrabbedObjectMeleeAttackSystem.activateGrabbedObjectMeleeAttack (attackType);
    }

    public void updateMainMeleeAttack (bool newCanUseAttackActiveState)
    {
        canUseAttackActive = newCanUseAttackActiveState;
    }

    public void setCombatSystemActiveState (bool state)
    {
        if (!combatSystemEnabled) {
            return;
        }

        combatSystemActive = state;

        if (state) {
            if (mainMeleeWeaponsGrabbedManager == null) {
                mainMeleeWeaponsGrabbedManager = mainGrabbedObjectMeleeAttackSystem.mainMeleeWeaponsGrabbedManager;
            }
        }

        checkEventsOnCombatStateChange (combatSystemActive);

        if (combatSystemActive) {
            currentActionPriority = Random.Range (1, 3);
        }

        eventIfTargetCantBeReachedButVisibleActivated = false;

        lastTimeAttack = 0;

        waitToActivateAttackActive = false;

        waitToActivateAttackActiveCounter = 0;
    }

    void checkEventsOnCombatStateChange (bool state)
    {
        if (useEventsOnCombatActive) {
            if (state) {
                eventOnCombatActive.Invoke ();
            } else {
                eventOnCombatDeactivate.Invoke ();
            }
        }
    }

    public void pauseAttackDuringXTime (float newDuration)
    {
        currentPauseAttackStateDuration = newDuration;

        lastTimeAttackPauseWithDuration = Time.time;

        attackStatePaused = true;

        if (showAttackDebugPrint) {
            print ("Pause attack");
        }
    }

    public void setWaitToActivateAttackActiveState (bool state)
    {
        if (!changeWaitToActivateAttackEnabled) {
            return;
        }

        if (useWaitToActivateAttackActiveCounter) {
            if (state) {
                waitToActivateAttackActiveCounter++;
            } else {
                waitToActivateAttackActiveCounter--;

                if (waitToActivateAttackActiveCounter < 0) {
                    waitToActivateAttackActiveCounter = 0;
                }
            }

            if (waitToActivateAttackActiveCounter > 0) {
                if (waitToActivateAttackActive) {
                    return;
                } else {
                    state = true;
                }
            } else {
                if (!waitToActivateAttackActive) {
                    return;
                } else {
                    state = false;
                }
            }
        }

        waitToActivateAttackActive = state;

        if (showDebugPrint) {
            print ("set waitToActivateAttackActive state " + state);
        }

        if (activateRandomWalkIfWaitToActivateAttackActive) {
            if (state) {
                currentWalkTime = Random.Range (randomWalkWaitTime.x, randomWalkWaitTime.y);

                currentWalkDuration = Random.Range (randomWalkDuration.x, randomWalkDuration.y);

                currentWalkRadius = Random.Range (randomWalkRadius.x, randomWalkRadius.y);

                mainFindObjectivesSystem.setignoreRandomWalkInFrontDirectionEnabledState (ignoreRandomWalkInFrontDirectionEnabled);

                mainFindObjectivesSystem.setRandomWalkPositionState (currentWalkRadius);

                mainFindObjectivesSystem.setStrafeModeActive (true);

                lastTimeWalkActive = Time.time;

                walkActive = true;
            } else {
                if (walkActive) {
                    resetRandomWalkState ();
                }
            }
        }
    }

    public void setUseRandomWalkEnabledState (bool state)
    {
        randomWalkEnabled = state;
    }

    public void setOriginalUseRandomWalkEnabledState ()
    {
        setUseRandomWalkEnabledState (originalRandomWalkEnabled);
    }

    public void resetBehaviorStates ()
    {
        resetStates ();

        waitingForAttackActive = false;

        waitingForFullComboComplete = false;

        currentRandomTimeToFullCombo = 0;

        checkIfDrawMeleeWeaponActive = true;

        if (currentMeleeWeaponAtDistance) {
            setAimMeleeWeaponState (false);
        }

        if (keepWeaponsIfNotTargetsToAttack) {
            setDrawOrHolsterWeaponState (false);
        }

        insideMinDistanceToAttack = false;

        aimingMeleeWeapon = false;
    }

    public void setDrawOrHolsterWeaponState (bool state)
    {
        if (state) {
            if (!mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
                mainGrabbedObjectMeleeAttackSystem.drawOrKeepMeleeWeapon ();

                weaponEquiped = true;

                weaponInfoStored = false;
            }
        } else {
            if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
                mainGrabbedObjectMeleeAttackSystem.drawOrKeepMeleeWeapon ();

                weaponEquiped = false;

                weaponInfoStored = false;
            }
        }
    }

    public void setCurrentMeleeWeaponAtDistanceState (bool state)
    {
        currentMeleeWeaponAtDistance = state;

        if (!currentMeleeWeaponAtDistance) {
            setAimMeleeWeaponState (false);
        }
    }

    void setAimMeleeWeaponState (bool state)
    {
        if (showDebugPrint) {
            print ("setting aim active state " + state);
        }

        if (state) {
            if (!aimingMeleeWeapon) {
                lastTimeMeleeAttackAtDistance = Time.time;

                eventToStartAimMeleeWeapon.Invoke ();

                aimingMeleeWeapon = true;
            }
        } else {
            if (aimingMeleeWeapon) {
                eventToStopAimMeleeWeapon.Invoke ();

                aimingMeleeWeapon = false;
            }
        }
    }

    public void setPauseRollState (bool state)
    {
        rollPaused = state;

        if (rollPaused) {
            resetRollState ();

            lastTimeRollActive = 0;
        }
    }

    public void checkIfDrawMeleeWeaponAfterResumingAI ()
    {
        if (combatSystemActive) {
            if (checkIfDrawMeleeWeaponActive) {
                if (!mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
                    mainGrabbedObjectMeleeAttackSystem.drawOrKeepMeleeWeapon ();

                    weaponEquiped = true;

                    weaponInfoStored = false;
                }

                checkIfDrawMeleeWeaponActive = false;
            }
        }
    }

    public void updateWeaponsAvailableState ()
    {
        characterHasWeapons = mainGrabbedObjectMeleeAttackSystem.getCurrentNumberOfWeaponsAvailable () > 0;
    }

    public void setBehaviorStatesPausedState (bool state)
    {
        behaviorStatesPaused = state;
    }

    public void setSameAttackTypeNameValue (string newValue)
    {
        sameAttackTypeName = newValue;
    }

    public bool isWeaponEquiped ()
    {
        return weaponEquiped;
    }

    public bool isAIBehaviorAttackInProcess ()
    {
        return mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ();
    }

    public void checkIfActivateParryCounterOnPerfectBlock ()
    {
        if (combatSystemActive) {
            if (activateParryCounterOnPerfectBlock) {
                bool activateParryCounterResult = true;

                if (useProbablityToActivateParryCounterOnPerfectBlock) {
                    float probablityToParryCounter = Random.Range (0, 100);

                    if (probablityToActivateParryCounterOnPerfectBlock < probablityToParryCounter) {
                        activateParryCounterResult = false;
                    }
                }

                if (activateParryCounterResult) {
                    if (useDelayToActivateParryCounterOnPerfectBlock) {
                        stopParryCounterOnPerfectBlockWithDelayCoroutine ();

                        parryCounterOnPerfectBlockWithDelayCoroutine = StartCoroutine (activateParryCounterOnPerfectBlockWithDelayCoroutine ());
                    } else {
                        eventToActivateParryCounterOnPerfectBlock.Invoke ();
                    }
                }
            }
        }
    }

    Coroutine parryCounterOnPerfectBlockWithDelayCoroutine;

    void stopParryCounterOnPerfectBlockWithDelayCoroutine ()
    {
        if (parryCounterOnPerfectBlockWithDelayCoroutine != null) {
            StopCoroutine (parryCounterOnPerfectBlockWithDelayCoroutine);
        }
    }

    IEnumerator activateParryCounterOnPerfectBlockWithDelayCoroutine ()
    {
        var currentWaitTime = new WaitForSeconds (delayToActivateParryCounterOnPerfectBlock);

        yield return currentWaitTime;

        eventToActivateParryCounterOnPerfectBlock.Invoke ();
    }

    public void stopCurrentAttackInProcess ()
    {
        if (isAIBehaviorAttackInProcess ()) {
            mainGrabbedObjectMeleeAttackSystem.disableCurrentAttackInProcess ();
        }
    }

    public void setTurnBasedCombatActionActiveState (bool state)
    {
        turnBasedCombatActionActive = state;
    }

    public void checkAIBehaviorStateOnCharacterSpawn ()
    {
        if (checkInitialWeaponsOnCharacterSpawnEnabled) {
            mainGrabbedObjectMeleeAttackSystem.resetStartWithWeaponCheckedOnCharacterSpawn ();
        }
    }

    public void checkAIBehaviorStateOnCharacterDespawn ()
    {

    }

    public void setMaxWaitTimeToForceAttackIfNotUsedLongTimeAgoValue (float newValue)
    {
        maxWaitTimeToForceAttackIfNotUsedLongTimeAgo = newValue;
    }

    public void setCheckToForceAttackIfNotUsedLongTimeAgoState (bool state)
    {
        checkToForceAttackIfNotUsedLongTimeAgo = state;
    }

    public void checkIfDisableCurrentWeaponToChangeAttackMode (string newModeName)
    {
        changeAttackMode (newModeName);
    }

    public void changeCurrentAttackMode (string newModeName)
    {
        changeAttackMode (newModeName);
    }

    void changeAttackMode (string newModeName)
    {
        if (!combatSystemActive) {
            return;
        }

        stopAttackState ();

        eventToChangeAttackMode.Invoke (newModeName);
    }

    public void stopAttackState ()
    {
        if (!combatSystemActive) {
            return;
        }

        if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
            bool playerIsBusy = mainGrabbedObjectMeleeAttackSystem.isAttackInProcess () ||
                mainGrabbedObjectMeleeAttackSystem.isActionActive ();

            if (playerIsBusy) {
                //print ("player is busy");

                resetBehaviorStates ();

                mainMeleeWeaponsGrabbedManager.setIgnoreUseDrawKeepWeaponAnimationState (true);

                mainGrabbedObjectMeleeAttackSystem.drawOrKeepMeleeWeaponWithoutCheckingInputActive ();

                mainMeleeWeaponsGrabbedManager.setOriginalIgnoreUseDrawKeepWeaponAnimationState ();
            } else {
                //print ("player is not busy");
            }
        }
    }

    public void setAttackEnabledState (bool state)
    {
        attackEnabled = state;
    }

    public void setAttackEnabledStateFromEditor (bool state)
    {
        setAttackEnabledState (state);

        updateComponent ();
    }

    public void updateComponent ()
    {
        GKC_Utils.updateComponent (this);

        GKC_Utils.updateDirtyScene ("Update AI Brain " + gameObject.name, gameObject);
    }
}