#define DEBUG	0

#if DEBUG

#define EVALUATE_EXPRESSION(result, field)											\
	printf( "Display Debug --- Evaluating expression \"%s\"\n", valueName );		\
	if ( PS3EvaluateExpression( processId, threadId, &value, valueName ) )			\
	{																				\
		printf( "Display Debug --- Couldn't evaluate expression\n" );				\
		sprintf( output, "Couldn't evaluate expression for " #result );				\
		return;																		\
	}																				\
	(result) = value.val.##field;
	
#define GET_MEMORY(buffer, address, size)											\
	if ( PS3GetMemory( processId, threadId, (void*)(buffer), (address), (size) ) )	\
	{																				\
		printf( "Display Debug --- Couldn't fetch memory\n" );						\
		sprintf( output, "Couldn't get memory at specified address" );				\
		return;																		\
	}

#else // DEBUG

#define EVALUATE_EXPRESSION(result, field)											\
	if ( PS3EvaluateExpression( processId, threadId, &value, valueName ) )			\
	{																				\
		sprintf( output, "Couldn't evaluate expression for " #result );				\
		return;																		\
	}																				\
	(result) = value.val.##field;

#define GET_MEMORY(buffer, address, size)											\
	if ( PS3GetMemory( processId, threadId, (void*)(buffer), (address), (size) ) )	\
	{																				\
		sprintf( output, "Couldn't get memory at specified address" );				\
		return;																		\
	}

#endif // else DEBUG

#define MAX_STR_LEN 128

void atHashStringDisplayHandler_Impl(
	sn_uint32 processId,
	sn_uint32 threadIdWord0,
	sn_uint32 threadIdWord1,
	char *varName,
	char *output,
	sn_uint32 outputSize, 
	int nameSpace)
{
	sn_uint64		threadId;
	
	char			valueName[4096];
	sn_val			value;
	
	sn_uint32		hash;
	sn_uint32		entryAddress;
		
	sn_int32		maxIterations = 16;
	
	char			refdStringMap[4096];
	
	threadId.word[0] = threadIdWord0;
	threadId.word[1] = threadIdWord1;
	
	sprintf( valueName, "(%s).m_hash", varName );
	EVALUATE_EXPRESSION( hash, u32 );
	
	if ( hash == 0 )
	{
		sprintf( output, "Hash 0, String \"\"" );
		return;
	}
	
	sprintf( refdStringMap, "rage::atHashStringNamespaceSupport::g_StringMaps[%d]", nameSpace);
	
	sprintf( valueName, "%s.m_Hash[ %u %% (%s.m_Slots) ]", refdStringMap, hash, refdStringMap );
	EVALUATE_EXPRESSION( entryAddress, u32 );
		
	while (maxIterations--)
	{
		sn_uint32		key;
	
		if ( entryAddress == 0 )
			break;
	
		sprintf( valueName, "(((rage::atHashStringNamespaceSupport::RefdStringMap::Entry*)0x%x))->key", entryAddress );
		EVALUATE_EXPRESSION( key, u32 );
				
		if ( hash == key )
		{
			sn_address	stringAddress;
			sn_uint32	stringSize;
			char		string[MAX_STR_LEN];
			int count;
			
			sprintf( valueName, "((((rage::atHashStringNamespaceSupport::RefdStringMap::Entry*)0x%x))->data)", entryAddress );
			EVALUATE_EXPRESSION( stringAddress, Address );
			
			GET_MEMORY( string, stringAddress, MAX_STR_LEN );
			
			for(count = 0; count < MAX_STR_LEN; count++)
			{
				if (!string[count]) break;
			}
			
			if (count == MAX_STR_LEN)
			{
				string[MAX_STR_LEN-4] = '.';
				string[MAX_STR_LEN-3] = '.';
				string[MAX_STR_LEN-2] = '.';
				string[MAX_STR_LEN-1] = '\0';
			}
			
			sprintf( output, "m_hash=0x%08x \"%s\"", hash, string );
			return;
		}
		
		sprintf( valueName, "(((rage::atHashStringNamespaceSupport::RefdStringMap::Entry*)0x%x))->next", entryAddress );
		EVALUATE_EXPRESSION( entryAddress, u32 );
	}
	
	sprintf( output, "Couldn't find the hash in the string repository" );
}

#define DISPHANDLER(n) void atHashStringDisplayHandler##n (sn_uint32 processId, sn_uint32 threadIdWord0, sn_uint32 threadIdWord1, char *varName, char *output, sn_uint32 outputSize) { \
	atHashStringDisplayHandler_Impl(processId, threadIdWord0, threadIdWord1, varName, output, outputSize, n); \
}

DISPHANDLER(0);
DISPHANDLER(1);
DISPHANDLER(2);
DISPHANDLER(3);
DISPHANDLER(4);
DISPHANDLER(5);
DISPHANDLER(6);
DISPHANDLER(7);
DISPHANDLER(8);
DISPHANDLER(9);
DISPHANDLER(10);
DISPHANDLER(11);
DISPHANDLER(12);
DISPHANDLER(13);
DISPHANDLER(14);
DISPHANDLER(15);

#undef DISPHANDLER


int main(int argc, char** argv)
{
	RegisterTypeDisplayHandler( "rage::atHashValue:[atHashValue]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atHashString:[atHashString]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atNonFinalHashString:[atNonFinalHashString]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atHashWithString:[atHashWithString]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atHashWithStringDev:[atHashWithStringDev]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atHashWithStringBank:[atHashWithStringBank]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atHashWithStringNotFinal:[atHashWithStringNotFinal]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atFinalHashString:[atFinalHashString]atHashStringDisplayHandler1");
	RegisterTypeDisplayHandler( "rage::strStreamingObjectName:[strStreamingObjectName]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::strStreamingObjectNameString:[strStreamingObjectNameString]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atLiteralHashValue:[atLiteralHashValue]atHashStringDisplayHandler2");
	RegisterTypeDisplayHandler( "rage::atLiteralHashString:[atLiteralHashString]atHashStringDisplayHandler2");
	RegisterTypeDisplayHandler( "rage::atDiagHashValue:[atDiagHashValue]atHashStringDisplayHandler3");
	RegisterTypeDisplayHandler( "rage::atDiagHashString:[atDiagHashString]atHashStringDisplayHandler3");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<0>:[HashString]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<1>:[HashString]atHashStringDisplayHandler1");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<2>:[HashString]atHashStringDisplayHandler2");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<3>:[HashString]atHashStringDisplayHandler3");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<4>:[HashString]atHashStringDisplayHandler4");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<5>:[HashString]atHashStringDisplayHandler5");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<6>:[HashString]atHashStringDisplayHandler6");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<7>:[HashString]atHashStringDisplayHandler7");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<8>:[HashString]atHashStringDisplayHandler8");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<9>:[HashString]atHashStringDisplayHandler9");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<10>:[HashString]atHashStringDisplayHandler10");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<11>:[HashString]atHashStringDisplayHandler11");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<12>:[HashString]atHashStringDisplayHandler12");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<13>:[HashString]atHashStringDisplayHandler13");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<14>:[HashString]atHashStringDisplayHandler14");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashString<15>:[HashString]atHashStringDisplayHandler15");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<0>:[HashString]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<1>:[HashString]atHashStringDisplayHandler1");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<2>:[HashString]atHashStringDisplayHandler2");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<3>:[HashString]atHashStringDisplayHandler3");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<4>:[HashString]atHashStringDisplayHandler4");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<5>:[HashString]atHashStringDisplayHandler5");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<6>:[HashString]atHashStringDisplayHandler6");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<7>:[HashString]atHashStringDisplayHandler7");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<8>:[HashString]atHashStringDisplayHandler8");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<9>:[HashString]atHashStringDisplayHandler9");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<10>:[HashString]atHashStringDisplayHandler10");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<11>:[HashString]atHashStringDisplayHandler11");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<12>:[HashString]atHashStringDisplayHandler12");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<13>:[HashString]atHashStringDisplayHandler13");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<14>:[HashString]atHashStringDisplayHandler14");
	RegisterTypeDisplayHandler( "rage::atNamespacedHashValue<15>:[HashString]atHashStringDisplayHandler15");
	RegisterTypeDisplayHandler( "rage::fwGenericAssetDef<*,rage::strStreamingObjectName>::S:[HashString]atHashStringDisplayHandler0");
	RegisterTypeDisplayHandler( "rage::fwGenericAssetDef<*,rage::strStreamingObjectNameString>::S:[HashString]atHashStringDisplayHandler0");

	return 0;
}