// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
//
// This file was originally written by Salvatore Russo.
// I (Nikolaus Gebhardt) did some minor modifications changes to it and integrated
// it into Irrlicht:
// - removed STL dependency
// - removed log file and replaced it with irrlicht logging
// - adapted code formatting a bit to Irrlicht style
// - removed memory leaks
// Thanks a lot to Salvatore for his work on this and that he gave me
// his permission to add it into Irrlicht.

// This support library has been made by Salvatore Russo and is released under GNU public license for general uses.
// For uses in Irrlicht core and only for Irrlicht related uses I release this library under zlib license.

#ifndef __DMF_SUPPORT_H_INCLUDED__
#define __DMF_SUPPORT_H_INCLUDED__

#include "irrString.h"
#include "fast_atof.h"

namespace irr
{
namespace scene
{
namespace
{

/** A structure representing some DeleD infos.
This structure contains data about DeleD level file like: version, ambient color, number of objects etc...*/
struct dmfHeader
{
	//main file header
	core::stringc dmfName; //!<Scene name
	f32 dmfVersion;     //!<File version
	video::SColor dmfAmbient; //!<Ambient color
	f32 dmfShadow;     //!<Shadow intensity
	u32 numObjects;    //!<Number of objects in this scene
	u32 numMaterials;  //!<Number of materials in this scene
	u32 numVertices;   //!<Total number of vertices faces*(vertices for each face)
	u32 numFaces;      //!<Total number of faces
	u32 numLights;     //!<Number of dynamic lights in this scene
	u32 numWatVertices; //!<Total number of vertices of water plains watfaces*(vertices for each face)
	u32 numWatFaces;   //!<Total number of faces for water plains.Note that each water plane is a rectangle with one face only.
};


/** A structure representing a DeleD material.
This structure contains texture names, an ID and some flags.*/
struct dmfMaterial
{
	u32 materialID;//!<This material unique ID.
	u32 textureLayers;//!<First texture Flag (0=Normal, 1=Color).
	u32 textureFlag;//!<First texture Flag (0=Normal, 1=Color).
	u32 lightmapFlag;//!<Lightmap Flag (0=Normal, others not considered).
	u32 textureBlend;//!<Texture Blend mode used to support alpha maps (4=Alpha map, others not implemented yet).
	core::stringc pathName;//!<Name of path defined in path element.
	core::stringc textureName;//!<Name of first texture (only file name, no path).
	core::stringc lightmapName;//!<Name of lightmap (only file name, no path).
	u32 lightmapBlend;//!<Blend mode used to support alpha maps (not implemented yet).
};


/** A structure representing a single face.
This structure contains first vertice index, number of vertices and the material used.*/
struct dmfFace
{
	u32 firstVert;//!<First vertex index.
	u32 numVerts;//!<Number of vertices for this face.
	u32 materialID;//!<Material used for this face.
};


/** A structure representing a single vertice.
This structure contains vertice position coordinates and texture an lightmap UV.*/
struct dmfVert
{
	core::vector3df pos;//!<Position of vertex
	core::vector2df tc;//!<Texture UV coords
	core::vector2df lc;//!<Lightmap UV coords
};


/** A structure representing a single dynamic light.
This structure contains light position coordinates, diffuse color, specular color and maximum radius of light.*/
struct dmfLight
{
	core::vector3df pos;//!<Position of this light.
	video::SColorf diffuseColor;//!<Diffuse color.
	video::SColorf specularColor;//!<Specular color.
	f32 radius;//!<Maximum radius of light.
};

/** A structure representing a single water plane.
This structure contains light position coordinates, diffuse color, specular color and maximum radius of light.*/
struct dmfWaterPlane
{
	u32 waterID;//!<ID of specified water plane.
	u32 numFaces;//!<number of faces that make this plain.Owing to the fact that this is a rectangle you'll have 1 every time.
	u32 firstFace;//!<first face of this plain.
	core::dimension2d<u32> tileNum;//!<number of tiles of this water plain.
	f32 waveHeight;//!<height of waves.
	f32 waveSpeed;//!<waves speed.
	f32 waveLength;//!<waves length.
};


/** A function to convert a hexstring to a int.
This function converts an hex string (i.e. FF) to its int value (i.e. 255).
\return An int representing the hex input value.*/
int axtoi(const char *hexStg)
{
	unsigned int intValue = 0;  // integer value of hex string
	sscanf(hexStg, "%x", &intValue);
	return (intValue);
}

typedef core::array<core::stringc> StringList;

//Loads a stringlist from a file
//note that each String added to StringList
//is separated by a \\n character and it's present
//at the end of line.
/** Loads a StringList from a file.
This function loads a StringList from a file where each string is divided by a \\n char.*/
void LoadFromFile(io::IReadFile* file, StringList& strlist)
{
	const long sz = file->getSize();
	char* buf = new char[sz+1];
	file->read(buf, sz);
	buf[sz] = 0;
	char* p = buf;
	char* start = p;

	while(*p)
	{
		if (*p == '\n')
		{
			core::stringc str(start, (u32)(p - start - 1));
			str.trim();
			strlist.push_back(str);
			start = p+1;
		}

		++p;
	}

	if (p - start > 1)
	{
		core::stringc str(start, (u32)(p - start - 1));
		str.trim();
		strlist.push_back(str);
	}

	delete [] buf;
};

//This function subdivides a string in a list of strings
/** This function subdivides strings divided by divider in a list of strings.
\return A StringList made of all strings divided by divider.*/
StringList SubdivideString(const core::stringc& str, const core::stringc& divider)
{
	StringList strings; //returned StringList
	strings.clear();    //clear returned stringlist

	int c=0;
	int l=str.size();

	//process entire string
	while(c<l)
	{
		core::stringc resultstr;
		resultstr = "";
		//read characters until divider is encountered
		while((str[c]!=divider[0]) && c<l)
		{
			resultstr += str[c];
			++c;
		}

		//Remove spaces \t and \n from string in my implementation...
		//pay attention or change it in dll.h if you don't want to remove
		//a particular char.
		resultstr.trim();//trims string resultstr
		strings.push_back(resultstr);//add trimmed string
		++c;
	}

	return strings;
}


//Get DeleD information and convert in dmfHeader
/**This function extract a dmfHeader from a DMF file.
You must give in input a StringList representing a DMF file loaded with LoadFromFile.
\return true if function succeed or false on fail.*/
bool GetDMFHeader(const StringList& RawFile, dmfHeader& header)
{
	StringList temp;
	RawFile[0].split(temp, ";"); //file info
//	StringList temp=SubdivideString(RawFile[0],";"); //file info

	if ( temp[0] != "DeleD Map File" )
		return false; //not a deled file

	temp.clear();
	temp = SubdivideString(RawFile[1]," ");//get version
	StringList temp1=SubdivideString(temp[1],";");

	header.dmfVersion = (float)atof(temp1[0].c_str());//save version
	if (header.dmfVersion < 0.91)
		return false;//not correct version

	temp.clear();
	temp = SubdivideString(RawFile[2],";");//get name,ambient color and shadow opacity
	header.dmfName=temp[0];//save name

	//set ambient color
	header.dmfAmbient.set(axtoi(temp[1].c_str()));

	//set Shadow intensity
	header.dmfShadow = (float)atof(temp[2].c_str());

	//set current position
	int offs=3;

	//set Materials Number
	header.numMaterials=atoi(RawFile[offs].c_str());
	offs+=header.numMaterials;
	++offs;

	//set Object Number
	header.numObjects=atoi(RawFile[offs].c_str());

	//retrieve face and vertices number
	header.numVertices=0;
	header.numFaces=0;
	header.numWatFaces=0;
	header.numWatVertices=0;
	offs++;

	s32 fac;
	int i;

	for(i=0; i < (int)header.numObjects; i++)
	{
		StringList wat=SubdivideString(RawFile[offs],";");
		StringList wat1=SubdivideString(wat[0],"_");

		++offs;
		offs += atoi(RawFile[offs].c_str());
		++offs;

		fac=atoi(RawFile[offs].c_str());

		if(!(wat1[0]=="water" && wat[2]=="0"))
			header.numFaces = header.numFaces + fac;
		else
			header.numWatFaces = header.numWatFaces + fac;

		offs++;

		for(int j=0; j<fac; j++)
		{
			if(!(wat1[0] == "water" && wat[2] == "0"))
				header.numVertices=header.numVertices + atoi(RawFile[offs+j].c_str());
			else
				header.numWatVertices=header.numWatVertices + atoi(RawFile[offs + j].c_str());
		}

		offs = offs + fac;
	}

	//retrieve number of dynamic lights
	header.numLights=0;
	temp.clear();
	temp1.clear();
	s32 lit = atoi(RawFile[offs].c_str());

	for (i=0; i<lit; i++)
	{
		offs++;
		temp=SubdivideString(RawFile[offs],";");

		if(atoi(temp[0].c_str())==1)
		{
			temp1=SubdivideString(temp[18],"_");

			if(temp1[0]=="dynamic")
			header.numLights++;
		}
		temp.clear();
		temp1.clear();
	}

	return true; //everything is OK so loading is correct
}


/**This function extract an array of dmfMaterial from a DMF file.
You must give in input a StringList representing a DMF file loaded with LoadFromFile.
\param RawFile StringList representing a DMF file.
\param materials Materials returned.
\param num_material Number of materials contained in DMF file.
\param use_material_dirs Here you can choose to use default DeleD structure for material dirs.
\return true if function succeed or false on fail.*/
bool GetDMFMaterials(const StringList& RawFile,
			core::array<dmfMaterial>& materials,
			int num_material)
{
	// offset for already handled lines
	const int offs=4;

	StringList temp;
	StringList temp1;

	// The number of materials is predetermined
	materials.reallocate(num_material);
	for(int i=0; i<num_material; ++i)
	{
		materials.push_back(dmfMaterial());
		// get all tokens
		temp=SubdivideString(RawFile[offs+i],";");
		// should be equal to first token
		materials[i].materialID = i;
		// The path used for the texture
		materials[i].pathName = temp[2];
		materials[i].pathName.replace('\\','/');
		materials[i].pathName += "/";
		// temp[3] is reserved, temp[4] is the number of texture layers
		materials[i].textureLayers = core::strtoul10(temp[4].c_str());
		// Three values are separated by commas
		temp1=SubdivideString(temp[5],",");

		materials[i].textureFlag = atoi(temp1[0].c_str());
		materials[i].textureName=temp1[1];
		materials[i].textureName.replace('\\','/');
		materials[i].textureBlend = atoi(temp1[2].c_str());
		if(temp.size()>=9)
		{
			temp1=SubdivideString(temp[temp.size() - 1],",");
			materials[i].lightmapFlag=atoi(temp1[0].c_str());
			materials[i].lightmapName=temp1[1];
			materials[i].lightmapName.replace('\\','/');
			materials[i].lightmapBlend = atoi(temp1[2].c_str());
		}
		else
		{
			materials[i].lightmapFlag=1;
			materials[i].lightmapName="";
		}
	}
	return true;
}


/**This function extract an array of dmfVert and dmfFace from a DMF file.
You must give in input a StringList representing a DMF file loaded with LoadFromFile and two arrays long enough.
Please use GetDMFHeader() before this function to know number of vertices and faces.
\return true if function succeed or false on fail.*/
bool GetDMFVerticesFaces(const StringList& RawFile/**<StringList representing a DMF file.*/,
		dmfVert vertices[]/**<Vertices returned*/,
		dmfFace faces[]/**Faces returned*/
		)
{
	StringList temp,temp1;

	// skip materials
	s32 offs = 4 + atoi(RawFile[3].c_str());

	const s32 objs = atoi(RawFile[offs].c_str());
	offs++;
#ifdef _IRR_DMF_DEBUG_
	os::Printer::log("Reading objects", core::stringc(objs).c_str());
#endif

	s32 vert_cnt=0, face_cnt=0;
	for (int i=0; i<objs; ++i)
	{
		StringList wat=SubdivideString(RawFile[offs],";");
		StringList wat1=SubdivideString(wat[0],"_");
#ifdef _IRR_DMF_DEBUG_
	os::Printer::log("Reading object", wat[0].c_str());
#endif

		offs++;
		// load vertices
		core::array<core::vector3df> pos;
		const u32 posCount = core::strtoul10(RawFile[offs].c_str());
		++offs;
		pos.reallocate(posCount);
		for (u32 i=0; i<posCount; ++i)
		{
			temp1=SubdivideString(RawFile[offs].c_str(),";");
			pos.push_back(core::vector3df(core::fast_atof(temp1[0].c_str()),
					core::fast_atof(temp1[1].c_str()),
					-core::fast_atof(temp1[2].c_str())));
			++offs;
		}

		const u32 numFaces=core::strtoul10(RawFile[offs].c_str());
		offs++;
		if(!(wat1[0]=="water" && wat[2]=="0"))
		{
			for(u32 j=0; j<numFaces; ++j)
			{
				temp=SubdivideString(RawFile[offs+j],";");

				//first value is vertices number for this face
				const u32 vert=core::strtoul10(temp[0].c_str());
				faces[face_cnt].numVerts=vert;
				//second is material ID
				faces[face_cnt].materialID=core::strtoul10(temp[1].c_str());
				//vertices are ordined
				faces[face_cnt].firstVert=vert_cnt;

				//now we'll create vertices structure
				for(u32 k=0; k<vert; ++k)
				{
					//copy position
					vertices[vert_cnt].pos.set(pos[core::strtoul10(temp[2+k].c_str())]);
					//get uv coords for tex and light if any
					vertices[vert_cnt].tc.set(core::fast_atof(temp[2+vert+(2*k)].c_str()),
							core::fast_atof(temp[2+vert+(2*k)+1].c_str()));
					const u32 tmp_sz=temp.size();
					vertices[vert_cnt].lc.set(core::fast_atof(temp[tmp_sz-(2*vert)+(2*k)].c_str()),
							core::fast_atof(temp[tmp_sz-(2*vert)+(2*k)+1].c_str()));
					vert_cnt++;
				}

				face_cnt++;
			}
		}

		offs+=numFaces;
	}

	return true;
}

#if 0	// functions unused and compiler gives us warnings about it. Keeping them in case anyone ever wants to improve support for this.
/**This function extract an array of dmfMaterial from a DMF file considering 1st an 2nd layer for water plains.
You must give in input a StringList representing a DMF file loaded with LoadFromFile.
\return true if function succeed or false on fail.*/
bool GetDMFWaterMaterials(const StringList& RawFile /**<StringList representing a DMF file.*/,
		core::array<dmfMaterial>& materials/**<Materials returned.*/,
		int num_material/**<Number of materials contained in DMF file.*/
		)
{
	int offs=4;
	StringList temp;
	StringList temp1;
	StringList temp2;
	//Checking if this is a DeleD map File of version >= 0.91
	temp=SubdivideString(RawFile[0],";");//file info

	if ( temp[0] != "DeleD Map File" )
		return false;//not a deled file

	temp.clear();
	temp=SubdivideString(RawFile[1]," ");//get version
	temp1=SubdivideString(temp[1],";");

	if (atof(temp1[0].c_str()) < 0.91)
		return false;//not correct version

	//end checking
	temp.clear();
	temp1.clear();

	for(int i=0;i<num_material;i++)
	{
		temp = SubdivideString(RawFile[offs+i],";");
		materials[i].materialID=i;

		temp1 = SubdivideString(temp[5],",");
		materials[i].textureFlag=atoi(temp1[0].c_str());
		temp2 = SubdivideString(temp1[1],"\\");

		materials[i].textureName=temp2.getLast();
		temp1.clear();
		temp2.clear();
		int a=temp.size();
		if(a==7)
		{
			temp1=SubdivideString(temp[6],",");
			materials[i].lightmapFlag=atoi(temp1[0].c_str());
			temp2=SubdivideString(temp1[1],"\\");
			materials[i].lightmapName=temp2.getLast();
		}
		else
		{
			materials[i].lightmapFlag=1;
			materials[i].lightmapName="FFFFFFFF";
		}
		temp1.clear();
		temp2.clear();
	}
	return true;
}

/**This function extract an array of dmfLights from a DMF file.
You must give in input a StringList representing a DMF file loaded with
LoadFromFile and one array long enough.  Please use GetDMFHeader() before this
function to know number of dynamic lights.
\return true if function succeed or false on fail.*/
bool GetDMFLights(const StringList& RawFile/**<StringList representing a DMF file.*/,
		dmfLight lights[]/**<Lights returned.*/
		)
{
	int offs=3;
	StringList temp,temp1;

	//Checking if this is a DeleD map File of version >= 0.91
	temp=SubdivideString(RawFile[0],";");//file info

	if ( temp[0] != "DeleD Map File" )
		return false;//not a deled file

	temp.clear();
	temp=SubdivideString(RawFile[1]," ");//get version
	temp1=SubdivideString(temp[1],";");

	if (atof(temp1[0].c_str()) < 0.91)
		return false;//not correct version

	//end checking

	temp.clear();
	temp1.clear();
	offs=offs + atoi(RawFile[offs].c_str());
	offs++;
	s32 objs = atoi(RawFile[offs].c_str());
	s32 lit=0;
	s32 d_lit=0;
	offs++;

	//let's get position of lights in file
	int i;
	for(i=0;i<objs;i++)
	{
		offs++;

		offs = offs + atoi(RawFile[offs].c_str());
		offs++;

		offs = offs + atoi(RawFile[offs].c_str());
		offs++;
	}

	//let's find dynamic lights
	lit = atoi(RawFile[offs].c_str());

	for(i=0;i<lit;i++)
	{
		offs++;
		temp=SubdivideString(RawFile[offs],";");
		if(atoi(temp[0].c_str())==1)
		{
			temp1=SubdivideString(temp[18],"_");
			if(temp1[0]=="dynamic")
			{
				lights[d_lit].radius = (float)atof(temp[4].c_str());
				lights[d_lit].pos.set((float)atof(temp[5].c_str()),
						(float)atof(temp[6].c_str()),
						(float)-atof(temp[7].c_str()));

				lights[d_lit].diffuseColor = video::SColorf(
						video::SColor(255, atoi(temp[10].c_str()), atoi(temp[11].c_str()),
						atoi(temp[12].c_str())));

				lights[d_lit].specularColor = video::SColorf(
						video::SColor(255, atoi(temp[13].c_str()), atoi(temp[14].c_str()),
						atoi(temp[15].c_str())));

				d_lit++;
			}
		}
		temp.clear();
		temp1.clear();
	}

	return true;
}


/**This function extracts an array of dmfWaterPlane,dmfVert and dmfFace from a DMF file.
You must give in input a StringList representing a DMF file loaded with LoadFromFile and three arrays long enough.
Please use GetDMFHeader() before this function to know number of water plains and water faces as well as water vertices.
\return true if function succeed or false on fail.*/
bool GetDMFWaterPlanes(const StringList& RawFile/**<StringList representing a DMF file.*/,
		dmfWaterPlane wat_planes[]/**<Water planes returned.*/,
		dmfVert vertices[]/**<Vertices returned*/,
		dmfFace faces[]/**Faces returned*/
		)
{
	int offs=3;
	int offs1=0;
	StringList temp,temp1;

	//Checking if this is a DeleD map File of version >= 0.91
	temp=SubdivideString(RawFile[0],";");//file info

	if ( temp[0] != "DeleD Map File" )
		return false;//not a deled file

	temp.clear();
	temp=SubdivideString(RawFile[1]," ");//get version
	temp1=SubdivideString(temp[1],";");

	if (atof(temp1[0].c_str()) < 0.91)
		return false;//not correct version

	//end checking

	temp.clear();
	temp1.clear();
	offs=offs+atoi(RawFile[offs].c_str());
	offs++;
	s32 objs=atoi(RawFile[offs].c_str());
	s32 fac=0,vert=0,tmp_sz=0,vert_cnt=0,face_cnt=0,wat_id=0;
	core::dimension2d<u32> tilenum(40,40);
	f32 waveheight=3.0f;
	f32 wavespeed=300.0f;
	f32 wavelength=80.0f;
	offs++;

	for(int i=0;i<objs;i++)
	{
		StringList wat=SubdivideString(RawFile[offs],";");
		StringList wat1=SubdivideString(wat[0],"_");
		offs++;
		offs1=offs;
		offs=offs+atoi(RawFile[offs].c_str());
		offs++;
		offs1++;
		fac=atoi(RawFile[offs].c_str());
		offs++;

		if(wat1[0]=="water" && wat[2]=="0")
		{
			StringList userinfo=SubdivideString(wat[7],",");

			int j;

			for (j=0; j<(int)userinfo.size(); j++)
			{
				switch(j)
				{
				case 0:
					if(atoi(userinfo[0].c_str()))
						tilenum.Width = atoi(userinfo[0].c_str());
				break;
				case 1:
					if(atoi(userinfo[1].c_str()))
						tilenum.Height = atoi(userinfo[1].c_str());
				break;
				case 2:
					if(atof(userinfo[2].c_str()))
						waveheight = (float)atof(userinfo[2].c_str());
				break;
				case 3:
					if(atof(userinfo[3].c_str()))
						wavespeed = (float)atof(userinfo[3].c_str());
				break;
				case 4:
					if(atof(userinfo[4].c_str()))
						wavelength = (float)atof(userinfo[4].c_str());
				break;
				}
			}

			wat_planes[wat_id].waterID=wat_id;
			wat_planes[wat_id].numFaces=fac;
			wat_planes[wat_id].firstFace=face_cnt;
			wat_planes[wat_id].tileNum=tilenum;
			wat_planes[wat_id].waveHeight=waveheight;
			wat_planes[wat_id].waveSpeed=wavespeed;
			wat_planes[wat_id].waveLength=wavelength;

			for(j=0;j<fac;j++)
			{
				temp=SubdivideString(RawFile[offs+j],";");

				//first value is vertices number for this face
				faces[face_cnt].numVerts=atoi(temp[0].c_str());
				vert=faces[face_cnt].numVerts;
				//second is material ID
				faces[face_cnt].materialID=atoi(temp[1].c_str());
				//vertices are ordined
				faces[face_cnt].firstVert=vert_cnt;

				//now we'll create vertices structure
				for(int k=0;k<vert;k++)
				{
					//get vertex position
					temp1=SubdivideString(RawFile[offs1+atoi(temp[2+k].c_str())], ";");

					//copy x,y,z values
					vertices[vert_cnt].pos.set((float)atof(temp1[0].c_str()),
							(float)atof(temp1[1].c_str()),
							(float)-atof(temp1[2].c_str()));

					//get uv coords for tex and light if any
					vertices[vert_cnt].tc.set((float)atof(temp[2+vert+(2*k)].c_str()),
							(float)atof(temp[2+vert+(2*k)+1].c_str()));
					tmp_sz=temp.size();

					vertices[vert_cnt].lc.set((float)atof(temp[tmp_sz-(2*vert)+(2*k)].c_str()),
							(float)atof(temp[tmp_sz-(2*vert)+(2*k)+1].c_str()));
					++vert_cnt;
					temp1.clear();
				}
				++face_cnt;
				temp.clear();
			}
		}
		offs=offs+fac;
	}

	return true;
}
#endif

} // end namespace
} // end namespace scene
} // end namespace irr

#endif /* __DMF_SUPPORT_H__ */