//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: LCD support
//
//=====================================================================================//

#if defined( WIN32 ) && !defined( _X360 )
#include <windows.h>
#endif

#include "cbase.h"

#ifdef POSIX
#define HICON intp
const int DT_LEFT = 1;
const int DT_CENTER = 2;
const int DT_RIGHT = 3;
#endif

#include "hud_lcd.h"

#include "vgui_controls/Controls.h"
#include "vgui_controls/SectionedListPanel.h"
#include "vgui/ISurface.h"
#include "vgui/IScheme.h"
#include "vgui/IVGui.h"
#include "vgui/ILocalize.h"
#include "vgui/IPanel.h"

#include "c_team.h"
#include "c_playerresource.h"
#include "filesystem.h"
#include "g15/ig15.h"

#include "tier0/icommandline.h"

#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#endif

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#define G15_RESOURCE_FILE "resource/g15.res"
#define G15_MODULE_NAME "bin/g15.dll"

#define SMALL_ITEM_HEIGHT	10
#define G15_DEFAULT_MAX_CHAT_HISTORY 4

CLCD gLCD;
IHudLCD *hudlcd = &gLCD;

CON_COMMAND( g15_reload, "Reloads the Logitech G-15 Keyboard configs." )
{
	if ( !CommandLine()->FindParm( "-g15" ) )
	{
		Msg( "Must run with -g15 to enable support for the LCD Keyboard\n" );
		return;
	}

	gLCD.Reload();
}

CON_COMMAND( g15_dumpplayer, "Spew player data." )
{
	if ( !CommandLine()->FindParm( "-g15" ) )
	{
		Msg( "Must run with -g15 to enable support for the LCD Keyboard\n" );
		return;
	}

	gLCD.DumpPlayer();
}

static ConVar g15_update_msec( "g15_update_msec", "250", FCVAR_ARCHIVE, "Logitech G-15 Keyboard update interval." );

void CLCDItem::Wipe( IG15 *lcd )
{
	for ( int i = 0; i < m_Children.Count(); ++i )
	{
		if ( m_Children[ i ]->m_Handle )
		{
			lcd->RemoveAndDestroyObject( m_Children[ i ]->m_Handle );
		}

		m_Children[ i ]->Wipe( lcd );

		delete m_Children[ i ];
	}

	m_Children.Purge();

}
void CLCDItemAggregate::Create( IG15 *lcd )
{
	// Nothing
}

void CLCDItemAggregate::Wipe( IG15 *lcd )
{
	BaseClass::Wipe( lcd );

	for ( int i = 0; i < m_Definition.Count(); ++i )
	{
		m_Definition[ i ]->Wipe( lcd );

		delete m_Definition[ i ];
	}

	m_Definition.Purge();
}

void CLCDItemAggregate::WipeChildrenOnly( IG15 *lcd )
{
	BaseClass::Wipe( lcd );
}

void CLCDItemIcon::Create( IG15 *lcd )
{	
#ifdef WIN32
	m_Handle = lcd->AddIcon( (HICON)m_icon, w, h );
#else
	m_Handle = lcd->AddIcon( (void *)m_icon, w, h );
#endif
	lcd->SetOrigin( m_Handle, x, y );
	lcd->SetVisible( m_Handle, false );
}

void CLCDItemText::Create( IG15 *lcd )
{	
	m_Handle = lcd->AddText( G15_STATIC_TEXT, (G15TextSize)m_iSize, m_iAlign, w );
	lcd->SetOrigin( m_Handle, x, y );
	lcd->SetText( m_Handle, m_OriginalText );
	lcd->SetVisible( m_Handle, false );
}


///-----------------------------------------------------------------------------
/// Constructor
///-----------------------------------------------------------------------------
CLCD::CLCD( void )
	:	m_lcd( NULL ),
	m_nCurrentPage( 0 ),
	m_nSubPage( 0 ),
	m_bHadPlayer( false ),
	m_dwNextUpdateTime( 0u ),
	m_nMaxChatHistory( G15_DEFAULT_MAX_CHAT_HISTORY ),
	m_pG15Module( 0 ),
	m_G15Factory( 0 )
{
	m_Size[ 0 ] = m_Size[ 1 ] = 0;
}

///-----------------------------------------------------------------------------
/// Destructor
///-----------------------------------------------------------------------------
CLCD::~CLCD( void )
{
}

void CLCD::Reload()
{
	Shutdown();

	Msg( "Reloading G15 config\n" );

	Init();
}

