#include "ResourceManager.h"
#include "Matrix4x4.h"
#include "Geometry.h"
#include "SceneEntity.h"
#include "Material.h"
#include "Texture.h"
#include "gzstream.h"
#include "Matrix4x4.h"
#include "Vector3.h"
#include "Transform3.h"
#include "Shape.h"
#include "LODInfo.h"
#include "RenderState.h"
#include "ShaderProgram.h"
#include <Cg/cg.h>
#include <Cg/cgGL.h>


#ifdef _CRT_SET
	#define _CRTDBG_MAP_ALLOC
	#include <stdlib.h>
	#include <crtdbg.h>

	// redefine new operator
	#define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
	#define new DEBUG_NEW
#endif


using namespace std;


namespace CHCDemoEngine
{


/////////
//-- cg stuff

static CGcontext sCgContext = NULL;

static CGprofile sCgFragmentProfile;
static CGprofile sCgVertexProfile; 
static ShaderProgram *sTreeAnimation;

// only instance of the resource manager
ResourceManager *ResourceManager::sResourceManager = NULL;


static void cgErrorCallback()
{
	CGerror lastError = cgGetError();

	if(lastError)
	{
		printf("%s\n\n", cgGetErrorString(lastError));
		printf("%s\n", cgGetLastListing(sCgContext));
		
		printf("Cg error, exiting...\n");

		exit(0);
	}
}


ResourceManager::ResourceManager()
{ 
	InitCg(); 
}


ResourceManager::~ResourceManager()
{
	// delete all resources.
	CLEAR_CONTAINER(mSceneEntities);
	CLEAR_CONTAINER(mGeometry);
	CLEAR_CONTAINER(mMaterials);
	CLEAR_CONTAINER(mTextures);
	CLEAR_CONTAINER(mTrafos);
	CLEAR_CONTAINER(mShapes);
	CLEAR_CONTAINER(mLODs);
	CLEAR_CONTAINER(mGPUParameters);
	CLEAR_CONTAINER(mShaders);
	
	if (sCgContext)
		cgDestroyContext(sCgContext);
}


SceneEntity *ResourceManager::LoadSceneEntity(igzstream &str)
{	
	bool hasTrafo;
	str.read(reinterpret_cast<char *>(&hasTrafo), sizeof(bool));
	
	SceneEntity *sceneGeom;
	Transform3 *trafo;

	if (!hasTrafo)
	{
		// identity
		trafo = new Transform3();
	}
	else
	{
		Matrix4x4 m;
		str.read(reinterpret_cast<char *>(m.x), sizeof(Matrix4x4));
		
		trafo = new Transform3(m);
	}

	mTrafos.push_back(trafo);

	sceneGeom = new SceneEntity(trafo);


	///////////////
	//-- load lod levels

	// note: lods must be ordered from smallest distance to largest
	int numLODs;
	str.read(reinterpret_cast<char *>(&numLODs), sizeof(int));

	for (int i = 0; i < numLODs; ++ i)
	{
		float dist;
		str.read(reinterpret_cast<char *>(&dist), sizeof(float));

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

		LODLevel *lodLevel = new LODLevel(dist);

		for (int j = 0; j < numShapes; ++ j)
		{
			int shapeId;
			str.read(reinterpret_cast<char *>(&shapeId), sizeof(int));

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

			// create shape
			Shape *shape = new Shape(geom, mat, sceneGeom);

			mShapes.push_back(shape);

			sceneGeom->AddShape(shape);
			lodLevel->AddShape(shape);
		}

		mLODs.push_back(lodLevel);
		sceneGeom->AddLODLevel(lodLevel);
	}

	///////////
	//-- hack: tree animation

	if (numLODs > 1)
	{
		for (int i = 0; i < min(numLODs, 2); ++ i)
		{
			ShapeContainer::iterator sstart, send;
			sceneGeom->GetLODLevel(i, sstart, send);

			for (ShapeContainer::iterator it = sstart; it != send; ++ it)
			{
				Shape *shape = *it;

				Material *mat = shape->GetMaterial();

				// add the vertex animation program
				for (int i = 0; i < 2; ++ i)
				{
					Technique *tech = mat->GetTechnique(i);
					tech->SetVertexProgram(sTreeAnimation);

					GPUProgramParameters *vtxParams = tech->GetVertexProgramParameters();

					vtxParams->SetTimerParam(0);
					// wind direction
					static Vector3 windDir = Normalize(Vector3(0.8f, 0.2f, 0.0f));
					vtxParams->SetValue3f(1, windDir.x, windDir.y, windDir.z);
					// amplitude
					vtxParams->SetValue1f(2, 0.3f);

					AxisAlignedBox3 box = sceneGeom->GetBoundingBox();
					vtxParams->SetValue2f(3, box.Min().z, box.Max().z);
					// frequency
					vtxParams->SetValue1f(4, 0.1f);
				}
			}
		}
	}

	return sceneGeom;
}


void ResourceManager::LoadTextures(igzstream &str)
{
	int numTextures;
	str.read(reinterpret_cast<char *>(&numTextures), sizeof(int));
	
	for (int i = 0; i < numTextures; ++ i)
	{
		// load texture name
		int texnameSize;
		str.read(reinterpret_cast<char *>(&texnameSize), sizeof(int));

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

		Texture *tex = new Texture(model_path + texname);

		int boundS, boundT;

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

		tex->SetBoundaryModeS(boundS);
		tex->SetBoundaryModeT(boundT);

		tex->Create();

		mTextureTable[i] = tex;
		mTextures.push_back(tex);

		delete [] texname;
	}

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


void ResourceManager::LoadShapes(igzstream &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;		

		mGeometry.push_back(geom);
		mMaterials.push_back(mat);
	}

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


Material *ResourceManager::LoadMaterial(igzstream &str)
{
	// default material
	Material *mat = new Material();
	
	// set default fragment + vertex programs
	Technique *tech = mat->GetDefaultTechnique();

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

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

	// gl material
	bool hasGlMaterial;
	str.read(reinterpret_cast<char *>(&hasGlMaterial), sizeof(bool));

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


	///////////////
	//-- add technique for deferred shading

	Technique *deferred = new Technique(*tech);

	if (deferred->GetTexture())
	{
		deferred->SetFragmentProgram(mMrtDefaultFragmentTexProgram);
		deferred->GetFragmentProgramParameters()->SetViewMatrixParam(0);
		deferred->GetFragmentProgramParameters()->SetTexture(1, tech->GetTexture()->GetId());
	}	
	else
	{
		deferred->SetFragmentProgram(mMrtDefaultFragmentProgram);
		deferred->GetFragmentProgramParameters()->SetViewMatrixParam(0);
	}

	deferred->SetVertexProgram(mMrtDefaultVertexProgram);
	
	mat->AddTechnique(deferred);

	return mat;
}


Geometry *ResourceManager::LoadGeometry(igzstream &str)
{
	Vector3 *vertices;
	Vector3 *normals;
	Texcoord2 *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)
	{
		texcoords = new Texcoord2[texCoordCount];
		str.read(reinterpret_cast<char *>(texcoords), sizeof(Texcoord2) * texCoordCount);
	}
	else
	{
		texcoords = NULL;
	}

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


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

	entities.reserve(entityCount);

	for (int i = 0; i < entityCount; ++ i)
	{
		SceneEntity *ent = LoadSceneEntity(str);

		// return loaded entities
		entities.push_back(ent);
		// also store internally
		mSceneEntities.push_back(ent);
	}

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


bool ResourceManager::Load(const std::string &filename, SceneEntityContainer &entities)
{
	igzstream istr(filename.c_str());
	
	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;

	// clean up
	mTextureTable.clear();
	mGeometryTable.clear();
	mMaterialTable.clear();

	return true;
}



ShaderProgram *ResourceManager::CreateFragmentProgram(const std::string &filename, 
													  const std::string &funcName)
{
	const string fullName = "src/shaders/" + filename + ".cg";

	ShaderProgram *p = new ShaderProgram(sCgContext, fullName, sCgFragmentProfile, funcName);

	mShaders.push_back(p);

	if (!p->IsValid())
	{
		DEL_PTR(p);
		cerr << "Program " << funcName << " in " << fullName << " failed to load" << endl;
	}
	
	cout << "Program " << funcName << " in " << fullName << " loaded" << endl;

	return p;
}


ShaderProgram *ResourceManager::CreateVertexProgram(const std::string &filename, const std::string &funcName)
{
	const string fullName = "src/shaders/" + filename + ".cg";
	
	ShaderProgram *p = new ShaderProgram(sCgContext, fullName, sCgVertexProfile, funcName);
	mShaders.push_back(p);

	if (!p->IsValid())
	{
		DEL_PTR(p);
		cerr << "Program " << funcName << " in " << fullName << " failed to load" << endl;
	}
	
	cout << "Program " << funcName << " in " << fullName << " loaded" << endl;

	return p;
}


void ResourceManager::InitCg() 
{
	// setup cg
	cgSetErrorCallback(cgErrorCallback);
	// create context.
	sCgContext = cgCreateContext();
	// get the optimal fragment profile
	sCgFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
	cgGLSetOptimalOptions(sCgFragmentProfile);
	// get the optimal vertex profile
	sCgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
	cgGLSetOptimalOptions(sCgVertexProfile);

	// set textures to auto load
	cgGLSetManageTextureParameters(sCgContext, false);

	mMrtDefaultVertexProgram = CreateVertexProgram("mrt", "vtx");
	mMrtDefaultFragmentProgram = CreateFragmentProgram("mrt", "frag");
	mMrtDefaultFragmentTexProgram = CreateFragmentProgram("mrt", "fragtex");

	// provide the current view matrix
	mMrtDefaultFragmentProgram->AddParameter("viewMatrix", 0);
	mMrtDefaultFragmentTexProgram->AddParameter("viewMatrix", 0);

	// add a texture parameter
	mMrtDefaultFragmentTexProgram->AddParameter("tex", 1);

	sTreeAnimation = CreateVertexProgram("treeanimation", "animateVtxMrt");

	sTreeAnimation->AddParameter("timer", 0);
	sTreeAnimation->AddParameter("windDir", 1);
	sTreeAnimation->AddParameter("windStrength", 2);
	sTreeAnimation->AddParameter("minMaxPos", 3);
	sTreeAnimation->AddParameter("frequency", 4);

	cout << "cg initialization successful" << endl;
}


void ResourceManager::EnableFragmentProfile()
{
	cgGLEnableProfile(sCgFragmentProfile);
}


void ResourceManager::EnableVertexProfile()
{
	cgGLEnableProfile(sCgVertexProfile);
}


void ResourceManager::DisableFragmentProfile()
{
	cgGLDisableProfile(sCgFragmentProfile);
}


void ResourceManager::DisableVertexProfile()
{
	cgGLDisableProfile(sCgVertexProfile);
	
}


}