/*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
**]  All rights reserved.
*
* vi:ts=4 sw=4 tw=75
*
* Distributable under the terms and conditions of the 2-clause BSD license;
* see the file COPYING for a complete text of the license.
*
**************************************************************************/

#include "../config.h"

#include <algorithm>
#if HAVE_BYTESWAP_H
#include <byteswap.h>
#endif
#include <cstdlib>

#if HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif

#include <SDL/SDL.h>

#include "Packet.hh"


#ifndef bswap_16
#define bswap_16(x) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8))
#endif

#ifndef bswap_32
#define bswap_32(x) ((((x) & 0xff000000) >> 24) | \
					(((x)  & 0x00ff0000) >>  8) | \
					(((x)  & 0x0000ff00) <<  8) | \
					(((x)  & 0x000000ff) << 24))
#endif

#ifndef bswap_64
#define bswap_64(x)	(((x) << 56) | \
					(((x) << 40) & 0xff000000000000ULL) | \
					(((x) << 24) & 0xff0000000000ULL) | \
					(((x) << 8)  & 0xff00000000ULL) | \
					(((x) >> 8)  & 0xff000000ULL) | \
					(((x) >> 24) & 0xff0000ULL) | \
					(((x) >> 40) & 0xff00ULL) | \
					((x)  >> 56))
#endif


#if !HAVE_ARPA_INET_H
static uint16_t htons(uint16_t x)
{
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
	return bswap_16(x);
#else
	return x;
#endif
}
static uint16_t ntohs(uint16_t x)
{
	return htons(x);
}

static uint32_t htonl(uint32_t x)
{
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
	return bswap_32(x);
#else
	return x;
#endif
}
static uint32_t ntohl(uint32_t x)
{
	return htonl(x);
}
#endif


static uint64_t htonll(uint64_t x)
{
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
	return bswap_64(x);
#else
	return x;
#endif
}
static uint64_t ntohll(uint64_t x)
{
	return htonll(x);
}


