//====== Copyright © 1996-2004, Valve Corporation, All rights reserved. =======
//
// Purpose: 
//
//=============================================================================

#include "importkeyvaluebase.h"
#include "dmserializers.h"
#include "datamodel/idatamodel.h"
#include "datamodel/dmelement.h"
#include "datamodel/dmattributevar.h"
#include "tier1/KeyValues.h"
#include "tier1/UtlBuffer.h"
#include "datamodel/dmattribute.h"
#include "filesystem.h"
#include "tier2/tier2.h"


//-----------------------------------------------------------------------------
// Serialization class for Key Values
//-----------------------------------------------------------------------------
class CImportVMT : public CImportKeyValueBase
{
public:
	virtual const char *GetName() const { return "vmt"; }
	virtual const char *GetDescription() const { return "Valve Material File"; }
	virtual int GetCurrentVersion() const { return 0; } // doesn't store a version
  	virtual const char *GetImportedFormat() const { return "vmt"; }
 	virtual int GetImportedVersion() const { return 1; }

	bool Serialize( CUtlBuffer &outBuf, CDmElement *pRoot );
	CDmElement* UnserializeFromKeyValues( KeyValues *pKeyValues );

private:
	// Unserialize fallbacks
	bool UnserializeFallbacks( CDmElement *pRoot, KeyValues *pFallbackKeyValues );

	// Unserialize proxies
	bool UnserializeProxies( CDmElement *pRoot, KeyValues *pKeyValues );

	// Creates a shader parameter from a key value
	bool UnserializeShaderParam( CDmElement *pRoot, KeyValues* pKeyValue );

	// Creates a matrix material var
	bool CreateMatrixMaterialVarFromKeyValue( CDmElement *pRoot, const char *pParamName, const char *pString );

	// Creates a vector shader parameter
	bool CreateVectorMaterialVarFromKeyValue( CDmElement *pRoot, const char *pParamName, const char *pString );

	// Writes out a single shader parameter
	bool SerializeShaderParameter( CUtlBuffer &buf, CDmAttribute *pAttribute );

	// Writes out all shader parameters
	bool SerializeShaderParameters( CUtlBuffer &buf, CDmElement *pRoot );

	// Writes out all shader fallbacks
	bool SerializeFallbacks( CUtlBuffer &buf, CDmElement *pRoot );

	// Writes out all material proxies
	bool SerializeProxies( CUtlBuffer &buf, CDmElement *pRoot );

	// Handle patch files
	void ExpandPatchFile( KeyValues *pKeyValues );
};


//-----------------------------------------------------------------------------
// Singleton instance
//-----------------------------------------------------------------------------
static CImportVMT s_ImportVMT;

void InstallVMTImporter( IDataModel *pFactory )
{
	pFactory->AddSerializer( &s_ImportVMT );
}


