/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */

#ifndef HPL_MESH_LOADER_COLLADA_H
#define HPL_MESH_LOADER_COLLADA_H

#include "common/list.h"
#include "hpl1/engine/graphics/VertexBuffer.h"
#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/physics/PhysicsJoint.h"
#include "hpl1/engine/resources/MeshLoader.h"
#include "hpl1/engine/system/MemoryManager.h"

class TiXmlElement;

namespace hpl {

class cMesh;
class cNode3D;
class iVertexBuffer;
class cBone;
class cAnimation;
class cAnimationTrack;
class cSkeleton;
class cWorld3D;
class cSector;
class cMeshEntity;
class iPhysicsBody;
class cColliderEntity;
class cMeshJoint;
class cSystem;

//////////////////////////////////////////////
// HELP CLASSES

class cColladaImage {
public:
	tString msId;
	tString msName;

	tString msSource;
};

typedef Common::Array<cColladaImage> tColladaImageVec;

//------------------------------------------------

class cColladaTexture {
public:
	tString msId;
	tString msName;

	tString msImage;
};

typedef Common::Array<cColladaTexture> tColladaTextureVec;

//------------------------------------------------

class cColladaMaterial {
public:
	tString msId;
	tString msName;

	tString msTexture;
	cColor mDiffuseColor;
};

typedef Common::Array<cColladaMaterial> tColladaMaterialVec;

//------------------------------------------------

class cColladaLight {
public:
	tString msId;
	tString msName;
	tString msType;

	cColor mDiffuseColor;
	float mfAngle;
};

typedef Common::Array<cColladaLight> tColladaLightVec;

//------------------------------------------------

class cColladaVtxArray {
public:
	cColladaVtxArray() : mbIsInVertex(false) {}

	tString msId;
	tString msType;
	bool mbIsInVertex;

	tVector3fVec mvArray;
};

typedef Common::Array<cColladaVtxArray> tColladaVtxArrayVec;

class cColladaVtxIndex {
public:
	int mlVtx;
	int mlNorm;
	int mlTex;
};

typedef Common::Array<cColladaVtxIndex> tColladaVtxIndexVec;

//------------------------------------------------

class cColladaExtraVtx {
public:
	cColladaExtraVtx(int alVtx, int alNorm, int alTex, int alNewVtx) {
		mlVtx = alVtx;
		mlNorm = alNorm;
		mlTex = alTex;
		mlNewVtx = alNewVtx;
	}

	cColladaExtraVtx() {}

	int mlVtx;
	int mlNorm;
	int mlTex;

	int mlNewVtx;

	bool Equals(const cColladaVtxIndex &aData) {
		if (mlVtx == aData.mlVtx && mlNorm == aData.mlNorm && mlTex == aData.mlTex) {
			return true;
		}

		return false;
	}
};

typedef Common::List<cColladaExtraVtx> tColladaExtraVtxList;
typedef tColladaExtraVtxList::iterator tColladaExtraVtxListIt;

typedef Common::Array<tColladaExtraVtxList> tColladaExtraVtxListVec;

//------------------------------------------------

class cColladaGeometry {
public:
	cColladaGeometry() : mlPosArrayIdx(-1), mlNormArrayIdx(-1), mlTexArrayIdx(-1),
						 mlPosIdxNum(-1), mlNormIdxNum(-1), mlTexIdxNum(-1) {}

	void Clear() {
		mvIndices.clear();

		for (int i = 0; i < (int)mvArrayVec.size(); i++) {
			mvArrayVec[i].mvArray.clear();
		}
		/*mvVertexVec.clear();
		mvIndexVec.clear();
		mvExtraVtxVec.clear();*/
	}

	tString msId;
	tString msName;

	tVertexVec mvVertexVec;
	tUIntVec mvIndexVec;
	tColladaExtraVtxListVec mvExtraVtxVec;
	tFloatVec mvTangents;

	tString msMaterial;

	// THe following are ONLY used when loading from a geometry element.!!
	tColladaVtxArrayVec mvArrayVec;
	tColladaVtxIndexVec mvIndices;

	int mlPosIdxNum;  // The position in the triangle element
	int mlNormIdxNum; // for eternal use only
	int mlTexIdxNum;

