/* ************************
   Copyright Terrain Experts Inc.
   Terrain Experts Inc (TERREX) reserves all rights to this source code
   unless otherwise specified in writing by the President of TERREX.
   This copyright may be updated in the future, in which case that version
   supercedes this one.
   -------------------
   Terrex Experts Inc.
   4400 East Broadway #314
   Tucson, AZ  85711
   info@terrex.com
   Tel: (520) 323-7990
   ************************
   */

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

/* trpage_writebuf.cpp
	This source file contains the implementation of trpgMemWriteBuffer.
	That is a subclass of trpgWriteBuffer, which implements an interface
	 definition for an object which can accept data to be written.
	The Mem version is used to write (for example) a tile's worth of data.
	That data can then be written to a file (or sent over the network).
	You should not need to change this implementation.  Simply sublcass
	 trpgWriteBuffer and implement all of the required methods.  The
	 resulting class can then be used in all the places a trpgWriteBuffer
	 is required.
	 */

#include <trpage_io.h>
#include <trpage_swap.h>

/* **********************
   Memory Write Buffer functions
   **********************
   */
// Constructor
trpgMemWriteBuffer::trpgMemWriteBuffer(trpgEndian in_ness)
{
	ness = in_ness;
	cpuNess = trpg_cpu_byte_order();
	data = NULL;
	curLen = totLen = 0;
}

// Destructor
trpgMemWriteBuffer::~trpgMemWriteBuffer()
{
	if (data)
		delete [] data;
	data = NULL;
}

/* Length()
	Return the length of the given buffer.
	*/
int trpgMemWriteBuffer::length() const
{
	return curLen;
}

/* getData()
	Return a pointer to the memory buffer.
	*/
const char *trpgMemWriteBuffer::getData() const
{
	return data;
}

/* Length()
	Set the maximum buffer length.
	*/
void trpgMemWriteBuffer::setLength(unsigned int len)
{
	if ((int)len > totLen) {
		char *old_data = data;
		int oldLen = totLen;
		totLen = 2*len;
		data = new char[totLen];

		if (old_data) {
			memcpy(data,old_data,oldLen);
			delete [] old_data;
		}
	}
}

/* append()
	Append the given data to our buffer.
	*/
void trpgMemWriteBuffer::append(unsigned int len,const char *val)
{
	if (len == 0)  return;
	setLength(curLen+len);
	memcpy(&data[curLen],val,len);
	curLen += len;
}

/* set()
	Set a specific portion of the buffer to a given value.
	*/
void trpgMemWriteBuffer::set(unsigned int pos,unsigned int len,const char *val)
{
	if (len == 0) return;
	if (pos+len > (unsigned int)curLen) return;

	memcpy(&data[pos],val,len);
}

/* --- replacement virtual functions --- */

/* Reset()
	Drop whatever's being stored.
	*/
void trpgMemWriteBuffer::Reset()
{
	curLen = 0;
}

// Add(Int32)
void trpgMemWriteBuffer::Add(int32 val)
{
	if (ness != cpuNess)
		val = trpg_byteswap_int(val);
	append(sizeof(int32),(const char *)&val);
}

// Add(int64)
void trpgMemWriteBuffer::Add(int64 val)
{
	if (ness != cpuNess)
		val = trpg_byteswap_llong(val);
	append(sizeof(int64),(const char *)&val);
}

// Add(string)
// [len] [value...]
void trpgMemWriteBuffer::Add(const char *val)
{
	int32 len = (val ? strlen(val) : 0),vlen = len;
	if (ness != cpuNess)
		vlen = trpg_byteswap_int(vlen);
	append(sizeof(int32),(const char *)&vlen);
	append(len,val);
}

// Add(std::string)
void trpgMemWriteBuffer::Add(std::string &val)
{
	Add(val.c_str());
}

// Add(float32)
void trpgMemWriteBuffer::Add(float32 val)
{
	char cval[4];
	if (ness != cpuNess)
		trpg_byteswap_float_to_4bytes(val,cval);
	else
		memcpy(cval,&val,4);

	append(sizeof(float32),cval);
}

// Add(float64)
void trpgMemWriteBuffer::Add(float64 val)
{
	char cval[8];
	if (ness != cpuNess)
		trpg_byteswap_double_to_8bytes(val,cval);
	else
		memcpy(cval,&val,8);

	append(sizeof(float64),cval);
}

// Add(int8)
void trpgMemWriteBuffer::Add(uint8 val)
{
	// No byte swapping needed
	append(sizeof(uint8),(const char *)&val);
}

//#if (bool != int32)
// Add(bool)
void trpgMemWriteBuffer::Add(bool val)
{
	uint8 ival;

	ival = (val ? 1 : 0);
	Add(ival);
}
//#endif

