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

    File: AuRNGStaticUtilities.cpp
    Date: 2022-9-17
    File: RNG.cpp
    Date: 2021-6-11
    Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include "AuRNG.hpp"
#include "AuRNGStaticUtilities.hpp"

namespace Aurora::RNG
{
    AUKN_SYM AuString ReadString(AuUInt32 dwLength, ERngStringCharacters type)
    {
        return gFastDevice->NextString(dwLength, type);
    }

    AUKN_SYM void RngString(char *pString, AuUInt32 dwLength, ERngStringCharacters type)
    {
        gFastDevice->NextString(pString, dwLength, type);
    }

    AUKN_SYM AuUInt8 RngByte()
    {
        return gFastDevice->NextByte();
    }

    AUKN_SYM bool RngBoolean()
    {
        return gFastDevice->NextBoolean();
    }

    AUKN_SYM AuUInt32 RngU32()
    {
        return gFastDevice->NextU32();
    }

    AUKN_SYM AuUInt32 RngU32Range(AuUInt32 uMin, AuUInt32 uMax)
    {
        return gFastDevice->NextU32Range(uMin, uMax);
    }

    AUKN_SYM AuUInt64 RngU64()
    {
        return gFastDevice->NextU64();
    }

    AUKN_SYM AuInt32  RngI32Range(AuInt32 uMin, AuInt32 uMax)
    {
        return gFastDevice->NextI32Range(uMin, uMax);
    }

    AUKN_SYM double RngDecimal()
    {
        return gFastDevice->NextDecimal();
    }

    AUKN_SYM double RngNumber(double min, double max)
    {
        return gFastDevice->NextNumber(min, max);
    }

    AUKN_SYM AuUInt32 RngIndex(AuUInt32 uCount /* = max + 1*/)
    {
        return gFastDevice->NextIndex(uCount);
    }

    AUKN_SYM uuids::uuid RngUUID()
    {
        return gFastDevice->NextUUID();
    }

    AUKN_SYM AuList<AuInt32> RngArrayI32Range(AuUInt32 uCount, AuInt32 iMin, AuInt32 iMax)
    {
        return gFastDevice->NextArrayI32Range(uCount, iMin, iMax);
    }

    AUKN_SYM AuList<AuUInt32> RngArrayU32Range(AuUInt32 uCount, AuUInt32 uMin, AuUInt32 uMax)
    {
        return gFastDevice->NextArrayU32Range(uCount, uMin, uMax);
    }

    AUKN_SYM AuList<double> RngArrayDoubleRange(AuUInt32 uCount, double dMin, double dMax)
    {
        return gFastDevice->NextArrayDoubleRange(uCount, dMin, dMax);
    }

    AUKN_SYM AuList<AuInt32> RngArrayI32(AuUInt32 uCount)
    {
        return gFastDevice->NextArrayI32(uCount);
    }

    AUKN_SYM AuList<AuUInt32> RngArrayU32(AuUInt32 uCount)
    {
        return gFastDevice->NextArrayU32(uCount);
    }

    AUKN_SYM AuList<double> RngArrayDouble(AuUInt32 uCount)
    {
        return gFastDevice->NextArrayDouble(uCount);
    }

    AUKN_SYM AuList<double> RngArrayDecimals(AuUInt32 uCount)
    {
        return gFastDevice->NextArrayDecimals(uCount);
    }

    AUKN_SYM AuList<uuids::uuid> RngArrayUUIDs(AuUInt32 uCount)
    {
        return gFastDevice->NextArrayUUIDs(uCount);
    }

    AUKN_SYM AuUInt64 RngU64Range(AuUInt64 uMin, AuUInt64 uMax)
    {
        return gFastDevice->NextU64Range(uMin, uMax);
    }

    AUKN_SYM AuInt64 RngI64Range(AuInt64 iMin, AuInt64 iMax)
    {
        return gFastDevice->NextI64Range(iMin, iMax);
    }

    AUKN_SYM AuVec2 RngVec2(AuVec2 boundA, AuVec2 boundB)
    {
        return gFastDevice->NextVec2(boundA, boundB);
    }

    AUKN_SYM AuVec2 RngVec2Sorted(AuVec2 min, AuVec2 max)
    {
        return gFastDevice->NextVec2Sorted(min, max);
    }

    AUKN_SYM AuVec3 RngVec3(AuVec3 boundA, AuVec3 boundB)
    {
        return gFastDevice->NextVec3(boundA, boundB);
    }

    AUKN_SYM AuVec3 RngVec3Sorted(AuVec3 min, AuVec3 max)
    {
        return gFastDevice->NextVec3Sorted(min, max);
    }