	int mlPosArrayIdx;  // The index for array containing positions
	int mlNormArrayIdx; // The index for array containing normals
	int mlTexArrayIdx;  // The index for array containing texcoords
};

typedef Common::Array<cColladaGeometry> tColladaGeometryVec;

//------------------------------------------------

class cColladaJointPair {
public:
	cColladaJointPair() {}
	cColladaJointPair(int alJoint, int alWeight) {
		mlJoint = alJoint;
		mlWeight = alWeight;
	}

	int mlJoint;
	int mlWeight;
};

typedef Common::List<cColladaJointPair> tColladaJointPairList;
typedef tColladaJointPairList::iterator tColladaJointPairListIt;

typedef Common::Array<tColladaJointPairList> tColladaJointPairListVec;

class cColladaController {
public:
	cColladaController() : mlJointPairIdx(-1), mlWeightPairIdx(-1) {}

	tString msTarget;
	tString msId;

	cMatrixf m_mtxBindShapeMatrix;

	int mlJointPairIdx;
	int mlWeightPairIdx;

	tStringVec mvJoints;
	tFloatVec mvWeights;
	tMatrixfVec mvMatrices;

	tColladaJointPairListVec mvPairs;
};

typedef Common::Array<cColladaController> tColladaControllerVec;

//------------------------------------------------

class cColladaChannel {
public:
	tString msId;
	tString msTarget;
	tString msSource;
};

typedef Common::Array<cColladaChannel> tColladaChannelVec;

class cColladaSampler {
public:
	tString msId;
	tString msTimeArray;
	tString msValueArray;

	tString msTarget;
};

typedef Common::Array<cColladaSampler> tColladaSamplerVec;

class cColladaAnimSource {
public:
	tString msId;
	tFloatVec mvValues;
};

typedef Common::Array<cColladaAnimSource> tColladaAnimSourceVec;

class cColladaAnimation {
public:
	tString msId;
	// tString msName;
	tString msTargetNode;

	tColladaChannelVec mvChannels;
	tColladaSamplerVec mvSamplers;

	tColladaAnimSourceVec mvSources;

	tFloatVec *GetSourceVec(const tString &asId) {
		for (size_t i = 0; i < mvSources.size(); i++) {
			if (mvSources[i].msId == asId) {
				return &mvSources[i].mvValues;
			}
		}

		return NULL;
	}
};

typedef Common::Array<cColladaAnimation> tColladaAnimationVec;

//------------------------------------------------

class cColladaTransform {
public:
	tString msSid;
	tString msType;
	tFloatVec mvValues;
};

typedef Common::List<cColladaTransform> tColladaTransformList;
typedef tColladaTransformList::iterator tColladaTransformListIt;

class cColladaNode;
typedef Common::List<cColladaNode *> tColladaNodeList;
typedef tColladaNodeList::iterator tColladaNodeListIt;

class cColladaNode {
public:
	cColladaNode() : mlCount(0), pParent(NULL), mvScale(1, 1, 1), mbSourceIsFile(false) {}

	tString msId;
	tString msName;
	tString msType;

	tString msSource;
	bool mbSourceIsFile;

	cMatrixf m_mtxTransform;
	cMatrixf m_mtxWorldTransform;

	cColladaNode *pParent;

	cVector3f mvScale;

	int mlCount;

	tColladaNodeList mlstChildren;

	tColladaTransformList mlstTransforms;

	/*void DeleteChildren()
	{
		STLDeleteAll(mlstChildren);
	}*/

	cColladaNode *CreateChild() {
		cColladaNode *pNode = hplNew(cColladaNode, ());
		mlstChildren.push_back(pNode);
		pNode->pParent = this;
		return pNode;
	}

	cColladaTransform *GetTransform(const tString &asSid) {
		tColladaTransformListIt it = mlstTransforms.begin();
		for (; it != mlstTransforms.end(); it++) {
			cColladaTransform &Trans = *it;
			if (Trans.msSid == asSid) {
				return &Trans;
			}
		}
		return NULL;
	}
};

class cColladaScene {
public:
	cColladaScene() {
		mRoot.m_mtxTransform = cMatrixf::Identity;
		mRoot.m_mtxWorldTransform = cMatrixf::Identity;

		mfDeltaTime = 0;
	}

