#include <cstring>
#include <netinet/in.h>

#include "common/stream/Stream.h"

Stream::Stream() : error(false), writeIndex(0), readIndex(0)
{
}

Stream::Stream(size_t capacity) : data(capacity), error(false), writeIndex(0), readIndex(0)
{
}

bool Stream::hasData() const
{
    return readIndex < writeIndex;
}

bool Stream::hasError() const
{
    return error;
}

void Stream::clearError()
{
    error = false;
}

void Stream::write(const void* writeData, size_t length)
{
    if(data.write(writeIndex, writeData, length))
    {
        writeIndex += length;
    }
    else
    {
        error = true;
    }
}

void Stream::write(const char* writeData)
{
    write(writeData, strlen(writeData));
}

void Stream::writeUnsignedChar(uint8_t uc)
{
    write(&uc, sizeof(uint8_t));
}

void Stream::writeUnsignedShort(uint16_t us)
{
    us = htons(us);
    write(&us, sizeof(uint16_t));
}

void Stream::writeUnsignedInt(uint32_t ui)
{
    ui = htonl(ui);
    write(&ui, sizeof(uint32_t));
}

void Stream::read(void* buffer, size_t length)
{
    if(readIndex + length <= writeIndex && data.read(readIndex, buffer, length))
    {
        readIndex += length;
    }
    else
    {
        error = true;
    }
}

uint8_t Stream::readUnsignedChar()
{
    unsigned char uc;
    read(&uc, sizeof(unsigned char));
    return uc;
}

uint16_t Stream::readUnsignedShort()
{
    uint16_t us;
    read(&us, sizeof(uint16_t));
    us = ntohs(us);
    return us;
}

uint32_t Stream::readUnsignedInt()
{
    uint32_t ui;
    read(&ui, sizeof(uint32_t));
    ui = ntohl(ui);
    return ui;
}

bool Stream::readSocket(int socket)
{
    readIndex = 0;
    return data.readSocket(socket, writeIndex);
}

void Stream::sendToSocket(int socket) const
{
    data.sendToSocket(socket, writeIndex);
}