/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include <DebugEventStream.h>

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

#include <DataIO.h>

#include <system_profiler_defs.h>


#define INPUT_BUFFER_SIZE       (128 * 1024)


BDebugEventInputStream::BDebugEventInputStream()
        :
        fStream(NULL),
        fFlags(0),
        fEventMask(0),
        fBuffer(NULL),
        fBufferCapacity(0),
        fBufferSize(0),
        fBufferPosition(0),
        fStreamPosition(0),
        fOwnsBuffer(false)
{
}


BDebugEventInputStream::~BDebugEventInputStream()
{
        Unset();

        if (fOwnsBuffer)
                free(fBuffer);
}


status_t
BDebugEventInputStream::SetTo(BDataIO* stream)
{
        Unset();

        // set the new values
        if (stream == NULL)
                return B_BAD_VALUE;

        fStream = stream;

        // allocate a buffer
        if (fBuffer == NULL) {
                fBuffer = (uint8*)malloc(INPUT_BUFFER_SIZE);
                if (fBuffer == NULL) {
                        Unset();
                        return B_NO_MEMORY;
                }

                fOwnsBuffer = true;
                fBufferCapacity = INPUT_BUFFER_SIZE;
                fBufferSize = 0;
        }

        return _Init();
}


status_t
BDebugEventInputStream::SetTo(const void* data, size_t size,
        bool takeOverOwnership)
{
        Unset();

        if (data == NULL || size == 0)
                return B_BAD_VALUE;

        if (fBuffer != NULL) {
                if (fOwnsBuffer)
                        free(fBuffer);
                fBuffer = NULL;
                fBufferCapacity = 0;
                fBufferSize = 0;
        }

        fBuffer = (uint8*)data;
        fBufferCapacity = fBufferSize = size;
        fOwnsBuffer = takeOverOwnership;

        return _Init();
}


void
BDebugEventInputStream::Unset()
{
        fStream = NULL;
        fFlags = 0;
        fEventMask = 0;

        // If we have a buffer that we own and has the right size, we keep it.
        if (fOwnsBuffer) {
                if (fBuffer != NULL && fBufferSize != INPUT_BUFFER_SIZE) {
                        free(fBuffer);
                        fBuffer = NULL;
                        fBufferCapacity = 0;
                        fBufferSize = 0;
                }
        } else {
                fBuffer = NULL;
                fBufferCapacity = 0;
                fBufferSize = 0;
        }
}


status_t
BDebugEventInputStream::Seek(off_t streamOffset)
{
        // TODO: Support for streams, at least for BPositionIOs.
        if (fStream != NULL)
                return B_UNSUPPORTED;

        if (streamOffset < 0 || streamOffset > (off_t)fBufferCapacity)
                return B_BUFFER_OVERFLOW;

        fStreamPosition = 0;
        fBufferPosition = streamOffset;
        fBufferSize = fBufferCapacity - streamOffset;

        return B_OK;
}


/*!     \brief Returns the next event in the stream.

        At the end of the stream \c 0 is returned and \c *_buffer is set to \c NULL.
        For events that don't have data associated with them, \c *_buffer will still
        be non-NULL, even if dereferencing that address is not allowed.

        \param _event Pointer to a pre-allocated location where the event ID shall
                be stored.
        \param _cpu Pointer to a pre-allocated location where the CPU index shall
                be stored.
        \param _buffer Pointer to a pre-allocated location where the pointer to the
                event data shall be stored.
        \param _streamOffset Pointer to a pre-allocated location where the event
                header's offset relative to the beginning of the stream shall be stored.
                May be \c NULL.
        \return A negative error code in case an error occurred while trying to read
                the info, the size of the data associated with the event otherwise.
*/
ssize_t
BDebugEventInputStream::ReadNextEvent(uint32* _event, uint32* _cpu,
        const void** _buffer, off_t* _streamOffset)
{
        // get the next header
        status_t error = _GetData(sizeof(system_profiler_event_header));
        if (error != B_OK) {
                if (error == B_BAD_DATA && fBufferSize == 0) {
                        *_buffer = NULL;
                        return 0;
                }
                return error;
        }

        system_profiler_event_header header
                = *(system_profiler_event_header*)(fBuffer + fBufferPosition);

        off_t streamOffset = fStreamPosition + fBufferPosition;

        // skip the header in the buffer
        fBufferSize -= sizeof(system_profiler_event_header);
        fBufferPosition += sizeof(system_profiler_event_header);

        // get the data
        if (header.size > 0) {
                error = _GetData(header.size);
                if (error != B_OK)
                        return error;
        }

        *_event = header.event;
        *_cpu = header.cpu;
        *_buffer = fBuffer + fBufferPosition;
        if (_streamOffset)
                *_streamOffset = streamOffset;

        // skip the event in the buffer
        fBufferSize -= header.size;
        fBufferPosition += header.size;

        return header.size;
}


