/* FileIO */
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <zlib.h>
#include <assert.h>

//#include "Graphics.h"
#include "FileIO.h"
//#include "Init.h"

using namespace exh;

DataFile::DataFile(void)
{
	filename = NULL;
	data = NULL;
	length = 0;
}

DataFile::~DataFile(void)
{
	if (filename)
	{
		delete [] filename;
	}

	if (data)
	{
		delete [] data;
	}
}

int FileIO::read(char *ptr, size_t nmemb)
{
	if (dataFilePoint+(unsigned int)nmemb <= dataFile->length)
	{
		for(size_t i = 0; i < nmemb; i++)
		{
			ptr[i] = dataFile->data[dataFilePoint++];
		}

		return 1;
	}

	//Trying retrieve more data than what's available
	return -1;
}

FileIO::FileIO(void)
{
	isOpen = false;
	dataFilePoint = 0;
	dataFile = NULL;
}

FileIO::FileIO(std::string _filename)
{
	isOpen = false;
	dataFilePoint = 0;
	dataFile = NULL;

	this->open(_filename);
}

FileIO::~FileIO(void)
{
	close();
}

//read const char chunk
const char *FileIO::readCStr(void)
{
	std::string tmpstr = "";
	signed char chunk_char=' ';
	for(int i=0; chunk_char != '\0'; i++)
	{
		chunk_char = readChar();
		tmpstr.append(1,chunk_char);
	}
	return tmpstr.c_str();
}

//read line
const char *FileIO::readLine(void)
{
	std::string tmpstr = "";
	signed char chunk_char=' ';
	int i;
	for(i = 0; (chunk_char != '\n') && (chunk_char != '\0'); i++)
	{
		chunk_char = readChar();
		tmpstr.append(1,chunk_char);
	}

	if (tmpstr.at(i-1) == '\r')
	{
		tmpstr.erase(i-1,1);
	}

	return tmpstr.c_str();
}

//read float[3] chunk
Vector FileIO::readVector(void)
{
	Vector vector;

	vector.x = this->readFloat();
	vector.y = this->readFloat();
	vector.z = this->readFloat();

	return vector;
}

//read float chunk
float FileIO::readFloat(void)
{
	float ptr;

#ifdef __i386__
	read((char*)&ptr, sizeof(float));

#else
	//convert little endian to big endian
	Sint32 tmpi;

	read((char*)&tmpi, sizeof(Sint32));

	tmpi = ((((tmpi)&0x000000FF)<<24)+(((tmpi)&0x0000FF00)<<8)+(((tmpi)&0x00FF0000)>>8)+(((tmpi)&0xFF000000)>>24));
	memcpy(&ptr, &tmpi, sizeof(float));
#endif

	return ptr;
}

//read 32bit signed int chunk
Sint32 FileIO::readInt32(void)
{
	Sint32 ptr;

	read((char*)&ptr, sizeof(Sint32));

#ifdef __ppc__
	ptr = ((((ptr)&0x000000FF)<<24)+(((ptr)&0x0000FF00)<<8)+(((ptr)&0x00FF0000)>>8)+(((ptr)&0xFF000000)>>24));
#endif

	return ptr;
}

//read 32bit unsigned int chunk
Uint32 FileIO::readUInt32(void)
{
	Uint32 ptr;

	read((char*)&ptr, sizeof(Uint32));

#ifdef __ppc__
	ptr = ((((ptr)&0x000000FF)<<24)+(((ptr)&0x0000FF00)<<8)+(((ptr)&0x00FF0000)>>8)+(((ptr)&0xFF000000)>>24));
#endif

	return ptr;
}

//read 16bit signed int chunk
Sint16 FileIO::readInt16(void)
{
	Sint16 ptr;

	read((char*)&ptr, sizeof(Sint16));

#ifdef __ppc__
	ptr = (((ptr)&0x00FF)<<8)+(((ptr)&0xFF00)>>8);
#endif

	return ptr;
}

