private async Task SwitchGatherType()
        {
            if (this.classConfiguration.Mode == Mode.AttendedGather && this.lastGatherClick.AddSeconds(3) < DateTime.Now && this.classConfiguration.GatherFindKeyConfig.Count > 0)
            {
                lastGatherKey++;
                if (lastGatherKey >= this.classConfiguration.GatherFindKeyConfig.Count)
                {
                    lastGatherKey = 0;
                }

                await input.KeyPress(classConfiguration.GatherFindKeyConfig[lastGatherKey].ConsoleKey, 200, "Gatherkey 1");

                lastGatherClick = DateTime.Now;
            }
        }
        protected async Task <bool> SwitchToCorrectStanceForm(Form beforeForm, KeyAction item)
        {
            if (string.IsNullOrEmpty(item.Form))
            {
                return(true);
            }

            if (playerReader.Form == item.FormEnum)
            {
                return(true);
            }

            var formKeyAction = classConfig.Form
                                .Where(s => s.FormEnum == item.FormEnum)
                                .FirstOrDefault();

            if (formKeyAction == null)
            {
                logger.LogWarning($"Unable to find key in Form to transform into {item.FormEnum}");
                return(false);
            }

            await input.KeyPress(formKeyAction.ConsoleKey, formKeyAction.PressDuration);

            (bool notChanged, double elapsedMs) = await wait.InterruptTask(SpellQueueTimeMs, () => beforeForm != playerReader.Form);

            item.LogInformation($" ... form changed: {!notChanged} | Delay: {elapsedMs}ms");

            if (playerReader.Form == Form.None)
            {
                item.LogInformation($" ... wait for GCD after form change {beforeForm}->{playerReader.Form}!");
                await WaitForGCD(item, playerReader.HasTarget);
            }

            return(playerReader.Form == item.FormEnum);
        }
        public async Task PressKey(ConsoleKey key, string description = "", int duration = 50)
        {
            if (lastKeyPressed == classConfig.Interact.ConsoleKey)
            {
                var distance = WowPoint.DistanceTo(classConfig.Interact.LastClickPostion, this.playerReader.PlayerLocation);

                if (distance > 1)
                {
                    logger.LogInformation($"Stop moving: We have moved since the last interact: {distance}");
                    await input.TapStopKey();

                    classConfig.Interact.SetClicked();
                    await playerReader.WaitForNUpdate(1);
                }
            }

            await input.KeyPress(key, duration, description);

            lastKeyPressed = key;
        }
        public override async Task PerformAction()
        {
            if (SecondsSincePullStarted > 7)
            {
                await input.TapClearTarget();

                await input.KeyPress(random.Next(2) == 0?ConsoleKey.LeftArrow : ConsoleKey.RightArrow, 1000, "Too much time to pull!");

                pullStart = DateTime.Now;

                return;
            }

            SendActionEvent(new ActionEventArgs(GoapKey.fighting, true));

            if (!await Pull())
            {
                if (HasPickedUpAnAdd)
                {
                    Log($"Combat={this.playerReader.Bits.PlayerInCombat}, Is Target targetting me={this.playerReader.Bits.TargetOfTargetIsPlayer}");
                    Log($"Add on approach");

                    await stopMoving.Stop();

                    await input.TapNearestTarget();

                    await wait.Update(1);

                    if (this.playerReader.HasTarget && playerReader.Bits.TargetInCombat)
                    {
                        if (this.playerReader.TargetTarget == TargetTargetEnum.TargetIsTargettingMe)
                        {
                            return;
                        }
                    }

                    await input.TapClearTarget();

                    await wait.Update(1);

                    pullStart = DateTime.Now;

                    return;
                }

                if (!stuckDetector.IsMoving())
                {
                    await stuckDetector.Unstick();
                }

                if (classConfiguration.Approach.GetCooldownRemaining() == 0)
                {
                    await input.TapApproachKey($"{GetType().Name}");

                    await wait.Update(1);
                }
            }
            else
            {
                SendActionEvent(new ActionEventArgs(GoapKey.pulled, true));
            }
        }
        public override async Task PerformAction()
        {
            lastPlayerLocation = playerReader.PlayerLocation;
            await wait.Update(1);

            if (!playerReader.Bits.PlayerInCombat)
            {
                playerWasInCombat = false;
            }
            else
            {
                // we are in combat
                if (!playerWasInCombat && HasPickedUpAnAdd)
                {
                    logger.LogInformation("WARN Bodypull -- Looks like we have an add on approach");
                    logger.LogInformation($"Combat={playerReader.Bits.PlayerInCombat}, Is Target targetting me={playerReader.Bits.TargetOfTargetIsPlayer}");

                    await stopMoving.Stop();

                    await input.TapClearTarget();

                    await wait.Update(1);

                    if (playerReader.PetHasTarget)
                    {
                        await input.TapTargetPet();

                        await input.TapTargetOfTarget();

                        await wait.Update(1);
                    }
                }

                playerWasInCombat = true;
            }

            if (input.ClassConfig.Approach.GetCooldownRemaining() == 0)
            {
                await input.TapApproachKey("");
            }

            lastPlayerDistance = WowPoint.DistanceTo(lastPlayerLocation, playerReader.PlayerLocation);

            if (lastPlayerDistance < 0.05 && playerReader.LastUIErrorMessage == UI_ERROR.ERR_AUTOFOLLOW_TOO_FAR)
            {
                playerReader.LastUIErrorMessage = UI_ERROR.NONE;

                input.SetKeyState(ConsoleKey.UpArrow, true, false, $"{GetType().Name}: Too far, start moving forward!");
                await wait.Update(1);
            }

            if (SecondsSinceApproachStarted > 1 && lastPlayerDistance < 0.05 && !playerReader.Bits.PlayerInCombat)
            {
                await input.TapClearTarget("");

                await wait.Update(1);

                await input.KeyPress(random.Next(2) == 0?ConsoleKey.LeftArrow : ConsoleKey.RightArrow, 1000, $"Seems stuck! Clear Target. Turn away. d: {lastPlayerDistance}");

                approachStart = DateTime.Now;
            }

            if (SecondsSinceApproachStarted > 15 && !playerReader.Bits.PlayerInCombat)
            {
                await input.TapClearTarget("");

                await wait.Update(1);

                await input.KeyPress(random.Next(2) == 0?ConsoleKey.LeftArrow : ConsoleKey.RightArrow, 1000, "Too long time. Clear Target. Turn away.");

                approachStart = DateTime.Now;
            }

            if (playerReader.TargetGuid == initialTargetGuid)
            {
                var initialTargetMinRange = playerReader.MinRange;
                if (!playerReader.Bits.PlayerInCombat)
                {
                    await input.TapNearestTarget("Try to find closer target...");

                    await wait.Update(1);
                }

                if (playerReader.TargetGuid != initialTargetGuid)
                {
                    if (playerReader.HasTarget) // blacklist
                    {
                        if (playerReader.MinRange < initialTargetMinRange)
                        {
                            Log($"Found a closer target! {playerReader.MinRange} < {initialTargetMinRange}");
                            initialMinRange = playerReader.MinRange;
                        }
                        else
                        {
                            initialTargetGuid = -1;
                            await input.TapLastTargetKey($"Stick to initial target!");

                            await wait.Update(1);
                        }
                    }
                    else
                    {
                        Log($"Lost the target due blacklist!");
                    }
                }
            }

            if (initialMinRange < playerReader.MinRange && !playerReader.Bits.PlayerInCombat)
            {
                Log($"We are going away from the target! {initialMinRange} < {playerReader.MinRange}");
                await input.TapClearTarget();

                await wait.Update(1);

                approachStart = DateTime.Now;
            }

            await RandomJump();
        }