status_t
BDebugEventInputStream::_Init()
{
        fStreamPosition = 0;
        fBufferPosition = 0;

        // get the header
        status_t error = _GetData(sizeof(debug_event_stream_header));
        if (error != B_OK) {
                Unset();
                return error;
        }
        const debug_event_stream_header& header
                = *(const debug_event_stream_header*)(fBuffer + fBufferPosition);

        fBufferPosition += sizeof(debug_event_stream_header);
        fBufferSize -= sizeof(debug_event_stream_header);

        // check the header
        if (strncmp(header.signature, B_DEBUG_EVENT_STREAM_SIGNATURE,
                        sizeof(header.signature)) != 0
                || header.version != B_DEBUG_EVENT_STREAM_VERSION
                || (header.flags & B_DEBUG_EVENT_STREAM_FLAG_HOST_ENDIAN) == 0) {
                // TODO: Support non-host endianess!
                Unset();
                return B_BAD_DATA;
        }

        fFlags = header.flags;
        fEventMask = header.event_mask;

        return B_OK;
}


ssize_t
BDebugEventInputStream::_Read(void* _buffer, size_t size)
{
        uint8* buffer = (uint8*)_buffer;
        size_t totalBytesRead = 0;
        ssize_t bytesRead = 0;

        while (size > 0 && (bytesRead = fStream->Read(buffer, size)) > 0) {
                totalBytesRead += bytesRead;
                buffer += bytesRead;
                size -= bytesRead;
        }

        if (bytesRead < 0)
                return bytesRead;

        return totalBytesRead;
}


status_t
BDebugEventInputStream::_GetData(size_t size)
{
        if (fBufferSize >= size)
                return B_OK;

        if (size > fBufferCapacity)
                return B_BUFFER_OVERFLOW;

        // move remaining data to the start of the buffer
        if (fBufferSize > 0 && fBufferPosition > 0)
                memmove(fBuffer, fBuffer + fBufferPosition, fBufferSize);
        fStreamPosition += fBufferPosition;
        fBufferPosition = 0;

        // read more data
        if (fStream != NULL) {
                ssize_t bytesRead = _Read(fBuffer + fBufferSize,
                        fBufferCapacity - fBufferSize);
                if (bytesRead < 0)
                        return bytesRead;

                fBufferSize += bytesRead;
        }

        return fBufferSize >= size ? B_OK : B_BAD_DATA;
}


// #pragma mark - BDebugEventOutputStream


BDebugEventOutputStream::BDebugEventOutputStream()
        :
        fStream(NULL),
        fFlags(0)
{
}


BDebugEventOutputStream::~BDebugEventOutputStream()
{
        Unset();
}


status_t
BDebugEventOutputStream::SetTo(BDataIO* stream, uint32 flags, uint32 eventMask)
{
        Unset();

        // set the new values
        if (stream == NULL)
                return B_BAD_VALUE;

        fStream = stream;
        fFlags = /*(flags & B_DEBUG_EVENT_STREAM_FLAG_ZIPPED)
                |*/ B_DEBUG_EVENT_STREAM_FLAG_HOST_ENDIAN;
                // TODO: Support zipped data!

        // init and write the header
        debug_event_stream_header header;
        memset(header.signature, 0, sizeof(header.signature));
        strlcpy(header.signature, B_DEBUG_EVENT_STREAM_SIGNATURE,
                sizeof(header.signature));
        header.version = B_DEBUG_EVENT_STREAM_VERSION;
        header.flags = fFlags;
        header.event_mask = eventMask;

        ssize_t written = fStream->Write(&header, sizeof(header));
        if (written < 0) {
                Unset();
                return written;
        }
        if ((size_t)written != sizeof(header)) {
                Unset();
                return B_FILE_ERROR;
        }

        return B_OK;
}


void
BDebugEventOutputStream::Unset()
{
        Flush();
        fStream = NULL;
        fFlags = 0;
}


status_t
BDebugEventOutputStream::Write(const void* buffer, size_t size)
{
        if (size == 0)
                return B_OK;
        if (buffer == NULL)
                return B_BAD_VALUE;

        ssize_t written = fStream->Write(buffer, size);
        if (written < 0)
                return written;
        if ((size_t)written != size)
                return B_FILE_ERROR;

        return B_OK;
}


status_t
BDebugEventOutputStream::Flush()
{
        return B_OK;
}