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

    File: AuroraTypedefs.hpp
    Date: 2021-6-10
    Author: Reece
***/
#pragma once

#if !defined(AURORA_RUNTINE_TYPEDEFS_INCLUDE)
    #include <vector>
    #include <utility>
    #include <map>
    #include <string>
    #include <array>
    #include <algorithm>
    #include <unordered_map>
    #include <memory>
#else
    #if defined(AURORA_RUNTINE_TYPEDEFS_INCLUDE_HEADER)
        #include <AURORA_RUNTINE_TYPEDEFS_INCLUDE_HEADER>
    #endif
#endif

#if !defined(AURORA_RUNTIME_AU_LIST)
    #define AURORA_RUNTIME_AU_LIST std::vector
#endif

#if defined(_CPPSHARP)

template<typename T>
using AuList = AURORA_RUNTIME_AU_LIST<T>;

#else

namespace Aurora::Memory
{
    template <class T>
    struct SpeedyArrayAllocator;
}

template<typename T>
using AuList = typename std::conditional<std::is_class<T>::value, AURORA_RUNTIME_AU_LIST<T>, AURORA_RUNTIME_AU_LIST<T, Aurora::Memory::SpeedyArrayAllocator<T>>>::type;

#endif


#if !defined(AURORA_RUNTIME_AU_ARRAY)
    #define AURORA_RUNTIME_AU_ARRAY std::array
#endif

template<typename T, size_t Z>
using AuArray = AURORA_RUNTIME_AU_ARRAY<T, Z>;


#if !defined(AURORA_RUNTIME_AU_FUNC)
    #define AURORA_RUNTIME_AU_FUNC std::function
#endif

template<class T>
using AuFunction = AURORA_RUNTIME_AU_FUNC<T>;


#if !defined(AURORA_RUNTIME_AU_HASH_MAP)
#define AURORA_RUNTIME_AU_HASH_MAP std::unordered_map
#endif

template<typename T, typename Z>
using AuHashMap = AURORA_RUNTIME_AU_HASH_MAP<T, Z>;

template<typename T, typename Z, class Utility>
using AuHashMapEx = AURORA_RUNTIME_AU_HASH_MAP<T, Z, Utility, Utility>;

#if !defined(AURORA_RUNTIME_AU_BST)
#define AURORA_RUNTIME_AU_BST std::map
#endif

template<typename T, typename Z>
using AuBST = AURORA_RUNTIME_AU_BST<T, Z>;

template<typename T, typename Z, class Utility>
using AuBSTEx = AURORA_RUNTIME_AU_BST<T, Z, Utility>;

#if !defined(AURORA_RUNTIME_AU_SHARED_PTR)
#define AURORA_RUNTIME_AU_SHARED_PTR std::shared_ptr
#endif

template<typename T>
using AuSPtr = AURORA_RUNTIME_AU_SHARED_PTR<T>;

#if !defined(AURORA_RUNTIME_AU_WEAK_PTR)
#define AURORA_RUNTIME_AU_WEAK_PTR std::weak_ptr
#endif

template<typename T>
using AuWPtr = AURORA_RUNTIME_AU_WEAK_PTR<T>;

#if !defined(AURORA_RUNTIME_AU_UNIQUE_PTR)
#define AURORA_RUNTIME_AU_UNIQUE_PTR std::unique_ptr
#endif

template<typename T, typename Deleter_t>
using AuUPtr = AURORA_RUNTIME_AU_UNIQUE_PTR<T, Deleter_t>;

#if !defined(AURORA_RUNTIME_AU_PAIR)
#define AURORA_RUNTIME_AU_PAIR std::pair
#endif

template<typename A_t, typename B_t>
using AuPair = AURORA_RUNTIME_AU_PAIR<A_t, B_t>;

#if defined(AURORA_COMPILER_MSVC)
using AuAtomicInt = long;
#else
using AuAtomicInt = int;
#endif 

#if !defined(AURORA_RUNTIME_AU_OPTIONAL)
#define AURORA_RUNTIME_AU_OPTIONAL std::optional
#endif

template<typename T>
using AuOptional = AURORA_RUNTIME_AU_OPTIONAL<T>;

template<class T = void>
using AuPredicate = AuFunction<bool(T)>;

using AuVoidFunc = AuFunction<void(void)>;

template<class T>
using AuConsumer = AuFunction<void(T)>;

template<class T>
using AuSupplier = AuFunction<T(void)>;

//#include "tinyutf8.h"

using AuString = std::string;// tiny_utf8::utf8_string;


using AuUInt64 = Aurora::Types::uint64_t;
using AuUInt32 = Aurora::Types::uint32_t;
using AuUInt16 = Aurora::Types::uint16_t;
using AuUInt8  = Aurora::Types::uint8_t;
using AuInt64  = Aurora::Types::int64_t;
using AuInt32  = Aurora::Types::int32_t;
using AuInt16  = Aurora::Types::int16_t;

#if defined(_CPPSHARP)
using AuInt8   = Aurora::Types::uint8_t;
#else
using AuInt8   = Aurora::Types::int8_t;
#endif
using AuMach   = Aurora::Types::size_t;
using AuSMach  = Aurora::Types::ssize_t;
using AuSInt   = AuSMach;
using AuUInt   = AuMach;

using AuStreamReadWrittenPair_t = AuPair<AuUInt32, AuUInt32>;

using AuThreadId_t = AuUInt64;
static const AuThreadId_t kThreadIdSpecialMask = AuThreadId_t(1) << AuThreadId_t(63);

#if defined(__has_include) && !defined(_AUHAS_GLM)
    #if __has_include(<glm/glm.hpp>)
        #define _AUHAS_GLM
    #endif
#endif

#if !defined(_AUHAS_GLM)
    template<int N>
    struct AuFVec
    {
        float elements[N];

        float &operator [](int idx) const
        {
            return elements[N];
        }
    };
    
    using AuVec3 = AuFVec<3>;
    using AuVec4 = AuFVec<4>;
#else
    #include <glm/glm.hpp>

    using AuVec3 = glm::vec3;
    using AuVec4 = glm::vec4;
#endif