EOSCore WriteAchievements not using stats

struct FUnlockAchievements : public EOS_Achievements_UnlockAchievementsOptions
{
    TArray<char*> PointerArray;

    FUnlockAchievements(int32 numAchievements, EOS_ProductUserId userId)
        : EOS_Achievements_UnlockAchievementsOptions()
    {
        PointerArray.AddZeroed(numAchievements);

        for (int32 i = 0; i < PointerArray.Num(); i++)
        {
            PointerArray[i] = new char[256];
        }

        ApiVersion = EOS_ACHIEVEMENTS_UNLOCKACHIEVEMENTS_API_LATEST;
        UserId = userId;
        AchievementsCount = PointerArray.Num();
        AchievementIds = const_cast<const char**>(PointerArray.GetData());
    }
};

struct FSubsystemUnlockAchievementsCallback
{
public:
    FOnAchievementsWrittenDelegate m_Callback;
    FUniqueNetIdEOSCorePtr m_PlayerNetId;
public:
    FSubsystemUnlockAchievementsCallback(const FOnAchievementsWrittenDelegate& Callback, FUniqueNetIdEOSCorePtr PlayerNetId)
        : m_Callback(Callback)
        , m_PlayerNetId(PlayerNetId)
    {
    }
};

void FOnlineAchievementsEOSCore::WriteAchievements(const FUniqueNetId& PlayerId, FOnlineAchievementsWriteRef& WriteObject, const FOnAchievementsWrittenDelegate& Delegate)
{
    bool bUseStats = false;

    TArray<FOnlineStatsUserUpdatedStats> StatsToWrite;
    FUniqueNetIdEOSCorePtr NetId = MakeShared<FUniqueNetIdEOSCore>(PlayerId);
    FOnlineStatsUserUpdatedStats& UpdatedStats = StatsToWrite.Emplace_GetRef(NetId.ToSharedRef());

    for (const TPair<FName, FVariantData>& Stat : WriteObject->Properties)
    {
        UpdatedStats.Stats.Add(Stat.Key.ToString(), FOnlineStatUpdate(Stat.Value, FOnlineStatUpdate::EOnlineStatModificationType::Unknown));
    }

    if (bUseStats)
    {

        EOSSubsystem->m_StatsInterfacePtr->UpdateStats(NetId.ToSharedRef(), StatsToWrite, FOnlineStatsUpdateStatsComplete());

        WriteObject->WriteState = EOnlineAsyncTaskState::Done;
        Delegate.ExecuteIfBound(PlayerId, true);
    }
    else
    {
        const EOS_ProductUserId UserId = EOS_ProductUserId_FromString(TCHAR_TO_UTF8(*NetId->m_ProductUserIdStr));

        // Pre count how many of these we'll be sending along so we can init the array to the proper size.
        // Only unlock achievements if they are 100% complete
        int32 achievementsUnlockingCount = 0;
        for (const TPair<FName, FVariantData>& Stat : WriteObject->Properties)
        {
            float Percent = 0.0f;
            Stat.Value.GetValue(Percent);
            if (Percent >= 100.0f)
            {
                achievementsUnlockingCount++;
            }
        }

        if (achievementsUnlockingCount <= 0)
        {
            // There were no achievements to write
            LogVerbose("WriteAchievements: No Achievements marked as 100% complete to write. ");
            Delegate.ExecuteIfBound(PlayerId, true);
        }
        else
        {
            // We have atleast one achievement to write.

            FUnlockAchievements UnlockAchievementsOperation(achievementsUnlockingCount, UserId);
            for (const TPair<FName, FVariantData>& Stat : WriteObject->Properties)
            {
                float Percent = 0.0f;
                Stat.Value.GetValue(Percent);

                int32 i = 0;
                if (Percent >= 100.0f)
                {
                    FCStringAnsi::Strncpy(UnlockAchievementsOperation.PointerArray[i], TCHAR_TO_UTF8(*Stat.Key.ToString()), 256);
                    i++;
                }
            }

            FSubsystemUnlockAchievementsCallback* CallbackObj = new FSubsystemUnlockAchievementsCallback({ Delegate, NetId });
            EOS_Achievements_UnlockAchievements(EOSSubsystem->m_AchievementsHandle, &UnlockAchievementsOperation, CallbackObj,
                [](const EOS_Achievements_OnUnlockAchievementsCompleteCallbackInfo* Data)
                {
                    LogVerbose("EOS_Achievements_UnlockAchievements Callback with EOS result code (%s)", *FString(EOS_EResult_ToString(Data->ResultCode)));

                    bool bWasSuccessful = Data->ResultCode == EOS_EResult::EOS_Success;
                    if (!bWasSuccessful)
                    {
                        UE_LOG_ONLINE_ACHIEVEMENTS(Error, TEXT("EOS_Achievements_UnlockAchievements failed with error code (%s)"), ANSI_TO_TCHAR(EOS_EResult_ToString(Data->ResultCode)));
                    }

                    FSubsystemUnlockAchievementsCallback* CallbackObj = static_cast<FSubsystemUnlockAchievementsCallback*>(Data->ClientData);
                    check(CallbackObj);

                    if (CallbackObj)
                    {
                        CallbackObj->m_Callback.ExecuteIfBound(*CallbackObj->m_PlayerNetId, bWasSuccessful);

                        delete CallbackObj;
                    }
                }
            );
        }
        WriteObject->WriteState = EOnlineAsyncTaskState::Done;
    }
}