#ifdef WIN32
#include <windows.h>
#endif

#include <string.h>
#include <stdio.h>
#include <math.h>
#include <string>
#include <map>
#include <vector>
#include <set>

#include "adt.h"
#include "mpq_libmpq.h"

//#include <windows.h>
unsigned int iRes=256;
extern uint16*areas;

vec wmoc;

Cell * cell;
uint32 wmo_count;
mcell *mcells;

bool LoadADT(char* filename)
{
	size_t size;
	MPQFile mf(filename);

	if(mf.isEof ())
	{
		//printf("No such file.\n");	
		return false;
	}
	mcells=new mcell;

	wmoc.x =65*TILESIZE;
	wmoc.z =65*TILESIZE;

	size_t mcnk_offsets[256], mcnk_sizes[256];

	wmo_count=0;
	bool found=false;
	//uint32 fs=mf.getSize ()-3;
	//while (mf.getPos ()<fs)
	while (!mf.isEof  ())
	{
		uint32 fourcc;		
		mf.read(&fourcc,4);
		mf.read(&size, 4);

		size_t nextpos = mf.getPos () + size;
		if(fourcc==0x4d43494e)
		{
		//	printf("Found chunks info\n");
			// mapchunk offsets/sizes
			for (int i=0; i<256; i++)
			{
				mf.read(&mcnk_offsets[i],4);
				mf.read(&mcnk_sizes[i],4);
				mf.seekRelative(8);
			}
		//break;
		}
		else 
			if(fourcc==0x4d4f4446)
			{
			
			/*	if(size)
				{	
					//printf("\nwmo count %d\n",size/64);
					wmo_count =size/64;
					for (int i=0; i<wmo_count; i++)
					{
						int id;
						mf.read(&id, 4);
						WMO *wmo = (WMO*)wmomanager.items[wmomanager.get(wmos[id])];
						WMOInstance inst(wmo, mf);
						wmois.push_back(inst);
					}

				}*/
			
			}else 
			if(fourcc==0x4d574d4f)//mwmo
			{
				/*if (size)
				{
					char *buf = new char[size];
					mf.read(buf, size);
					char *p=buf;
					while (p<buf+size)
					{
					std::string path(p);
						p+=strlen(p)+1;
						fixname(path);
						
						wmomanager.add(path);
						wmos.push_back(path);
					}
					delete[] buf;
			    }*/
			}
		//	else mf.seekRelative(-3);

		mf.seek(nextpos);
	}
		//printf("Loading chunks info\n");
		// read individual map chunks
		for (int j=0; j<16; j++) 
			for (int i=0; i<16; i++) 
			{

				mf.seek((int)mcnk_offsets[j*16+i]);
				LoadMapChunk (mf,&(mcells->ch [i][j]));

			}

		/*	for(uint32 t=0;t<wmo_count ;t++)
			{
				wmois[t].draw ();

			}*/
	mf.close ();
	return true;
}



struct MapChunkHeader {
	uint32 flags;
	uint32 ix;
	uint32 iy;
	uint32 nLayers;
	uint32 nDoodadRefs;
	uint32 ofsHeight;
	uint32 ofsNormal;
	uint32 ofsLayer;
	uint32 ofsRefs;
	uint32 ofsAlpha;
	uint32 sizeAlpha;
	uint32 ofsShadow;
	uint32 sizeShadow;
	uint32 areaid;
	uint32 nMapObjRefs;
	uint32 holes;
	uint16 s1;
	uint16 s2;
	uint32 d1;
	uint32 d2;
	uint32 d3;
	uint32 predTex;
	uint32 nEffectDoodad;
	uint32 ofsSndEmitters;
	uint32 nSndEmitters;
	uint32 ofsLiquid;
	uint32 sizeLiquid;
	float  zpos;
	float  xpos;
	float  ypos;
	uint32 textureId;
	uint32 props;
	uint32 effectId;
};


