/*
 * Copyright 2022 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Leorize, leorize+oss@disroot.org
 */


#include <MemoryRingIO.h>

#include <AutoLocker.h>

#include <algorithm>

#include <stdlib.h>
#include <string.h>


class PThreadLocking {
public:
        inline bool Lock(pthread_mutex_t* mutex)
        {
                return pthread_mutex_lock(mutex) == 0;
        }

        inline void Unlock(pthread_mutex_t* mutex)
        {
                pthread_mutex_unlock(mutex);
        }
};


typedef AutoLocker<pthread_mutex_t, PThreadLocking> PThreadAutoLocker;


struct ReadCondition {
        inline bool operator()(BMemoryRingIO &ring) {
                return ring.BytesAvailable() != 0;
        }
};


struct WriteCondition {
        inline bool operator()(BMemoryRingIO &ring) {
                return ring.SpaceAvailable() != 0;
        }
};


#define RING_MASK(x) ((x) & (fBufferSize - 1))


static size_t
next_power_of_two(size_t value)
{
        value--;
        value |= value >> 1;
        value |= value >> 2;
        value |= value >> 4;
        value |= value >> 8;
        value |= value >> 16;
#if SIZE_MAX >= UINT64_MAX
        value |= value >> 32;
#endif
        value++;

        return value;
}


BMemoryRingIO::BMemoryRingIO(size_t size)
        :
        fBuffer(NULL),
        fBufferSize(0),
        fWriteAtNext(0),
        fReadAtNext(0),
        fBufferFull(false),
        fWriteDisabled(false)
{
        // We avoid the use of pthread_mutexattr as it can possibly fail.
        //
        // The only Haiku-specific behavior that we depend on is that
        // PTHREAD_MUTEX_DEFAULT mutexes check for double-locks.
        pthread_mutex_init(&fLock, NULL);
        pthread_cond_init(&fEvent, NULL);

        SetSize(size);
}


BMemoryRingIO::~BMemoryRingIO()
{
        SetSize(0);

        pthread_mutex_destroy(&fLock);
        pthread_cond_destroy(&fEvent);
}


status_t
BMemoryRingIO::InitCheck() const
{
        if (fBufferSize == 0)
                return B_NO_INIT;

        return B_OK;
}


ssize_t
BMemoryRingIO::Read(void* _buffer, size_t size)
{
        if (_buffer == NULL)
                return B_BAD_VALUE;
        if (size == 0)
                return 0;

        PThreadAutoLocker _(fLock);

        if (!fWriteDisabled)
                WaitForRead();

        size = std::min(size, BytesAvailable());
        uint8* buffer = reinterpret_cast<uint8*>(_buffer);
        if (fReadAtNext + size < fBufferSize)
                memcpy(buffer, fBuffer + fReadAtNext, size);
        else {
                const size_t upper = fBufferSize - fReadAtNext;
                const size_t lower = size - upper;
                memcpy(buffer, fBuffer + fReadAtNext, upper);
                memcpy(buffer + upper, fBuffer, lower);
        }
        fReadAtNext = RING_MASK(fReadAtNext + size);
        fBufferFull = false;

        pthread_cond_signal(&fEvent);

        return size;
}


ssize_t
BMemoryRingIO::Write(const void* _buffer, size_t size)
{
        if (_buffer == NULL)
                return B_BAD_VALUE;
        if (size == 0)
                return 0;

        PThreadAutoLocker locker(fLock);

        if (!fWriteDisabled)
                WaitForWrite();

        // We separate this check from WaitForWrite() as the boolean
        // might have been toggled during our wait on the conditional.
        if (fWriteDisabled)
                return B_READ_ONLY_DEVICE;

        const uint8* buffer = reinterpret_cast<const uint8*>(_buffer);
        size = std::min(size, SpaceAvailable());
        if (fWriteAtNext + size < fBufferSize)
                memcpy(fBuffer + fWriteAtNext, buffer, size);
        else {
                const size_t upper = fBufferSize - fWriteAtNext;
                const size_t lower = size - upper;
                memcpy(fBuffer + fWriteAtNext, buffer, size);
                memcpy(fBuffer, buffer + upper, lower);
        }
        fWriteAtNext = RING_MASK(fWriteAtNext + size);
        fBufferFull = fReadAtNext == fWriteAtNext;

        pthread_cond_signal(&fEvent);

        return size;
}


