#include "Object.h"
#include <iostream>



/////////////////////////////////////////////////////////////////////////
// public constructor/destructor

Object::Object(const char* path)
{
	// open file
	fsMesh.open(path, std::ios::in | std::ios::binary);

	if (!fsMesh.is_open())
		throw std::invalid_argument(std::string("file not found: ") += path);

	// jump into msh2 todo: search for MSH2 if there is a shadowvolume
	fsMesh.seekg(8);
	char tempChunkName[5] = { 0 };
	fsMesh.read(reinterpret_cast<char*>(&tempChunkName[0]), sizeof(tempChunkName) - 1);

	if (strcmp(tempChunkName, "MSH2"))
		throw std::invalid_argument(std::string("corrupted file MSH2 expected instead of ") += tempChunkName);

	std::uint32_t tempSize;
	fsMesh.read(reinterpret_cast<char*>(&tempSize), sizeof(tempSize));

	// get all sub chunks from MSH2
	loadChunks(lChunkMsh2, fsMesh.tellg(), tempSize);

	// search for all MODL Chunks
	for (std::list<ChunkHeader*>::iterator it = lChunkMsh2.begin(); it != lChunkMsh2.end(); it++)
	{
		if (!strcmp("MODL", (*it)->name))
		{
			Modl* tempModl = new Modl;

			// get all subchunks
			std::list<ChunkHeader*> tempChunks;
			loadChunks(tempChunks, (*it)->position, (*it)->size);
			
			// evaluate MODL subchunks
			analyseModlChunks(tempModl, tempChunks);

			//clean up
			while (!tempChunks.empty())
			{
				ChunkHeader* tempCursor = tempChunks.front();
				tempChunks.pop_front();
				delete tempCursor;
			}

			// save Model data
			lModls.push_back(tempModl);
		}
	}

	// close file
	fsMesh.close();
}

Object::~Object()
{
	//delete Chunk list;	
}



/////////////////////////////////////////////////////////////////////////
// private functions

void Object::loadChunks(std::list<ChunkHeader*>& destination, std::streampos start, const std::uint32_t end)
{
	// jump to first chunk
	fsMesh.seekg(start);

	do
	{
		ChunkHeader* tempHeader = new ChunkHeader();

		fsMesh.read(reinterpret_cast<char*>(&tempHeader->name[0]), sizeof(tempHeader->name) - 1);
		fsMesh.read(reinterpret_cast<char*>(&tempHeader->size), sizeof(tempHeader->size));
		tempHeader->position = fsMesh.tellg();

		destination.push_back(tempHeader);

		fsMesh.seekg(tempHeader->size, std::ios_base::cur);

		// reached end
		if (fsMesh.tellg() - start == end)
			break;

		// error. Maybe the size information is corrupted
		if (!fsMesh.good())
		{
			std::cout << "WARNING: corrupted file. Trying to continue" << std::endl;
			fsMesh.clear();
			break;
		}

	} while (true);

	std::cout << "got all chunks, totaly found: " << destination.size() << std::endl;

}

void Object::analyseModlChunks(Modl* dataDestination, std::list<ChunkHeader*>& chunkList)
{
	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
		if (!strcmp("MTYP", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			std::uint32_t tempType;
			fsMesh.read(reinterpret_cast<char*>(&tempType), sizeof(tempType));
			dataDestination->type = (Mtyp)tempType;
		}

		if (!strcmp("MNDX", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->zeroBaseIndex), sizeof(dataDestination->zeroBaseIndex));
		}

		if (!strcmp("PRNT", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			char tempName[33] = { 0 };
			fsMesh.read(reinterpret_cast<char*>(&tempName[0]), (*it)->size > 32 ? 32 : (*it)->size);
			dataDestination->parent = tempName;
		}

		if (!strcmp("NAME", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			char tempName[33] = { 0 };
			fsMesh.read(reinterpret_cast<char*>(&tempName[0]), (*it)->size > 32 ? 32 : (*it)->size);
			dataDestination->name = tempName;
		}

		if (!strcmp("FLGS", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->renderFlags), sizeof(dataDestination->renderFlags));
		}

		if (!strcmp("TRAN", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.scale[0]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.scale[1]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.scale[2]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.rotation[0]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.rotation[1]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.rotation[2]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.rotation[3]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.translation[0]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.translation[1]), sizeof(float));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->tran.translation[2]), sizeof(float));
		}

		if (!strcmp("GEOM", (*it)->name))
		{
			// get all subchunks
			std::list<ChunkHeader*> tempGeomChunks;
			loadChunks(tempGeomChunks, (*it)->position, (*it)->size);

			// evaluate GEOM subchunks
			analyseGeomChunks(dataDestination, tempGeomChunks);

			// clean up
			while (!tempGeomChunks.empty())
			{
				ChunkHeader* tempCursor = tempGeomChunks.front();
				tempGeomChunks.pop_front();
				delete tempCursor;
			}
		}

		if (!strcmp("SWCI", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->swci.type), sizeof(dataDestination->swci.type));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->swci.data1), sizeof(dataDestination->swci.data1));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->swci.data2), sizeof(dataDestination->swci.data2));
			fsMesh.read(reinterpret_cast<char*>(&dataDestination->swci.data3), sizeof(dataDestination->swci.data3));
		}
	}

}