//-----------------------------------------------------------------------------
// Writes out a single shader parameter
//-----------------------------------------------------------------------------
bool CImportVMT::SerializeShaderParameter( CUtlBuffer &buf, CDmAttribute *pAttribute )
{
	// We have a shader parameter at this point.
	switch ( pAttribute->GetType() )
	{
	case AT_INT:
		buf.Printf( "\"%s\" \"%d\"\n", pAttribute->GetName(), pAttribute->GetValue<int>( ) );
		break;

	case AT_BOOL:
		buf.Printf( "\"%s\" \"%d\"\n", pAttribute->GetName(), pAttribute->GetValue<bool>( ) );
		break;

	case AT_FLOAT:
		buf.Printf( "\"%s\" \"%f\"\n", pAttribute->GetName(), pAttribute->GetValue<float>( ) );
		break;

	case AT_STRING:
		{
			CUtlSymbolLarge symbol = pAttribute->GetValue<CUtlSymbolLarge>();
			const char *pString = symbol.String();
			buf.Printf( "\"%s\" \"%s\"\n", pAttribute->GetName(), pString );
		}
		break;

	case AT_VECTOR2:
		{
			const Vector2D &vec = pAttribute->GetValue<Vector2D>( );
			buf.Printf( "\"%s\" \"[ %f %f ]\"\n", pAttribute->GetName(), vec.x, vec.y );
		}
		break;

	case AT_VECTOR3:
		{
			const Vector &vec = pAttribute->GetValue<Vector>( );
			buf.Printf( "\"%s\" \"[ %f %f %f ]\"\n", pAttribute->GetName(), vec.x, vec.y, vec.z );
		}
		break;

	case AT_VECTOR4:
		{
			const Vector4D &vec = pAttribute->GetValue<Vector4D>( );
			buf.Printf( "\"%s\" \"[ %f %f %f %f ]\"\n", pAttribute->GetName(), vec.x, vec.y, vec.z, vec.w );
		}
		break;

	case AT_COLOR:
		{
			// NOTE: VMTs only support 3 component color (no alpha)
			const Color &color = pAttribute->GetValue<Color>( );
			buf.Printf( "\"%s\" \"{ %d %d %d }\"\n", pAttribute->GetName(), color.r(), color.g(), color.b() );
		}
		break;

	case AT_VMATRIX:
		{
			const VMatrix &mat = pAttribute->GetValue<VMatrix>( );
			buf.Printf( "\"%s\" \"[ %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f ]\"\n", pAttribute->GetName(), 
				mat[0][0], mat[0][1], mat[0][2], mat[0][3],
				mat[1][0], mat[1][1], mat[1][2], mat[1][3],
				mat[2][0], mat[2][1], mat[2][2], mat[2][3],
				mat[3][0], mat[3][1], mat[3][2], mat[3][3] );
		}
		break;

	default:
		Warning( "Attempted to serialize an unsupported shader parameter type %s (%s)\n", 
			pAttribute->GetName(), g_pDataModel->GetAttributeNameForType( pAttribute->GetType() ) );
		return false;
	}

	return true;
}


//-----------------------------------------------------------------------------
// Writes out all shader parameters
//-----------------------------------------------------------------------------
bool CImportVMT::SerializeShaderParameters( CUtlBuffer &buf, CDmElement *pRoot )
{
	for ( CDmAttribute *pAttribute = pRoot->FirstAttribute(); pAttribute; pAttribute = pAttribute->NextAttribute() )
	{
		// Skip the standard attributes
		if ( pAttribute->IsStandard() )
			continue;

		// Skip the shader name
		const char *pName = pAttribute->GetName();
		if ( !Q_stricmp( pAttribute->GetName(), "shader" ) )
			continue;

		// Names that don't start with a $ or a % are not shader parameters
		if ( pName[0] != '$' && pName[0] != '%' )
			continue;

		// Skip element array children; we'll handle them separately.
		if ( pAttribute->GetType() == AT_ELEMENT_ARRAY )
			continue;

		// Write out the shader parameter
		if ( !SerializeShaderParameter( buf, pAttribute ) )
			return false;
	}
	return true;
}


//-----------------------------------------------------------------------------
// Writes out all shader fallbacks
//-----------------------------------------------------------------------------
bool CImportVMT::SerializeFallbacks( CUtlBuffer &buf, CDmElement *pRoot )
{
	if ( !pRoot->HasAttribute( "fallbacks" ) )
		return true;

	CDmAttribute *pFallbacks = pRoot->GetAttribute( "fallbacks" );
	if ( pFallbacks->GetType() != AT_ELEMENT_ARRAY )
		return false;

	CDmrElementArray<> array( pFallbacks );
	int nCount = array.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmElement *pFallback = array[i];
		Assert( pFallback );

		PrintStringAttribute( pFallback, buf, "shader", false, true );
		buf.Printf( "{\n" );
		buf.PushTab();
		if ( !SerializeShaderParameters( buf, pFallback ) )
			return false;
		buf.PopTab();
		buf.Printf( "}\n" );
	}
	return true;
}


//-----------------------------------------------------------------------------
// Writes out all material proxies
//-----------------------------------------------------------------------------
bool CImportVMT::SerializeProxies( CUtlBuffer &buf, CDmElement *pRoot )
{
	if ( !pRoot->HasAttribute( "proxies" ) )
		return true;

	CDmAttribute *pProxies = pRoot->GetAttribute( "proxies" );
	if ( pProxies->GetType() != AT_ELEMENT_ARRAY )
		return false;

	CDmrElementArray<> array( pProxies );
	int nCount = array.Count();
	if ( nCount == 0 )
		return true;

	buf.Printf( "\"Proxies\"\n" );
	buf.Printf( "{\n" );
	buf.PushTab();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmElement *pProxy = array[i];
		Assert( pProxy );

		PrintStringAttribute( pProxy, buf, "proxyType", false, true );
		buf.Printf( "{\n" );
		buf.PushTab();
		if ( !SerializeShaderParameters( buf, pProxy ) )
			return false;
		buf.PopTab();
		buf.Printf( "}\n" );
	}
	buf.PopTab();
	buf.Printf( "}\n" );
	return true;
}


