/*
 * Copyright 2016 Dario Casalinuovo. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 */

#include "AdapterIO.h"

#include <MediaIO.h>

#include <string.h>

#include "MediaDebug.h"


#define TIMEOUT_QUANTA 100000


class RelativePositionIO : public BPositionIO {
public:
        RelativePositionIO(BAdapterIO* owner, BPositionIO* buffer,
                bigtime_t timeout)
                :
                BPositionIO(),
                fOwner(owner),
                fBackPosition(0),
                fStartOffset(0),
                fBuffer(buffer),
                fTimeout(timeout)
        {
        }

        virtual ~RelativePositionIO()
        {
                delete fBuffer;
        }

        status_t ResetStartOffset(off_t offset)
        {
                status_t ret = fBuffer->SetSize(0);
                if (ret != B_OK)
                        return ret;

                fBackPosition = 0;
                fStartOffset = offset;
                return B_OK;
        }

        status_t FlushBefore(off_t position, BPositionIO* buffer, const void* oldBuffer,
                size_t oldLength)
        {
                AutoWriteLocker _(fLock);
                off_t relative = _PositionToRelative(position);
                if (relative < 0)
                        return B_OK;
                if (relative > (off_t)oldLength)
                        return B_BAD_VALUE;
                status_t status = buffer->WriteAt(0, (void*)((addr_t)oldBuffer + relative),
                        oldLength - relative);
                if (status < B_OK)
                        return status;
                status = buffer->Seek(fBuffer->Position() - relative, SEEK_SET);
                if (status < B_OK)
                        return status;
                fBackPosition -= relative;
                fStartOffset += relative;
                SetBuffer(buffer);
                return B_OK;
        }

        status_t EvaluatePosition(off_t position, off_t totalSize)
        {
                if (position < 0)
                        return B_ERROR;

                if (position < fStartOffset)
                        return B_RESOURCE_UNAVAILABLE;

                if (totalSize > 0 && position > totalSize) {
                        // This is an endless stream, we don't know
                        // how much data will come and when, we could
                        // block on that.
                        if (IsMutable())
                                return B_WOULD_BLOCK;
                        else
                                return B_ERROR;
                }

                return B_OK;
        }

        status_t WaitForData(off_t position, off_t size)
        {
                off_t bufferSize = 0;
                status_t ret = GetSize(&bufferSize);
                if (ret != B_OK)
                        return B_ERROR;

                bigtime_t totalTimeOut = 0;

                while (bufferSize < position + size) {
                        // We are not running, no luck to receive
                        // more data, let's return and avoid locking.
                        if (!fOwner->IsRunning())
                                return B_NOT_SUPPORTED;

                        if (fTimeout != B_INFINITE_TIMEOUT && totalTimeOut >= fTimeout)
                                return B_TIMED_OUT;

                        snooze(TIMEOUT_QUANTA);

                        totalTimeOut += TIMEOUT_QUANTA;
                        GetSize(&bufferSize);
                }
                return B_OK;
        }

        virtual ssize_t ReadAt(off_t position, void* buffer,
                size_t size)
        {
                AutoReadLocker _(fLock);

                return fBuffer->ReadAt(
                        _PositionToRelative(position), buffer, size);

        }

        virtual ssize_t WriteAt(off_t position,
                const void* buffer, size_t size)
        {
                AutoWriteLocker _(fLock);

                return fBuffer->WriteAt(
                        _PositionToRelative(position), buffer, size);
        }

        virtual off_t Seek(off_t position, uint32 seekMode)
        {
                AutoWriteLocker _(fLock);

                if (seekMode == SEEK_SET)
                        return fBuffer->Seek(_PositionToRelative(position), seekMode);
                return fBuffer->Seek(position, seekMode);
        }

        virtual off_t Position() const
        {
                AutoReadLocker _(fLock);

                return _RelativeToPosition(fBuffer->Position());
        }