    AUKN_SYM AuVec4 RngVec4(AuVec4 boundA, AuVec4 boundB)
    {
        return gFastDevice->NextVec4(boundA, boundB);
    }

    AUKN_SYM AuVec4 RngVec4Sorted(AuVec4 min, AuVec4 max)
    {
        return gFastDevice->NextVec4Sorted(min, max);
    }

    AUKN_SYM AuList<AuInt64> RngArrayI64Range(AuUInt32 uCount, AuInt64 iMin, AuInt64 iMax)
    {
        return gFastDevice->NextArrayI64Range(uCount, iMin, iMax);
    }

    AUKN_SYM AuList<AuUInt64> RngArrayU64Range(AuUInt32 uCount, AuUInt64 uMin, AuUInt64 uMax)
    {
        return gFastDevice->NextArrayU64Range(uCount, uMin, uMax);
    }

    AUKN_SYM AuList<AuUInt32> RngArrayU32Mask(AuUInt32 uCount, AuUInt32 uMask)
    {
        return gFastDevice->NextArrayU32Mask(uCount, uMask);
    }

    AUKN_SYM AuList<AuUInt64> RngArrayU64Mask(AuUInt32 uCount, AuUInt64 uMask)
    {
        return gFastDevice->NextArrayU64Mask(uCount, uMask);
    }

    AUKN_SYM AuList<AuInt64> RngArrayI64(AuUInt32 uCount)
    {
        return gFastDevice->NextArrayI64(uCount);
    }

    AUKN_SYM AuList<AuUInt64> RngArrayU64(AuUInt32 uCount)
    {
        return gFastDevice->NextArrayU64(uCount);
    }

    AUKN_SYM AuList<AuVec2> RngArrayVec2(AuUInt32 uCount, AuVec2 boundA, AuVec2 boundB)
    {
        return gFastDevice->NextArrayVec2(uCount, boundA, boundB);
    }

    AUKN_SYM AuList<AuVec2> RngArrayVec2Fast(AuUInt32 uCount, AuVec2 boundA, AuVec2 boundB)
    {
        return gFastDevice->NextArrayVec2Fast(uCount, boundA, boundB);
    }

    AUKN_SYM AuList<AuVec2> RngArrayVec2Sorted(AuUInt32 uCount, AuVec2 min, AuVec2 max)
    {
        return gFastDevice->NextArrayVec2Sorted(uCount, min, max);
    }

    AUKN_SYM AuList<AuVec3> RngArrayVec3(AuUInt32 uCount, AuVec3 boundA, AuVec3 boundB)
    {
        return gFastDevice->NextArrayVec3(uCount, boundA, boundB);
    }

    AUKN_SYM AuList<AuVec3> RngArrayVec3Fast(AuUInt32 uCount, AuVec3 boundA, AuVec3 boundB)
    {
        return gFastDevice->NextArrayVec3Fast(uCount, boundA, boundB);
    }

    AUKN_SYM AuList<AuVec3> RngArrayVec3Sorted(AuUInt32 uCount, AuVec3 min, AuVec3 max)
    {
        return gFastDevice->NextArrayVec3Sorted(uCount, min, max);
    }

    AUKN_SYM AuList<AuVec4> RngArrayVec4(AuUInt32 uCount, AuVec4 boundA, AuVec4 boundB)
    {
        return gFastDevice->NextArrayVec4(uCount, boundA, boundB);
    }

    AUKN_SYM AuList<AuVec4> RngArrayVec4Fast(AuUInt32 uCount, AuVec4 boundA, AuVec4 boundB)
    {
        return gFastDevice->NextArrayVec4Fast(uCount, boundA, boundB);
    }

    AUKN_SYM AuList<AuVec4> RngArrayVec4Sorted(AuUInt32 uCount, AuVec4 min, AuVec4 max)
    {
        return gFastDevice->NextArrayVec4Sorted(uCount, min, max);
    }

    AUKN_SYM AuList<AuVec4> RngArrayVec4SortedFast(AuUInt32 uCount, AuVec4 min, AuVec4 max)
    {
        return gFastDevice->NextArrayVec4SortedFast(uCount, min, max);
    }

    AUKN_SYM AuList<AuVec3> RngArrayVec3SortedFast(AuUInt32 uCount, AuVec3 min, AuVec3 max)
    {
        return gFastDevice->NextArrayVec3SortedFast(uCount, min, max);
    }

    AUKN_SYM AuList<AuVec2> RngArrayVec2SortedFast(AuUInt32 uCount, AuVec2 min, AuVec2 max)
    {
        return gFastDevice->NextArrayVec2SortedFast(uCount, min, max);
    }

