// ==============================================================
//	This file is part of Glest Shared Library (www.glest.org)
//
//	Copyright (C) 2001-2008 Martiño Figueroa
//
//	You can redistribute this code and/or modify it under
//	the terms of the GNU General Public License as published
//	by the Free Software Foundation; either version 2 of the
//	License, or (at your option) any later version
// ==============================================================

#ifndef _SHARED_GRAPHICS_MODEL_H_
#define _SHARED_GRAPHICS_MODEL_H_

#include <string>
#include <map>
#include "data_types.h"
#include "pixmap.h"
#include "texture_manager.h"
#include "texture.h"
#include "model_header.h"
#include <memory>
#include "common_scoped_ptr.h"
#include "byte_order.h"
#include "leak_dumper.h"

using std::string;
using std::map;
using std::pair;

namespace Shared {
	namespace Graphics {

		class Model;
		class Mesh;
		class ShadowVolumeData;
		class InterpolationData;
		class TextureManager;

		// =====================================================
		//	class Mesh
		//
		//	Part of a 3D model
		// =====================================================

		class Mesh {
		private:
			//mesh data
			Texture2D *textures[meshTextureCount];
			bool texturesOwned[meshTextureCount];
			string texturePaths[meshTextureCount];

			string name;
			//vertex data counts
			uint32 frameCount;
			uint32 vertexCount;
			uint32 indexCount;
			uint32 texCoordFrameCount;

			//vertex data
			Vec3f *vertices;
			Vec3f *normals;
			Vec2f *texCoords;
			Vec3f *tangents;
			uint32 *indices;

			//material data
			Vec3f diffuseColor;
			Vec3f specularColor;
			float specularPower;
			float opacity;

			//properties
			bool twoSided;
			bool customColor;
			bool noSelect;
			bool glow;

			uint32 textureFlags;

			InterpolationData *interpolationData;
			TextureManager *textureManager;

			// Vertex Buffer Object Names
			bool    hasBuiltVBOs;
			uint32	m_nVBOVertices;					// Vertex VBO Name
			uint32	m_nVBOTexCoords;				// Texture Coordinate VBO Name
			uint32	m_nVBONormals;					// Normal VBO Name
			uint32	m_nVBOIndexes;					// Indexes VBO Name

		public:
			//init & end
			Mesh();
			~Mesh();
			void init();
			void end();

			void copyInto(Mesh *dest, bool ignoreInterpolationData, bool destinationOwnsTextures);

			//maps
			const Texture2D *getTexture(int i) const {
				return textures[i];
			}

			//counts
			uint32 getFrameCount() const {
				return frameCount;
			}
			uint32 getVertexCount() const {
				return vertexCount;
			}
			uint32 getIndexCount() const {
				return indexCount;
			}
			uint32 getTriangleCount() const;

			uint32	getVBOVertices() const {
				return m_nVBOVertices;
			}
			uint32	getVBOTexCoords() const {
				return m_nVBOTexCoords;
			}
			uint32	getVBONormals() const {
				return m_nVBONormals;
			}
			uint32	getVBOIndexes() const {
				return m_nVBOIndexes;
			}
			bool    hasBuiltVBOEntities() const {
				return hasBuiltVBOs;
			}
			void BuildVBOs();
			void ReleaseVBOs();

			//data
			const Vec3f *getVertices() const {
				return vertices;
			}
			const Vec3f *getNormals() const {
				return normals;
			}
			const Vec2f *getTexCoords() const {
				return texCoords;
			}
			const Vec3f *getTangents() const {
				return tangents;
			}
			const uint32 *getIndices() const {
				return indices;
			}

			void setVertices(Vec3f *data, uint32 count);
			void setNormals(Vec3f *data, uint32 count);
			void setTexCoords(Vec2f *data, uint32 count);
			void setIndices(uint32 *data, uint32 count);

			//material
			const Vec3f &getDiffuseColor() const {
				return diffuseColor;
			}
			const Vec3f &getSpecularColor() const {
				return specularColor;
			}
			float getSpecularPower() const {
				return specularPower;
			}
			float getOpacity() const {
				return opacity;
			}

			//properties
			bool getTwoSided() const {
				return twoSided;
			}
			bool getCustomTexture() const {
				return customColor;
			}
			bool getNoSelect() const {
				return noSelect;
			}
			bool getGlow() const {
				return glow;
			}
			string getName() const {
				return name;
			}

			uint32 getTextureFlags() const {
				return textureFlags;
			}

			//external data
			const InterpolationData *getInterpolationData() const {
				return interpolationData;
			}

			//interpolation
			void buildInterpolationData();
			void cleanupInterpolationData();

			void updateInterpolationData(float t, bool cycle);
			void updateInterpolationVertices(float t, bool cycle);

			Texture2D *loadMeshTexture(int meshIndex, int textureIndex, TextureManager *textureManager, string textureFile,
				int textureChannelCount, bool &textureOwned,
				bool deletePixMapAfterLoad, std::map<string, vector<pair<string, string> > > *loadedFileList = NULL,
				string sourceLoader = "", string modelFile = "");