//read 16bit unsigned int chunk
Uint16 FileIO::readUInt16(void)
{
	Uint16 ptr;

	read((char*)&ptr, sizeof(Uint16));

#ifdef __ppc__
	ptr = (((ptr)&0x00FF)<<8)+(((ptr)&0xFF00)>>8);
#endif

	return ptr;
}

//read 8bit signed int chunk
Sint8 FileIO::readInt8(void)
{
	Sint8 ptr;

	read((char*)&ptr, sizeof(Sint8));

	return ptr;
}

//read 8bit unsigned int chunk
Uint8 FileIO::readUInt8(void)
{
	Uint8 ptr;

	read((char*)&ptr, sizeof(Uint8));

	return ptr;
}

//read char data
//this is useless but for the sake of
//completeness, porting and easy reading :)
signed char FileIO::readChar(void)
{
	signed char ptr;

	read((char*)&ptr, sizeof(signed char));

	return ptr;
}

unsigned char FileIO::readUChar(void)
{
	unsigned char ptr;
	read((char*)&ptr, sizeof(unsigned char));

	return ptr;
}

void FileIO::readChar(char *ptr, Uint32 nmemb)
{
	read(ptr, nmemb);
}

char* FileIO::readFile(void)
{
	return dataFile->data;
}

//skip bytes
void FileIO::readSkip(int skip)
{
	dataFilePoint += skip;
}

//write c type string
void FileIO::writeCStr(const char* var)
{
	for(unsigned int i = 0; i < strlen(var); i++)
	{
		writeChar(var[i]);
	}

	writeChar('\0');
}

//write float[3]
void FileIO::writeVector(Vector vec)
{
	writeFloat(vec.x);
	writeFloat(vec.y);
	writeFloat(vec.z);
}

//write float 32bit
void FileIO::writeFloat(float var)
{
	char *ptr = new char[sizeof(float)];

#ifdef __i386__
	memcpy(ptr, &var, sizeof(float));
#else
	Sint32 tmpi;
	memcpy(&tmpi, &var, sizeof(float));
	tmpi = ((((tmpi)&0x000000FF)<<24)+(((tmpi)&0x0000FF00)<<8)+(((tmpi)&0x00FF0000)>>8)+(((tmpi)&0xFF000000)>>24));
	memcpy(&ptr, &tmpi, sizeof(float));
#endif

	f.write(ptr, sizeof(float));
	delete [] ptr;
}

//write signed int 32bit
void FileIO::writeInt32(Sint32 var)
{
	char *ptr = new char[sizeof(Sint32)];

#ifdef __ppc__
	var = ((((var)&0x000000FF)<<24)+(((var)&0x0000FF00)<<8)+(((var)&0x00FF0000)>>8)+(((var)&0xFF000000)>>24));
#endif

	memcpy(ptr, &var, sizeof(Sint32));

	f.write(ptr, sizeof(Sint32));
	delete [] ptr;
}

//write unsigned int 32bit
void FileIO::writeUInt32(Uint32 var)
{
	char *ptr = new char[sizeof(Uint32)];

#ifdef __ppc__
	var = ((((var)&0x000000FF)<<24)+(((var)&0x0000FF00)<<8)+(((var)&0x00FF0000)>>8)+(((var)&0xFF000000)>>24));
#endif

	memcpy(ptr, &var, sizeof(Uint32));

	f.write(ptr, sizeof(Uint32));
	delete [] ptr;
}

//write signed int 16bit
void FileIO::writeInt16(Sint16 var)
{
	char *ptr = new char[sizeof(Sint16)];

#ifdef __ppc__
	var = (((var)&0x00FF)<<8)+(((var)&0xFF00)>>8);
#endif

	memcpy(ptr, &var, sizeof(Sint16));

	f.write(ptr, sizeof(Sint16));
	delete [] ptr;
}

//write unsigned int 16bit
void FileIO::writeUInt16(Uint16 var)
{
	char *ptr = new char[sizeof(Uint16)];

#ifdef __ppc__
	var = (((var)&0x00FF)<<8)+(((var)&0xFF00)>>8);
#endif

	memcpy(ptr, &var, sizeof(Uint16));

	f.write(ptr, sizeof(Uint16));
	delete [] ptr;
}