    AUKN_SYM AuList<double> RngArrayDoubleRangeFast(AuUInt32 uCount, double dMin, double dMax)
    {
        return gFastDevice->NextArrayDoubleRangeFast(uCount, dMin, dMax);
    }

    AUKN_SYM AuList<double> RngArrayDecimalsFast(AuUInt32 uCount)
    {
        return gFastDevice->NextArrayDecimalsFast(uCount);
    }

    AUKN_SYM AuList<AuInt32> RngArrayI32RangeFast(AuUInt32 uCount, AuInt32 iMin, AuInt32 iMax)
    {
        return gFastDevice->NextArrayI32RangeFast(uCount, iMin, iMax);
    }
    
    AUKN_SYM AuList<AuUInt32> RngArrayU32RangeFast(AuUInt32 uCount, AuUInt32 uMin, AuUInt32 uMax)
    {
        return gFastDevice->NextArrayU32RangeFast(uCount, uMin, uMax);
    }

    AUKN_SYM AuList<AuInt64> RngArrayI64RangeFast(AuUInt32 uCount, AuInt64 iMin, AuInt64 iMax)
    {
        return gFastDevice->NextArrayI64RangeFast(uCount, iMin, iMax);
    }

    AUKN_SYM AuList<AuUInt64> RngArrayU64RangeFast(AuUInt32 uCount, AuUInt64 uMin, AuUInt64 uMax)
    {
        return gFastDevice->NextArrayU64RangeFast(uCount, uMin, uMax);
    }

    AUKN_SYM AuUInt           RngArrayI32RangeInView(Memory::MemoryViewWrite write, AuInt32 iMin, AuInt32 iMax)
    {
        return gFastDevice->NextArrayI32RangeInView(write, iMin, iMax);
    }

    AUKN_SYM AuUInt           RngArrayI32RangeFastInView(Memory::MemoryViewWrite write, AuInt32 iMin, AuInt32 iMax)
    {
        return gFastDevice->NextArrayI32RangeFastInView(write, iMin, iMax);
    }

    AUKN_SYM AuUInt           RngArrayU32RangeInView(Memory::MemoryViewWrite write, AuUInt32 uMin, AuUInt32 uMax)
    {
        return gFastDevice->NextArrayU32RangeInView(write, uMin, uMax);
    }

    AUKN_SYM AuUInt           RngArrayU32RangeFastInView(Memory::MemoryViewWrite write, AuUInt32 uMin, AuUInt32 uMax)
    {
        return gFastDevice->NextArrayU32RangeFastInView(write, uMin, uMax);
    }

    AUKN_SYM AuUInt           RngArrayI64RangeInView(Memory::MemoryViewWrite write, AuInt64 iMin, AuInt64 iMax)
    {
        return gFastDevice->NextArrayI64RangeInView(write, iMin, iMax);
    }

    AUKN_SYM AuUInt           RngArrayI64RangeFastInView(Memory::MemoryViewWrite write, AuInt64 iMin, AuInt64 iMax)
    {
        return gFastDevice->NextArrayI64RangeFastInView(write, iMin, iMax);
    }

    AUKN_SYM AuUInt           RngArrayU64RangeInView(Memory::MemoryViewWrite write, AuUInt64 uMin, AuUInt64 uMax)
    {
        return gFastDevice->NextArrayU64RangeInView(write, uMin, uMax);
    }

    AUKN_SYM AuUInt           RngArrayU64RangeFastInView(Memory::MemoryViewWrite write, AuUInt64 uMin, AuUInt64 uMax)
    {
        return gFastDevice->NextArrayU64RangeFastInView(write, uMin, uMax);
    }

    AUKN_SYM AuUInt           RngArrayU32MaskInView(Memory::MemoryViewWrite write, AuUInt32 uMask)
    {
        return gFastDevice->NextArrayU32MaskInView(write, uMask);
    }

    AUKN_SYM AuUInt           RngArrayU64MaskInView(Memory::MemoryViewWrite write, AuUInt64 uMask)
    {
        return gFastDevice->NextArrayU64MaskInView(write, uMask);
    }

    AUKN_SYM AuUInt           RngArrayDoubleRangeInView(Memory::MemoryViewWrite write, double dMin, double dMax)
    {
        return gFastDevice->NextArrayDoubleRangeInView(write, dMin, dMax);
    }

    AUKN_SYM AuUInt           RngArrayDoubleRangeFastInView(Memory::MemoryViewWrite write, double dMin, double dMax)
    {
        return gFastDevice->NextArrayDoubleRangeFastInView(write, dMin, dMax);
    }

