/*
   Copyright (C) 1999-2007 id Software, Inc. and contributors.
   For a list of contributors, see the accompanying CONTRIBUTORS file.

   This file is part of GtkRadiant.

   GtkRadiant 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 2 of the License, or
   (at your option) any later version.

   GtkRadiant 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 GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

// Hydra - FIXME : TTimo, We need to know what game + engine we're using for
// the halflife (not Q2) specific stuff
// we need an API for modules to get this info!

//
// parses quake3 map format into internal objects
//

#include "plugin.h"

// cmdlib
extern void ExtractFileName( const char *path, char *dest );

extern int g_MapVersion;
int abortcode; // see imap.h for values.

// Start of half-life specific stuff

GSList *g_WadList; // halflife specific.
GSList *g_TextureNameCache; // halflife specific.

// NOTE TTimo: yuck..
void FreeGSList( GSList *l ){
	while ( l )
	{
		free( l->data );
		l = g_slist_remove( l, l->data );
	}
}

// NOTE TTimo: ideally, this would be using Str functions instead
void trim( char *str ){
	int len;
	len = strlen( str );
	while ( str[--len] == ' ' )
		str[len] = 0;
}

void BuildWadList( char *wadstr ){
	char wads[2048]; // change to CString usage ?
	wads[0] = 0;
	char *p1,*p2;
	char cleanwadname[QER_MAX_NAMELEN];

	g_WadList = NULL;

	strcpy( wads,wadstr );
	QE_ConvertDOSToUnixName( wads,wads );

	// ok, we got the list of ; delimited wads, now split it into a GSList that contains
	// just the wad names themselves.

	p1 = wads;

	do
	{
		p2 = strchr( p1,';' );
		if ( p2 ) {
			*p2 = 0; // swap the ; with a null terminator

		}
		if ( strchr( p1,'/' ) || strchr( p1,'\\' ) ) {
			ExtractFileName( p1,cleanwadname );

			trim( cleanwadname );

			if ( *cleanwadname ) {
				g_WadList = g_slist_append( g_WadList, strdup( cleanwadname ) );
				Sys_Printf( "wad: %s\n",cleanwadname );
			}
		}
		else
		{
			trim( p1 );
			if ( *p1 ) {
				g_WadList = g_slist_append( g_WadList, strdup( p1 ) );
				Sys_Printf( "wad: %s\n",p1 );
			}
		}
		if ( p2 ) {
			p1 = p2 + 1; // point back to the remainder of the string
		}
		else{
			p1 = NULL; // make it so we exit the loop.

		}
	} while ( p1 );

	// strip the ".wad" extensions.
	for ( GSList *l = g_WadList; l != NULL ; l = l->next )
	{
		p1 = (char *)l->data;

		if ( p1[strlen( p1 ) - 4] == '.' ) {
			p1[strlen( p1 ) - 4] = 0;
		}
	}
}

// FIXME: usefulness of this cache sounds very discutable
char *CheckCacheForTextureName( const char *cleantexturename ){
	char *str;
	int len;
	GSList *l;

	// search our little cache first to speed things up.
	// cache strings are stored as "<cleanname>;<actualnameshader>"
	len = strlen( cleantexturename );
	for ( l = g_TextureNameCache; l != NULL ; l = l->next )
	{
		str = (char *)l->data;
		if ( ( strnicmp( cleantexturename,str,len ) == 0 ) && ( str[len] == ';' ) ) { // must do in this order or we'll get an access violation, even though it's slower.
			return ( str + len + 1 ); // skip the delimiter ;
		}
	}
	return NULL;
}

char *AddToCache( const char *cleantexturename, const char *actualname ){
	char *cachestr;
	cachestr = (char *)malloc( strlen( cleantexturename ) + 1 + strlen( actualname ) + 1 ); // free()'d when g_TextureNameCache is freed
	sprintf( cachestr,"%s;%s",cleantexturename,actualname );
	g_TextureNameCache = g_slist_append( g_TextureNameCache, cachestr );
	return cachestr;
}

char *SearchWadsForTextureName( const char *cleantexturename ){
	char *str;
	char *wadname;
	char *actualtexturename = NULL;
	GSList *l;
	int count;

	actualtexturename = CheckCacheForTextureName( cleantexturename );
	if ( actualtexturename ) {
		return actualtexturename;
	}

	// still here ?  guess it's not in the cache then!

	// search the wads listed in the worldspawn "wad" key
	for ( l = g_WadList; l != NULL && actualtexturename == NULL ; l = l->next )
	{
		wadname = (char *)l->data;

		str = new char[strlen( wadname ) + strlen( cleantexturename ) + 9 + 1 + 4 + 1];

		// hlw here is ok as we never have anything other than hlw files in a wad.
		sprintf( str,"textures/%s/%s.hlw",wadname,cleantexturename );
		count = vfsGetFileCount( str, VFS_SEARCH_PAK ); // only search pack files
		// LordHavoc: hacked in .mip loading here
		if ( !count ) {
			sprintf( str,"textures/%s/%s.mip",wadname,cleantexturename );
			count = vfsGetFileCount( str, VFS_SEARCH_PAK ); // only search pack files
		}

		if ( count > 0 ) {
			// strip the extension, build the cache string and add the the cache
			str[strlen( str ) - 4] = 0;

			actualtexturename = AddToCache( cleantexturename,str );

			//point the return value to the actual name, not what we add to the cache
			actualtexturename += 1 + strlen( cleantexturename );
		}
		delete [] str;
	}
	return actualtexturename;
}
// End of half-life specific stuff

void Patch_Parse( patchMesh_t *pPatch ){
	int i, j;
	char *str;

	char *token = Token();

	GetToken( true ); //{

	// parse shader name
	GetToken( true );
	str = new char[strlen( token ) + 10];
	strcpy( str, "textures/" );
	strcpy( str + 9, token );
	pPatch->pShader = QERApp_Shader_ForName( str );
	pPatch->d_texture = pPatch->pShader->getTexture();
	delete [] str;

	GetToken( true ); //(

	// parse matrix dimensions
	GetToken( false );
	pPatch->width = atoi( token );
	GetToken( false );
	pPatch->height = atoi( token );

	// ignore contents/flags/value
	GetToken( false );
	GetToken( false );
	GetToken( false );

	GetToken( false ); //)

	// parse matrix
	GetToken( true ); //(
	for ( i = 0; i < pPatch->width; i++ )
	{
		GetToken( true ); //(
		for ( j = 0; j < pPatch->height; j++ )
		{
			GetToken( false ); //(

			GetToken( false );
			pPatch->ctrl[i][j].xyz[0] = atof( token );
			GetToken( false );
			pPatch->ctrl[i][j].xyz[1] = atof( token );
			GetToken( false );
			pPatch->ctrl[i][j].xyz[2] = atof( token );
			GetToken( false );
			pPatch->ctrl[i][j].st[0] = atof( token );
			GetToken( false );
			pPatch->ctrl[i][j].st[1] = atof( token );

			GetToken( false ); //)
		}
		GetToken( false ); //)
	}
	GetToken( true ); //)

	GetToken( true ); //}
}

void Face_Parse( face_t *face, bool bAlternateTexdef = false ){
	int i, j;
	char *str;
	bool bworldcraft = false;

	char *token = Token();

	// parse planepts
	str = NULL;
	for ( i = 0; i < 3; i++ )
	{
		GetToken( true ); //(
		for ( j = 0; j < 3; j++ )
		{
			GetToken( false );
			face->planepts[i][j] = atof( token );
		}
		GetToken( false ); //)
	}

	if ( bAlternateTexdef ) {
		// parse alternate texdef
		GetToken( false ); // (
		GetToken( false ); // (
		for ( i = 0; i < 3; i++ )
		{
			GetToken( false );
			face->brushprimit_texdef.coords[0][i] = atof( token );
		}
		GetToken( false ); // )
		GetToken( false ); // (
		for ( i = 0; i < 3; i++ )
		{
			GetToken( false );
			face->brushprimit_texdef.coords[1][i] = atof( token );
		}
		GetToken( false ); // )
		GetToken( false ); // )
	}


	// parse shader name
	GetToken( false ); // shader

	// if we're loading a halflife map then we don't have a relative texture name
	// we just get <texturename>.  So we need to convert this to a relative name
	// like this: "textures/<wadname>/shader", so we use vfsFileFile to get the filename.

	// *** IMPORTANT ***
	// For Halflife we need to see if the texture is in wads listed in the
	// map's worldspawn "wad" e-pair.  If we don't then the image used will be the
	// first image with this texture name that is found in any of the wads on the
	// user's system.  this is not a huge problem, because the map compiler obeys
	// the "wad" epair when compiling the map, but the user might end up looking at
	// the wrong texture in the editor. (more of a problem if the texture we use
	// here has a different size from the one in the wad the map compiler uses...)

	// Hydra: - TTimo: I looked all over for other places to put this, but really it
	// is an issue with map loading (because of a limitation of halflife/q2 map format)
	// so it's gone in here, it also stops incorrect shader/texdef names getting used
	// in the radiant core and it's modules which we'd only have to change later on.
	// (either in map_importentities() or the shader module).  so it's actually cleaner
	// in the long run, even if a little odd.  And it keeps more game specific stuff
	// OUT of the core, which is a good thing.

	if ( g_MapVersion == MAPVERSION_HL ) {
		qboolean done = false;

		// FIXME: This bit is halflife specific.
		// look in the list of wads supplied in the worldspawn "wad" key/pair for the
		// texture first, if it's not in any then we carry on searching the vfs for it
		// as usual.

		// each time we find a texture, we add it to the a cache
		// so we don't have to hunt the vfs for it each time.
		// See SearchWadsForTextureName() and AddToCache() above for cache stuff

		char *wadname;
		wadname = SearchWadsForTextureName( token );

		if ( wadname ) {
			face->texdef.SetName( wadname );
			done = true;
		}
		else
		{
			// using the cache below means that this message is only ever printed out once!
			Sys_Printf( "WARNING: could not find \"%s\" in any listed wad files, searching all wad files instead!\n",token );
		}
		// end of half-life specific bit.

		// check the cache!
		if ( !done ) {
			str = CheckCacheForTextureName( token );
			if ( str ) {
				face->texdef.SetName( str );
				done = true;
			}
		}

		if ( !done ) {
			char *fullpath;

			str = new char[strlen( token ) + 4 + 1];

			// FIXME: halflife specific file extension, we'll have to support Q2/Q1 formats
			// and maybe tga texture format for HL here too..
			sprintf( str,"%s.hlw",token );
			fullpath = vfsGetFullPath( str,0,VFS_SEARCH_PAK | VFS_SEARCH_DIR );

			// MIP support for quake
			if ( !fullpath ) {
				sprintf( str,"%s.mip",token );
				fullpath = vfsGetFullPath( str, 0, 0 );
			}

			// TGA support in halflife ?
			/*
			   if (!fullpath)
			   {
			   sprintf(str,"%s.tga",token);
			   fullpath = vfsGetFullPath(str);
			   }
			 */
			delete [] str;

			if ( fullpath ) {
				// strip the extension.
				int len = strlen( fullpath );
				if ( fullpath[len - 4] == '.' ) {
					fullpath[len - 4] = '\0';
				}

				// and set the correct name!
				face->texdef.SetName( fullpath );
				AddToCache( token,fullpath );
			}
			else
			{
				Sys_Printf( "WARNING: could not find \"%s\" in the vfs search path\n",token );
				str = new char[strlen( token ) + 10];
				strcpy( str, "textures/" );
				strcpy( str + 9, token );
				face->texdef.SetName( str );
				AddToCache( token,str );
				delete [] str;
			}
		}
	}
	else // !MAPVERSION_HL
	{
		str = new char[strlen( token ) + 10];
		strcpy( str, "textures/" );
		strcpy( str + 9, token );
		face->texdef.SetName( str );
		delete [] str;
	}

	if ( !bAlternateTexdef ) {
		if ( g_MapVersion == MAPVERSION_HL ) { // Q1 as well ?
			GetToken( false );
			if ( token[0] == '[' && token[1] == '\0' ) {
				bworldcraft = true;

				GetToken( false ); // UAxis[0]
				GetToken( false ); // UAxis[1]
				GetToken( false ); // UAxis[2]

				GetToken( false ); // shift
				face->texdef.shift[0] = atof( token );

				GetToken( false ); // ]

				GetToken( false ); // [
				GetToken( false ); // VAxis[0]
				GetToken( false ); // VAxis[1]
				GetToken( false ); // VAxis[2]

				GetToken( false ); // shift
				face->texdef.shift[1] = atof( token );

				GetToken( false ); // ]

				// rotation is derived from the U and V axes.
				// ZHLT ignores this setting even if present in a .map file.
				GetToken( false );
				face->texdef.rotate = atof( token );

				// Scales
				GetToken( false );
				face->texdef.scale[0] = atof( token );
				GetToken( false );
				face->texdef.scale[1] = atof( token );
			}
			else
			{
				UnGetToken();
			}
		}

		if ( !bworldcraft ) { // !MAPVERSION_HL
			// parse texdef
			GetToken( false );
			face->texdef.shift[0] = atof( token );
			GetToken( false );
			face->texdef.shift[1] = atof( token );
			GetToken( false );
			face->texdef.rotate = atof( token );
			GetToken( false );
			face->texdef.scale[0] = atof( token );
			GetToken( false );
			face->texdef.scale[1] = atof( token );
		}
	}
	// parse the optional contents/flags/value
	if ( !bworldcraft && TokenAvailable() ) {
		GetToken( true );
		if ( isdigit( token[0] ) ) {
			face->texdef.contents = atoi( token );
			GetToken( false );
			face->texdef.flags = atoi( token );
			GetToken( false );
			face->texdef.value = atoi( token );
		}
		else
		{
			UnGetToken();
		}
	}
}