	~cColladaScene() {
		// mRoot.DeleteChildren();
		STLDeleteAll(mlstNodes);
	}

	void ResetNodes() {
		STLDeleteAll(mlstNodes);
		mRoot.mlstChildren.clear();
	}

	cColladaNode *GetNode(const tString asId) {
		tColladaNodeListIt it = mlstNodes.begin();
		for (; it != mlstNodes.end(); ++it) {
			cColladaNode *pNode = *it;
			if (pNode->msId == asId || pNode->msName == asId) {
				return pNode;
			}
		}

		return NULL;
	}

	cColladaNode *GetNodeFromSource(const tString asSource) {
		tColladaNodeListIt it = mlstNodes.begin();
		for (; it != mlstNodes.end(); ++it) {
			cColladaNode *pNode = *it;
			if (pNode->msSource == asSource) {
				return pNode;
			}
		}

		return NULL;
	}

	float mfStartTime;
	float mfEndTime;
	float mfDeltaTime;

	cColladaNode mRoot;

	tColladaNodeList mlstNodes;
};

//------------------------------------------------

class cMeshLoaderCollada : public iMeshLoader {
public:
	cMeshLoaderCollada(iLowLevelGraphics *apLowLevelGraphics);
	virtual ~cMeshLoaderCollada();

	cMesh *LoadMesh(const tString &asFile, tMeshLoadFlag aFlags);
	bool SaveMesh(cMesh *apMesh, const tString &asFile) { return false; }

	cWorld3D *LoadWorld(const tString &asFile, cScene *apScene, tWorldLoadFlag aFlags);

	cAnimation *LoadAnimation(const tString &asFile);

	bool IsSupported(const tString asFileType);

	void AddSupportedTypes(tStringVec *avFileTypes);

private:
	bool mbZToY;

	tWorldLoadFlag mFlags;

	tString GetParentName(cColladaNode *apNode, tColladaGeometryVec *apColladaGeometries);

	void CreateMeshJoint(cMeshJoint *apJoint, ePhysicsJointType aJointType, cBoundingVolume &aBV,
						 tStringVec &avStrings, cColladaNode *apNode, cColladaScene &aColladaScene,
						 tColladaGeometryVec &avColladaGeom);

	void CreateHierarchyNodes(cMesh *apMesh, cNode3D *mpParentNode,
							  cColladaNode *apColladaNode,
							  tColladaGeometryVec &avColladaGeom);

	cColladaGeometry *GetGeometry(const tString &asId, tColladaGeometryVec &avGeomVec);
	cColladaLight *GetLight(const tString &asId, tColladaLightVec &avLightVec);

	cMeshEntity *CreateStaticMeshEntity(cColladaNode *apNode, cWorld3D *apWorld,
										cColladaGeometry *apGeom, bool abInRoomGroup,
										tColladaMaterialVec &avColladaMaterials,
										tColladaTextureVec &avColladaTextures,
										tColladaImageVec &avColladaImages);

	cColliderEntity *CreateStaticCollider(cColladaNode *apNode, cWorld3D *apWorld,
										  cColladaGeometry *apGeom,
										  tColladaMaterialVec &avColladaMaterials,
										  tColladaTextureVec &avColladaTextures,
										  tColladaImageVec &avColladaImages,
										  bool abCharacterCollider);

	void AddSceneObjects(cColladaNode *apNode, cWorld3D *apWorld,
						 tColladaGeometryVec &avColladaGeometries, tColladaLightVec &avColladaLights,
						 tColladaMaterialVec &avColladaMaterials, tColladaTextureVec &avColladaTextures,
						 tColladaImageVec &avColladaImages, cColladaScene *apColladaScene);

	void AddSectorChildren(cColladaNode *apNode, tString asSector, cWorld3D *apWorld,
						   tColladaGeometryVec &avColladaGeometries, tColladaLightVec &avColladaLights,
						   tColladaMaterialVec &avColladaMaterials, tColladaTextureVec &avColladaTextures,
						   tColladaImageVec &avColladaImages);