    AUKN_SYM AuUInt           RngArrayI32InView(Memory::MemoryViewWrite write)
    {
        return gFastDevice->NextArrayI32InView(write);
    }

    AUKN_SYM AuUInt           RngArrayU32InView(Memory::MemoryViewWrite write)
    {
        return gFastDevice->NextArrayU32InView(write);
    }

    AUKN_SYM AuUInt           RngArrayI64InView(Memory::MemoryViewWrite write)
    {
        return gFastDevice->NextArrayI64InView(write);
    }

    AUKN_SYM AuUInt           RngArrayU64InView(Memory::MemoryViewWrite write)
    {
        return gFastDevice->NextArrayU64InView(write);
    }

    AUKN_SYM AuUInt           RngArrayVec2InView(Memory::MemoryViewWrite write, AuVec2 boundA, AuVec2 boundB)
    {
        return gFastDevice->NextArrayVec2InView(write, boundA, boundB);
    }

    AUKN_SYM AuUInt           RngArrayVec2FastInView(Memory::MemoryViewWrite write, AuVec2 boundA, AuVec2 boundB)
    {
        return gFastDevice->NextArrayVec2FastInView(write, boundA, boundB);
    }

    AUKN_SYM AuUInt           RngArrayVec2SortedInView(Memory::MemoryViewWrite write, AuVec2 min, AuVec2 max)
    {
        return gFastDevice->NextArrayVec2SortedInView(write, min, max);
    }

    AUKN_SYM AuUInt           RngArrayVec2SortedFastInView(Memory::MemoryViewWrite write, AuVec2 min, AuVec2 max)
    {
        return gFastDevice->NextArrayVec2SortedFastInView(write, min, max);
    }

    AUKN_SYM AuUInt           RngArrayVec3InView(Memory::MemoryViewWrite write, AuVec3 boundA, AuVec3 boundB)
    {
        return gFastDevice->NextArrayVec3InView(write, boundA, boundB);
    }

    AUKN_SYM AuUInt           RngArrayVec3FastInView(Memory::MemoryViewWrite write, AuVec3 boundA, AuVec3 boundB)
    {
        return gFastDevice->NextArrayVec3FastInView(write, boundA, boundB);
    }

    AUKN_SYM AuUInt           RngArrayVec3SortedInView(Memory::MemoryViewWrite write, AuVec3 min, AuVec3 max)
    {
        return gFastDevice->NextArrayVec3SortedInView(write, min, max);
    }

    AUKN_SYM AuUInt           RngArrayVec3SortedFastInView(Memory::MemoryViewWrite write, AuVec3 min, AuVec3 max)
    {
        return gFastDevice->NextArrayVec3SortedFastInView(write, min, max);
    }

    AUKN_SYM AuUInt           RngArrayVec4InView(Memory::MemoryViewWrite write, AuVec4 boundA, AuVec4 boundB)
    {
        return gFastDevice->NextArrayVec4InView(write, boundA, boundB);
    }

    AUKN_SYM AuUInt           RngArrayVec4FastInView(Memory::MemoryViewWrite write, AuVec4 boundA, AuVec4 boundB)
    {
        return gFastDevice->NextArrayVec4FastInView(write, boundA, boundB);
    }

    AUKN_SYM AuUInt           RngArrayVec4SortedInView(Memory::MemoryViewWrite write, AuVec4 min, AuVec4 max)
    {
        return gFastDevice->NextArrayVec4SortedInView(write, min, max);
    }

    AUKN_SYM AuUInt           RngArrayVec4SortedFastInView(Memory::MemoryViewWrite write, AuVec4 min, AuVec4 max)
    {
        return gFastDevice->NextArrayVec4SortedFastInView(write, min, max);
    }

    AUKN_SYM AuUInt           RngArrayDoubleInView(Memory::MemoryViewWrite write)
    {
        return gFastDevice->NextArrayDoubleInView(write);
    }

    AUKN_SYM AuUInt           RngArrayDecimalsInView(Memory::MemoryViewWrite write)
    {
        return gFastDevice->NextArrayDecimalsInView(write);
    }

    AUKN_SYM AuUInt           RngArrayDecimalsFastInView(Memory::MemoryViewWrite write)
    {
        return gFastDevice->NextArrayDecimalsFastInView(write);
    }

    AUKN_SYM AuUInt           RngArrayUUIDsInView(Memory::MemoryViewWrite write)
    {
        return gFastDevice->NextArrayUUIDsInView(write);
    }
}