        virtual status_t SetSize(off_t size)
        {
                AutoWriteLocker _(fLock);

                return fBuffer->SetSize(_PositionToRelative(size));
        }

        virtual status_t GetSize(off_t* size) const
        {
                AutoReadLocker _(fLock);

                // We use the backend position to make our buffer
                // independant of that.
                *size = _RelativeToPosition(fBackPosition);

                return B_OK;
        }

        ssize_t BackWrite(const void* buffer, size_t size)
        {
                AutoWriteLocker _(fLock);

                off_t ret = fBuffer->WriteAt(fBackPosition, buffer, size);
                fBackPosition += ret;
                return ret;
        }

        void SetBuffer(BPositionIO* buffer)
        {
                delete fBuffer;
                fBuffer = buffer;
        }

        bool IsStreaming() const
        {
                int32 flags = 0;
                fOwner->GetFlags(&flags);
                return ((flags & B_MEDIA_STREAMING) == B_MEDIA_STREAMING);
        }

        bool IsMutable() const
        {
                int32 flags = 0;
                fOwner->GetFlags(&flags);
                return ((flags & B_MEDIA_MUTABLE_SIZE) == B_MEDIA_MUTABLE_SIZE);
        }

        bool IsSeekable() const
        {
                int32 flags = 0;
                fOwner->GetFlags(&flags);
                return ((flags & B_MEDIA_SEEKABLE) == B_MEDIA_SEEKABLE);
        }

        const BPositionIO* Buffer() const
        {
                return fBuffer;
        }

private:

        off_t _PositionToRelative(off_t position) const
        {
                return position - fStartOffset;
        }

        off_t _RelativeToPosition(off_t position) const
        {
                return position + fStartOffset;
        }

        BAdapterIO*                     fOwner;
        off_t                           fBackPosition;
        off_t                           fStartOffset;

        BPositionIO*            fBuffer;

        mutable RWLocker        fLock;

        bigtime_t                       fTimeout;
};


BAdapterIO::BAdapterIO(int32 flags, bigtime_t timeout)
        :
        fFlags(flags),
        fBuffer(NULL),
        fTotalSize(0),
        fOpened(false),
        fSeekSem(-1),
        fInputAdapter(NULL)
{
        CALLED();

        fBuffer = new RelativePositionIO(this, new BMallocIO(), timeout);
}


BAdapterIO::BAdapterIO(const BAdapterIO &)
{
        // copying not allowed...
}


BAdapterIO::~BAdapterIO()
{
        CALLED();

        delete fInputAdapter;
        delete fBuffer;
}


void
BAdapterIO::GetFlags(int32* flags) const
{
        CALLED();

        *flags = fFlags;
}


ssize_t
BAdapterIO::ReadAt(off_t position, void* buffer, size_t size)
{
        CALLED();

        status_t ret = _EvaluateWait(position, size);
        if (ret != B_OK)
                return ret;

        return fBuffer->ReadAt(position, buffer, size);
}


ssize_t
BAdapterIO::WriteAt(off_t position, const void* buffer, size_t size)
{
        CALLED();

        return fBuffer->WriteAt(position, buffer, size);
}


off_t
BAdapterIO::Seek(off_t position, uint32 seekMode)
{
        CALLED();

        off_t absolutePosition = 0;
        off_t size = 0;

        if (seekMode == SEEK_CUR)
                absolutePosition = Position()+position;
        else if (seekMode == SEEK_END) {
                if (GetSize(&size) != B_OK)
                        return B_NOT_SUPPORTED;

                absolutePosition = size-position;
        }

        status_t ret = _EvaluateWait(absolutePosition, 0);

        if (ret == B_RESOURCE_UNAVAILABLE && fBuffer->IsStreaming()
                        && fBuffer->IsSeekable()) {

                fSeekSem = create_sem(0, "BAdapterIO seek sem");

                if (SeekRequested(absolutePosition) != B_OK)
                        return B_NOT_SUPPORTED;

                TRACE("BAdapterIO::Seek: Locking on backend seek\n");
                acquire_sem(fSeekSem);
                TRACE("BAdapterIO::Seek: Seek completed!\n");
                fBuffer->ResetStartOffset(absolutePosition);
        } else if (ret != B_OK)
                return B_NOT_SUPPORTED;

        return fBuffer->Seek(position, seekMode);
}


