/***
    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

template<bool v>
struct AuBoolType
{
    static constexpr bool value = v;
    using value_type = bool;
    using type = AuBoolType;

    constexpr operator value_type() const noexcept
    {
        return value;
}

    constexpr value_type operator()() const noexcept
    {
        return value;
    }
};

using AuFalseType = AuBoolType<false>;
using AuTrueType = AuBoolType<true>;

template<class T, class U>
struct AuIsSame : AuFalseType
{};

template<class T>
struct AuIsSame<T, T> : AuTrueType
{};

template< class T, class U >
inline constexpr bool AuIsSame_v = AuIsSame<T, U>::value;

namespace _audetail {
    template <class T>
    AuBoolType<!std::is_union<T>::value> test(int T:: *);

    template <class>
    AuFalseType test(...);

    template <typename B>
    std::true_type test_pre_ptr_convertible(const volatile B *);
    template <typename>
    std::false_type test_pre_ptr_convertible(const volatile void *);

    template <typename, typename>
    auto test_pre_is_base_of(...)->std::true_type;
    template <typename B, typename D>
    auto test_pre_is_base_of(int) ->
        decltype(test_pre_ptr_convertible<B>(static_cast<D *>(nullptr)));
}

template<class T>
struct AuIsClass : decltype(_audetail::test<T>(nullptr))
{};

template<class T>
inline constexpr bool AuIsClass_v = AuIsClass<T>::value;

template <typename Base, typename Derived>
struct AuIsBaseOf :
    AuBoolType<
        AuIsClass_v<Base> &&
        AuIsClass_v<Derived> &&
        decltype(_audetail::test_pre_is_base_of<Base, Derived>(0))::value
    >
{};

template <typename Base, typename Derived>
inline constexpr bool AuIsBaseOf_v = AuIsBaseOf<Base, Derived>::value;

template <class>
inline constexpr bool AuIsPointer_v = false;

template <class _Ty>
inline constexpr bool AuIsPointer_v<_Ty *> = true;

template <class _Ty>
inline constexpr bool AuIsPointer_v<_Ty *const> = true;

template <class _Ty>
inline constexpr bool AuIsPointer_v<_Ty *volatile> = true;

template <class _Ty>
inline constexpr bool AuIsPointer_v<_Ty *const volatile> = true;

template<class T>
struct AuRemovePointer {typedef T type;};

template<class T>
struct AuRemovePointer<T*> {typedef T type;};

template<class T>
struct AuRemovePointer<T* const> {typedef T type;};

template<class T>
struct AuRemovePointer<T* volatile> {typedef T type;};

template<class T>
struct AuRemovePointer<T* const volatile> {typedef T type;};

template<class T>
using AuRemovePointer_t = typename AuRemovePointer<T>::type;

template<class T>
using AuIsVoid = AuIsSame<void, T>;

template <class T>
inline constexpr bool AuIsVoid_v = AuIsVoid<T>::value;

template <class T>
struct AuRemoveReference
{
    using type = T;
};

template <class T>
struct AuRemoveReference<T &>
{
    using type = T;
};

template <class T>
struct AuRemoveReference<T &&>
{
    using type = T;
};

template <class T>
using AuRemoveReference_t = typename AuRemoveReference<T>::type;

template <class T>
constexpr AuRemoveReference_t<T> &&AuMove(T &&arg) noexcept
{
    return static_cast<AuRemoveReference_t<T> &&>(arg);
}


template<bool Test, class T = void>
struct AuEnableIf
{
};

template<class T>
struct AuEnableIf<true, T>
{
    using type = T;
};

template<bool Test, class T = void>
using AuEnableIf_t = typename AuEnableIf<Test, T>::type;


template<bool Test, class T, class T2>
struct AuConditional
{
    using type = T;
};

template<class T, class T2>
struct AuConditional<false, T, T2>
{
    using type = T2;
};

template<bool Test, class T, class T2>
using AuConditional_t = typename AuConditional<Test, T, T2>::type;


#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<AuIsClass_v<T>, 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

#if !defined(AURORA_RUNTIME_AU_DEFAULT_DELETER)
#define AURORA_RUNTIME_AU_DEFAULT_DELETER = std::default_delete<T>
#endif

template<typename T, typename Deleter_t AURORA_RUNTIME_AU_DEFAULT_DELETER>
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_RUNTIME_AU_TUPLE)
#define AURORA_RUNTIME_AU_TUPLE std::tuple
#endif

template<class... Types>
using AuTuple = AURORA_RUNTIME_AU_TUPLE<Types...>;

#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<typename ...T>
using AuPredicate = AuFunction<bool(T...)>;

using AuVoidFunc = AuFunction<void(void)>;

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

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

template<class T, typename ...Args>
using AuSupplierConsumer = AuFunction<T(Args...)>;

//#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) && defined(_AU_DETECT_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];
        }
        
        float &operator [](int idx)
        {
            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