			//load
			void loadV2(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,
				bool deletePixMapAfterLoad, std::map<string, vector<pair<string, string> > > *loadedFileList = NULL, string sourceLoader = "", string modelFile = "");
			void loadV3(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,
				bool deletePixMapAfterLoad, std::map<string, vector<pair<string, string> > > *loadedFileList = NULL, string sourceLoader = "", string modelFile = "");
			void load(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager, bool deletePixMapAfterLoad, std::map<string, vector<pair<string, string> > > *loadedFileList = NULL, string sourceLoader = "", string modelFile = "");
			void save(int meshIndex, const string &dir, FILE *f, TextureManager *textureManager,
				string convertTextureToFormat, std::map<string, int> &textureDeleteList,
				bool keepsmallest, string modelFile);

			void deletePixels();

			void toEndian();
			void fromEndian();

		private:
			string findAlternateTexture(vector<string> conversionList, string textureFile);
			void computeTangents();

		};

		// =====================================================
		//	class Model
		//
		//	3D Model, than can be loaded from a g3d file
		// =====================================================

		class Model {
		private:
			TextureManager *textureManager;

		private:
			uint8 fileVersion;
			uint32 meshCount;
			Mesh *meshes;

			float lastTData;
			bool lastCycleData;
			float lastTVertex;
			bool lastCycleVertex;

			string fileName;
			string sourceLoader;

			//static bool masterserverMode;

		public:
			//constructor & destructor
			Model();
			virtual ~Model();
			virtual void init() = 0;
			virtual void end() = 0;

			//static void setMasterserverMode(bool value) { masterserverMode=value; }

			//data
			void updateInterpolationData(float t, bool cycle);
			void updateInterpolationVertices(float t, bool cycle);
			void buildShadowVolumeData() const;

			//get
			uint8 getFileVersion() const {
				return fileVersion;
			}
			uint32 getMeshCount() const {
				return meshCount;
			}
			const Mesh *getMesh(int i) const {
				return &meshes[i];
			}
			Mesh *getMeshPtr(int i) const {
				return &meshes[i];
			}

			uint32 getTriangleCount() const;
			uint32 getVertexCount() const;

			//io
			void save(const string &path, string convertTextureToFormat, bool keepsmallest);
			void saveG3d(const string &path, string convertTextureToFormat, bool keepsmallest);

			void setTextureManager(TextureManager *textureManager) {
				this->textureManager = textureManager;
			}
			void deletePixels();

			string getFileName() const {
				return fileName;
			}

			void toEndian();
			void fromEndian();

		protected:
			void load(const string &path, bool deletePixMapAfterLoad = false, std::map<string, vector<pair<string, string> > > *loadedFileList = NULL, string *sourceLoader = NULL);
			void loadG3d(const string &path, bool deletePixMapAfterLoad = false, std::map<string, vector<pair<string, string> > > *loadedFileList = NULL, string sourceLoader = "");


		private:
			void buildInterpolationData() const;
			void autoJoinMeshFrames();
		};

		class PixelBufferWrapper {
		public:
			PixelBufferWrapper(int pboCount, int bufferSize);
			~PixelBufferWrapper();

			Pixmap2D *getPixelBufferFor(int x, int y, int w, int h, int colorComponents);
			static void begin();
			static void end();
			static bool getIsPBOEnable() {
				return isPBOEnabled;
			}

		private:
			static bool isPBOEnabled;
			static int index;
			static vector<uint32> pboIds;
			int bufferSize;

			void cleanup();
			void addBuffersToPixelBuf(int pboCount);
		};

		class BaseColorPickEntity {

		public:
			BaseColorPickEntity();
			virtual ~BaseColorPickEntity() {
				recycleUniqueColor();
			}

			//static const int COLOR_COMPONENTS = 3;
			static const int COLOR_COMPONENTS = 4;
			static void init(int bufferSize);
			static void beginPicking();
			static void endPicking();
			static vector<int> getPickedList(int x, int y, int w, int h, const vector<BaseColorPickEntity *> &rendererModels);

			void setUniquePickingColor() const;
			bool isUniquePickingColor(unsigned char *pixel) const;

			string getColorDescription() const;
			virtual string getUniquePickName() const = 0;

			static void resetUniqueColors();

			static void setUsingLoopMethod(bool value) {
				using_loop_method = value;
			}

			static void setTrackColorUse(bool value) {
				trackColorUse = value;
			}
			unsigned char * getUniqueColorID() {
				return &uniqueColorID[0];
			}
			bool get_next_assign_color(unsigned char *assign_to);

			static int getUsedColorIDListSize() {
				return (int) usedColorIDList.size();
			}

			static void cleanupPBO();

		private:

			static int bufferSizeRequired;
			unsigned char uniqueColorID[COLOR_COMPONENTS];

			static unsigned char nextColorID[COLOR_COMPONENTS];
			static unsigned int nextColorRGB;
			static const unsigned int k, p;

			static bool using_loop_method;

			static bool trackColorUse;
			static map<string, bool> usedColorIDList;

			static vector<vector<unsigned char> > nextColorIDReuseList;

			static auto_ptr<PixelBufferWrapper> pbo;
			//static auto_ptr<Pixmap2D> cachedPixels;

			void assign_color();

			void assign_color_using_prime(unsigned char *assign_to);
			void assign_color_using_loop(unsigned char *assign_to);

			void recycleUniqueColor();
		};

	}
}//end namespace

#endif