	cAnimationTrack *CreateAnimTrack(cAnimation *apAnimation, cSkeleton *apSkeleton,
									 cColladaAnimation &aAnim, cColladaScene *apScene);

	void CalcLocalMatrixRec(cBone *apBone, cMatrixf a_mtxParentGlobal, int alDepth);

	void CreateSkeletonBone(cColladaNode *apColladaNode, cBone *apParentBone);

	iVertexBuffer *CreateVertexBuffer(cColladaGeometry &aGeometry,
									  eVertexBufferUsageType aUsageType);
	// tColladaExtraVtxListVec &vExtraVtxVec);

	bool FillStructures(const tString &asFile,
						tColladaImageVec *apColladaImageVec,
						tColladaTextureVec *apColladaTextureVec,
						tColladaMaterialVec *apColladaMaterialVec,
						tColladaLightVec *apColladaLightVec,
						tColladaGeometryVec *apColladaGeometryVec,
						tColladaControllerVec *apColladaControllerVec,
						tColladaAnimationVec *apColladaAnimVec,
						cColladaScene *apColladaScene,
						bool abCache);

	bool SaveStructures(const tString &asFile,
						tColladaImageVec *apColladaImageVec,
						tColladaTextureVec *apColladaTextureVec,
						tColladaMaterialVec *apColladaMaterialVec,
						tColladaLightVec *apColladaLightVec,
						tColladaGeometryVec *apColladaGeometryVec,
						tColladaControllerVec *apColladaControllerVec,
						tColladaAnimationVec *apColladaAnimVec,
						cColladaScene *apColladaScene);

	bool LoadStructures(const tString &asFile,
						tColladaImageVec *apColladaImageVec,
						tColladaTextureVec *apColladaTextureVec,
						tColladaMaterialVec *apColladaMaterialVec,
						tColladaLightVec *apColladaLightVec,
						tColladaGeometryVec *apColladaGeometryVec,
						tColladaControllerVec *apColladaControllerVec,
						tColladaAnimationVec *apColladaAnimVec,
						cColladaScene *apColladaScene);

	void LoadColladaScene(TiXmlElement *apRootElem, cColladaNode *apParentNode, cColladaScene *apScene,
						  tColladaLightVec *apColladaLightVec);

	void LoadAnimations(TiXmlElement *apRootElem, tColladaAnimationVec &avAnimations,
						cColladaScene *apColladaScene);

	void LoadImages(TiXmlElement *apRootElem, tColladaImageVec &avColladaImageVec);

	void LoadTextures(TiXmlElement *apRootElem, tColladaTextureVec &avColladaTextureVec);

	void LoadMaterials(TiXmlElement *apRootElem, tColladaMaterialVec &avColladaMaterialVec);

	void LoadLights(TiXmlElement *apRootElem, tColladaLightVec &avColladaLightVec);

	void LoadGeometry(TiXmlElement *apRootElem, tColladaGeometryVec &avColladaGeometryVec, cColladaScene *apColladaScene);
	void LoadVertexData(TiXmlElement *apSourceElem, tVector3fVec &avVtxVec);

	void LoadControllers(TiXmlElement *apRootElem, tColladaControllerVec &avColladaControllerVec,
						 tColladaGeometryVec *apColladaGeometryVec);
	void LoadJointData(TiXmlElement *apSourceElem, cColladaController &aController);

	// Helpers
	void SplitVertices(cColladaGeometry &aGeometry, tColladaExtraVtxListVec &avExtraVtxVec,
					   tVertexVec &avVertexVec, tUIntVec &avIndexVec);

	void FillVertexVec(const char *apChars, tVector3fVec &avVtxVec, int alElements, int alVtxCount);
	tString GetTopString(const tString asPath);
	tString GetMaterialTextureFile(const tString &asMaterial, tColladaMaterialVec &avColladaMaterialVec,
								   tColladaTextureVec &avColladaTextureVec,
								   tColladaImageVec &avColladaImageVec);

	cVector3f GetVectorPos(const cVector3f &avVec);
	cVector3f GetVectorPosFromPtr(float *apVec);
	cVector3f GetVectorScaleFromPtr(float *apVec);
};

} // namespace hpl

#endif // HPL_MESH_LOADER_COLLADA_H