#include "GeoSerializer.h"


namespace Geometry
{
	//---------------------------------------------------------------------
	Serializer::Serializer(String name, Mode mode)
		: mMode(mode)
		{
			char *char_mode = 0;
			switch (mMode)
			{
				case READ : 
					char_mode = "rb"; 
					break;
				case APPEND:
					char_mode = "a+b";
					break;
				case WRITE:
					char_mode = "wb";
					break;
			}

			mFile = fopen(name.c_str(),char_mode);
			mSize = 0;
			assert(mFile);
		}

	//---------------------------------------------------------------------
	Serializer::~Serializer()
	{
		fflush(mFile);
		fclose(mFile);
	}

	//---------------------------------------------------------------------
	void Serializer::WriteArray(const float* const pFloat, size_t count)
	{
#	if GEO_ENDIAN == GEO_ENDIAN_BIG
		float *float_to_write = (float *)malloc(sizeof(float) * count);
		memcpy(float_to_write, pFloat, sizeof(float) * count);

		flipToLittleEndian(float_to_write, sizeof(float), count);
		writeData(float_to_write, sizeof(float), count);

		free(float_to_write);
# 	else
		WriteData(pFloat, sizeof(float), count);
#	endif
	}

	//---------------------------------------------------------------------
	void Serializer::WriteArray(const uint16* const pShort, size_t count = 1)
	{
#	if GEO_ENDIAN == GEO_ENDIAN_BIG
		unsigned short *short_to_write = (unsigned short *)malloc(sizeof(unsigned short) * count);
		memcpy(short_to_write, pShort, sizeof(unsigned short) * count);

		flipToLittleEndian(short_to_write, sizeof(unsigned short), count);
		WriteData(short_to_write, sizeof(unsigned short), count);

		free(short_to_write);
# 	else
		WriteData(pShort, sizeof(unsigned short), count);
#	endif
	}
	
	//---------------------------------------------------------------------
	void Serializer::WriteArray(const uint32* const pInt, size_t count = 1)
	{
#	if GEO_ENDIAN == GEO_ENDIAN_BIG
		unsigned int *int_to_write = (unsigned int *)malloc(sizeof(unsigned int) * count);
		memcpy(int_to_write, pInt, sizeof(unsigned int) * count);

		FlipToLittleEndian(int_to_write, sizeof(unsigned int), count);
		WriteData(int_to_write, sizeof(unsigned int), count);

		free(int_to_write);
# 	else
		WriteData(pInt, sizeof(unsigned int), count);
#	endif
	}

	//---------------------------------------------------------------------
	void Serializer::WriteArray(const bool* const pBool, size_t count = 1)
	{
		//TODO: Apple has problems 
		WriteData(pBool, sizeof(bool), count);
	}
	
	//---------------------------------------------------------------------
	void Serializer::WriteArray(const Vector3* const pDest, size_t count)
	{
		for(size_t i = 0; i < count; ++i)
		{
			WriteArray(pDest[i].val,3);
		}
	}
	
	//---------------------------------------------------------------------
	void Serializer::WriteArray(const Vector2* const pDest, size_t count)
	{
		for(size_t i = 0; i < count; ++i)
		{
			WriteArray(pDest[i].val,2);
		}
	}

	//---------------------------------------------------------------------
	void Serializer::WriteData(const void* const buf, size_t size, size_t count)
	{
		size_t wcount = fwrite((void* const)buf, size, count, mFile);
		assert(wcount == count);
		mSize += size*count;
	}

	//---------------------------------------------------------------------
	void Serializer::ReadData(void *pDest, size_t size, size_t count)
	{
		size_t rcount = fread(pDest,size,count,mFile);
		assert(rcount == count);
		mSize += size*count;
	};


	// JGA
	char * Serializer::miReadData(char *pDest, size_t pDestsize)
	{
		return fgets(pDest, (int)pDestsize, mFile);
	};

	void Serializer::miReadData2(void *pDest, size_t size, size_t count)
	{
		size_t rcount = fread(pDest,size,count,mFile);
		assert(rcount == count);
		mSize += size*count;
	};
	// fin JGA

	//	GPR.
	void	Serializer::WriteData(const	String	&string)
	{
		fputs(string.c_str(), mFile);

		// Write terminating newline char
		//fputc('\n', mFile);

		mSize	+=	string.length();
	}
	//	fin	GPR

	void	Serializer::WriteData(const char	*string)
	{
		fputs(string, mFile);

		// Write terminating newline char
		//fputc('\n', mFile);

		mSize	+=	strlen(string) /*+ 1*/;
	}

	//---------------------------------------------------------------------
	void Serializer::ReadArray(bool *pDest, size_t count)
	{
		//TODO:: Apple has problmes with bools
		ReadData(pDest,sizeof(bool), count);
	}

	//---------------------------------------------------------------------
	void Serializer::ReadArray(float *pDest, size_t count)
	{
		ReadData(pDest, sizeof(float), count);
		FlipFromLittleEndian(pDest, sizeof(float), count);
	}
	
	//---------------------------------------------------------------------
	void Serializer::ReadArray(unsigned short *pDest, size_t count)
	{
		ReadData(pDest, sizeof(unsigned short), count);
		FlipFromLittleEndian(pDest, sizeof(unsigned short), count);
	}
	
	//---------------------------------------------------------------------
	void Serializer::ReadArray(unsigned int *pDest, size_t count)
	{
		ReadData(pDest, sizeof(unsigned int), count);
		FlipFromLittleEndian(pDest, sizeof(unsigned int), count);
	}
	
	//---------------------------------------------------------------------
	void Serializer::ReadArray(Vector3 *pDest, size_t count)
	{
		for(size_t i = 0; i < count; ++i)
		{
			ReadArray(pDest[i].val,3);
		}
	}
	
	//---------------------------------------------------------------------
	void Serializer::ReadArray(Vector2 *pDest, size_t count)
	{
		for(size_t i = 0; i < count; ++i)
		{
			ReadArray(pDest[i].val,2);
		}
	}

	//---------------------------------------------------------------------
	void Serializer::FlipToLittleEndian(void *pData, size_t size, size_t count)
	{
#	if GEO_ENDIAN == GEO_ENDIAN_BIG
		FlipEndian(pData, size, count);
#	endif
	}

	void Serializer::FlipFromLittleEndian(void *pData, size_t size, size_t count)
	{
#	if GEO_ENDIAN == GEO_ENDIAN_BIG
		FlipEndian(pData, size, count);
#	endif
	}

	void Serializer::FlipEndian(void *pData, size_t size, size_t count)
	{
		for(unsigned int index = 0; index < count; index++)
		{
			FlipEndian((void *)((char*)pData + (index * size)), size);
		}
	}

	void Serializer::FlipEndian(void *pData, size_t size)
	{
		char swapByte;
		for(unsigned int byteIndex = 0; byteIndex < size/2; byteIndex++)
		{
			swapByte = *((char *)pData + byteIndex);
			*((char *)pData + byteIndex) = *((char *)pData + size - byteIndex - 1);
			*((char *)pData + size - byteIndex - 1) = swapByte;
		}
	}

}