///------------------------------------------------------------------------------
/// Initializes the LCD device, and sets up the text handles
///------------------------------------------------------------------------------
void CLCD::Init( void )
{
	if ( !CommandLine()->FindParm( "-g15" ) )
		return;

	if ( m_lcd ) 
		return;

	m_pG15Module = Sys_LoadModule( G15_MODULE_NAME );
	if ( !m_pG15Module )
	{
		return;
	}

    m_G15Factory = Sys_GetFactory( m_pG15Module );
	if ( !m_G15Factory )
	{
		Shutdown();
		return;
	}

	m_lcd = reinterpret_cast< IG15 * >( m_G15Factory( G15_INTERFACE_VERSION, NULL ) );
	if ( !m_lcd )
	{
		Shutdown();
		return;
	}
	
	m_lcd->GetLCDSize( m_Size[ 0 ], m_Size[ 1 ] );
	
	m_nCurrentPage = 0;
	m_nSubPage = 0;

	m_TextSizes.Insert( "small", G15_SMALL );
	m_TextSizes.Insert( "medium", G15_MEDIUM );
	m_TextSizes.Insert( "big", G15_BIG );

	m_TextAlignments.Insert( "left", DT_LEFT );
	m_TextAlignments.Insert( "center", DT_CENTER );
	m_TextAlignments.Insert( "right", DT_RIGHT );

	KeyValues *kv = new KeyValues( "G15" );
	if ( kv->LoadFromFile( filesystem, G15_RESOURCE_FILE, "MOD" ) )
	{
		char const *title = kv->GetString( "game", "Source Engine" );
		m_nMaxChatHistory = clamp( 1, kv->GetInt( "chatlines", m_nMaxChatHistory ), 64 );
		Assert( title );
		m_Title = title;
		m_lcd->Init( m_Title.String() );

		for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() )
		{
			char const *keyName = sub->GetName();
			if ( !Q_stricmp( keyName, "game" ) )
			{
				// Handled above!!!
			}
			else if ( !Q_stricmp( keyName, "icons" ) )
			{
				ParseIconMappings( sub );
			}
			else if ( !Q_stricmp( keyName, "replace" ) )
			{
				ParseReplacements( sub );
			}
			else if ( !Q_stricmp( keyName, "page" ) )
			{
				ParsePage( sub );
			}
		}
	}
	kv->deleteThis();

	UpdateChat();

	Msg( "Logitech LCD Keyboard initialized\n" );
}

///--------------------------------------------------------------------------
/// Destroys the local EZ LCD Object
///--------------------------------------------------------------------------
void CLCD::Shutdown( void )
{
	for ( int i = 0; i < m_Pages.Count(); ++i )
	{
		CLCDPage *page = m_Pages[ i ];
		page->Wipe( m_lcd );
		delete page;
	}

	m_Pages.Purge();

	if ( m_lcd )
	{
		m_lcd->Shutdown();
		m_lcd = NULL;
	}

	m_TextSizes.Purge();
	m_TextAlignments.Purge();
	m_GlobalStats.Purge();

	m_G15Factory = 0;
	
	if ( m_pG15Module )
	{
		Sys_UnloadModule( m_pG15Module );
		m_pG15Module = 0;
	}
}

int CLCD::FindTitlePage()
{
	for ( int i = 0; i < m_Pages.Count(); ++i )
	{
		if ( m_Pages[ i ]->m_bTitlePage )
			return i;
	}

	return -1;
}

bool CLCD::IsPageValid( int currentPage, C_BasePlayer *player )
{
	if ( m_Pages[ currentPage ]->m_bTitlePage && player )
		return false;

	if ( m_Pages[ currentPage ]->m_bRequiresPlayer && !player )
		return false;

	return true;
}

///---------------------------------------------------------------------
/// Update routine
///---------------------------------------------------------------------
void CLCD::Update( void )
{
	if ( !m_lcd ) 
		return ;

	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
	bool hasplayer = player ? true : false;

	bool changed = hasplayer != m_bHadPlayer;
	m_bHadPlayer = hasplayer;

	int pageCount = m_Pages.Count();

	int prevPage = m_nCurrentPage;

	if ( pageCount > 0 )
	{
		bool force = false;
		if ( changed && hasplayer )
		{
			force = true;
			m_nCurrentPage = 0;
			m_nSubPage = 0;
		}

		if ( !IsPageValid( m_nCurrentPage, player ) )
		{
			force = true;
		}
		
		if ( m_lcd->ButtonTriggered( G15_BUTTON_1 ) || force )
		{
			m_nSubPage = 0;

			for ( int i = 0; i < pageCount; ++i )
			{
                m_nCurrentPage = ( m_nCurrentPage + 1 ) % pageCount;
				if ( !IsPageValid( m_nCurrentPage, player ) )
					continue;



				break;
			}
		}

		if ( m_lcd->ButtonTriggered( G15_BUTTON_2 ) )
		{
			int pc = m_Pages[ m_nCurrentPage ]->m_nSubPageCount;

			m_nSubPage = ( m_nSubPage + 1 ) % pc;
		}
	}
	else
	{
		m_nCurrentPage = -1;
		m_nSubPage = 0;
	}

	bool pageChanged = prevPage != m_nCurrentPage;

	unsigned int dwCurTime = (unsigned int)( 1000.0 * gpGlobals->realtime );

	if ( m_lcd->IsConnected() )
	{
		if ( dwCurTime >= m_dwNextUpdateTime || pageChanged )
		{
			m_dwNextUpdateTime = dwCurTime + g15_update_msec.GetInt();
            DisplayCurrentPage( dwCurTime );
		}
	}

	m_lcd->UpdateLCD( dwCurTime );
}

///--------------------------------------------------------------------------
///
///--------------------------------------------------------------------------
bool CLCD::IsConnected( void ) const
{
	return m_lcd ? m_lcd->IsConnected() : false;
}