off_t
BAdapterIO::Position() const
{
        CALLED();

        return fBuffer->Position();
}


status_t
BAdapterIO::SetSize(off_t size)
{
        CALLED();

        if (!fBuffer->IsMutable()) {
                fTotalSize = size;
                return B_OK;
        }

        return fBuffer->SetSize(size);
}


status_t
BAdapterIO::GetSize(off_t* size) const
{
        CALLED();

        if (!fBuffer->IsMutable()) {
                *size = fTotalSize;
                return B_OK;
        }

        return fBuffer->GetSize(size);
}


status_t
BAdapterIO::Open()
{
        CALLED();

        fOpened = true;
        return B_OK;
}


bool
BAdapterIO::IsRunning() const
{
        return fOpened;
}


void
BAdapterIO::SeekCompleted()
{
        CALLED();
        release_sem(fSeekSem);
        delete_sem(fSeekSem);
        fSeekSem = -1;
}


status_t
BAdapterIO::SetBuffer(BPositionIO* buffer)
{
        // We can't change the buffer while we
        // are running.
        if (fOpened)
                return B_ERROR;

        fBuffer->SetBuffer(buffer);
        return B_OK;
}


status_t
BAdapterIO::FlushBefore(off_t position)
{
        BMallocIO* buffer = new BMallocIO();
        BMallocIO* oldBuffer = (BMallocIO*)fBuffer->Buffer();
        fBuffer->FlushBefore(position, buffer, oldBuffer->Buffer(), oldBuffer->BufferLength());
        return B_OK;
}


BInputAdapter*
BAdapterIO::BuildInputAdapter()
{
        if (fInputAdapter != NULL)
                return fInputAdapter;

        fInputAdapter = new BInputAdapter(this);
        return fInputAdapter;
}


status_t
BAdapterIO::SeekRequested(off_t position)
{
        CALLED();

        return B_ERROR;
}


ssize_t
BAdapterIO::BackWrite(const void* buffer, size_t size)
{
        return fBuffer->BackWrite(buffer, size);
}


status_t
BAdapterIO::_EvaluateWait(off_t pos, off_t size)
{
        CALLED();

        off_t totalSize = 0;
        if (GetSize(&totalSize) != B_OK)
                TRACE("BAdapterIO::ReadAt: Can't get our size!\n");

        TRACE("BAdapterIO::_EvaluateWait TS %" B_PRId64 " P %" B_PRId64
                " S %" B_PRId64 "\n", totalSize, pos, size);

        status_t err = fBuffer->EvaluatePosition(pos, totalSize);

        TRACE("BAdapterIO::_EvaluateWait: %s\n", strerror(err));

        if (err != B_OK && err != B_WOULD_BLOCK)
                return err;

        TRACE("BAdapterIO::_EvaluateWait: waiting for data\n");

        return fBuffer->WaitForData(pos, size);
}


BInputAdapter::BInputAdapter(BAdapterIO* io)
        :
        fIO(io)
{
}


BInputAdapter::~BInputAdapter()
{
}


ssize_t
BInputAdapter::Write(const void* buffer, size_t size)
{
        return fIO->BackWrite(buffer, size);
}


// FBC
void BAdapterIO::_ReservedAdapterIO1() {}
void BAdapterIO::_ReservedAdapterIO2() {}
void BAdapterIO::_ReservedAdapterIO3() {}
void BAdapterIO::_ReservedAdapterIO4() {}
void BAdapterIO::_ReservedAdapterIO5() {}

void BInputAdapter::_ReservedInputAdapter1() {}
void BInputAdapter::_ReservedInputAdapter2() {}