bool Primitive_Parse( brush_t *pBrush ){
	char *token = Token();

	GetToken( true );
	if ( !strcmp( token, "patchDef2" ) ) {
		pBrush->patchBrush = true;
		pBrush->pPatch = Patch_Alloc();
		pBrush->pPatch->pSymbiot = pBrush;
		Patch_Parse( pBrush->pPatch );
		GetToken( true ); //}

		// A patchdef should never be loaded from a quake2 map file
		// so we just return false and the brush+patch gets freed
		// and the user gets told.
		if ( g_MapVersion != MAPVERSION_Q3 ) {
			// FIXME: Hydra - I wanted to write out a line number here, but I can't because there's no API to access the core's "scriptline" variable.
			Syn_Printf( "ERROR: patchDef2's are not supported in Quake%d format .map files!\n",g_MapVersion );
			abortcode = MAP_WRONGVERSION;
			return false;
		}
	}
	else if ( !strcmp( token, "brushDef" ) ) {
		pBrush->bBrushDef = true;
		GetToken( true ); // {
		while ( 1 )
		{
			face_t    *f = pBrush->brush_faces;
			pBrush->brush_faces = Face_Alloc();
			Face_Parse( pBrush->brush_faces, true );
			pBrush->brush_faces->next = f;
			// check for end of brush
			GetToken( true );
			if ( strcmp( token,"}" ) == 0 ) {
				break;
			}
			UnGetToken();
		}
		GetToken( true ); // }
	}
	else
	{
		UnGetToken();
		while ( 1 )
		{
			face_t    *f = pBrush->brush_faces;
			pBrush->brush_faces = Face_Alloc();
			Face_Parse( pBrush->brush_faces );
			pBrush->brush_faces->next = f;

			// check for end of brush
			GetToken( true );
			if ( strcmp( token,"}" ) == 0 ) {
				break;
			}
			UnGetToken();
		}
	}
	return true;
}

