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

    File: TLSVariable.hpp
    Date: 2021-6-11
    Author: Reece
***/
#pragma once

namespace Aurora::Threading::Threads
{
    AUKN_SYM bool DeadTest();

    template<typename T, bool bIsStatic = false>
    struct TLSVariable
    {
        TLSVariable()
        {
            // NOP
        }

        ~TLSVariable()
        {
        #if 0
            if constexpr (!bIsStatic)
        #endif
            {
                if (DeadTest())
                {
                    return;
                }

                TLSView::Remove(this->key);
            }
        }

        T *operator ->()
        {
            return &Get();
        }

        const T *operator ->() const
        {
            return &Get();
        }

        operator T &()
        {
            return Get();
        }

        operator const T &() const
        {
            return Get();
        }

        T operator *() const
        {
            return Get();
        }

        TLSVariable &operator =(const T &val)
        {
            Get() = val;
            return *this;
        }

        TLSVariable &operator =(T &&val)
        {
            Get() = AuMove(val);
            return *this;
        }

    private:
        TLSKey key;

        T &Get() const
        {
            return *reinterpret_cast<T *>(TLSView::InitTLS(((TLSVariable *)this)->key, //const-ness isnt enforced here
                                                           sizeof(T),
                                                           [](void *buffer) -> void
            {
                if constexpr (AuIsClass_v<T>)
                {
                    new (buffer) T();
                }
                else
                {
                    AuMemset(buffer, 0, sizeof(T));
                }
            },
                                                           [](void *buffer) -> void
            {
                if constexpr (AuIsClass_v<T>)
                {
                    reinterpret_cast<T *>(buffer)->~T();
                }
            }));
        }
    };
}