/*
---------------------------------------------------------------------------
Open Asset Import Library (ASSIMP)
---------------------------------------------------------------------------

Copyright (c) 2006-2008, ASSIMP Development Team

All rights reserved.

Redistribution and use of this software in source and binary forms, 
with or without modification, are permitted provided that the following 
conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the ASSIMP team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the ASSIMP Development Team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/

/** @file Implementation of the MD3 importer class */
#include "MD3Loader.h"
#include "MaterialSystem.h"
#include "StringComparison.h"

#include "../include/IOStream.h"
#include "../include/IOSystem.h"
#include "../include/aiMesh.h"
#include "../include/aiScene.h"
#include "../include/aiAssert.h"
#include "../include/DefaultLogger.h"

#include <boost/scoped_ptr.hpp>

using namespace Assimp;


// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
MD3Importer::MD3Importer()
{
}

// ------------------------------------------------------------------------------------------------
// Destructor, private as well 
MD3Importer::~MD3Importer()
{
}

// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file. 
bool MD3Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
{
	// simple check of file extension is enough for the moment
	std::string::size_type pos = pFile.find_last_of('.');
	// no file extension - can't read
	if( pos == std::string::npos)
		return false;
	std::string extension = pFile.substr( pos);

	if (extension.length() < 4)return false;
	if (extension[0] != '.')return false;
	if (extension[1] != 'm' && extension[1] != 'M')return false;
	if (extension[2] != 'd' && extension[2] != 'D')return false;
	if (extension[3] != '3')return false;

	return true;
}
// ------------------------------------------------------------------------------------------------
void MD3Importer::ValidateHeaderOffsets()
{
	if (this->m_pcHeader->OFS_FRAMES	>= this->fileSize ||
		this->m_pcHeader->OFS_SURFACES	>= this->fileSize || 
		this->m_pcHeader->OFS_EOF		> this->fileSize)
	{
		delete[] this->mBuffer;
		throw new ImportErrorException("Invalid MD3 header: some offsets are outside the file");
	}
}
// ------------------------------------------------------------------------------------------------
void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface* pcSurf)
{
	// calculate the relative offset of the surface
	int32_t ofs = int32_t((const unsigned char*)pcSurf-this->mBuffer);

	if (pcSurf->OFS_TRIANGLES	+ ofs + pcSurf->NUM_TRIANGLES * sizeof(MD3::Triangle)	> this->fileSize ||
		pcSurf->OFS_SHADERS		+ ofs + pcSurf->NUM_SHADER * sizeof(MD3::Shader)		> this->fileSize ||
		pcSurf->OFS_ST			+ ofs + pcSurf->NUM_VERTICES * sizeof(MD3::TexCoord)	> this->fileSize ||
		pcSurf->OFS_XYZNORMAL	+ ofs + pcSurf->NUM_VERTICES * sizeof(MD3::Vertex)		> this->fileSize)
	{
		delete[] this->mBuffer;
		throw new ImportErrorException("Invalid MD3 surface header: some offsets are outside the file");
	}

	if (pcSurf->NUM_TRIANGLES > AI_MD3_MAX_TRIANGLES)
		DefaultLogger::get()->warn("The model contains more triangles than Quake 3 supports");
	if (pcSurf->NUM_SHADER > AI_MD3_MAX_SHADERS)
		DefaultLogger::get()->warn("The model contains more shaders than Quake 3 supports");
	if (pcSurf->NUM_VERTICES > AI_MD3_MAX_VERTS)
		DefaultLogger::get()->warn("The model contains more vertices than Quake 3 supports");
	if (pcSurf->NUM_FRAMES > AI_MD3_MAX_FRAMES)
		DefaultLogger::get()->warn("The model contains more frames than Quake 3 supports");
}
// ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure. 
void MD3Importer::InternReadFile( 
	const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
{
	boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));

	// Check whether we can read from the file
	if( file.get() == NULL)
	{
		throw new ImportErrorException( "Failed to open md3 file " + pFile + ".");
	}

	// check whether the md3 file is large enough to contain
	// at least the file header
	fileSize = (unsigned int)file->FileSize();
	if( fileSize < sizeof(MD3::Header))
	{
		throw new ImportErrorException( ".md3 File is too small.");
	}

	// allocate storage and copy the contents of the file to a memory buffer
	this->mBuffer = new unsigned char[fileSize];
	file->Read( (void*)mBuffer, 1, fileSize);

	this->m_pcHeader = (const MD3::Header*)this->mBuffer;

	// check magic number
	if (this->m_pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_BE &&
		this->m_pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_LE)
	{
		delete[] this->mBuffer;
		throw new ImportErrorException( "Invalid md3 file: Magic bytes not found");
	}

	// check file format version
	if (this->m_pcHeader->VERSION > 15)
	{
		DefaultLogger::get()->warn( "Unsupported md3 file version. Continuing happily ...");
	}

	// check some values whether they are valid
	if (0 == this->m_pcHeader->NUM_FRAMES)
	{
		delete[] this->mBuffer;
		throw new ImportErrorException( "Invalid md3 file: NUM_FRAMES is 0");
	}
	if (0 == this->m_pcHeader->NUM_SURFACES)
	{
		delete[] this->mBuffer;
		throw new ImportErrorException( "Invalid md3 file: NUM_SURFACES is 0");
	}
	this->ValidateHeaderOffsets();

	// now navigate to the list of surfaces
	const MD3::Surface* pcSurfaces = (const MD3::Surface*)
		(this->mBuffer + this->m_pcHeader->OFS_SURFACES);

	// allocate output storage
	pScene->mNumMeshes = this->m_pcHeader->NUM_SURFACES;
	pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];

	pScene->mNumMaterials = this->m_pcHeader->NUM_SURFACES;
	pScene->mMaterials = new aiMaterial*[pScene->mNumMeshes];

	// if an exception is thrown before the meshes are allocated ->
	// otherwise the pointer value would be invalid and delete would crash
	::memset(pScene->mMeshes,0,pScene->mNumMeshes*sizeof(aiMesh*));
	::memset(pScene->mMaterials,0,pScene->mNumMaterials*sizeof(aiMaterial*));

	unsigned int iNum = this->m_pcHeader->NUM_SURFACES;
	unsigned int iNumMaterials = 0;
	unsigned int iDefaultMatIndex = 0xFFFFFFFF;
	while (iNum-- > 0)
	{
		// validate the surface
		this->ValidateSurfaceHeaderOffsets(pcSurfaces);

		// navigate to the vertex list of the surface
		const MD3::Vertex* pcVertices = (const MD3::Vertex*)
			(((unsigned char*)pcSurfaces) + pcSurfaces->OFS_XYZNORMAL);

		// navigate to the triangle list of the surface
		const MD3::Triangle* pcTriangles = (const MD3::Triangle*)
			(((unsigned char*)pcSurfaces) + pcSurfaces->OFS_TRIANGLES);

		// navigate to the texture coordinate list of the surface
		const MD3::TexCoord* pcUVs = (const MD3::TexCoord*)
			(((unsigned char*)pcSurfaces) + pcSurfaces->OFS_ST);

		// navigate to the shader list of the surface
		const MD3::Shader* pcShaders = (const MD3::Shader*)
			(((unsigned char*)pcSurfaces) + pcSurfaces->OFS_SHADERS);

		// if the submesh is empty ignore it
		if (0 == pcSurfaces->NUM_VERTICES || 0 == pcSurfaces->NUM_TRIANGLES)
		{
			pcSurfaces = (const MD3::Surface*)(((unsigned char*)pcSurfaces) + pcSurfaces->OFS_END);
			pScene->mNumMeshes--;
			continue;
		}

		// allocate the output mesh
		pScene->mMeshes[iNum] = new aiMesh();
		aiMesh* pcMesh = pScene->mMeshes[iNum];

		pcMesh->mNumVertices = pcSurfaces->NUM_TRIANGLES*3;
		//pcMesh->mNumBones = 0;
		//pcMesh->mColors[0] = pcMesh->mColors[1] = pcMesh->mColors[2] = pcMesh->mColors[3] = NULL;
		pcMesh->mNumFaces = pcSurfaces->NUM_TRIANGLES;
		pcMesh->mFaces = new aiFace[pcSurfaces->NUM_TRIANGLES];
		pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
		pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
		pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
		//pcMesh->mTextureCoords[1] = pcMesh->mTextureCoords[2] = pcMesh->mTextureCoords[3] = NULL;
		pcMesh->mNumUVComponents[0] = 2;

		// fill in all triangles
		unsigned int iCurrent = 0;
		for (unsigned int i = 0; i < (unsigned int)pcSurfaces->NUM_TRIANGLES;++i)
		{
			pcMesh->mFaces[i].mIndices = new unsigned int[3];
			pcMesh->mFaces[i].mNumIndices = 3;

			unsigned int iTemp = iCurrent;
			for (unsigned int c = 0; c < 3;++c,++iCurrent)
			{
				// read vertices
				pcMesh->mVertices[iCurrent].x = pcVertices[ pcTriangles->INDEXES[c]].X;
				pcMesh->mVertices[iCurrent].y = pcVertices[ pcTriangles->INDEXES[c]].Y*-1.0f;
				pcMesh->mVertices[iCurrent].z = pcVertices[ pcTriangles->INDEXES[c]].Z;

				// convert the normal vector to uncompressed float3 format
				LatLngNormalToVec3(pcVertices[pcTriangles->INDEXES[c]].NORMAL,
					(float*)&pcMesh->mNormals[iCurrent]);

				pcMesh->mNormals[iCurrent].y *= -1.0f;

				// read texture coordinates
				pcMesh->mTextureCoords[0][iCurrent].x = pcUVs[ pcTriangles->INDEXES[c]].U;
				pcMesh->mTextureCoords[0][iCurrent].y = 1.0f-pcUVs[ pcTriangles->INDEXES[c]].V;
			}
			// FIX: flip the face ordering for use with OpenGL
			pcMesh->mFaces[i].mIndices[0] = iTemp+2;
			pcMesh->mFaces[i].mIndices[1] = iTemp+1;
			pcMesh->mFaces[i].mIndices[2] = iTemp+0;
			pcTriangles++;
		}

		// get the first shader (= texture?) assigned to the surface
		if (0 != pcSurfaces->NUM_SHADER)
		{
			// make a relative path.
			// if the MD3's internal path itself and the given path are using
			// the same directory remove it
			const char* szEndDir1 = ::strrchr((const char*)this->m_pcHeader->NAME,'\\');
			if (!szEndDir1)szEndDir1 = ::strrchr((const char*)this->m_pcHeader->NAME,'/');

			const char* szEndDir2 = ::strrchr((const char*)pcShaders->NAME,'\\');
			if (!szEndDir2)szEndDir2 = ::strrchr((const char*)pcShaders->NAME,'/');

			if (szEndDir1 && szEndDir2)
			{
				// both of them are valid
				const unsigned int iLen1 = (unsigned int)(szEndDir1 - (const char*)this->m_pcHeader->NAME);
				const unsigned int iLen2 = std::min (iLen1, (unsigned int)(szEndDir2 - (const char*)pcShaders->NAME) );

				bool bSuccess = true;
				for (unsigned int a = 0; a  < iLen2;++a)
				{
					char sz = tolower ( pcShaders->NAME[a] );
					char sz2 = tolower ( this->m_pcHeader->NAME[a] );
					if (sz != sz2)
					{
						bSuccess = false;
						break;
					}
				}
				if (bSuccess)
				{
					// use the file name only
					szEndDir2++;
				}
				else
				{
					// use the full path
					szEndDir2 = (const char*)pcShaders->NAME;
				}
			}

			// now try to find out whether we have this shader already
			bool bHave = false;
			for (unsigned int p = 0; p < iNumMaterials;++p)
			{
				if (iDefaultMatIndex == p)continue;

				aiString szOut;
				if(AI_SUCCESS == aiGetMaterialString ( (aiMaterial*)pScene->mMaterials[p],
					AI_MATKEY_TEXTURE_DIFFUSE(0),&szOut))
				{
					if (0 == ASSIMP_stricmp(szOut.data,szEndDir2))
					{
						// equal. reuse this material (texture)
						bHave = true;
						pcMesh->mMaterialIndex = p;
						break;
					}
				}
			}

			if (!bHave)
			{
				MaterialHelper* pcHelper = new MaterialHelper();

				if (szEndDir2)
				{
					if (szEndDir2[0])
					{
						aiString szString;
						const size_t iLen = ::strlen(szEndDir2);
						::memcpy(szString.data,szEndDir2,iLen);
						szString.data[iLen] = '\0';
						szString.length = iLen;

						pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0));
					}
					else 
					{
						DefaultLogger::get()->warn("Texture file name has zero length. "
							"It will be skipped.");
					}
				}

				int iMode = (int)aiShadingMode_Gouraud;
				pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);

				// add a small ambient color value - Quake 3 seems to have one
				aiColor3D clr;
				clr.b = clr.g = clr.r = 0.05f;
				pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);

				aiString szName;
				szName.Set(AI_DEFAULT_MATERIAL_NAME);
				pcHelper->AddProperty(&szName,AI_MATKEY_NAME);

				pScene->mMaterials[iNumMaterials] = (aiMaterial*)pcHelper;
				pcMesh->mMaterialIndex = iNumMaterials++;
			}
		}
		else
		{
			if (0xFFFFFFFF != iDefaultMatIndex)
			{
				pcMesh->mMaterialIndex = iDefaultMatIndex;
			}
			else
			{
				MaterialHelper* pcHelper = new MaterialHelper();

				// fill in a default material
				int iMode = (int)aiShadingMode_Gouraud;
				pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);

				aiColor3D clr;
				clr.b = clr.g = clr.r = 0.6f;
				pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
				pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);

				clr.b = clr.g = clr.r = 0.05f;
				pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);

				pScene->mMaterials[iNumMaterials] = (aiMaterial*)pcHelper;
				pcMesh->mMaterialIndex = iNumMaterials++;
			}
		}
		// go to the next surface
		pcSurfaces = (const MD3::Surface*)(((unsigned char*)pcSurfaces) + pcSurfaces->OFS_END);
	}

	if (0 == pScene->mNumMeshes)
	{
		// cleanup before returning
		delete[] this->mBuffer;
		throw new ImportErrorException( "Invalid md3 file: File contains no valid mesh");
	}
	pScene->mNumMaterials = iNumMaterials;

	// now we need to generate an empty node graph
	pScene->mRootNode = new aiNode();
	pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
	pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];

	for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
		pScene->mRootNode->mMeshes[i] = i;

	// delete the file buffer and return
	delete[] this->mBuffer;
	return;
}