inline
void LoadMapChunk(MPQFile & mf, chunk*_chunk)
{
	
	float h;
	uint32 fourcc;
	uint32 size;
	MapChunkHeader header;
	
	mf.seekRelative(4);
	mf.read(&size, 4);

	size_t lastpos = mf.getPos() + size;
	mf.read(&header, 0x80);
	_chunk->area_id =header.areaid ;
	_chunk->flag =0;

	float xbase = header.xpos;
	float ybase = header.ypos;
	float zbase = header.zpos;
	zbase = TILESIZE*32-zbase;
	xbase = TILESIZE*32-xbase;
	if(wmoc.x >xbase)wmoc.x =xbase;
	if(wmoc.z >zbase)wmoc.z =zbase;
	int chunkflags = header.flags;
	float zmin=999999999.0f;
	float zmax=-999999999.0f;
	//must be there, bl!zz uses some crazy format
	int nTextures;
	while (mf.getPos ()<lastpos)
	{
		mf.read(&fourcc,4);
		mf.read(&size, 4);
	//	if(size!=580)
	//	printf("\n sz=%d",size);
		size_t nextpos = mf.getPos()  + size;
		if(fourcc==0x4d435654)
		 {
			for (int j=0; j<17; j++)
			for (int i=0; i<((j%2)?8:9); i++) 
				{
					mf.read(&h,4);
					float z=h+ybase;
					if (j%2)
						_chunk->v8[i][j/2] = z;
					else
						_chunk->v9[i][j/2] = z;

					if(z>zmax)zmax=z;
				//	if(z<zmin)zmin=z;
				}
		}
		 else
			if(fourcc==0x4d434e52)
			{
			nextpos = mf.getPos() + 0x1C0; // size fix

			}
		else
			if(fourcc==0x4d434c51)
			{
				// liquid / water level
			//	bool haswater;
				char fcc1[5];
				mf.read(fcc1,4);
				flipcc(fcc1);
				fcc1[4]=0;

				if (!strcmp(fcc1,"MCSE"))
                {
                    for(int i=0;i<9;i++)
                        for(int j=0;j<9;j++)
                            _chunk->waterlevel[i][j]=-999999; // no liquid/water
                }
                else
				{
                    float maxheight;
                    mf.read(&maxheight, 4);
					
                    for(int j=0;j<9;j++)
                        for(int i=0;i<9;i++)
                        {
                            mf.read(&h, 4);
                            mf.read(&h, 4);
                            if(h > maxheight)
                                _chunk->waterlevel[i][j]=-999999;
                            else
                                _chunk->waterlevel[i][j]=h;
                        }

                    if(chunkflags & 4 || chunkflags & 8)
						_chunk->flag |=1;
					if(chunkflags & 16)
						_chunk->flag |=2;



				}
				

			break;
			}else if (fourcc==0x4d434c59)
			{
			// texture info
			nTextures = (int)size;
			}else if (fourcc==0x4d43414c)
			{
			
			if (nTextures<=0) 
			continue;
			}
		


		mf.seek(nextpos);
	}
	
	
	printf("");
}



double solve (vec *v,vec *p)
{
double a = v[0].y *(v[1].z - v[2].z) + v[1].y *(v[2].z - v[0].z) + v[2].y *(v[0].z - v[1].z);
double b = v[0].z *(v[1].x - v[2].x) + v[1].z *(v[2].x - v[0].x) + v[2].z *(v[0].x - v[1].x);
double c = v[0].x *(v[1].y - v[2].y) + v[1].x *(v[2].y - v[0].y) + v[2].x *(v[0].y - v[1].y);
double d = v[0].x *(v[1].y*v[2].z - v[2].y*v[1].z) + v[1].x* (v[2].y*v[0].z - v[0].y*v[2].z) + v[2].x* (v[0].y*v[1].z - v[1].y*v[0].z);
//-d

//plane equation ax+by+cz+d=0
return ((a*p->x+c*p->z-d)/b);
}