//-----------------------------------------------------------------------------
// Writes out a new vmt file
//-----------------------------------------------------------------------------
bool CImportVMT::Serialize( CUtlBuffer &buf, CDmElement *pRoot )
{
	PrintStringAttribute( pRoot, buf, "shader", false, true );
	buf.Printf( "{\n" );
	buf.PushTab();

	if ( !SerializeShaderParameters( buf, pRoot ) )
		return false;

	if ( !SerializeFallbacks( buf, pRoot ) )
		return false;

	if ( !SerializeProxies( buf, pRoot ) )
		return false;

	buf.PopTab();
	buf.Printf( "}\n" );
	return true;
}


//-----------------------------------------------------------------------------
// Parser utilities
//-----------------------------------------------------------------------------
static inline bool IsWhitespace( char c )
{
	return c == ' ' || c == '\t';
}

static inline bool IsEndline( char c )
{
	return c == '\n' || c == '\0';
}

static inline bool IsVector( char const* v )
{
	while (IsWhitespace(*v))
	{
		++v;
		if (IsEndline(*v))
			return false;
	}
	return *v == '[' || *v == '{';
}


//-----------------------------------------------------------------------------
// Creates a vector material var
//-----------------------------------------------------------------------------
int ParseVectorFromKeyValueString( const char *pParamName, const char* pScan, const char *pMaterialName, float vecVal[4] )
{
	bool divideBy255 = false;

	// skip whitespace
	while( IsWhitespace(*pScan) )
	{
		++pScan;
	}

	if( *pScan == '{' )
	{
		divideBy255 = true;
	}
	else
	{
		Assert( *pScan == '[' );
	}
	
	// skip the '['
	++pScan;
	int i;
	for( i = 0; i < 4; i++ )
	{
		// skip whitespace
		while( IsWhitespace(*pScan) )
		{
			++pScan;
		}

		if( IsEndline(*pScan) || *pScan == ']' || *pScan == '}' )
		{
			if (*pScan != ']' && *pScan != '}')
			{
				Warning( "Warning in .VMT file (%s): no ']' or '}' found in vector key \"%s\".\n"
					"Did you forget to surround the vector with \"s?\n", pMaterialName, pParamName );
			}

			// allow for vec2's, etc.
			vecVal[i] = 0.0f;
			break;
		}

		char* pEnd;

		vecVal[i] = strtod( pScan, &pEnd );
		if (pScan == pEnd)
		{
			Warning( "Error in .VMT file: error parsing vector element \"%s\" in \"%s\"\n", pParamName, pMaterialName );
			return 0;
		}

		pScan = pEnd;
	}

	if( divideBy255 )
	{
		vecVal[0] *= ( 1.0f / 255.0f );
		vecVal[1] *= ( 1.0f / 255.0f );
		vecVal[2] *= ( 1.0f / 255.0f );
		vecVal[3] *= ( 1.0f / 255.0f );
	}

	return i;
}


//-----------------------------------------------------------------------------
// Sets shader parameter attributes
//-----------------------------------------------------------------------------
template< class T >
inline bool SetShaderParamAttribute( CDmElement *pElement, const char *pAttributeName, const T &value )
{
	if ( !pElement )
		return false;

	if ( !pElement->SetValue( pAttributeName, value ) )
		return false;

	CDmAttribute *pAttribute = pElement->GetAttribute( pAttributeName );
	pAttribute->AddFlag( FATTRIB_USERDEFINED );
	return true;
}

inline bool SetShaderParamAttribute( CDmElement *pElement, const char *pAttributeName, const char *value )
{
	if ( !pElement )
		return false;

	if ( !pElement->SetValue( pAttributeName, value ) )
		return false;

	CDmAttribute *pAttribute = pElement->GetAttribute( pAttributeName );
	pAttribute->AddFlag( FATTRIB_USERDEFINED );
	return true;
}