void Object::analyseGeomChunks(Modl * dataDestination, std::list<ChunkHeader*>& chunkList)
{

	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
		if (!strcmp("SEGM", (*it)->name))
		{
			// get all subchunks
			std::list<ChunkHeader*> tempSegmChunks;
			loadChunks(tempSegmChunks, (*it)->position, (*it)->size);

			// evaluate SEGM subchunks
			analyseSegmChunks(dataDestination, tempSegmChunks);

			// clean up
			while (!tempSegmChunks.empty())
			{
				ChunkHeader* tempCursor = tempSegmChunks.front();
				tempSegmChunks.pop_front();
				delete tempCursor;
			}
		}

		if (!strcmp("CLTH", (*it)->name))
		{
			// get all subchunks
			std::list<ChunkHeader*> tempClthChunks;
			loadChunks(tempClthChunks, (*it)->position, (*it)->size);

			// evaluate CLTH subchunks
			analyseClthChunks(dataDestination, tempClthChunks);

			// clean up
			while (!tempClthChunks.empty())
			{
				ChunkHeader* tempCursor = tempClthChunks.front();
				tempClthChunks.pop_front();
				delete tempCursor;
			}
		}
	}

}

void Object::analyseSegmChunks(Modl * dataDestination, std::list<ChunkHeader*>& chunkList)
{
	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
		if (!strcmp("SHDW", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			/* shadow mesh geometry

			long int - 4 - number of vertex positions
			float[3][] - 12 each - vertex positions (XYZ)
			long int - 4 - number of edges
			short int[4][] - 8 each - edge the following 4 entries from one edge
			> short int - 2 - vertex index of this edge, referes to the vertex list
			> short int - 2 - Reference into an edge. Defines the target vertex (the local edge vertex of the referenced edge) to which the edge should be dran from the local vertex
			> short int - 2 - Second reference into an edge. In all example .msh files I've seen this always refers to the same vertex as the first edge reference
			> short int - 2 - MAX_VALUE of short integers (65535). Indicates the end of this edge
			*/

		}

		if (!strcmp("MATI", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			// material index index into MATL
			// long int - 4 - material index
		}

		if (!strcmp("POSL", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			// list of vertex coordinates
			// long int - 4 - number of coordinates stored in this list
			// float[3][] - 12 each - XYZ coordinates
		}

		if (!strcmp("NRML", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			// List of normals
			// long int - 4 - number of normal vectores stored in this list
			// float[3][] - 12 each - UVW vector for each vertex
		}

		if (!strcmp("UV0L", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			// List of UV
			// long int - 4 - number of UV
			// float[2][] - 8 each - UV coordinate
		}

		if (!strcmp("STRP", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			/*
			List of triangles strips. The start of a strip is indicated by 2 entries
			with a high bit set (0x8000 or 32768 added). Triangles are listed CW, CCW,
			CW, CCW... NOTE: In some meshes this chunk has a trailing short which is not
			calculated into the length/size of this chunk or the # of indices. This
			short can be ignored. If added to the last polygon it will break it as it
			always seems to be 0.
			long int - 4 - number of indicies into POSL
			short int[] - 2 each - index into POSL the indices will form polygons
			*/
		}
	}
}

void Object::analyseClthChunks(Modl * dataDestination, std::list<ChunkHeader*>& chunkList)
{
	for (std::list<ChunkHeader*>::iterator it = chunkList.begin(); it != chunkList.end(); it++)
	{
		if (!strcmp("CTEX", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			// texture name with extension (how long could it be??)
			// ascii
		}

		if (!strcmp("CPOS", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			// list of Vertex coordinates
			// long int (4) number of vertex
			// float[3][] (12 each) XYZ coordinates
		}

		if (!strcmp("CUV0", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			// list of UV coordinates
			// long int (4) number of UV Coordinates
			// float[2][] (8 each) UV coordinate
		}

		if (!strcmp("CMSH", (*it)->name))
		{
			fsMesh.seekg((*it)->position);
			// cloth tirangles
			// long int (4) number of points
			// long int[3][] (16 each) triangle points defined CCW
		}

	}

}


/////////////////////////////////////////////////////////////////////////
// public getter



/////////////////////////////////////////////////////////////////////////
// public functions