status_t
BMemoryRingIO::SetSize(size_t _size)
{
        PThreadAutoLocker locker(fLock);

        const size_t size = next_power_of_two(_size);

        const size_t availableBytes = BytesAvailable();
        if (size < availableBytes)
                return B_BAD_VALUE;

        if (size == 0) {
                free(fBuffer);
                fBuffer = NULL;
                fBufferSize = 0;
                Clear(); // resets other internal counters
                return B_OK;
        }

        uint8* newBuffer = reinterpret_cast<uint8*>(malloc(size));
        if (newBuffer == NULL)
                return B_NO_MEMORY;

        Read(newBuffer, availableBytes);
        free(fBuffer);

        fBuffer = newBuffer;
        fBufferSize = size;
        fReadAtNext = 0;
        fWriteAtNext = RING_MASK(availableBytes);
        fBufferFull = fBufferSize == availableBytes;

        pthread_cond_signal(&fEvent);

        return B_OK;
}


void
BMemoryRingIO::Clear()
{
        PThreadAutoLocker locker(fLock);

        fReadAtNext = 0;
        fWriteAtNext = 0;
        fBufferFull = false;
}


size_t
BMemoryRingIO::BytesAvailable()
{
        PThreadAutoLocker locker(fLock);

        if (fWriteAtNext == fReadAtNext) {
                if (fBufferFull)
                        return fBufferSize;
                return 0;
        }
        return RING_MASK(fWriteAtNext - fReadAtNext);
}


size_t
BMemoryRingIO::SpaceAvailable()
{
        PThreadAutoLocker locker(fLock);

        return fBufferSize - BytesAvailable();
}


size_t
BMemoryRingIO::BufferSize()
{
        PThreadAutoLocker locker(fLock);

        return fBufferSize;
}


template<typename Condition>
status_t
BMemoryRingIO::_WaitForCondition(bigtime_t timeout)
{
        PThreadAutoLocker autoLocker;

        struct timespec absTimeout;
        if (timeout == B_INFINITE_TIMEOUT) {
                autoLocker.SetTo(fLock, false);
        } else {
                memset(&absTimeout, 0, sizeof(absTimeout));
                bigtime_t target = system_time() + timeout;
                absTimeout.tv_sec = target / 100000;
                absTimeout.tv_nsec = (target % 100000) * 1000L;
                int err = pthread_mutex_timedlock(&fLock, &absTimeout);
                if (err == ETIMEDOUT)
                        return B_TIMED_OUT;
                if (err != EDEADLK)
                        autoLocker.SetTo(fLock, true);
        }

        Condition cond;
        while (!cond(*this)) {
                if (fWriteDisabled)
                        return B_READ_ONLY_DEVICE;

                int err = 0;

                if (timeout == B_INFINITE_TIMEOUT)
                        err = pthread_cond_wait(&fEvent, &fLock);
                else
                        err = pthread_cond_timedwait(&fEvent, &fLock, &absTimeout);

                if (err != 0)
                        return err;
        }

        return B_OK;
}


status_t
BMemoryRingIO::WaitForRead(bigtime_t timeout)
{
        return _WaitForCondition<ReadCondition>(timeout);
}


status_t
BMemoryRingIO::WaitForWrite(bigtime_t timeout)
{
        return _WaitForCondition<WriteCondition>(timeout);
}


void
BMemoryRingIO::SetWriteDisabled(bool disabled)
{
        PThreadAutoLocker autoLocker(fLock);

        fWriteDisabled = disabled;

        pthread_cond_broadcast(&fEvent);
}


bool
BMemoryRingIO::WriteDisabled()
{
        PThreadAutoLocker autoLocker(fLock);

        return fWriteDisabled;
}