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

    File: AuMutex.Linux.cpp
    Date: 2022-12-28
    Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include "AuMutex.Generic.hpp"

#include <sys/syscall.h>
#include <linux/futex.h>
#include "SMTYield.hpp"

#if !defined(_AURUNTIME_GENERIC_MUTEX)
#include <Source/Time/Time.hpp>
        
namespace Aurora::Threading::Primitives
{
    #define barrier() __asm__ __volatile__("sfence": : :"memory")
    #define compilerReorderBarrier() __asm__ __volatile__("": : :"memory")

    MutexImpl::MutexImpl()
    {

    }
    
    MutexImpl::~MutexImpl()
    {

    }

    bool MutexImpl::HasOSHandle(AuMach &mach)
    {
        return false;
    }
    
    bool MutexImpl::HasLockImplementation()
    {
        return true;
    }
    
    bool MutexImpl::TryLock()
    {
        return DoTryIf([=]()
        {
            return AuAtomicTestAndSet(&this->state_, 0) == 0;
        });
    }

    bool MutexImpl::LockMS(AuUInt64 uTimeout)
    {
        return LockNS(AuMSToNS<AuUInt64>(uTimeout));
    }

    bool MutexImpl::LockNS(AuUInt64 uTimeout)
    {
        AuUInt64 uStart {};
        AuUInt64 uEnd {};
        
        if (this->TryLock())
        {
            return true;
        }

        AuAtomicAdd(&this->dwSleeping_, 1u);
        
        //redundant: 8.2.3.8
        //barrier();

        struct timespec tspec;
        if (uTimeout != 0)
        {
            uStart = AuTime::SteadyClockNS();
            uEnd   = uStart + uTimeout;
            
            Time::monoabsns2ts(&tspec, uEnd);
        }

        auto state = this->state_;
        while (!(state == 0 && 
                 AuAtomicCompareExchange<AuUInt32>(&this->state_, 1, state) == state))
        {
            if (uTimeout != 0)
            {
                if (Time::SteadyClockNS() >= uEnd)
                {
                    AuAtomicSub(&this->dwSleeping_, 1u);
                    return false;
                }

                int ret {};
                do
                {
                    ret = futex_wait(&this->state_, state, &tspec);
                }
                while (ret == EINTR);
            }
            else
            {
                int ret {};
                bool bStatus {};

                do
                {
                    if ((ret = futex_wait(&this->state_, state)) == 0)
                    {
                        bStatus = true;
                        break;
                    }

                    if (ret == EAGAIN || errno == EAGAIN)
                    {
                        bStatus = true;
                        break;
                    }
                    
                }
                while (ret == EINTR);

                RUNTIME_ASSERT_SHUTDOWN_SAFE(bStatus, "Mutex wait failed: {}", ret)
            }

            state = this->state_;
        }

        AuAtomicSub(&this->dwSleeping_, 1u);
        return true;
    }
    
    void MutexImpl::SlowLock()
    {
        auto status = LockMS(0);
        SysAssert(status, "Couldn't lock mutex");
    }
    
    void MutexImpl::Unlock()
    {
        __sync_lock_release(&this->state_);
        compilerReorderBarrier();
        if (this->dwSleeping_)
        {
            futex_wake(&this->state_, 1);
        }
    }
    
    AUKN_SYM IHyperWaitable *MutexNew()
    {
        return _new MutexImpl();
    }

    AUKN_SYM void MutexRelease(IHyperWaitable *pMutex)
    {
        AuSafeDelete<MutexImpl *>(pMutex);
    }

    AUROXTL_INTERFACE_SOO_SRC_EX(AURORA_SYMBOL_EXPORT, Mutex, MutexImpl)
}
#endif