/*
 * Copyright 2006-2007, Haiku. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Stephan Aßmus <superstippi@gmx.de>
 */


#include "LittleEndianBuffer.h"

#include <ByteOrder.h>

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


_USING_ICON_NAMESPACE


#define CHUNK_SIZE 256


// constructor
LittleEndianBuffer::LittleEndianBuffer()
        : fBuffer((uint8*)malloc(CHUNK_SIZE)),
          fHandle(fBuffer),
          fBufferEnd(fBuffer + CHUNK_SIZE),
          fSize(CHUNK_SIZE),
          fOwnsBuffer(true)
{
}

// constructor
LittleEndianBuffer::LittleEndianBuffer(size_t size)
        : fBuffer((uint8*)malloc(size)),
          fHandle(fBuffer),
          fBufferEnd(fBuffer + size),
          fSize(size),
          fOwnsBuffer(true)
{
}

// constructor
LittleEndianBuffer::LittleEndianBuffer(uint8* buffer, size_t size)
        : fBuffer(buffer),
          fHandle(fBuffer),
          fBufferEnd(fBuffer + size),
          fSize(size),
          fOwnsBuffer(false)
{
}

// destructor
LittleEndianBuffer::~LittleEndianBuffer()
{
        if (fOwnsBuffer)
                free(fBuffer);
}

// Write 8
bool
LittleEndianBuffer::Write(uint8 value)
{
        if (fHandle == fBufferEnd)
                _SetSize(fSize + CHUNK_SIZE);

        if (!fBuffer)
                return false;

        *fHandle = value;
        fHandle++;

        return true;
}

// Write 16
bool
LittleEndianBuffer::Write(uint16 value)
{
        if ((fHandle + 1) >= fBufferEnd)
                _SetSize(fSize + CHUNK_SIZE);

        if (!fBuffer)
                return false;

        *(uint16*)fHandle = B_HOST_TO_LENDIAN_INT16(value);
        fHandle += 2;

        return true;
}

// Write 32
bool
LittleEndianBuffer::Write(uint32 value)
{
        if ((fHandle + 3) >= fBufferEnd)
                _SetSize(fSize + CHUNK_SIZE);

        if (!fBuffer)
                return false;

        *(uint32*)fHandle = B_HOST_TO_LENDIAN_INT32(value);
        fHandle += 4;

        return true;
}

// Write double
bool
LittleEndianBuffer::Write(float value)
{
        if ((fHandle + sizeof(float) - 1) >= fBufferEnd)
                _SetSize(fSize + CHUNK_SIZE);

        if (!fBuffer)
                return false;

        *(float*)fHandle = B_HOST_TO_LENDIAN_FLOAT(value);
        fHandle += sizeof(float);

        return true;
}

// Write double
bool
LittleEndianBuffer::Write(double value)
{
        if ((fHandle + sizeof(double) - 1) >= fBufferEnd)
                _SetSize(fSize + CHUNK_SIZE);

        if (!fBuffer)
                return false;

        *(double*)fHandle = B_HOST_TO_LENDIAN_DOUBLE(value);
        fHandle += sizeof(double);

        return true;
}

// Write LittleEndianBuffer
bool
LittleEndianBuffer::Write(const LittleEndianBuffer& other)
{
        return Write(other.Buffer(), other.SizeUsed());
}

// Write buffer
bool
LittleEndianBuffer::Write(const uint8* buffer, size_t bytes)
{
        if (bytes == 0)
                return true;

        // figure out needed size and suitable new size
        size_t neededSize = SizeUsed() + bytes;
        size_t newSize = fSize;
        while (newSize < neededSize)
                newSize += CHUNK_SIZE;

        // resize if necessary
        if (newSize > fSize)
                _SetSize(newSize);

        if (!fBuffer)
                return false;

        // paste buffer
        memcpy(fHandle, buffer, bytes);
        fHandle += bytes;

        return true;
}

// #pragma mark -

// Read 8
bool
LittleEndianBuffer::Read(uint8& value)
{
        if (fHandle >= fBufferEnd)
                return false;

        value = *fHandle++;

        return true;
}

// Read 16
bool
LittleEndianBuffer::Read(uint16& value)
{
        if ((fHandle + 1) >= fBufferEnd)
                return false;

        value = B_LENDIAN_TO_HOST_INT16(*(uint16*)fHandle);
        fHandle += 2;

        return true;
}

// Read 32
bool
LittleEndianBuffer::Read(uint32& value)
{
        if ((fHandle + 3) >= fBufferEnd)
                return false;

        value = B_LENDIAN_TO_HOST_INT32(*(uint32*)fHandle);
        fHandle += 4;

        return true;
}

// Read float
bool
LittleEndianBuffer::Read(float& value)
{
        if ((fHandle + sizeof(float) - 1) >= fBufferEnd)
                return false;

        value = B_LENDIAN_TO_HOST_FLOAT(*(float*)fHandle);
        fHandle += sizeof(float);

        return true;
}

// Read double
bool
LittleEndianBuffer::Read(double& value)
{
        if ((fHandle + sizeof(double) - 1) >= fBufferEnd)
                return false;

        value = B_LENDIAN_TO_HOST_DOUBLE(*(double*)fHandle);
        fHandle += sizeof(double);

        return true;
}

// Read LittleEndianBuffer
bool
LittleEndianBuffer::Read(LittleEndianBuffer& other, size_t bytes)
{
        if ((fHandle + bytes - 1) >= fBufferEnd)
                return false;

        if (other.Write(fHandle, bytes)) {
                // reset other handle to beginning of pasted data
                other.fHandle -= bytes;
                fHandle += bytes;
                return true;
        }

        return false;
}

// #pragma mark -

// Skip
void
LittleEndianBuffer::Skip(size_t bytes)
{
        // NOTE: is ment to be used while reading!!
        // when used while writing, the growing will not work reliably
        fHandle += bytes;
}

// Reset
void
LittleEndianBuffer::Reset()
{
        fHandle = fBuffer;
}

// #pragma mark -

// _SetSize
void
LittleEndianBuffer::_SetSize(size_t size)
{
        if (!fOwnsBuffer) {
                // prevent user error
                // (we are in read mode)
                fBuffer = NULL;
                return;
        }

        int32 pos = fHandle - fBuffer;
        fBuffer = (uint8*)realloc((void*)fBuffer, size);
        fHandle = fBuffer + pos;
        fBufferEnd = fBuffer + size;
        fSize = size;
}