namespace Mf {
	

Packet::Packet(size_t capacity) :
	mBuffer((char*)malloc(capacity)),
	mSize(capacity),
	mR(0),
	mW(0),
	mOriginalW(0),
	mBoolR(0),
	mBoolW(0),
	mBoolNumR(0),
	mBoolNumW(0) {}

Packet::Packet(const char* data, size_t size) :
	mBuffer((char*)malloc(size)),
	mSize(size),
	mR(0),
	mW(size),
	mOriginalW(size),
	mBoolR(0),
	mBoolW(0),
	mBoolNumR(0),
	mBoolNumW(0)
{
	if (mBuffer) memcpy(mBuffer, data, size);
}


Packet::Packet(const Packet& copy) :
	mBuffer((char*)malloc(copy.mSize)),
	mSize(copy.mSize),
	mR(copy.mR),
	mW(copy.mW),
	mOriginalW(copy.mOriginalW),
	mBoolR(copy.mBoolR),
	mBoolW(copy.mBoolW),
	mBoolNumR(copy.mBoolNumR),
	mBoolNumW(copy.mBoolNumW)
{
	if (mBuffer) memcpy(mBuffer, copy.mBuffer, mSize);
}

Packet& Packet::operator=(const Packet& copy)
{
	free(mBuffer);

	mBuffer = (char*)malloc(copy.mSize);
	mSize = copy.mSize;
	mR = copy.mR;
	mW = copy.mW;
	mOriginalW = copy.mOriginalW;
	mBoolR = copy.mBoolR;
	mBoolW = copy.mBoolW;
	mBoolNumR = copy.mBoolNumR;
	mBoolNumW = copy.mBoolNumW;
	if (mBuffer) memcpy(mBuffer, copy.mBuffer, mSize);
	return *this;
}


Packet::~Packet()
{
	free(mBuffer);
}


bool Packet::put(bool value)
{
	int bit = mBoolNumW % 8;
	if (bit == 0)
	{
		mBoolW = mW;

		unsigned char byte = 0;
		if (write(&byte, 1) == 0) return false;
	}

	if (value) mBuffer[mBoolW] |= (1 << bit);
	++mBoolNumW;
	return true;
}


bool Packet::put(int8_t value)
{
	return put(uint8_t(value));
}

bool Packet::put(int16_t value)
{
	return put(uint16_t(value));
}

bool Packet::put(int32_t value)
{
	return put(uint32_t(value));
}

bool Packet::put(int64_t value)
{
	return put(uint64_t(value));
}


bool Packet::put(uint8_t value)
{
	return write(&value, sizeof(value)) == sizeof(value);
}

bool Packet::put(uint16_t value)
{
	value = htons(value);
	return write(&value, sizeof(value)) == sizeof(value);
}

bool Packet::put(uint32_t value)
{
	value = htonl(value);
	return write(&value, sizeof(value)) == sizeof(value);
}

bool Packet::put(uint64_t value)
{
	value = htonll(value);
	return write(&value, sizeof(value)) == sizeof(value);
}

bool Packet::put(float value)
{
	// XXX: assumes the ieee-754
	uint32_t* integer = reinterpret_cast<uint32_t*>(&value);
	*integer = htonl(*integer);
	return write(integer, sizeof(value)) == sizeof(value);
}

bool Packet::put(double value)
{
	// XXX: assumes the ieee-754
	uint64_t* integer = reinterpret_cast<uint64_t*>(&value);
	*integer = htonll(*integer);
	return write(integer, sizeof(value)) == sizeof(value);
}


size_t Packet::write(const void* bytes, size_t size)
{
	size_t nBytes = std::min(size, mSize - mW);
	if (!mBuffer || nBytes < size)
	{
		int nPages = 1 + size / PAGE_SIZE;
		int newSize = mSize + nPages * PAGE_SIZE;
		char* newBuffer = (char*)realloc(mBuffer, newSize);
		if (newBuffer)
		{
			mBuffer = newBuffer;
			mSize = newSize;
			nBytes = size;
		}
		if (!mBuffer) return 0;
	}
	memcpy(mBuffer + mW, bytes, nBytes);
	mW += nBytes;
	return nBytes;
}


bool Packet::get(bool& value, int flags)
{
	int bit = mBoolNumR % 8;
	if (bit == 0)
	{
		mBoolR = mR;

		unsigned char byte = 0;
		if (read(&byte, 1, flags) == 0) return false;
	}

	value = 1 & (mBuffer[mBoolR] >> bit);
	if (!(flags & PEEK)) ++mBoolNumR;
	return true;
}

bool Packet::get(int8_t& value, int flags)
{
	return get((uint8_t&)value, flags);
}

bool Packet::get(int16_t& value, int flags)
{
	return get((uint16_t&)value, flags);
}

bool Packet::get(int32_t& value, int flags)
{
	return get((uint32_t&)value, flags);
}

bool Packet::get(int64_t& value, int flags)
{
	return get((uint64_t&)value, flags);
}

bool Packet::get(uint8_t& value, int flags)
{
	size_t numBytes = read(&value, sizeof(value), flags);
	return numBytes == sizeof(value);
}

bool Packet::get(uint16_t& value, int flags)
{
	size_t numBytes = read(&value, sizeof(value), flags);
	value = ntohs(value);
	return numBytes == sizeof(value);
}

bool Packet::get(uint32_t& value, int flags)
{
	size_t numBytes = read(&value, sizeof(value), flags);
	value = ntohl(value);
	return numBytes == sizeof(value);
}

bool Packet::get(uint64_t& value, int flags)
{
	size_t numBytes = read(&value, sizeof(value), flags);
	value = ntohll(value);
	return numBytes == sizeof(value);
}

bool Packet::get(float& value, int flags)
{
	// XXX: assumes the ieee-754
	uint32_t* integer = reinterpret_cast<uint32_t*>(&value);
	size_t numBytes = read(integer, sizeof(value));
	*integer = htonl(*integer);
	return numBytes == sizeof(value);
}

bool Packet::get(double& value, int flags)
{
	// XXX: assumes the ieee-754
	uint64_t* integer = reinterpret_cast<uint64_t*>(&value);
	size_t numBytes = read(integer, sizeof(value));
	*integer = htonll(*integer);
	return numBytes == sizeof(value);
}


size_t Packet::read(void* bytes, size_t size, int flags)
{
	size_t nBytes = std::min(size, mW - mR);
	memcpy(bytes, mBuffer + mR, nBytes);
	if (!(flags & PEEK)) mR += nBytes;
	return nBytes;
}


void Packet::clear()
{
	mR = 0;
	mW = 0;
	mBoolR = 0;
	mBoolW = 0;
	mBoolNumR = 0;
	mBoolNumW = 0;
}


void Packet::reset()
{
	mR = 0;
	mW = mOriginalW;
	mBoolR = 0;
	mBoolW = 0;
	mBoolNumR = 0;
	mBoolNumW = 0;
}


} // namespace Mf