void Entity_Parse( entity_t *pEntity ){
	brush_t *pBrush;
//  CPtrArray *brushes = NULL;
	char temptoken[1024];

	char *token = Token();

	while ( 1 )
	{
		GetToken( true ); // { or } or epair
		if ( !strcmp( token, "}" ) ) {
			break;
		}
		else if ( !strcmp( token, "{" ) ) {

			pBrush = Brush_Alloc();
			if ( Primitive_Parse( pBrush ) ) {
				( (CPtrArray*)pEntity->pData )->Add( pBrush );
			}
			else {
				Brush_Free( pBrush, true );
			}

		}
		else {

			strcpy( temptoken, token );
			GetToken( false );

			SetKeyValue( pEntity, temptoken, token );

			if ( g_MapVersion == MAPVERSION_HL ) {
				// if we've not god a "wads" key/pair already, then break it into a list.
				if ( !g_WadList && ( stricmp( temptoken,"wad" ) == 0 ) ) {
					BuildWadList( token );
				}
			}

		}
	}
}

void Map_Read( IDataStream *in, CPtrArray *map ){
	entity_t *pEntity;
	char *buf;

	unsigned long len = in->GetLength();
	buf = new char[len + 1];
	in->Read( buf, len );
	buf[len] = '\0';
	StartTokenParsing( buf );
	abortcode = MAP_NOERROR;

	while ( abortcode == MAP_NOERROR )
	{
		if ( !GetToken( true ) ) { // { or NULL
			break;
		}
		pEntity = Entity_Alloc();
		pEntity->pData = new CPtrArray;
		Entity_Parse( pEntity );
		map->Add( pEntity );
	}

	delete [] buf;

	if ( abortcode != MAP_NOERROR ) {
		int num_ents, num_brushes,i,j;
		entity_t *e;
		CPtrArray *brushes;

		num_ents = map->GetSize();
		for ( i = 0; i < num_ents; i++ )
		{
			e = (entity_t*)map->GetAt( i );
			brushes = (CPtrArray*)e->pData;
			num_brushes = brushes->GetSize();
			for ( j = 0; j < num_brushes; j++ )
			{
				Brush_Free( (brush_t *)brushes->GetAt( j ), true );
			}
			brushes->RemoveAll();
			delete brushes;
			Entity_Free( e );
		}
		map->RemoveAll();
	}
}

void Map_ReadQ3( IDataStream *in, CPtrArray *map ){
	g_MapVersion = MAPVERSION_Q3;
	Map_Read( in,map );
}

void Map_ReadHL( IDataStream *in, CPtrArray *map ){
	g_WadList = NULL;
	g_TextureNameCache = NULL;

	g_MapVersion = MAPVERSION_HL;
	Map_Read( in,map );

	FreeGSList( g_TextureNameCache );
	FreeGSList( g_WadList );
}

void Map_ReadQ2( IDataStream *in, CPtrArray *map ){
	g_MapVersion = MAPVERSION_Q2;
	Map_Read( in,map );
}