Steam Leaderboard Grouping

#include "SteamIdUtils.h"
#include "Misc/Char.h"
#include "Misc/AssertionMacros.h"

bool USteamIdUtils::IsAllDigits(const FString& S)
{
    if (S.IsEmpty()) return false;
    for (TCHAR C : S)
    {
        if (!FChar::IsDigit(C)) return false;
    }
    return true;
}

void USteamIdUtils::PackU64(uint64 V, int32& Lo, int32& Hi)
{
    Lo = static_cast<int32>(V & 0xFFFFFFFFull);
    Hi = static_cast<int32>((V >> 32) & 0xFFFFFFFFull);
}

uint64 USteamIdUtils::UnpackU64(int32 Lo, int32 Hi)
{
    uint64 LoU = static_cast<uint64>(static_cast<uint32>(Lo));
    uint64 HiU = static_cast<uint64>(static_cast<uint32>(Hi));
    return (HiU << 32) | LoU;
}

void USteamIdUtils::SplitSteamIdString(const FString& SteamIdStr, int32& OutLo, int32& OutHi, bool& bOk)
{
    OutLo = OutHi = 0;
    bOk = false;

    // Expect a decimal SteamID64 string like "7656119..."
    if (!IsAllDigits(SteamIdStr))
    {
        return; // Not a pure decimal string (e.g., "[U:1:123]" or "STEAM_1:1:..."); convert that first.
    }

    // Parse base-10 -> uint64
    uint64 Id64 = FCString::Strtoui64(*SteamIdStr, nullptr, 10);
    // Basic sanity: if the string wasn't "0", but parsed to 0, treat as failure
    if (Id64 == 0 && SteamIdStr != TEXT("0"))
    {
        return;
    }

    PackU64(Id64, OutLo, OutHi);
    bOk = true;
}

FString USteamIdUtils::MakeSteamIdString(int32 Lo, int32 Hi)
{
    uint64 Id64 = UnpackU64(Lo, Hi);
    return LexToString(Id64); // decimal string
}

void USteamIdUtils::Int32ArrayToSteamIdStrings(
    const TArray<int32>& In,
    TArray<FString>& Out,
    int32 OffsetInts,
    int32 NumIds,
    bool bSkipZero)
{
    UE_LOG(LogTemp, Verbose,
        TEXT("[SteamIdUtils] Int32ArrayToSteamIdStrings: In.Num=%d, OffsetInts=%d, NumIds=%d, bSkipZero=%s"),
        In.Num(), OffsetInts, NumIds,
        bSkipZero ? TEXT("true") : TEXT("false"));

    Out.Reset();

    // Bounds checks
    if (OffsetInts < 0 || OffsetInts >= In.Num())
    {
        UE_LOG(LogTemp, Error, TEXT("[SteamIdUtils] OffsetInts (%d) out of bounds (In.Num=%d). Aborting."),
               OffsetInts, In.Num());
        return;
    }

    const int32 Remaining = In.Num() - OffsetInts;
    if (Remaining < 2)
    {
        UE_LOG(LogTemp, Verbose, TEXT("[SteamIdUtils] Not enough ints to form a single pair. Remaining=%d."), Remaining);
        return;
    }

    if ((Remaining % 2) != 0)
    {
        UE_LOG(LogTemp, Verbose, TEXT("[SteamIdUtils] Odd count (%d) after Offset. Last int will be ignored."), Remaining);
    }

    int32 MaxPairs = Remaining / 2;
    if (NumIds >= 0)
    {
        if (NumIds > MaxPairs)
        {
            UE_LOG(LogTemp, Verbose, TEXT("[SteamIdUtils] Requested NumIds=%d exceeds available pairs=%d. Clamping."),
                   NumIds, MaxPairs);
        }
        MaxPairs = FMath::Min(MaxPairs, NumIds);
    }

    Out.Reserve(MaxPairs);

    int32 i = OffsetInts;
    for (int32 p = 0; p < MaxPairs; ++p, i += 2)
    {
        const int32 Lo = In[i];
        const int32 Hi = In[i + 1];

        // Combine low and high parts into 64-bit Steam ID
        const uint64 Id64 = UnpackU64(Lo, Hi);

        UE_LOG(LogTemp, Verbose, TEXT("[SteamIdUtils] Pair #%d Lo=%d Hi=%d -> uint64=%llu"),
               p, Lo, Hi, (unsigned long long)Id64);

        if (bSkipZero && Id64 == 0)
        {
            UE_LOG(LogTemp, Verbose, TEXT("[SteamIdUtils] Pair #%d resolved to 0 (skipped)."), p);
            continue;
        }

        const FString IdStr = LexToString(Id64);
        Out.Emplace(IdStr);
    }

    UE_LOG(LogTemp, Verbose, TEXT("[SteamIdUtils] Int32ArrayToSteamIdStrings: Produced %d SteamIDs from %d pairs."), Out.Num(), MaxPairs);
}