float GetRealDistanceFOV(float distance, QAngle angle, CUserCmd* cmd)
{
    Vector aimingAt;
    Math::AngleVectors(cmd->viewangles, aimingAt);
    aimingAt *= distance;

    Vector aimAt;
    Math::AngleVectors(angle, aimAt);
    aimAt *= distance;

    return aimingAt.DistTo(aimAt);
}

Vector VelocityExtrapolate(C_BasePlayer* player, Vector aimPos)
{
    return aimPos + (player->GetVelocity() * globalVars->interval_per_tick);
}

C_BasePlayer* GetClosestPlayer(CUserCmd* cmd, bool visible, Bone& bestBone, float& bestDamage, AimTargetType aimTargetType = AimTargetType::FOV)
{
    if (Settings::Aimbot::AutoAim::realDistance)
        aimTargetType = AimTargetType::REAL_DISTANCE;

    bestBone = static_cast<Bone>(Settings::Aimbot::bone);

    C_BasePlayer* localplayer = (C_BasePlayer*) entityList->GetClientEntity(engine->GetLocalPlayer());
    C_BasePlayer* closestEntity = NULL;

    // TODO Change the big value with a distance/fov slider
    float bestFov = Settings::Aimbot::AutoAim::fov;
    float bestRealDistance = Settings::Aimbot::AutoAim::fov * 5.f;
    float bestDistance = 999999999.0f;
    int bestHp = 100;

    if (!localplayer)
        return NULL;

    for (int i = 1; i < engine->GetMaxClients(); ++i)
    {
        C_BasePlayer* player = (C_BasePlayer*) entityList->GetClientEntity(i);

        if (!player
            || player == localplayer
            || player->GetDormant()
            || !player->GetAlive()
            || player->GetImmune())
            continue;

        if (!Settings::Aimbot::friendly && player->GetTeam() == localplayer->GetTeam())
            continue;

        IEngineClient::player_info_t entityInformation;
        engine->GetPlayerInfo(i, &entityInformation);

        if (std::find(Aimbot::friends.begin(), Aimbot::friends.end(), entityInformation.xuid) != Aimbot::friends.end())
            continue;

        Vector eVecTarget = player->GetBonePosition((int) Settings::Aimbot::bone);
        Vector pVecTarget = localplayer->GetEyePosition();

        QAngle viewAngles;
        engine->GetViewAngles(viewAngles);

        float distance = pVecTarget.DistTo(eVecTarget);
        float fov = Math::GetFov(viewAngles, Math::CalcAngle(pVecTarget, eVecTarget));
        float real_distance = GetRealDistanceFOV(distance, Math::CalcAngle(pVecTarget, eVecTarget), cmd);
        int hp = player->GetHealth();

        if (aimTargetType == AimTargetType::DISTANCE && distance > bestDistance)
            continue;

        if (aimTargetType == AimTargetType::FOV && fov > bestFov)
            continue;

        if (aimTargetType == AimTargetType::REAL_DISTANCE && real_distance > bestRealDistance)
            continue;

        if (aimTargetType == AimTargetType::HP && hp > bestHp)
            continue;

        if (visible && !Settings::Aimbot::AutoWall::enabled && !Entity::IsVisible(player, Settings::Aimbot::bone))
            continue;

        bestBone = static_cast<Bone>(Entity::GetBoneByName(player, targets[(int) Settings::Aimbot::bone]));

        if (Settings::Aimbot::AutoWall::enabled)
        {
            float damage = 0.0f;
            Bone bone;
            GetBestBone(player, damage, bone);

            if (damage >= bestDamage && damage >= Settings::Aimbot::AutoWall::value)
            {
                bestDamage = damage;
                bestBone = bone;
                closestEntity = player;
            }
        }
        else
        {
            closestEntity = player;
            bestFov = fov;
            bestRealDistance = real_distance;
            bestDistance = distance;
            bestHp = hp;
        }
    }

    return closestEntity;
}