//write signed int 8bit
void FileIO::writeInt8(Sint8 var)
{
	char *ptr = new char[sizeof(Sint8)];

	memcpy(ptr, &var, sizeof(Sint8));

	f.write(ptr, sizeof(Sint8));
	delete [] ptr;
}

//write unsigned int 8bit
void FileIO::writeUInt8(Uint8 var)
{
	char *ptr = new char[sizeof(Uint8)];

	memcpy(ptr, &var, sizeof(Uint8));

	f.write(ptr, sizeof(Uint8));
	delete [] ptr;
}

//write signed char
void FileIO::writeChar(signed char var)
{
	f << var;
}

//write unsigned char
void FileIO::writeUChar(unsigned char var)
{
	f << var;
}

//write string with specified length to a file
void FileIO::writeFile(const char *data, unsigned int length)
{
	for(unsigned int i = 0; i < length; i++)
	{
		this->writeChar(data[i]);
	}
}

//set the point of read cursor
void FileIO::setCursor(unsigned int _dataFilePoint)
{
	dataFilePoint = _dataFilePoint;
}

//return the point where the read cursor currently is
unsigned int FileIO::getCursor(void)
{
	return dataFilePoint;
}

//returns a pointer to char* where the cursor is
char *FileIO::getCursorCharPointer(void)
{
	return &dataFile->data[dataFilePoint];
}

DataFile *FileIO::getDataFile(void)
{
	return dataFile;
}

//get length of the file
unsigned int FileIO::getLength(void)
{
	return dataFile->length;
}

bool FileIO::open(std::string filename, std::ios::openmode mode)
{
if ((mode&std::ios::out) == std::ios::out)
{
	f.open(std::string(exh::init.getDataPath(filename.c_str())).c_str(), mode);
	return true;
}
	dataFile = new DataFile();

	DataFile *_dataFile = exh::init.getDataPackDataFile(filename.c_str());

	if (_dataFile)
	{
		/*dataFile->filename = new char[strlen(_dataFile->filename)+1];
		memcpy(dataFile->filename, _dataFile->filename, strlen(_dataFile->filename)+1);

		dataFile->data = new char[_dataFile->length];
		memcpy(dataFile->data, _dataFile->data, _dataFile->length);

		dataFile->length = _dataFile->length;*/

		dataFile = _dataFile;

		isOpen = isDataPackFile = true;
	}
	else
	{
		f.open(std::string(exh::init.getDataPath(filename.c_str())).c_str(), mode);
		isOpen = f.is_open();
		isDataPackFile = false;

		if (!isOpen)
		{
			f.open(filename.c_str(), mode);
			isOpen = f.is_open();
		}

		if ((isOpen) && ((mode&std::ios::in) == std::ios::in))
		{
			dataFile->filename = new char[strlen(filename.c_str())+1];
			memcpy(dataFile->filename, filename.c_str(), strlen(filename.c_str())+1);

			//get file size
			f.seekg (0, std::ios::end);
			dataFile->length = f.tellg();
			f.seekg (0, std::ios::beg);

			dataFile->data = new char[dataFile->length];
			f.read(dataFile->data, dataFile->length);
		}
#ifdef __DEBUG
		else
		{
			fprintf(stderr, "FileIO::open() -> Error: Unable to open %s\n", filename.c_str());
		}
#endif

		f.close();
	}

	return isOpen;
}

void FileIO::close(void)
{
	dataFilePoint = 0;

	if (!isDataPackFile)
	{
		if (dataFile)
		{
			delete dataFile;
			dataFile = NULL;
		}

		f.close();
	}
}

bool FileIO::isEnd(void)
{
	if (dataFilePoint >= dataFile->length)
	{
		return true;
	}

	return false;
}

bool FileIO::operator == (bool _isOpen)
{
	if (isOpen == _isOpen)
	{
		return true;
	}

	return false;
}

bool FileIO::operator != (bool _isOpen)
{
	if (isOpen != _isOpen)
	{
		return true;
	}

	return false;
}

bool FileIO::operator ! (void)
{
	return !isOpen;
}