void CLCD::ShowItems_R( CLCDPage *page, unsigned int dwCurTime, CUtlVector< CLCDItem * >& list, bool bShowItems )
{
	int itemCount = list.Count();
	for ( int j = 0; j < itemCount; ++j )
	{
		CLCDItem *item = list[ j ];
		if ( !item->m_bActive )
			continue;

		if ( bShowItems )
		{
			switch ( item->m_Type )
			{
			default:
				break;
			case LCDITEM_TEXT:
				{
					CLCDItemText *txt = static_cast< CLCDItemText * >( item );
					if ( txt )
					{
						// Need to build updated text
						CUtlString updated;
						CUtlString str = txt->m_OriginalText;
						BuildUpdatedText( str.String(), updated );
						DoGlobalReplacements( updated );
						ReduceParentheses( updated );

						m_lcd->SetText( item->m_Handle, updated.String() );
					}
				}
				break;
			case LCDITEM_ICON:
				{
					CLCDItemIcon *icon = static_cast< CLCDItemIcon * >( item );
					if ( icon )
					{
						// Need to build updated text
						CUtlString updated;
						CUtlString str = icon->m_IconName;
						BuildUpdatedText( str.String(), updated );
						DoGlobalReplacements( updated );
						ReduceParentheses( updated );

						int idx = m_Icons.Find( updated.String() );
						if ( idx != m_Icons.InvalidIndex() )
						{
							icon->m_icon = (void *)m_Icons[ idx ].m_handle;
						}

						// Recreate
						if ( icon->m_Handle )
						{
							m_lcd->RemoveAndDestroyObject( icon->m_Handle );
							icon->m_Handle = 0;
						}
						icon->Create( m_lcd );
					}
				}
				break;
			case LCDITEM_AGGREGATE:
				{
					CLCDItemAggregate *ag = static_cast< CLCDItemAggregate * >( item );
					if ( ag->m_dwNextUpdateTime > dwCurTime )
						break;

					// FIXME: encode update interval in text file
					ag->m_dwNextUpdateTime = dwCurTime + 1000;

					// Blow away current data
					ag->WipeChildrenOnly( m_lcd );
									
					CUtlVector< int >	validIndices;
					char prefix[ 256 ];
					char altprefix[ 256 ];
					prefix[ 0 ] = 0;
					altprefix[ 0 ] = 0;

					int curx = ag->x;
					int cury = ag->y;

					switch ( ag->m_AggType )
					{
					default:
						Assert( 0 );
						break;
					case AGGTYPE_PERPLAYER:
						// Add all players into list
						{
							for ( int pl = 1; pl <= gpGlobals->maxClients; ++pl )
							{
								if ( g_PR && g_PR->IsConnected( pl ) )
								{
									validIndices.AddToTail( pl );
								}
							}

							Q_strncpy( prefix, "(playerindex)", sizeof( prefix ) );
							Q_strncpy( altprefix, "(playerindexplusone)", sizeof( altprefix ) );
						}
						break;
					case AGGTYPE_PERTEAM:
						{
							C_BasePlayer *local = C_BasePlayer::GetLocalPlayer();

							if ( local )
							{
								for ( int pl = 1; pl <= gpGlobals->maxClients; ++pl )
								{
									if ( g_PR && g_PR->IsConnected( pl ) && local->GetTeamNumber() == g_PR->GetTeam( pl ) )
									{
										validIndices.AddToTail( pl );
									}
								}
							}

							Q_strncpy( prefix, "(playerindex)", sizeof( prefix ) );
							Q_strncpy( altprefix, "(playerindexplusone)", sizeof( altprefix ) );
						}
						break;
					}

					int subPage = 0;
					int spItems = 0;

					int ecount = validIndices.Count();
					for ( int e = 0; e < ecount; ++e )
					{
						// Now fixup any strings
						int index = validIndices[ e ];

						char s1[ 512 ], s2[ 512 ];
						Q_snprintf( s1, sizeof( s1 ), "%d", index );
						Q_snprintf( s2, sizeof( s2 ), "%d", index + 1 );
						
						// Now replace "playerindex" with the index as needed
						for( int r = 0; r < ag->m_Definition.Count(); ++r )
						{
							CLCDItem *newItem = NULL;

							CLCDItem *item = ag->m_Definition[ r ];
							switch ( item->m_Type )
							{
							default:
								break;

							case LCDITEM_TEXT:
								{
									CLCDItemText *text = static_cast< CLCDItemText * >( item );
									CUtlString s;
									s = text->m_OriginalText;
									Replace( s, prefix, s1 );
									Replace( s, altprefix, s2 );
									char itemNumber[ 32 ];
									Q_snprintf( itemNumber, sizeof( itemNumber ), "%d", e +1 );

									Replace( s, "(itemnumber)", itemNumber );

									DoGlobalReplacements( s );
									// ReduceParentheses( s );

									// text->m_OriginalText = s;

									CLCDItemText *copy = static_cast< CLCDItemText * >( page->Alloc( item->m_Type ) );
									*copy = *text;
									copy->m_bActive = true;
									copy->m_OriginalText = s;
									copy->Create( m_lcd );

									m_lcd->SetOrigin( copy->m_Handle, curx + copy->x, cury + copy->y );

									newItem = copy;
								}
								break;
							case LCDITEM_ICON:
								{
									CLCDItemIcon *icon = static_cast< CLCDItemIcon * >( item );
									CLCDItemIcon *copy = static_cast< CLCDItemIcon * >( page->Alloc( item->m_Type ) );
									*copy = *icon;
									copy->m_bActive = true;
									copy->Create( m_lcd );

									m_lcd->SetOrigin( copy->m_Handle, curx + copy->x, cury + copy->y );

									newItem = copy;
								}
								break;
							}

							if ( newItem )
							{
								++spItems;
								newItem->m_nSubPage = subPage;
								ag->m_Children.AddToTail( newItem );
							}
						}

						cury += ag->m_yincrement;

						if ( cury + SMALL_ITEM_HEIGHT > m_Size[ 1 ] )
						{
							spItems = 0;
							++subPage;
							cury = ag->y;
						}
					}

					if ( spItems > 0 )
					{
						page->m_nSubPageCount = subPage + 1;
					}
					else
					{
						// We thought we needed a new page, but didn't actually use it
						page->m_nSubPageCount = subPage;
					}
				}
			}
		}

		m_lcd->SetVisible( item->m_Handle, bShowItems && ( ( item->m_nSubPage == -1 ) || item->m_nSubPage == m_nSubPage ) );
		
		ShowItems_R( page, dwCurTime, item->m_Children, bShowItems );
	}
}