//-----------------------------------------------------------------------------
// Creates a vector shader parameter
//-----------------------------------------------------------------------------
bool CImportVMT::CreateVectorMaterialVarFromKeyValue( CDmElement *pElement, const char *pParamName, const char *pString )
{
	Vector4D vecVal;
	int nDim = ParseVectorFromKeyValueString( pParamName, pString, FileName(), vecVal.Base() );
	if ( nDim == 0 )
		return false;

	// Create the variable!
	switch ( nDim )
	{
	case 1:
		return SetShaderParamAttribute( pElement, pParamName, vecVal[0] );
	case 2:
		return SetShaderParamAttribute( pElement, pParamName, vecVal.AsVector2D() );
	case 3:
		return SetShaderParamAttribute( pElement, pParamName, vecVal.AsVector3D() );
	case 4:
		return SetShaderParamAttribute( pElement, pParamName, vecVal );
	}

	return false;
}


//-----------------------------------------------------------------------------
// Creates a matrix shader parameter
//-----------------------------------------------------------------------------
bool CImportVMT::CreateMatrixMaterialVarFromKeyValue( CDmElement *pElement, const char *pParamName, const char *pScan )
{
	// Matrices can be specified one of two ways:
	// [ # # # #  # # # #  # # # #  # # # # ]
	// or
	// center # # scale # # rotate # translate # #

	VMatrix mat;
	int count = sscanf( pScan, " [ %f %f %f %f  %f %f %f %f  %f %f %f %f  %f %f %f %f ]",
		&mat.m[0][0], &mat.m[0][1], &mat.m[0][2], &mat.m[0][3],
		&mat.m[1][0], &mat.m[1][1], &mat.m[1][2], &mat.m[1][3],
		&mat.m[2][0], &mat.m[2][1], &mat.m[2][2], &mat.m[2][3],
		&mat.m[3][0], &mat.m[3][1], &mat.m[3][2], &mat.m[3][3] );
	if (count == 16)
	{
		return SetShaderParamAttribute( pElement, pParamName, mat );
	}

	Vector2D scale, center;
	float angle;
	Vector2D translation;
	count = sscanf( pScan, " center %f %f scale %f %f rotate %f translate %f %f",
		&center.x, &center.y, &scale.x, &scale.y, &angle, &translation.x, &translation.y );
	if (count != 7)
		return false;

	VMatrix temp;
	MatrixBuildTranslation( mat, -center.x, -center.y, 0.0f );
	MatrixBuildScale( temp, scale.x, scale.y, 1.0f );
	MatrixMultiply( temp, mat, mat );
	MatrixBuildRotateZ( temp, angle );
	MatrixMultiply( temp, mat, mat );
	MatrixBuildTranslation( temp, center.x + translation.x, center.y + translation.y, 0.0f );
	MatrixMultiply( temp, mat, mat );

	// Create the variable!
	return SetShaderParamAttribute( pElement, pParamName, mat );
}


//-----------------------------------------------------------------------------
// Creates a shader parameter from a key value
//-----------------------------------------------------------------------------
bool CImportVMT::UnserializeShaderParam( CDmElement *pRoot, KeyValues* pKeyValues )
{
	char pParamName[512];
	Q_strncpy( pParamName, pKeyValues->GetName(), sizeof(pParamName) );
	Q_strlower( pParamName );

	switch( pKeyValues->GetDataType() )
	{
	case KeyValues::TYPE_INT:
		return SetShaderParamAttribute( pRoot, pParamName, pKeyValues->GetInt() );

	case KeyValues::TYPE_FLOAT:
		return SetShaderParamAttribute( pRoot, pParamName, pKeyValues->GetFloat() );

	case KeyValues::TYPE_STRING:
		{
			char const* pString = pKeyValues->GetString();

			// Only valid if it's a texture attribute
			if ( !pString || !pString[0] )
				return SetShaderParamAttribute( pRoot, pParamName, pString );

			// Look for matrices
			if ( CreateMatrixMaterialVarFromKeyValue( pRoot, pParamName, pString ) )
				return true;

			// Look for vectors
			if ( !IsVector( pString ) )
				return SetShaderParamAttribute( pRoot, pParamName, pString );

			// Parse the string as a vector...
			return CreateVectorMaterialVarFromKeyValue( pRoot, pParamName, pString );
		}
	}

	return false;
}


