#include "BinaryLoader.h"
#include "Matrix4x4.h"
#include "Geometry.h"
#include "SceneEntity.h"
#include "Material.h"
#include "Texture.h"
//#include "gzstream.h"


using namespace std;


namespace CHCDemoEngine
{


BinaryLoader::~BinaryLoader()
{
	/** delete all maps.
	*/
	std::map<int, Texture *>::iterator it, it_end = mTextureTable.end();

	for (it = mTextureTable.begin(); it != it_end; ++ it)
	{
		Texture *tex = (*it).second;
		delete tex;
	}

	std::map<int, Material *>::iterator nit, nit_end = mMaterialTable.end();

	for (nit = mMaterialTable.begin(); nit != nit_end; ++ nit)
	{
		Material *mat = (*nit).second;
		delete mat;
	}

	
	std::map<int, Geometry *>::iterator git, git_end = mGeometryTable.end();

	for (git = mGeometryTable.begin(); git != git_end; ++git)
	{
		Geometry *geom = (*git).second;
		delete geom;
	}
}

//SceneEntity *BinaryLoader::LoadSceneEntity(igzstream &str)
SceneEntity *BinaryLoader::LoadSceneEntity(ifstream &str)
{	
	// shape
	int shapeId;
	str.read(reinterpret_cast<char *>(&shapeId), sizeof(int));

	Geometry *geom = mGeometryTable[shapeId];
	Material *mat = mMaterialTable[shapeId];


	bool hasTrafo;
	str.read(reinterpret_cast<char *>(&hasTrafo), sizeof(bool));

	Matrix4x4 *trafo;
	
	if (!hasTrafo)
	{
		trafo = NULL;
	}
	else
	{
		trafo = new Matrix4x4();
		//*trafo = IdentityMatrix();
		str.read(reinterpret_cast<char *>(trafo->x), sizeof(Matrix4x4));
		//str.read(reinterpret_cast<char *>(trafo), sizeof(Matrix4x4));
		//cout << "m:\n" << *trafo<<endl;
	}

	SceneEntity *sceneGeom = new SceneEntity(geom, mat, trafo);

	return sceneGeom;
}


void BinaryLoader::LoadTextures(ifstream &str)
{
	int numTextures;
	str.read(reinterpret_cast<char *>(&numTextures), sizeof(int));

	for (int i = 0; i < numTextures; ++ i)
	{
		// texture
		int texnameSize;

		//str.read(reinterpret_cast<char *>(&id), sizeof(int));
		str.read(reinterpret_cast<char *>(&texnameSize), sizeof(int));

		char *texname = new char[texnameSize];
		str.read(texname, sizeof(char) * texnameSize);

		//cout << "loading texture " << texname << " with len " << texnameSize << " id: " << id << endl;
		Texture *tex = new Texture(model_path + texname);

		mTextureTable[i] = tex;
	}

	cout << "loaded " << mTextureTable.size() << " textures" << endl;
}


void BinaryLoader::LoadShapes(ifstream &str)
{
	int numShapes;
	str.read(reinterpret_cast<char *>(&numShapes), sizeof(int));

	for (int i = 0; i < numShapes; ++ i)
	{
		Geometry *geom = LoadGeometry(str);
		Material *mat = LoadMaterial(str);

		mGeometryTable[i] = geom;
		mMaterialTable[i] = mat;
	}

	cout << "loaded " << mGeometryTable.size() << " shapes" << endl;
}


//Appearance *BinaryLoader::LoadMaterial(igzstream &str)
Material *BinaryLoader::LoadMaterial(ifstream &str)
{
	// default material
	Material *mat = new Material();
	
	// texture
	int texId;
	str.read(reinterpret_cast<char *>(&texId), sizeof(int));

	if (texId >= 0)
		mat->SetTexture(mTextureTable[texId]);
	
	str.read(reinterpret_cast<char *>(&mat->mAlphaTestEnabled), sizeof(bool));

	// material
	bool hasMaterial;
	str.read(reinterpret_cast<char *>(&hasMaterial), sizeof(bool));
	
	if (hasMaterial)
	{
		// only write rgb part of the material
		str.read(reinterpret_cast<char *>(&mat->mAmbientColor), sizeof(Vector3));
		str.read(reinterpret_cast<char *>(&mat->mDiffuseColor), sizeof(Vector3));
		str.read(reinterpret_cast<char *>(&mat->mSpecularColor), sizeof(Vector3));
	}

	return mat;
}


//Geometry *BinaryLoader::LoadGeometry(igzstream &str)
Geometry *BinaryLoader::LoadGeometry(ifstream &str)
{
	Vector3 *vertices;
	Vector3 *normals;
	float *texcoords;


	//////////////
	//-- read in vertices

	int vertexCount;
	str.read(reinterpret_cast<char *>(&vertexCount), sizeof(int));
	
	// end of file reached
	if (str.eof())
		return NULL;

	//cout << "vertexcount: " << vertexCount << endl;

	vertices = new Vector3[vertexCount];
    str.read(reinterpret_cast<char *>(vertices), sizeof(Vector3) * vertexCount);
	
	normals = new Vector3[vertexCount];
	str.read(reinterpret_cast<char *>(normals), sizeof(Vector3) * vertexCount);

	int texCoordCount;
	str.read(reinterpret_cast<char *>(&texCoordCount), sizeof(int));

	if (texCoordCount)
	{
		//cout << "loading texcoords of size " << texCoordCount << endl;
		texcoords = new float[texCoordCount * 2];
		str.read(reinterpret_cast<char *>(texcoords), sizeof(float) * vertexCount * 2);
	}
	else
		texcoords = NULL;

	return new Geometry(vertices, normals, texcoords, vertexCount, true);
}


void BinaryLoader::LoadSceneEntities(ifstream &str, SceneEntityContainer &entities)
{
	int entityCount;
	str.read(reinterpret_cast<char *>(&entityCount), sizeof(int));

	entities.resize(entityCount);

	for (int i = 0; i < entityCount; ++ i)
	{
		SceneEntity *ent = LoadSceneEntity(str);
		ent->id = i;
		entities[i] = ent;
	}

	cout << "loaded " << entityCount << " scene entities" << endl;
}


bool BinaryLoader::Load(const std::string &filename, SceneEntityContainer &entities)
{
	//clear_textures(); // clear the texture table

	//igzstream str(filename.c_str());//, ios::binary);
	ifstream istr(filename.c_str(), ios::binary);
	
	if (!istr.is_open())
		return false;

	cout << "loading textures" << endl;
	
	// load the texture table
	LoadTextures(istr);

	cout << "loading shapes (geometry + materials)" << endl;

	// load the shapees
	LoadShapes(istr);

	cout << "loading scene entites" << endl;
	LoadSceneEntities(istr, entities);
	
	cout << "bin loading finished" << endl;

	return true;
}

}