void CLCD::DisplayCurrentPage( unsigned int dwCurTime )
{
	int pageCount = m_Pages.Count();
	for ( int i = 0; i < pageCount; ++i )
	{
		bool bShowItems = ( i == m_nCurrentPage ) ? true : false;

		CLCDPage* page = m_Pages[ i ];
		ShowItems_R( page, dwCurTime, page->m_Children, bShowItems );
	}
}

CLCDItemIcon *CLCD::ParseItemIcon( CLCDPage *page, bool bCreateHandles, KeyValues *sub )
{
	CLCDItemIcon *item = static_cast< CLCDItemIcon * >( page->Alloc( LCDITEM_ICON ) );

	item->m_IconName = sub->GetString( "name", "" );

	item->m_nSubPage = sub->GetInt( "header", 0 ) ? -1 : page->m_nSubPageCount - 1;
	item->w = sub->GetInt( "w", 24 );
	item->h = sub->GetInt( "h", 24 );
	item->x = sub->GetInt( "x", 0 );
	item->y = sub->GetInt( "y", 0 );

	int idx = m_Icons.Find( item->m_IconName.String() );
	item->m_icon = 0;
	if ( idx != m_Icons.InvalidIndex() )
	{
		item->m_icon = (void *)m_Icons[ idx ].m_handle;
	}

	if ( bCreateHandles )
	{
		item->Create( m_lcd );
	}

	return item;
}

CLCDItemText *CLCD::ParseItemText( CLCDPage *page, bool bCreateHandles, KeyValues *sub )
{
	CLCDItemText *item = static_cast< CLCDItemText * >( page->Alloc( LCDITEM_TEXT ) );

	const char *initialText = sub->GetString( "text", "" );
	item->m_bHasWildcard = Q_strstr( initialText, "%" ) ? true : false;

	item->m_nSubPage = sub->GetInt( "header", 0 ) ? -1 : page->m_nSubPageCount - 1;
	item->w = sub->GetInt( "w", 150 );
	item->x = sub->GetInt( "x", 0 );
	item->y = sub->GetInt( "y", 0 );

	const char *sizeStr = sub->GetString( "size", "small" );
	item->m_iSize = G15_SMALL;
	int iFound = m_TextSizes.Find( sizeStr );
	if ( iFound != m_TextSizes.InvalidIndex() )
	{
		item->m_iSize = m_TextSizes[ iFound ];
	}

	const char *alignStr = sub->GetString( "align", "left" );
	item->m_iAlign = DT_LEFT;
	iFound = m_TextAlignments.Find( alignStr );
	if ( iFound != m_TextAlignments.InvalidIndex() )
	{
		item->m_iAlign = m_TextAlignments[ iFound ];
	}

	item->m_OriginalText = initialText;
	if ( bCreateHandles )
	{
		item->Create( m_lcd );
	}

	return item;
}

void CLCD::ParseItems_R( CLCDPage *page, bool bCreateHandles, KeyValues *kv, CUtlVector< CLCDItem * >& list )
{
	for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() )
	{
		char const *keyName = sub->GetName();
		if ( !Q_stricmp( keyName, "iterate_players" ) ||
			      !Q_stricmp( keyName, "iterate_team" ) )
		{
			int aggType = AGGTYPE_UNKNOWN;
			if ( !Q_stricmp( keyName, "iterate_players" ) )
			{
				aggType = AGGTYPE_PERPLAYER;
			}
			else if ( !Q_stricmp( keyName, "iterate_team" ) )
			{
				aggType = AGGTYPE_PERTEAM;
			}

			// Now we parse the items out as we generally would
			CLCDItemAggregate *item = static_cast< CLCDItemAggregate * >( page->Alloc( LCDITEM_AGGREGATE ) );
			item->m_AggType = aggType;

			item->x = sub->GetInt( "x", 0 );
			item->y = sub->GetInt( "y", 0 );
			item->m_yincrement = sub->GetInt( "y_increment", 10 );

			// Parse the definition
			ParseItems_R( page, false, sub, item->m_Definition );

			// Add the definition items as "inactive" items to the scene (so they get destroyed)
			for ( int i = 0; i < item->m_Definition.Count(); ++i )
			{
				CLCDItem *pItem = item->m_Definition[ i ];
				pItem->m_bActive = false;
			}

			list.AddToTail( item );
		}
		else if ( !Q_stricmp( keyName, "static_icon" ) )
		{
			CLCDItemIcon *item = ParseItemIcon( page, true, sub );
			Assert( item );
			list.AddToTail(item );
		}
		else if ( !Q_stricmp( keyName, "static_text" ) )
		{
			CLCDItemText *item = ParseItemText( page, true, sub );
			Assert( item );
			list.AddToTail( item );
		}
		else if ( !Q_stricmp( keyName, "newsubpage" ) )
		{
			// Add to new subpage
			++page->m_nSubPageCount;
		}
		else
		{
			// Skip unknown stuff
			continue;
		}
	}
}

void CLCD::ParsePage( KeyValues *kv )
{
	CLCDPage *newPage = new CLCDPage();
	m_Pages.AddToTail( newPage );

	newPage->m_bTitlePage = kv->GetInt( "titlepage", 0 ) ? true : false;
	newPage->m_bRequiresPlayer = kv->GetInt( "requiresplayer", 0 ) ? true : false;

	ParseItems_R( newPage, true, kv, newPage->m_Children );
}

