AuroraRuntime/Include/Aurora/RNG/RNG.hpp

/***
    Copyright (C) 2021 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: RNG.hpp
    Date: 2021-7-14
    Author: Reece
***/
#pragma once 

#include "ERngStringCharacters.hpp"
#include "RandomDef.hpp"
#include "IRandomDevice.hpp"

namespace Aurora::RNG
{
    // May return any length between 1 and uBytes
    using RngGetBytesProvider_f = AuUInt32(*)(AuUInt8 *pBuffer, AuUInt32 uBytes);

    AUKN_SYM void                  SetSecureRNGBackendOverload(RngGetBytesProvider_f pSecureBackend);
    AUKN_SYM RngGetBytesProvider_f GetSecureRNGBackendOverload();
    AUKN_SYM RngGetBytesProvider_f GetSecureRNGBackend();

    AUKN_SYM void                  ReadSecureRNG(Memory::MemoryViewWrite writeView);
    AUKN_SYM void                  ReadFastRNG  (Memory::MemoryViewWrite writeView);
 
    AUKN_SYM AuString              ReadString(AuUInt32 uLength, ERngStringCharacters type = ERngStringCharacters::eAlphaCharacters);
    AUKN_SYM void                  RngString(char *pString, AuUInt32 uLength, ERngStringCharacters type = ERngStringCharacters::eAlphaCharacters);

    AUKN_SYM AuUInt8               RngByte();
    AUKN_SYM bool                  RngBoolean();
    AUKN_SYM AuUInt32              RngU32();
    AUKN_SYM AuUInt32              RngU32Range(AuUInt32 uMin, AuUInt32 uMax);
    AUKN_SYM AuInt32               RngI32Range(AuInt32 iMin, AuInt32 iMax);
    AUKN_SYM AuUInt64              RngU64Range(AuUInt64 uMin, AuUInt64 uMax);
    AUKN_SYM AuInt64               RngI64Range(AuInt64 iMin, AuInt64 iMax);
    AUKN_SYM AuVec2                RngVec2(AuVec2 boundA, AuVec2 boundB);
    AUKN_SYM AuVec2                RngVec2Sorted(AuVec2 min, AuVec2 max);
    AUKN_SYM AuVec3                RngVec3(AuVec3 boundA, AuVec3 boundB);
    AUKN_SYM AuVec3                RngVec3Sorted(AuVec3 min, AuVec3 max);
    AUKN_SYM AuVec4                RngVec4(AuVec4 boundA, AuVec4 boundB);
    AUKN_SYM AuVec4                RngVec4Sorted(AuVec4 min, AuVec4 max);
    AUKN_SYM AuUInt64              RngU64();
    AUKN_SYM double                RngDecimal();
    AUKN_SYM double                RngNumber(double dMin, double dMax);
    AUKN_SYM AuUInt32              RngIndex(AuUInt32 uCount /* = max + 1*/);
    AUKN_SYM uuids::uuid           RngUUID();
    AUKN_SYM AuList<AuInt32>       RngArrayI32Range(AuUInt32 uCount, AuInt32 iMin, AuInt32 iMax);
    AUKN_SYM AuList<AuInt32>       RngArrayI32RangeFast(AuUInt32 uCount, AuInt32 iMin, AuInt32 iMax);
    AUKN_SYM AuList<AuUInt32>      RngArrayU32Range(AuUInt32 uCount, AuUInt32 uMin, AuUInt32 uMax);
    AUKN_SYM AuList<AuUInt32>      RngArrayU32RangeFast(AuUInt32 uCount, AuUInt32 uMin, AuUInt32 uMax);
    AUKN_SYM AuList<AuInt64>       RngArrayI64Range(AuUInt32 uCount, AuInt64 iMin, AuInt64 iMax);
    AUKN_SYM AuList<AuInt64>       RngArrayI64RangeFast(AuUInt32 uCount, AuInt64 iMin, AuInt64 iMax);
    AUKN_SYM AuList<AuUInt64>      RngArrayU64Range(AuUInt32 uCount, AuUInt64 uMin, AuUInt64 uMax);
    AUKN_SYM AuList<AuUInt64>      RngArrayU64RangeFast(AuUInt32 uCount, AuUInt64 uMin, AuUInt64 uMax);
    AUKN_SYM AuList<AuUInt32>      RngArrayU32Mask(AuUInt32 uCount, AuUInt32 uMask);
    AUKN_SYM AuList<AuUInt64>      RngArrayU64Mask(AuUInt32 uCount, AuUInt64 uMask);
    AUKN_SYM AuList<double>        RngArrayDoubleRange(AuUInt32 uCount, double dMin, double dMax);
    AUKN_SYM AuList<double>        RngArrayDoubleRangeFast(AuUInt32 uCount, double dMin, double dMax);
    AUKN_SYM AuList<AuInt32>       RngArrayI32(AuUInt32 uCount);
    AUKN_SYM AuList<AuUInt32>      RngArrayU32(AuUInt32 uCount);
    AUKN_SYM AuList<AuInt64>       RngArrayI64(AuUInt32 uCount);
    AUKN_SYM AuList<AuUInt64>      RngArrayU64(AuUInt32 uCount);
    AUKN_SYM AuList<AuVec2>        RngArrayVec2(AuUInt32 uCount, AuVec2 boundA, AuVec2 boundB);
    AUKN_SYM AuList<AuVec2>        RngArrayVec2Fast(AuUInt32 uCount, AuVec2 boundA, AuVec2 boundB);
    AUKN_SYM AuList<AuVec2>        RngArrayVec2Sorted(AuUInt32 uCount, AuVec2 min, AuVec2 max);
    AUKN_SYM AuList<AuVec2>        RngArrayVec2SortedFast(AuUInt32 uCount, AuVec2 min, AuVec2 max);
    AUKN_SYM AuList<AuVec3>        RngArrayVec3(AuUInt32 uCount, AuVec3 boundA, AuVec3 boundB);
    AUKN_SYM AuList<AuVec3>        RngArrayVec3Fast(AuUInt32 uCount, AuVec3 boundA, AuVec3 boundB);
    AUKN_SYM AuList<AuVec3>        RngArrayVec3Sorted(AuUInt32 uCount, AuVec3 min, AuVec3 max);
    AUKN_SYM AuList<AuVec3>        RngArrayVec3SortedFast(AuUInt32 uCount, AuVec3 min, AuVec3 max);
    AUKN_SYM AuList<AuVec4>        RngArrayVec4(AuUInt32 uCount, AuVec4 boundA, AuVec4 boundB);
    AUKN_SYM AuList<AuVec4>        RngArrayVec4Fast(AuUInt32 uCount, AuVec4 boundA, AuVec4 boundB);
    AUKN_SYM AuList<AuVec4>        RngArrayVec4Sorted(AuUInt32 uCount, AuVec4 min, AuVec4 max);
    AUKN_SYM AuList<AuVec4>        RngArrayVec4SortedFast(AuUInt32 uCount, AuVec4 min, AuVec4 max);
    AUKN_SYM AuList<double>        RngArrayDouble(AuUInt32 uCount);
    AUKN_SYM AuList<double>        RngArrayDecimals(AuUInt32 uCount);
    AUKN_SYM AuList<double>        RngArrayDecimalsFast(AuUInt32 uCount);
    AUKN_SYM AuList<uuids::uuid>   RngArrayUUIDs(AuUInt32 uCount);
    // Note: it is conceivable that someone may want the following templates for some cryptographic purpose