inline
double GetZ(double x,double z)
{
	vec v[3];
	vec p;
	
	//bool inWMO=false;
	
	//if(!inWMO)
	{
		//find out quadrant
		int xc=(int)(x/UNITSIZE);
		int zc=(int)(z/UNITSIZE);
		if(xc>127)xc=127;
		if(zc>127)zc=127;

		double lx=x-xc*UNITSIZE;
		double lz=z-zc*UNITSIZE;
		p.x=lx;
		p.z=lz;
	

		v[0].x=UNITSIZE/2;
		v[0].y =cell->v8[xc][zc];
		v[0].z=UNITSIZE/2;

	
		if(lx>lz)
		{
				v[1].x=UNITSIZE;
				v[1].y =cell->v9[xc+1][zc];
				v[1].z=0;
		}else
		{
				v[1].x=0.0;
				v[1].y =cell->v9[xc][zc+1];
				v[1].z=UNITSIZE;
		}

		if(lz>UNITSIZE-lx)
		{
				v[2].x=UNITSIZE;
				v[2].y =cell->v9[xc+1][zc+1];
				v[2].z=UNITSIZE;

		}else
		{
				v[2].x=0;
				v[2].y=cell->v9[xc][zc];
				v[2].z=0;
		}

		return -solve(v,&p);
	}
}

inline
void TransformWaterData()
{
    cell= new Cell;

    for(int x=0;x<128;x++)
        for(int y=0;y<128;y++)
            cell->v9[x][y] = mcells->ch[x/8][y/8].waterlevel[x%8][y%8];

    //and the last 1
    cell->v9[128][128] = mcells->ch[15][15].waterlevel[8][8];
}

inline
void TransformData()
{
	cell= new Cell;

	for(int x=0;x<128;x++)
	{
		for(int y=0;y<128;y++)
		{
            cell->v8[x][y] = (float)mcells->ch[x/8][y/8].v8[x%8][y%8];
            cell->v9[x][y] = (float)mcells->ch[x/8][y/8].v9[x%8][y%8];
		}

		//extra 1 point on bounds
		cell->v9[x][128] = (float)mcells->ch[x/8][15].v9[x%8][8];
		//x==y
		cell->v9[128][x] = (float)mcells->ch[15][x/8].v9[8][x%8];

	}


	//and the last 1
	cell->v9[128][128] = (float)mcells->ch[15][15].v9[8][8];

	delete mcells;
}

const char MAP_MAGIC[] = "MAP_1.02";

bool ConvertADT(char * filename,char * filename2)
{
//	if(!strstr(filename,"oth_32_48"))return false;
	if(!LoadADT(filename))return false;

	FILE *output=fopen(filename2,"wb");
	if(!output)
	{
		printf("Can't create the output file '%s'\n",filename2);
		return false;
	}

    // write magic header
    fwrite(MAP_MAGIC,1,8,output);

    for(unsigned int x=0;x<16;x++)
    {
        for(unsigned int y=0;y<16;y++)
        {
            if(mcells->ch[y][x].area_id && mcells->ch[y][x].area_id < 0xFAA)
            {
                if(areas[mcells->ch[y][x].area_id]==0xffff)
                    printf("\nCan't find area flag for areaid %u.\n",mcells->ch[y][x].area_id);

                fwrite(&areas[mcells->ch[y][x].area_id],1,2,output);
            }
            else
            {
                uint16	flag=0xffff;
                fwrite(&flag,1,2,output);
            }
        }
    }

    for(unsigned int x=0;x<16;x++)
        for(unsigned int y=0;y<16;y++)
            fwrite(&mcells->ch[y][x].flag,1,1,output);

    TransformWaterData();

    for(unsigned int x=0;x<128;x++)
        for(unsigned int y=0;y<128;y++)
            fwrite(&cell->v9[y][x],1,sizeof(float),output);

    delete cell;
	TransformData();
	
	for(unsigned int x=0;x<iRes;x++)
	for(unsigned int y=0;y<iRes;y++)
	{
		float z=(float)GetZ(
					(((double)(y))*TILESIZE)/((double)(iRes-1)),
					(((double)(x))*TILESIZE)/((double)(iRes-1)));

		fwrite(&z,1,sizeof(z),output);
	}

	fclose(output);
	delete cell;
/*
	for (std::vector<std::string>::iterator it = wmos.begin(); it != wmos.end(); ++it)
	wmomanager.delbyname(*it);
		
	wmos.clear ();
	wmois.clear ();
	
	for (std::vector<model>::iterator it = wmomodel.begin(); it != wmomodel.end(); ++it)
	{
		it->tr.clear();

	}
//	printf("\n %d \n",in);
	wmomodel.clear ();
//	polygons.clear ();*/
	return true;

}