#if (trpgDiskRef != int64)
// Add(trpgDiskRef)
void trpgMemWriteBuffer::Add(trpgDiskRef val)
{
	if (ness != cpuNess)
		val = trpg_byteswap_llong(val);

	append(sizeof(trpgDiskRef),(const char *)&val);
}
#endif

// Add(trpgToken)
void trpgMemWriteBuffer::Add(trpgToken val)
{
	if (ness != cpuNess)
		val = trpg_byteswap_short(val);

	append(sizeof(trpgToken),(const char *)&val);
}

// Add(tx2iPoint)
void trpgWriteBuffer::Add(const trpg2iPoint &val)
{
	Add((int32)val.x);
	Add((int32)val.y);
}

// Add(tx2dPoint)
void trpgWriteBuffer::Add(const trpg2dPoint &val)
{
	Add((float64)val.x);
	Add((float64)val.y);
}

// Add(trpg3dPoint)
void trpgWriteBuffer::Add(const trpg3dPoint &val)
{
	Add((float64)val.x);
	Add((float64)val.y);
	Add((float64)val.z);
}

// Add(trpgColor)
void trpgWriteBuffer::Add(const trpgColor &val)
{
	Add(val.red);
	Add(val.green);
	Add(val.blue);
}

// Add(std::string)
void trpgWriteBuffer::Add(const std::string &val)
{
	Add(val.c_str());
}

/* Push()
	Starts defining a new object.
	Need to keep track of where length goes.
	*/
void trpgMemWriteBuffer::Begin(trpgToken tok)
{
	Add(tok);
	lengths.push_back(curLen);
	Add((int32)0);
}

/* Push()
	Pushes a level on the stack.  For defining children.
	*/
void trpgMemWriteBuffer::Push()
{
	Add((trpgToken)TRPG_PUSH);
}

/* Pop()
	Pops a level off the "stack".
	*/
void trpgMemWriteBuffer::Pop()
{
	Add((trpgToken)TRPG_POP);
}

/* End()
	Finished defining an object.
	Write the length out where appropriate.
	*/
void trpgMemWriteBuffer::End()
{
	if (lengths.size() == 0)
		// Note: say something clever here
		return;

	int id = lengths.size()-1;
	int32 len = curLen - lengths[id];
	int32 rlen = len-sizeof(int32);
	if (ness != cpuNess)
		rlen = trpg_byteswap_int(rlen);
	set(curLen - len,sizeof(int32),(const char *)&rlen);
	lengths.resize(id);
}

/* Appendable File
	This class is used as a simple appendable file.  It's used
	for dumping tile and texture (or most anything) into.
 */

trpgwAppFile::trpgwAppFile(trpgEndian inNess,const char *fileName)
{
	valid = false;
	ness = inNess;
	cpuNess = trpg_cpu_byte_order();

	if (!(fp = fopen(fileName,"wb")))
		return;

	lengthSoFar = 0;
	valid = true;
}

trpgwAppFile::~trpgwAppFile()
{
	if (fp)
		fclose(fp);
	valid = false;
}

// Return the amount of data written so far (in total)
int trpgwAppFile::GetLengthWritten()
{
    return lengthSoFar;
}

// Append the given buffer to our appendable file
bool trpgwAppFile::Append(const trpgMemWriteBuffer *buf1,const trpgMemWriteBuffer *buf2)
{
	if (!isValid()) return false;

	// Get the total length
	int totLen = buf1->length() + (buf2 ? buf2->length() : 0);

	// Write the length out
	if (fwrite(&totLen,sizeof(int32),1,fp) != 1) {
		valid = false;
		return false;
	}

	// Write the data out
	const char *data = buf1->getData();
	int len = buf1->length();
	if (fwrite(data,sizeof(char),len,fp) != (unsigned int)len) {
		valid = false;
		return false;
	}
	if (buf2) {
		data = buf2->getData();
		len = buf2->length();
		if (fwrite(data,sizeof(char),len,fp) != (unsigned int)len) {
			valid = false;
			return false;
		}
	}

	lengthSoFar += totLen;

	return true;
}

// Append the given raw data to our appendable file
bool trpgwAppFile::Append(const char *data,int size)
{
	if (!isValid()) return false;

	if (!data)
		return false;

	// Write the length out
	if (fwrite(&size,sizeof(int32),1,fp) != 1) {
		valid = false;
		return false;
	}

	// Write the data out
	if (fwrite(data,sizeof(char),size,fp) != (unsigned int)size) {
		valid = false;
		return false;
	}

	lengthSoFar += size;

	return true;
}

// Flushes the current tile file
bool trpgwAppFile::Flush()
{
	// Flush the File *
	if (fp)
		fflush(fp);

	return true;
}

// Return the current file position
int64 trpgwAppFile::Pos() const
{
	if (!isValid())
		return 0;
	
	// Note: This means an appendable file is capped at 2GB
	long pos = ftell(fp);

	return pos;
}

// Validity check
bool trpgwAppFile::isValid() const
{
	return valid;
}