//-----------------------------------------------------------------------------
// Unserialize proxies
//-----------------------------------------------------------------------------
bool CImportVMT::UnserializeProxies( CDmElement *pElement, KeyValues *pKeyValues )
{
	// Create a child element array to contain all material proxies
	CDmAttribute *pProxies = pElement->AddAttribute( "proxies", AT_ELEMENT_ARRAY );
	if ( !pProxies )
		return false;

	CDmrElementArray<> array( pProxies );

	// Proxies are a list of sub-keys, the name is the proxy name, subkeys are values
	for ( KeyValues *pProxy = pKeyValues->GetFirstTrueSubKey(); pProxy != NULL; pProxy = pProxy->GetNextTrueSubKey() )
	{
		CDmElement *pProxyElement = CreateDmElement( "DmElement", pProxy->GetName(), NULL ); 
		array.AddToTail( pProxyElement );
		pProxyElement->SetValue( "proxyType", pKeyValues->GetName() );
		pProxyElement->SetValue( "editorType", "vmtProxy" );

		// Normal keys are proxy parameters
		for ( KeyValues *pProxyParam = pProxy->GetFirstValue(); pProxyParam != NULL; pProxyParam = pProxyParam->GetNextValue() )
		{
			switch( pProxyParam->GetDataType() )
			{
			case KeyValues::TYPE_INT:
				pProxyElement->SetValue( pProxyParam->GetName(), pProxyParam->GetInt() );
				return true;

			case KeyValues::TYPE_FLOAT:
				pProxyElement->SetValue( pProxyParam->GetName(), pProxyParam->GetFloat() );
				return true;

			case KeyValues::TYPE_STRING:
				pProxyElement->SetValue( pProxyParam->GetName(), pProxyParam->GetString() );
				return true;

			default:
				Warning( "Unhandled proxy keyvalues type (proxy %s var %s)\n", pProxy->GetName(), pProxyParam->GetName() );
				return false;
			}
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Unserialize fallbacks
//-----------------------------------------------------------------------------
bool CImportVMT::UnserializeFallbacks( CDmElement *pElement, KeyValues *pFallbackKeyValues )
{
	// Create a child element array to contain all material proxies
	CDmAttribute *pFallbacks = pElement->AddAttribute( "fallbacks", AT_ELEMENT_ARRAY );
	if ( !pFallbacks )
		return false;

	CDmrElementArray<> array( pFallbacks );

	CDmElement *pFallback = CreateDmElement( "DmElement", pFallbackKeyValues->GetName(), NULL ); 
	array.AddToTail( pFallback );
	pFallback->SetValue( "editorType", "vmtFallback" );

	// Normal keys are shader parameters
	for ( KeyValues *pShaderParam = pFallbackKeyValues->GetFirstValue(); pShaderParam != NULL; pShaderParam = pShaderParam->GetNextValue() )
	{
		if ( !UnserializeShaderParam( pFallback, pShaderParam ) )
		{
			Warning( "Error importing vmt shader parameter %s\n", pShaderParam->GetName() );
			return NULL;
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// VMT parser
//-----------------------------------------------------------------------------
void InsertKeyValues( KeyValues& dst, KeyValues& src, bool bCheckForExistence )
{
	KeyValues *pSrcVar = src.GetFirstSubKey();
	while( pSrcVar )
	{
		if ( !bCheckForExistence || dst.FindKey( pSrcVar->GetName() ) )
		{
			switch( pSrcVar->GetDataType() )
			{
			case KeyValues::TYPE_STRING:
				dst.SetString( pSrcVar->GetName(), pSrcVar->GetString() );
				break;
			case KeyValues::TYPE_INT:
				dst.SetInt( pSrcVar->GetName(), pSrcVar->GetInt() );
				break;
			case KeyValues::TYPE_FLOAT:
				dst.SetFloat( pSrcVar->GetName(), pSrcVar->GetFloat() );
				break;
			case KeyValues::TYPE_PTR:
				dst.SetPtr( pSrcVar->GetName(), pSrcVar->GetPtr() );
				break;
			}
		}
		pSrcVar = pSrcVar->GetNextKey();
	}

	if( bCheckForExistence )
	{
		for( KeyValues *pScan = dst.GetFirstTrueSubKey(); pScan; pScan = pScan->GetNextTrueSubKey() )
		{
			KeyValues *pTmp = src.FindKey( pScan->GetName() );
			if( !pTmp )
				continue;
			// make sure that this is a subkey.
			if( pTmp->GetDataType() != KeyValues::TYPE_NONE )
				continue;
			InsertKeyValues( *pScan, *pTmp, bCheckForExistence );
		}
	}
}


//-----------------------------------------------------------------------------
// Handle patch files
//-----------------------------------------------------------------------------
void CImportVMT::ExpandPatchFile( KeyValues *pKeyValues )
{
	int count = 0;
	while( count < 10 && stricmp( pKeyValues->GetName(), "patch" ) == 0 )
	{
//		WriteKeyValuesToFile( "patch.txt", keyValues );
		const char *pIncludeFileName = pKeyValues->GetString( "include" );
		if( pIncludeFileName )
		{
			KeyValues * includeKeyValues = new KeyValues( "vmt" );
			bool success = includeKeyValues->LoadFromFile( g_pFullFileSystem, pIncludeFileName, IsX360() ? "GAME" : NULL );
			if( success )
			{
				KeyValues *pInsertSection = pKeyValues->FindKey( "insert" );
				if( pInsertSection )
				{
					InsertKeyValues( *includeKeyValues, *pInsertSection, false );
				}
				
				KeyValues *pReplaceSection = pKeyValues->FindKey( "replace" );
				if( pReplaceSection )
				{
					InsertKeyValues( *includeKeyValues, *pReplaceSection, true );
				}

				*pKeyValues = *includeKeyValues;
				includeKeyValues->deleteThis();
				// Could add other commands here, like "delete", "rename", etc.
			}
			else
			{
				includeKeyValues->deleteThis();
				return;
			}
		}
		else
		{
			return;
		}
		count++;
	}
	if( count >= 10 )
	{
		Warning( "Infinite recursion in patch file?\n" );
	}
}


//-----------------------------------------------------------------------------
// Main entry point for the unserialization
//-----------------------------------------------------------------------------
CDmElement* CImportVMT::UnserializeFromKeyValues( KeyValues *pKeyValues )
{
	ExpandPatchFile( pKeyValues );

	// Create the main element
	CDmElement *pRoot = CreateDmElement( "DmElement", "VMT", NULL );
	if ( !pRoot )
		return NULL;

	// Each material needs to have an editortype associated with it so it displays nicely in editors
	pRoot->SetValue( "editorType", "vmt" );

	// Each material needs a proxy list and a fallback list
	if ( !pRoot->AddAttribute( "proxies", AT_ELEMENT_ARRAY ) )
		return NULL;
	if ( !pRoot->AddAttribute( "fallbacks", AT_ELEMENT_ARRAY ) )
		return NULL;

	// The keyvalues name is the shader name
	pRoot->SetValue( "shader", pKeyValues->GetName() );

	// Normal keys are shader parameters
	for ( KeyValues *pShaderParam = pKeyValues->GetFirstValue(); pShaderParam != NULL; pShaderParam = pShaderParam->GetNextValue() )
	{
		if ( !UnserializeShaderParam( pRoot, pShaderParam ) )
		{
			Warning( "Error importing vmt shader parameter %s\n", pShaderParam->GetName() );
			return NULL;
		}
	}

	// Subkeys are either proxies or fallbacks
	for ( KeyValues *pSubKey = pKeyValues->GetFirstTrueSubKey(); pSubKey != NULL; pSubKey = pSubKey->GetNextTrueSubKey() )
	{
		if ( !Q_stricmp( pSubKey->GetName(), "Proxies" ) )
		{
			UnserializeProxies( pRoot, pSubKey );
		}
		else
		{
			UnserializeFallbacks( pRoot, pSubKey );
		}
	}

	// Resolve all element references recursively
	RecursivelyResolveElement( pRoot );

	return pRoot;
}