void CLCD::ParseIconMappings( KeyValues *kv )
{
	for ( KeyValues *icon = kv->GetFirstSubKey(); icon; icon = icon->GetNextKey() )
	{
		IconInfo_t info;
		HICON hIcon = 0;
		char const *name = icon->GetName();
		char fullpath[ 512 ];
		filesystem->RelativePathToFullPath( icon->GetString(), "GAME", fullpath, sizeof( fullpath ) );
#ifdef WIN32
		hIcon = (HICON)::LoadImageA( NULL, fullpath, IMAGE_ICON, 32, 32, LR_LOADFROMFILE );
#else
		hIcon = 0;
#endif
		info.m_handle = (void *)hIcon;
		m_Icons.Insert( name, info );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Simply dumps all data fields in object
//-----------------------------------------------------------------------------
class CDescribeData
{
public:
	CDescribeData( void const *src );

	void	DescribeShort( const short *invalue, int count );
	void	DescribeInt( const int *invalue, int count );		
	void	DescribeBool( const bool *invalue, int count );	
	void	DescribeFloat( const float *invalue, int count );	
	void	DescribeSimpleString( const char *indata, int length );		
	void	DescribeString( const string_t *instring, int count );			
	void	DescribeVector( const Vector *inValue, int count );
	void	DescribeColor( const Color *invalue, int count );	
	void	DumpDescription( datamap_t *pMap );

	void	GetValueForField( char const *fieldName, char *buf, size_t bufsize );

private:
	void	DescribeFields_R( int chain_count, datamap_t *pMap, typedescription_t *pFields, int fieldCount );
	bool	BuildFieldPath( CUtlString& path );
	
	void const		*m_pSrc;
	int				m_nSrcOffsetIndex;

	void			Describe( const char *fmt, ... );

	typedescription_t *m_pCurrentField;
	char const		*m_pCurrentClassName;
	datamap_t		*m_pCurrentMap;

	CUtlVector< CUtlString > m_FieldPath;
};

CDescribeData::CDescribeData( void const *src )
{
	m_pSrc				= src;
	m_nSrcOffsetIndex	= TD_OFFSET_NORMAL;

	m_pCurrentField		= NULL;
	m_pCurrentMap		= NULL;
	m_pCurrentClassName = NULL;
}

typedescription_t *FindFieldByName( datamap_t *pMap, char const *fn )
{
	while ( pMap )
	{
		for ( int i = 0; i < pMap->dataNumFields; i++ )
		{
			typedescription_t *current = &pMap->dataDesc[ i ];
			if ( !current->fieldName )
				continue;

			if ( !Q_stricmp( current->fieldName, fn ) )
				return current;
		}

		pMap = pMap->baseMap;
	}

	return NULL;
}

typedescription_t *FindField( datamap_t *pMap, char const *relativePath )
{
	if ( !Q_strstr( relativePath, "." ) )
	{
		// Simple case, just look up field name
		return FindFieldByName( pMap, relativePath );
	}

	// Complex case

	Assert( 0 );
	return NULL;
}

bool CDescribeData::BuildFieldPath( CUtlString& path )
{
	int c = m_FieldPath.Count();
	if ( c == 0 )
		return false;

	for ( int i = 0; i < c; ++i )
	{
		CUtlString& s = m_FieldPath[ i ];
		if ( i != 0 )
		{
			path += ".";
		}
		path += s;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *fmt - 
//			... - 
//-----------------------------------------------------------------------------
void CDescribeData::Describe( const char *fmt, ... )
{
	Assert( m_pCurrentMap );
	Assert( m_pCurrentClassName );

	const char *fieldname = "empty";

	if ( m_pCurrentField )
	{
		fieldname	= m_pCurrentField->fieldName ? m_pCurrentField->fieldName : "NULL";
	}

	va_list argptr;
	char data[ 4096 ];
	int len;
	va_start(argptr, fmt);
	len = Q_vsnprintf(data, sizeof( data ), fmt, argptr);
	va_end(argptr);

	CUtlString fp;
	if ( BuildFieldPath( fp ) )
	{
		Msg( "%s.%s%s",
			fp.String(),
			fieldname,
			data );
	}
	else
	{
		Msg( "%s%s",
			fieldname,
			data );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : size - 
//			*outdata - 
//			*indata - 
//-----------------------------------------------------------------------------
void CDescribeData::DescribeSimpleString( char const *invalue, int count )
{
	Describe( "%s\n", invalue ? invalue : "" );
}


void CDescribeData::DescribeShort( const short *invalue, int count )
{
	for ( int i = 0; i < count; ++i )
	{
		if ( count == 1 )
		{
			Describe( " short (%i)\n", (int)(invalue[i]) );
		}
		else
		{
			Describe( "[%i] short (%i)\n", i, (int)(invalue[i]) );
		}
	}
}


void CDescribeData::DescribeInt( const int *invalue, int count )
{
	for ( int i = 0; i < count; ++i )
	{
		if ( count == 1 )
		{
			Describe( " integer (%i)\n", invalue[i] );
		}
		else
		{
			Describe( "[%i] integer (%i)\n", i, invalue[i] );
		}
	}
}

void CDescribeData::DescribeBool( const bool *invalue, int count )
{
	for ( int i = 0; i < count; ++i )
	{
		if ( count == 1 )
		{
			Describe( " bool (%s)\n", (invalue[i]) ? "true" : "false" );
		}
		else
		{
			Describe( "[%i] bool (%s)\n", i, (invalue[i]) ? "true" : "false" );
		}
	}
}

void CDescribeData::DescribeFloat( const float *invalue, int count )
{
	for ( int i = 0; i < count; ++i )
	{
		if ( count == 1 )
		{
			Describe( " float (%f)\n", invalue[ i ] );
		}
		else
		{
			Describe( "[%i] float (%f)\n", i, invalue[ i ] );
		}
	}
}

void CDescribeData::DescribeString( const string_t *instring, int count )
{
	for ( int i = 0; i < count; ++i )
	{
		if ( count == 1 )
		{
			Describe( " string (%s)\n", instring[ i ] ? instring[ i ]  : "" );
		}
		else
		{
			Describe( "[%i] string (%s)\n", i, instring[ i ] ? instring[ i ]  : "" );
		}
	}
}

void CDescribeData::DescribeColor( const Color *invalue, int count )
{
	for ( int i = 0; i < count; ++i )
	{
		if ( count == 1 )
		{
			Describe( " color (%i %i %i %i)\n", invalue[ i ].r(), invalue[ i ].g(), invalue[ i ].b(), invalue[ i ].a() );
		}
		else
		{
			Describe( "[%i] color (%i %i %i %i)\n", i, invalue[ i ].r(), invalue[ i ].g(), invalue[ i ].b(), invalue[ i ].a() );
		}
	}
}

void CDescribeData::DescribeVector( const Vector *inValue, int count )
{
	for ( int i = 0; i < count; ++i )
	{
		if ( count == 1 )
		{
			Describe( " vector (%f %f %f)\n", 
				inValue[i].x, inValue[i].y, inValue[i].z );
		}
		else
		{
			Describe( "[%i] vector (%f %f %f)\n", 
				i,
				inValue[i].x, inValue[i].y, inValue[i].z );
		}
	}
}

void CDescribeData::DescribeFields_R( int chain_count, datamap_t *pRootMap, typedescription_t *pFields, int fieldCount )
{
	int				i;
	int				flags;
	int				fieldOffsetSrc;
	int				fieldSize;

	m_pCurrentMap = pRootMap;
	if ( !m_pCurrentClassName )
	{
		m_pCurrentClassName = pRootMap->dataClassName;
	}

	for ( i = 0; i < fieldCount; i++ )
	{
		m_pCurrentField = &pFields[ i ];
		flags = m_pCurrentField->flags;

		// Skip this field
		if ( flags & FTYPEDESC_VIEW_NEVER )
			continue;
		
		// Mark any subchains first
		if ( m_pCurrentField->override_field != NULL )
		{
			m_pCurrentField->override_field->override_count = chain_count;
		}

		// Skip this field?
		if ( m_pCurrentField->override_count == chain_count )
		{
			continue;
		}

		void const *pInputData;
		
		fieldOffsetSrc = m_pCurrentField->fieldOffset[ m_nSrcOffsetIndex ];
		fieldSize = m_pCurrentField->fieldSize;
		
		pInputData = (void const *)((char *)m_pSrc + fieldOffsetSrc );
		
		switch( m_pCurrentField->fieldType )
		{
		default:
			break;
		case FIELD_EMBEDDED:
			{
				typedescription_t *save = m_pCurrentField;
				void const *saveSrc = m_pSrc;
				const char *saveName = m_pCurrentClassName;
				
				m_pCurrentClassName = m_pCurrentField->td->dataClassName;
				
				CUtlString str;
				str = m_pCurrentField->fieldName;

				m_FieldPath.AddToTail( str );

				m_pSrc = pInputData;
				if ( ( flags & FTYPEDESC_PTR ) && (m_nSrcOffsetIndex == PC_DATA_NORMAL) )
				{
					m_pSrc = *((void**)m_pSrc);
				}

				DescribeFields_R( chain_count, pRootMap, m_pCurrentField->td->dataDesc, m_pCurrentField->td->dataNumFields );
				
				m_FieldPath.Remove( m_FieldPath.Count() - 1 );

				m_pCurrentClassName = saveName;
				m_pCurrentField = save;
				m_pSrc = saveSrc;
			}
			break;
		case FIELD_FLOAT:
			DescribeFloat( (float const *)pInputData, fieldSize );
			break;
		case FIELD_STRING:
			DescribeString( (const string_t*)pInputData, fieldSize );
			break;
		case FIELD_VECTOR:
			DescribeVector( (const Vector *)pInputData, fieldSize );
			break;
		case FIELD_COLOR32:
			DescribeColor( (const Color *)pInputData, fieldSize );
			break;
			
		case FIELD_BOOLEAN:
			DescribeBool( (bool const *)pInputData, fieldSize );
			break;
		case FIELD_INTEGER:
			DescribeInt( (int const *)pInputData, fieldSize );
			break;
			
		case FIELD_SHORT:
			DescribeShort( (short const *)pInputData, fieldSize );
			break;
			
		case FIELD_CHARACTER:
			DescribeSimpleString( (const char *)pInputData, fieldSize );
			break;
		}
	}

	m_pCurrentClassName = NULL;
}

static int g_nChainCount = 1;
extern void ValidateChains_R( datamap_t *dmap );

void CDescribeData::DumpDescription( datamap_t *pMap )
{
	++g_nChainCount;

	if ( !pMap->chains_validated )
	{
		ValidateChains_R( pMap );
	}

	while ( pMap )
	{
        DescribeFields_R( g_nChainCount, pMap, pMap->dataDesc, pMap->dataNumFields );

		pMap = pMap->baseMap;
	}
}


void CLCD::DumpPlayer()
{
	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
	if ( !player )
		return;

	Msg( "(localplayer)\n\n" );

	CDescribeData helper( player );
	helper.DumpDescription( player->GetPredDescMap() );

	Msg( "(localteam)\n\n" );

	C_Team *team = player->GetTeam();
	if ( team )
	{
		CDescribeData helper( team );
		helper.DumpDescription( team->GetPredDescMap() );
	}

	Msg( "(playerresource)\n\n" );

	if ( g_PR )
	{
		CDescribeData helper( g_PR );
		helper.DumpDescription( g_PR->GetPredDescMap() );
	}

	Msg( "(localplayerweapon)\n\n" );
	// Get the player's weapons, too
	C_BaseCombatWeapon *active = player->GetActiveWeapon();
	if ( active )
	{
		CDescribeData helper( active );
		helper.DumpDescription( active->GetPredDescMap() );
	}

	Msg( "Other replacements:\n\n" );

	// Global replacements
	for( int i = m_GlobalStats.First() ; i != m_GlobalStats.InvalidIndex(); i = m_GlobalStats.Next( i ) )
	{
		CUtlString& r = m_GlobalStats[ i ];

		char const *pReplace = r.String();
		char ansi[ 512 ];
		ansi[ 0 ] = 0;

		if ( pReplace[ 0 ] == '#' )
		{
			const wchar_t *pWString = g_pVGuiLocalize->Find( pReplace );
			if ( pWString )
			{
				g_pVGuiLocalize->ConvertUnicodeToANSI( pWString, ansi, sizeof( ansi ) );
				pReplace = ansi;
			}
		}

		Msg( "'%s' = '%s'\n", m_GlobalStats.GetElementName( i ), pReplace );
	}
}

bool CLCD::ExtractArrayIndex( char *str, size_t bufsize, int *index )
{
	Assert( index );
	*index = 0;

	char s[ 2048 ];
	Q_strncpy( s, str, sizeof( s ) );

	char *pos = Q_strstr( s, "[" );
	if ( !pos )
		return false;

	char *pos2 = Q_strstr( s, "]" );
	if ( !pos2 )
		return false;

	char num[ 32 ];
	Q_strncpy( num, pos + 1, pos2 - pos );
	*index = Q_atoi( num );

	int left = pos - s + 1;
	char o[ 2048 ];
	Q_strncpy( o, s, left );
	Q_strncat( o, pos2 + 1, sizeof( o ), COPY_ALL_CHARACTERS );

	Q_strncpy( str, o, bufsize );
	return true;
}

void CLCD::LookupToken( char const *in, CUtlString& value )
{
	value = "";

	C_BasePlayer *player = C_BasePlayer::GetLocalPlayer();
	if ( !player )
	{
		return;
	}

	C_BaseEntity *ref = NULL;

	char outbuf[ 1024 ];
	char *o = outbuf;
	char const *i = in;
	while ( *i )
	{
		if ( *i == '(' )
		{
			char token[ 512 ];
			char *to = token;
			// swallow everything until matching '%' character
			++i;
			while ( *i && *i != ')' )
			{
				*to++ = *i++;
			}

			if ( *i )
				++i;

			*to = 0;

			if ( !Q_stricmp( token, "localplayer" ) )
			{
				ref = player;
			}
			else if ( !Q_stricmp( token, "localteam" ) )
			{
				ref = player->GetTeam();
			}
			else if ( !Q_stricmp( token, "localplayerweapon" ) )
			{
				ref = player->GetActiveWeapon();
			}
			else if ( !Q_stricmp( token, "playerresource" ) )
			{
				ref = g_PR;
			}
		}
		else
		{
			*o++ = *i++;
		}
	}

	*o = '\0';

	// Fixme, also need to get array reference removed from end and do the . field searching stuff

	// Outbuf now has the actual field
	if ( !ref )
	{
		return;
	}

	int iIndex = 0;
	ExtractArrayIndex( outbuf, sizeof( outbuf ), &iIndex );
	
	typedescription_t *td = FindField( ref->GetPredDescMap(), outbuf );
	if ( !td )
	{
		return;
	}

	// Not allowed to see this one
	if ( td->flags & FTYPEDESC_VIEW_NEVER )
	{
		return;
	}

	int fieldOffsetSrc = td->fieldOffset[ TD_OFFSET_NORMAL ];
	// int fieldSize = td->fieldSize;
		
	void const *pInputData = (void const *)((char *)ref + fieldOffsetSrc );

	char sz[ 256 ];
	sz[ 0 ] = 0;
	// Found it, now get the value
	switch ( td->fieldType )
	{
	case FIELD_FLOAT:
		Q_snprintf( sz, sizeof( sz ), "%.2f", *((float *)pInputData + iIndex ) );
		break;
	case FIELD_STRING:
		{
			string_t *pString = (string_t *)((string_t *)pInputData + iIndex );
			Q_snprintf( sz, sizeof( sz ), "%s", pString ? STRING( *pString ) : "" );
		}
		break;
	case FIELD_VECTOR:
		{
			Vector v = *((Vector *)pInputData + iIndex );
            Q_snprintf( sz, sizeof( sz ), "%.2f %.2f %.2f", v.x, v.y, v.z );
		}
		break;
	case FIELD_COLOR32:
		{
			Color c = *(( Color * )pInputData + iIndex );
			Q_snprintf( sz, sizeof( sz ), "%d %d %d %d", c.r(), c.g(), c.b(), c.a() );
		}
		break;
		
	case FIELD_BOOLEAN:
		Q_snprintf( sz, sizeof( sz ), "%s", *( ( bool *)pInputData + iIndex ) ? "true" : "false" );
		break;
	case FIELD_INTEGER:
		Q_snprintf( sz, sizeof( sz ), "%i", *( (int *)pInputData + iIndex ));
		break;
		
	case FIELD_SHORT:
		Q_snprintf( sz, sizeof( sz ), "%i", *( (short *)pInputData + iIndex ) );
		break;
		
	case FIELD_CHARACTER:
		Q_snprintf( sz, sizeof( sz ), "%s", ((const char *)pInputData + iIndex ) );
		break;
	}

	value = sz;
}

void CLCD::BuildUpdatedText( char const *in, CUtlString& out )
{
	char outbuf[ 1024 ];
	char *o = outbuf;
	char const *i = in;
	while ( *i )
	{
		if ( *i == '%' )
		{
			char token[ 512 ];
			char *to = token;
			// swallow everything until matching '%' character
			++i;
			while ( *i && *i != '%' )
			{
				*to++ = *i++;
			}

			if ( *i )
				++i;

			*to = 0;

			// Now we have the token, do the lookup
			CUtlString value;
			LookupToken( token, value );

			to = (char *)value.String();
			while ( *to )
			{
				*o++ = *to++;
			}
		}
		else
		{
			*o++ = *i++;
		}
	}

	*o = '\0';

	out = outbuf;
}


bool CLCD::Replace( CUtlString& str, char const *search, char const *replace )
{
	// If search string is part of replacement, this is a bad thing!!!
	Assert( !*replace || !Q_strstr( replace, search ) );

	bool changed = false;
	if ( !Q_strstr( str.String(), search ) )
		return false;

	char s[ 2048 ];
	Q_strncpy( s, str.String(), sizeof( s ) );

	int searchlen = Q_strlen( search );
	while ( true )
	{
		char *pos = Q_strstr( s, search );
		if ( !pos )
			break;

		char temp[ 4096 ];
		// Found an instance
		int left = pos - s + 1;
		Assert( left < sizeof( temp ) );
		Q_strncpy( temp, s, left );
		Q_strncat( temp, replace, sizeof( temp ), COPY_ALL_CHARACTERS );
		int rightofs = left + searchlen - 1;
		Q_strncat( temp, &s[ rightofs ], sizeof( temp ), COPY_ALL_CHARACTERS );

		// Replace entire string
		Q_strncpy( s, temp, sizeof( s ) );
		changed = true;
	}

	str = s;

	return changed;
}

void CLCD::SetGlobalStat( char const *name, char const *value )
{
	if ( !m_lcd )
		return;

	int idx = m_GlobalStats.Find( name );
	if ( idx == m_GlobalStats.InvalidIndex() )
	{
		idx = m_GlobalStats.Insert( name );
	}

	m_GlobalStats[ idx ] = value;
}

void CLCD::AddChatLine( char const *txt )
{
	if ( !m_lcd )
		return;

	while ( m_ChatHistory.Count() >= m_nMaxChatHistory )
	{
		m_ChatHistory.Remove( 0 );
	}

	m_ChatHistory.AddToTail( CUtlString( txt ) );

	UpdateChat();
}

void CLCD::UpdateChat()
{
	for ( int i = 0; i < m_nMaxChatHistory; ++i )
	{
		char name[ 32 ];
		Q_snprintf( name, sizeof( name ), "chat_%d", i + 1 );

		SetGlobalStat( name, i < m_ChatHistory.Count() ? m_ChatHistory[ i ].String() : " " );
	}
}

void CLCD::DoGlobalReplacements( CUtlString& str )
{
	// Put some limit to avoid infinite recursion
	int maxChanges = 16;

	bool changed = false;
	do
	{
		changed = false;
		for ( int i = m_GlobalStats.First(); i != m_GlobalStats.InvalidIndex(); i = m_GlobalStats.Next( i ) )
		{
			CUtlString &r = m_GlobalStats[ i ];

			char const *pReplace = r.String();
			char ansi[ 512 ];
			ansi[ 0 ] = 0;

			if ( pReplace[ 0 ] == '#' )
			{
				const wchar_t *pWString = g_pVGuiLocalize->Find( pReplace );
				if ( pWString )
				{
					g_pVGuiLocalize->ConvertUnicodeToANSI( pWString, ansi, sizeof( ansi ) );
					pReplace = ansi;
				}
			}

			if ( Replace( str, m_GlobalStats.GetElementName( i ), pReplace ) )
			{
				changed = true;
			}
		}
	} while ( changed && --maxChanges >= 0 );
}

void CLCD::ReduceParentheses( CUtlString& str )
{
	char s[ 2048 ];
	Q_strncpy( s, str.String(), sizeof( s ) );

	while ( true )
	{
		char *pos = Q_strstr( s, "(" );
		if ( !pos )
			break;

		char *end = Q_strstr( pos, ")" );
		if ( !end )
			break;

		char temp[ 4096 ];
		// Found an instance
		int left = pos - s + 1;
		Assert( left < sizeof( temp ) );
		Q_strncpy( temp, s, left );
		int rightofs = end - s + 1;
		Q_strncat( temp, &s[ rightofs ], sizeof( temp ), COPY_ALL_CHARACTERS );

		// Replace entire string
		Q_strncpy( s, temp, sizeof( s ) );
	}

	str = s;
}

void CLCD::ParseReplacements( KeyValues *kv )
{
	for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() )
	{
		char const *key = sub->GetName();
		char const *value = sub->GetString();

		SetGlobalStat( key, value );
	}
}
