#include "main.h"
#include "resolver.h"
#include "logshots.hpp"
RecvVarProxyFn OldProxy_Y;

enum resolver_state {
    resolver_start,
    resolver_inverse,
    resolver_no_desync,
    resolver_jitter
};

enum brute_moving_state {
    resolver_moving_start,
    resolver_moving_start_inverse,
    resolver_moving_inverse,
    resolver_moving_no_desync,
    resolver_moving_jitter
};
float NormalizeYaw(float yaw)
{
    if (yaw > 180)
        yaw -= (round(yaw / 360) * 360.f);
    else if (yaw < -180)
        yaw += (round(yaw / 360) * -360.f);

    return yaw;
}

float brute_yaw;
float moving_brute_yaw;
resolver_state brute_state{};
brute_moving_state brute_moving_state{};

static std::random_device rd;
static std::mt19937 rng(rd());

float AAA_Yaw(C_BaseEntity* entity, ClientFrameStage_t stage) {
    int index = entity->GetIndex();
    float angle = gCorrections[index].y;

     if (!pEngine->IsInGame())
           return;

       C_BasePlayer* localplayer = (C_BasePlayer*) pEntList->GetClientEntity(pEngine->GetLocalPlayer());
       if (!localplayer)
           return;

       extern std::array<int, 64> missedShots;

       if (vars.aimbot.enabled && vars.aimbot.Yawresolver && stage == ClientFrameStage_t::FRAME_NET_UPDATE_POSTDATAUPDATE_START)
       {
           for (int i = 1; i < pEngine->GetMaxClients(); ++i)
           {
               C_BasePlayer* player = (C_BasePlayer*) pEntList->GetClientEntity(i);
               if (!player
                   || player == localplayer
                   || player->GetDormant()
                   || !player->GetAlive()
                   || player->GetImmune()
                   || player->GetTeam() == localplayer->GetTeam())
                   continue;

               CCSGOAnimState* animState = player->GetAnimState();
               if (!animState)
                   continue;

               if(vars.aimbot.Yawresolver)
                   continue;

               int missedShot = LogShots::missedShots[player->GetIndex() - 1];

               bool is_moving = player->GetVelocity().Length2D() > 0.1f && player->GetFlags() & FL_ONGROUND;

               if (is_moving) {
                   switch (brute_moving_state)
                   {
                       case resolver_moving_start:
                           brute_moving_state = resolver_moving_start_inverse;
                           break;
                       case resolver_moving_start_inverse:
                           brute_moving_state = resolver_moving_inverse;
                           moving_brute_yaw = -brute_yaw;
                           break;
                       case resolver_moving_inverse:
                           brute_moving_state = resolver_moving_no_desync;
                           moving_brute_yaw = 0.f;
                           break;
                       case resolver_moving_no_desync:
                           brute_moving_state = resolver_moving_jitter;
                           moving_brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -120.0f : 120.0f;
                           break;
                       default:
                       case resolver_moving_jitter:
                           brute_moving_state = resolver_moving_start;
                           moving_brute_yaw = -moving_brute_yaw;
                           break;
                   }
               }
               else {
                   switch (brute_state)
                   {
                       case resolver_start:
                           brute_state = resolver_inverse;
                           brute_yaw = -brute_yaw;
                           break;
                       case resolver_inverse:
                           brute_state = resolver_no_desync;
                           brute_yaw = 0.f;
                           break;
                       case resolver_no_desync:
                           brute_state = resolver_jitter;
                           brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -120.0f : 120.0f;
                           break;
                       default:
                       case resolver_jitter:
                           brute_state = resolver_start;
                           brute_yaw = -brute_yaw;
                           break;
                   }
               }
               switch (brute_state)
               {
                   case resolver_start:
                       brute_state = resolver_inverse;
                       brute_yaw = -brute_yaw;
                       break;
                   case resolver_inverse:
                       brute_state = resolver_no_desync;
                       brute_yaw = 0.f;
                       break;
                   case resolver_no_desync:
                       brute_state = resolver_jitter;
                       brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -120.0f : 120.0f;
                       break;
                   default:
                   case resolver_jitter:
                       brute_yaw = -brute_yaw;
                       break;
               }
               if (missedShot > 2)
               {
                   switch (missedShot % 4) {
                       case 0:
                           angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) + 45.0f;
                           break;
                       case 1:
                           angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) - 45.0f;
                           break;
                       case 2:
                           angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw)- 30.0f;
                           break;
                       case 3:
                           angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) + 30.0f;
                           break;

                       default:

                           return;
                   }
               }else{
                       const auto slow_walk = player->GetAnimState()->feetYawRate >= 0.01f && player->GetAnimState()->feetYawRate <= 0.8f;

                       if (brute_state == resolver_start)
                           brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -120.0f : 120.0f;

                       if (brute_moving_state == resolver_moving_start)
                           moving_brute_yaw = slow_walk ? std::uniform_int_distribution<int>(0, 1) (rng) ? -150.0f : 150.0f : 0.0f;

                       if (brute_moving_state == resolver_moving_start_inverse)
                           moving_brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -167.0f : 167.0f;

                       if (is_moving)
                           angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) + moving_brute_yaw;
                       else
                           angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) + brute_yaw;
                   }
               }
       }
    return angle;
}

void FixYaw(const CRecvProxyData *pData, void *pStruct, void *pOut) {
    float flYaw = pData->m_Value.m_Float;

    int index = ((C_BaseEntity*)pStruct)->GetIndex();

    gCorrections[index].y = flYaw;


    OldProxy_Y(pData, pStruct, pOut);
}