    template<bool fast = true, typename T, int N>
    static auline void RngFillArray(T(&array)[N])
    {
        if constexpr (fast)
        {
            ReadFastRNG(Memory::MemoryViewWrite(array));
        }
        else
        {
            ReadSecureRNG(Memory::MemoryViewWrite(array));
        }
    }

    template<bool fast = true, typename T>
    static auline void RngFillArray(T *array, AuUInt32 uCount)
    {
        if constexpr (fast)
        {
            ReadFastRNG(Memory::MemoryViewWrite(array, uCount * sizeof(T)));
        }
        else
        {
            ReadSecureRNG(Memory::MemoryViewWrite(array, uCount * sizeof(T)));
        }
    }

    template<bool fast = true, typename T>
    static auline void RngFillRange(T &container)
    {
        RngFillArray<fast>(container.begin(), container.end() - container.begin());
    }

    static auline void RngFillBuffer(Memory::ByteBuffer &buffer)
    {
        auto view = buffer.GetNextLinearWrite();
        RngFillRange(view);
        buffer.writePtr += view.length;
    }

    /**
     * @brief 
     * @deprecated
    */
    static auline void RngFillRange(Memory::ByteBuffer &buffer)
    {
        RngFillBuffer(buffer);
    }

    template<bool fast = true, typename T>
    static auline T RngTmpl()
    {
        T ret {};
        if constexpr (fast)
        {
            ReadFastRNG(Memory::MemoryViewWrite(&ret, sizeof(T)));
        }
        else
        {
            ReadSecureRNG(Memory::MemoryViewWrite(&ret, sizeof(T)));
        }
        return ret;
    }

    template<typename T>
    static auline T &RngArray(T *pItems, AuUInt32 uCount)
    {
        return pItems[RngIndex(uCount)];
    }

    template<typename T>
    inline T RngIterator(T begin, T end)
    {
        auto nextItr = begin;
        auto uCount = std::distance(begin, end);
        std::advance(nextItr, RngIndex(uCount));
        return nextItr;
    }

    template<typename T>
    static auline auto RngRange(T &items)
    {
        return RngIterator(std::begin(items), std::end(items));
    }

    template<typename T>
    static auline T &RngList(AuList<T> &items)
    {
        return *RngRange(items);
    }

    template<typename T>
    static auline const T &RngList(const AuList<T> &items)
    {
        return *RngRange(items);
    }

    template<typename T>
    inline void RngShuffleIterators(T begin, T end)
    {
        AU_DEBUG_MEMCRUNCH;

        auto uCount = std::distance(begin, end);
        auto nextIndexArray = RngArrayU32RangeFast(uCount, 0, uCount - 1);

        for (AU_ITERATE_N(i, AuUInt(uCount)))
        {
            auto nextItrA = begin;
            auto nextItrB = begin;
            std::advance(nextItrA, i);
            std::advance(nextItrB, nextIndexArray[i]);
            AuSwap(*nextItrA, *nextItrB);
        }
    }

    template<typename T>
    inline void RngShuffleList(AuList<T> &list)
    {
        RngShuffleIterators(list.begin(), list.end());
    }
}