path: root/game/shared/econ/econ_item_description.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//

#include "cbase.h"
#include "econ_item_description.h"
#include "econ_item_interface.h"
#include "econ_item_tools.h"
#include "econ_holidays.h"
#include "econ_store.h"
#include "tier1/ilocalize.h"
#include "localization_provider.h"
#include "rtime.h"
#include "econ_dynamic_recipe.h"

#ifdef GC
	// the GC needs accountdetails to get persona names
	#include "gcsdk/accountdetails.h"
#else // !GC

	#ifndef EXTERNALTESTS_DLL
		#include "econ_item_inventory.h"
	#endif

	#ifdef CLIENT_DLL
		#include "gc_clientsystem.h"
		#include "client_community_market.h"			// for Market data in tooltips
		#include "econ_ui.h"							// for money-value-to-display-string formatting
		#include "store/store_panel.h"					// for money-value-to-display-string formatting
	#endif // CLIENT_DLL
#endif // GC


#ifdef PROJECT_TF
	#include "tf_duel_summary.h"
	#include "econ_contribution.h"
	#include "tf_player_info.h"
	#include "tf_wardata.h"

	#ifdef TF_CLIENT_DLL
		#include "tf_gamerules.h"
		#include "tf_mapinfo.h"
	#endif 
#endif

#ifdef VPROF_ENABLED
	static const char *g_pszEconDescriptionVprofGroup = _T("Econ Description");
#endif

extern const char *GetWearLocalizationString( float flWear );

// --------------------------------------------------------------------------
// Local Helper
// --------------------------------------------------------------------------
const size_t k_VerboseStringBufferSize = 128;
static char *BuildVerboseStrings( char buf[k_VerboseStringBufferSize], bool bIsVerbose, const char *format, ... )
{
	if ( !bIsVerbose )
		return NULL;

	va_list argptr;
	va_start( argptr, format );
	Q_vsnprintf( buf, k_VerboseStringBufferSize, format, argptr );
	va_end(argptr);

	return buf;
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
static bool IsStorePreviewItem( const IEconItemInterface *pEconItem )
{
	Assert( pEconItem );

#ifdef CLIENT_DLL
	return pEconItem->GetFlags() & kEconItemFlagClient_StoreItem;
#else
	return false;
#endif
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void IEconItemDescription::YieldingFillOutEconItemDescription( IEconItemDescription *out_pDescription, CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	VPROF_BUDGET( "IEconItemDescription::YieldingFillOutEconItemDescription()", g_pszEconDescriptionVprofGroup );

	Assert( out_pDescription );
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	out_pDescription->YieldingCacheDescriptionData( pLocalizationProvider, pEconItem );
	out_pDescription->GenerateDescriptionLines( pLocalizationProvider, pEconItem );
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
const econ_item_description_line_t *IEconItemDescription::GetFirstLineWithMetaType( uint32 unMetaTypeSearchFlags ) const
{
	for ( unsigned int i = 0; i < GetLineCount(); i++ )
	{
		const econ_item_description_line_t& pLine = GetLine(i);
		if ( (pLine.unMetaType & unMetaTypeSearchFlags) == unMetaTypeSearchFlags )
			return &pLine;
	}

	return NULL;
}

#ifdef BUILD_ITEM_NAME_AND_DESC

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
CLocalizedStringArg<CLocalizedRTime32>::CLocalizedStringArg( const CLocalizedRTime32& cTimeIn )
{
#if TF_ANTI_IDLEBOT_VERIFICATION
	// We expect the client and the GC to display dates and times differently in certain situations (ie.,
	// they may disagree on whether to display in GMT). Rather than trying to find the specific cases where
	// they might agree and let them through, we just early out and feed back the empty string for all
	// date/time formatting when doing client verification.
	if ( cTimeIn.m_pHashContext )
		return;
#endif

	CRTime cTime( cTimeIn.m_unTime );

	// The GC will always display time in GMT. "Local time" isn't a useful thing from a client's perspective
	// when viewing an item in the Steam Community, etc.
#ifdef GC_DLL
	cTime.SetToGMT( true );
#else
	cTime.SetToGMT( cTimeIn.m_bForceGMTOnClient );
#endif

	const locchar_t *loc_LocalizationFormat = cTimeIn.m_pLocalizationProvider->Find( cTime.BIsGMT() ? "Econ_DateFormat_GMT" : "Econ_DateFormat" );

	time_t tTime = cTime.GetRTime32();
	struct tm tmStruct;
	struct tm *ptm = cTime.BIsGMT() ? Plat_gmtime( &tTime, &tmStruct ) : Plat_localtime( &tTime, &tmStruct );

	time_t tFinalTime = mktime( ptm );
	
	char rgchDateBuf[ 128 ];
	BGetLocalFormattedDate( tFinalTime, rgchDateBuf, sizeof( rgchDateBuf ) );

	KeyValues *pKeyValues = new KeyValues( "DateTokens" );

	pKeyValues->SetString( "day", &rgchDateBuf[0] );
	pKeyValues->SetInt( "hour", cTime.GetHour() );
	pKeyValues->SetString( "min", CFmtStr( "%02u", cTime.GetMinute() ).Access() );
	pKeyValues->SetString( "sec", CFmtStr( "%02u", cTime.GetSecond() ).Access() );

	m_Str = CConstructLocalizedString( loc_LocalizationFormat, pKeyValues );

	pKeyValues->deleteThis();
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::YieldingFillOutAccountPersonaName( const CLocalizationProvider *pLocalizationProvider, uint32 unAccountID )
{
	Assert( pLocalizationProvider );
 
	// Never cache invalid accounts.
	if ( unAccountID == 0 )
	return;
 
	// Make sure we have a cache entry for this account ID. If we're hashing, we won't fill
	// this with real data to avoid discrepancies between the GC view of a persona name and the
	// client view, both of which are cached differently. If we're not hashing, we'll do our best
	// to find the current name. Either way, by the time this function ends we expect to have a
	// value stored for this account ID.
	CEconItemDescription::steam_account_persona_name_t& AccountPersona = vecPersonaNames[ vecPersonaNames.AddToTail() ];
	AccountPersona.unAccountID = unAccountID;
 
#if TF_ANTI_IDLEBOT_VERIFICATION
	// Force persona names to match "verify" between the client and the GC for verification.
	if ( m_pHashContext )
	{
		AccountPersona.loc_sPersonaName = LOCCHAR("verify");
	}
	else
#endif // TF_ANTI_IDLEBOT_VERIFICATION
	{
		const char *utf8_PersonaName = NULL;
 
#ifdef GC
		CSteamID steamID( unAccountID, GCSDK::GGCHost()->GetUniverse(), k_EAccountTypeIndividual );
		utf8_PersonaName = GGCGameBase()->YieldingGetPersonaName( steamID );
#else // if defined( CLIENT_DLL )
		utf8_PersonaName = InventoryManager()->PersonaName_Get( unAccountID );
#endif

#if defined( CLIENT_DLL )
		m_bUnknownPlayer = Q_strncmp( utf8_PersonaName, "[unknown]", ARRAYSIZE( "[unknown]" ) ) == 0;
#endif
 
		// We should have filled this in with something by now, even if that something is "we couldn't
		// find useful information".
		Assert( utf8_PersonaName );
 
		// Convert our UTF8 to whatever we're using for localized display, and done.
		pLocalizationProvider->ConvertUTF8ToLocchar( utf8_PersonaName, &AccountPersona.loc_sPersonaName );
	}
 
	Assert( !AccountPersona.loc_sPersonaName.IsEmpty() );
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
const locchar_t *CEconItemDescription::FindAccountPersonaName( uint32 unAccountID ) const
{
	FOR_EACH_VEC( vecPersonaNames, i )
	{
		if ( vecPersonaNames[i].unAccountID == unAccountID )
			return vecPersonaNames[i].loc_sPersonaName.Get();
	}

	// FIXME: add localization token
	return LOCCHAR("Unknown User");
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::YieldingFillOutAccountTypeCache( uint32 unAccountID, int nClassID )
{
	if( !unAccountID )
		return;

#ifdef GC_DLL
	CEconSharedObjectCache *pSOCache = GGCEcon()->YieldingFindOrLoadEconSOCache( CSteamID( unAccountID, GCSDK::GGCHost()->GetUniverse(), k_EAccountTypeIndividual ) );
#else // if defined( CLIENT_DLL )
	EUniverse eUniverse = GetUniverse();

	if ( eUniverse == k_EUniverseInvalid )
		return;

	GCSDK::CGCClientSharedObjectCache *pSOCache = GCClientSystem()->GetSOCache( CSteamID( unAccountID, eUniverse, k_EAccountTypeIndividual ) );
#endif
	if ( !pSOCache )
		return;

	GCSDK::CSharedObjectTypeCache *pTypeCache = pSOCache->FindTypeCache( nClassID );
	if ( !pTypeCache )
		return;

	CEconItemDescription::steam_account_type_cache_t& AccountTypeCache = vecTypeCaches[ vecTypeCaches.AddToTail() ];

	AccountTypeCache.unAccountID = unAccountID;
	AccountTypeCache.nClassID	 = nClassID;
	AccountTypeCache.pTypeCache	 = pTypeCache;
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
GCSDK::CSharedObjectTypeCache *CEconItemDescription::FindAccountTypeCache( uint32 unAccountID, int nClassID ) const
{
	FOR_EACH_VEC( vecTypeCaches, i )
	{
		if ( vecTypeCaches[i].unAccountID == unAccountID &&
			 vecTypeCaches[i].nClassID == nClassID )
		{
			return vecTypeCaches[i].pTypeCache;
		}
	}

	return NULL;
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
template < typename T >
const T *CEconItemDescription::FindAccountTypeCacheSingleton( uint32 unAccountID, int nClassID ) const
{
	GCSDK::CSharedObjectTypeCache *pSOTypeCache = FindAccountTypeCache( unAccountID, nClassID );
	if ( !pSOTypeCache )
		return NULL;

	if ( pSOTypeCache->GetCount() != 1 )
		return NULL;

	return dynamic_cast<T *>( pSOTypeCache->GetObject( 0 ) );
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::YieldingCacheDescriptionData( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	VPROF_BUDGET( "CEconItemDescription::YieldingCacheDescriptionData()", g_pszEconDescriptionVprofGroup );
	
	vecPersonaNames.Purge();
	vecTypeCaches.Purge();

	// For each attribute that is set to display as an account ID, load the persona name for that account
	// ID in advance so that we don't yield somewhere crazy down below.
	
	// Walk our attribute list and accumulate IDs.
	CSteamAccountIDAttributeCollector AccountIDCollector;
	pEconItem->IterateAttributes( &AccountIDCollector );
	const CUtlVector<uint32>& vecSteamAccountIDs = AccountIDCollector.GetAccountIDs();

	// Look up the persona names for each account referenced by an attribute directly.
	FOR_EACH_VEC( vecSteamAccountIDs, i )
	{
		YieldingFillOutAccountPersonaName( pLocalizationProvider, vecSteamAccountIDs[i] );
	}

	// Look up the persona names for each account referencing an attribute indirectly (ie., just stuffed
	// into 32 bits).
	for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
	{
		uint32 unRestrictionType;
		if ( pEconItem->FindAttribute( GetKillEaterAttr_Restriction(i), &unRestrictionType ) &&
			 unRestrictionType == kStrangeEventRestriction_VictimSteamAccount )
		{
			uint32 unAccountID;
			DbgVerify( pEconItem->FindAttribute( GetKillEaterAttr_RestrictionValue(i), &unAccountID ) );
			YieldingFillOutAccountPersonaName( pLocalizationProvider, unAccountID );
		}
	}

#ifdef PROJECT_TF
	uint32 unAccountID = pEconItem->GetAccountID();

	// Duel summary.
	{
		// We'll need to access other information about our duel stats later, but we also need to precache
		// the account name of whoever our last kill was beforehand.
		YieldingFillOutAccountTypeCache( unAccountID, CTFDuelSummary::k_nTypeID );

		// In TF, we also store information about our previous duel target, stored way way down inside some
		// other structures.
		const CTFDuelSummary *pDuelSummary = FindAccountTypeCacheSingleton<CTFDuelSummary>( unAccountID, CTFDuelSummary::k_nTypeID );

		if ( pDuelSummary )
		{
			YieldingFillOutAccountPersonaName( pLocalizationProvider, pDuelSummary->Obj().last_duel_account_id() );
		}
	}

	// Map contributions.
	YieldingFillOutAccountTypeCache( unAccountID, CTFMapContribution::k_nTypeID );

	// New users helped.
	YieldingFillOutAccountTypeCache( unAccountID, CTFPlayerInfo::k_nTypeID );

	// War data
	YieldingFillOutAccountTypeCache( unAccountID, CWarData::k_nTypeID );

#ifdef CLIENT_DLL
	// Duck LeaderBoards
	{
		static CSchemaAttributeDefHandle pAttrDef_DisplayDuckLeaderboard( "display duck leaderboard" );
		if ( pEconItem->FindAttribute( pAttrDef_DisplayDuckLeaderboard ) )
		{
			CUtlVector< AccountID_t > accountIds;
			Leaderboards_GetDuckLeaderboardSteamIDs( accountIds );

			FOR_EACH_VEC( accountIds, i )
			{
				// Look up the persona names for each account referenced in the leaderboard
				YieldingFillOutAccountPersonaName( pLocalizationProvider, accountIds[i] );
			}
		}
	}
#endif // CLIENT_DLL

#if TF_ANTI_IDLEBOT_VERIFICATION
	if ( m_pHashContext )
	{
		// Feed in the account IDs of each person we care about. We don't feed in the actual persona name
		// string because this could theoretically differ between the GC and the client if one is out of sync.
		FOR_EACH_VEC( vecPersonaNames, i )
		{
			char verboseStringBuf[ k_VerboseStringBufferSize ];
			TFDescription_HashDataMunge( m_pHashContext, vecPersonaNames[i].unAccountID, m_bIsVerbose, BuildVerboseStrings( verboseStringBuf, m_bIsVerbose, "%d", vecPersonaNames[i].unAccountID ) );
		}

		// Are we in text mode or not? We'll use this to generate two different hashes to compare against.
		unsigned int unRunningTextMode = 
#ifdef GC_DLL
										  m_bTextModeEnabled
#else
										  *((bool *)g_pClientPurchaseInterface - 156)
#endif
									    ? 0x73aaff8e
										: 0x12800c0a;

		char verboseStringBuf[ k_VerboseStringBufferSize ];
		TFDescription_HashDataMunge( m_pHashContext, unRunningTextMode, m_bIsVerbose, BuildVerboseStrings( verboseStringBuf, m_bIsVerbose, "%d", unRunningTextMode ) );
	}
#endif // TF_ANTI_IBLEBOT_VERIFICATION

#endif // PROJECT_TF
}

void CEconItemDescription::GenerateDescriptionLines( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	VPROF_BUDGET( "CEconItemDescription::GenerateDescriptionLines()", g_pszEconDescriptionVprofGroup );

	Assert( pLocalizationProvider );
	Assert( pEconItem );

	m_vecDescLines.Purge();

	Generate_ItemName( pLocalizationProvider, pEconItem );
	Generate_ItemRarityDesc( pLocalizationProvider, pEconItem );
	Generate_ItemLevelDesc( pLocalizationProvider, pEconItem );
	//Generate_WearAmountDesc( pLocalizationProvider, pEconItem );
#if defined( STAGING_ONLY ) && defined( CLIENT_DLL )
	Generate_DebugInformation( pLocalizationProvider, pEconItem );
#endif

	// If we decide that for performance reasons some descriptions only want the name/description
	// information and not all the details, this is the block to skip over.
	{
		Generate_CraftTag( pLocalizationProvider, pEconItem );
		Generate_StyleDesc( pLocalizationProvider, pEconItem );
		Generate_Painted( pLocalizationProvider, pEconItem );

		Generate_HolidayRestriction( pLocalizationProvider, pEconItem );	
#ifdef PROJECT_TF
		Generate_SaxxyAwardDesc( pLocalizationProvider, pEconItem );
#endif // PROJECT_TF
		Generate_VisibleAttributes( pLocalizationProvider, pEconItem );

		Generate_QualityDesc( pLocalizationProvider, pEconItem );		
		Generate_ItemDesc( pLocalizationProvider, pEconItem );
		Generate_Bundle( pLocalizationProvider, pEconItem );
		Generate_GiftedBy( pLocalizationProvider, pEconItem );
#ifdef PROJECT_TF
		Generate_DuelingMedal( pLocalizationProvider, pEconItem );
		Generate_MapContributor( pLocalizationProvider, pEconItem );
		Generate_FriendlyHat( pLocalizationProvider, pEconItem );
		Generate_SquadSurplusClaimedBy( pLocalizationProvider, pEconItem );
		Generate_MvmChallenges( pLocalizationProvider, pEconItem );
		Generate_DynamicRecipe( pLocalizationProvider, pEconItem );
		Generate_Leaderboard( pLocalizationProvider, pEconItem );
#endif // PROJECT_TF
		Generate_XifierToolTargetItem( pLocalizationProvider, pEconItem );
		Generate_LootListDesc( pLocalizationProvider, pEconItem );
		Generate_EventDetail( pLocalizationProvider, pEconItem );
		Generate_ItemSetDesc( pLocalizationProvider, pEconItem );
		Generate_CollectionDesc( pLocalizationProvider, pEconItem );
		Generate_ExpirationDesc( pLocalizationProvider, pEconItem );
		Generate_DropPeriodDesc( pLocalizationProvider, pEconItem ); 

		Generate_MarketInformation( pLocalizationProvider, pEconItem );
		Generate_DirectX8Warning( pLocalizationProvider, pEconItem );
	}

	// Certain information (tradeability, etc.) used to only get displayed if we were the owning player, or
	// if we were looking at an unowned item (ie., a store preview) and want to show what it will look like
	// when it *is* owned. Unfortunately this led to problems where you wouldn't know if the item you were
	// about to be traded (currently not owned by you) would be craftable, etc.
	Generate_FlagsAttributes( pLocalizationProvider, pEconItem );
}

// --------------------------------------------------------------------------
// Purpose: Code to build up the item display name, including any relevant quality
//			strings, custom renaming, craft numbers, and anything else we decide
//			to throw at it.
// --------------------------------------------------------------------------

/*static*/ uint32 GetScoreTypeForKillEaterAttr( const IEconItemInterface *pEconItem, const CEconItemAttributeDefinition *pAttribDef )
{
	// What sort of event are we tracking? If we don't have an attribute at all we're one of the
	// old kill-eater weapons that didn't specify what it was tracking.
	uint32 unKillEaterEventType = 0;

	// This will overwrite our default 0 value if we have a value set but leave it if not.
	{
		float fKillEaterEventType;
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconItem, pAttribDef, &fKillEaterEventType ) )
		{
			unKillEaterEventType = fKillEaterEventType;
		}
	}

	return unKillEaterEventType;
}

// The item backend may add craft numbers well past what we want to display in the game. This
// function determines whether a given number should be visible rather than always showing
// whatever the GC shows.
bool ShouldDisplayCraftCounterValue( int iValue )
{
	return iValue > 0 && iValue <= 100;
}

// This function will return the localized string (ie., "Face-Melting") for a specific item based
// on the score it has accumulated.
#if defined( CLIENT_DLL ) && defined( STAGING_ONLY )
	ConVar staging_force_strange_score_selector_value( "staging_force_strange_score_selector_value", "-1" );
#endif // defined( CLIENT_DLL ) && defined( STAGING_ONLY )

class CStrangeRankLocalizationGenerator
{
public:
	CStrangeRankLocalizationGenerator( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem, bool bHashContextOff );

	bool IsValid() const { return m_bValid; }

	const locchar_t *GetRankLocalized() const { Assert( m_bValid ); return m_loc_Rank; }
	const locchar_t *GetRankSecondaryLocalized() const { Assert( m_bValid ); return m_loc_SecondaryRank; }

	uint32 GetStrangeType() const { Assert( m_bValid ); return m_unType; }
	uint32 GetStrangeScore() const { Assert( m_bValid ); return m_unScore; }
	uint32 GetUsedStrangeSlot() const { Assert( m_bValid ); return m_unUsedStrangeSlot; }

private:
	bool m_bValid;

	const locchar_t *m_loc_Rank;
	const locchar_t *m_loc_SecondaryRank;

	uint32 m_unType;
	uint32 m_unScore;
	uint32 m_unUsedStrangeSlot;
};

CStrangeRankLocalizationGenerator::CStrangeRankLocalizationGenerator( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem, bool bHashContextOff )
	: m_bValid( false )
	, m_loc_Rank( NULL )
	, m_loc_SecondaryRank( NULL )
	, m_unType( kKillEaterEvent_PlayerKill )
	, m_unScore( 0 )
	, m_unUsedStrangeSlot( 0 )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaAttributeDefHandle pAttrDef_StrangeScoreSelector( "strange score selector" );

	// Do we have a strange score selector attribute? If so, the value of this attribute will tell us which strange
	// attribute we're actually going to use to generate a name. Leaving this value as 0 will fall back to the
	// default behavior of looking at the base "kill eater" attribute.
	if ( pEconItem->FindAttribute( pAttrDef_StrangeScoreSelector, &m_unUsedStrangeSlot ) )
	{
		// Make sure the value we pulled from the database is within range.
		m_unUsedStrangeSlot = MIN( m_unUsedStrangeSlot, static_cast<uint32>( GetKillEaterAttrCount() ) );
	}

#if defined( CLIENT_DLL ) && defined( STAGING_ONLY )
	if ( staging_force_strange_score_selector_value.GetInt() > 0 )
	{
		m_unUsedStrangeSlot = staging_force_strange_score_selector_value.GetInt();
	}
#endif // defined( CLIENT_DLL ) && defined( STAGING_ONLY )

	// Use the strange prefix if the weapon has one.
	if ( !pEconItem->FindAttribute( GetKillEaterAttr_Score( m_unUsedStrangeSlot ), &m_unScore ) )
		return;

	// What type of event are we tracking and how does it describe itself?
	m_unType = GetScoreTypeForKillEaterAttr( pEconItem, GetKillEaterAttr_Type( m_unUsedStrangeSlot ) );

	const char *pszLevelingDataName = GetItemSchema()->GetKillEaterScoreTypeLevelingDataName( m_unType );
	if ( !pszLevelingDataName )
	{
		pszLevelingDataName = KILL_EATER_RANK_LEVEL_BLOCK_NAME;
	}

	uint32 uUsedScore = m_unScore;
#ifdef TF_ANTI_IDLEBOT_VERIFICATION	
	// TF2 Anti-Idle hack.  It totally needs to be fixed
	if ( !bHashContextOff )
	{
		uUsedScore = 0;
	}
#endif //TF_ANTI_IDLEBOT_VERIFICATION

	// For TF - Strange Scores reset on Trade, sharing that information is actually misleading so we'll always display base strange name
#ifdef TF_GC_DLL
	uUsedScore = 0;
#endif // TF_GC_DLL

	const CItemLevelingDefinition *pLevelDef = GetItemSchema()->GetItemLevelForScore( pszLevelingDataName, uUsedScore );
	if ( !pLevelDef )
		return;

	// Primary rank established!
	m_loc_Rank = pLocalizationProvider->Find( pLevelDef->GetNameLocalizationKey() );
	m_bValid = true;

	// Does this score slot have a restriction that adds additional text somewhere in the localization token?
	uint32 unFilterType;
	uint32 unFilterValue;
	if ( pEconItem->FindAttribute( GetKillEaterAttr_Restriction( m_unUsedStrangeSlot ), &unFilterType ) &&
		 pEconItem->FindAttribute( GetKillEaterAttr_RestrictionValue( m_unUsedStrangeSlot ), &unFilterValue ) )
	{
		// Game-specific code doesn't belong here. "We're shipping soon" hack fun!
#ifdef PROJECT_TF
		if ( unFilterType == kStrangeEventRestriction_Map )
		{
			const MapDef_t *pMap = GetItemSchema()->GetMasterMapDefByIndex( unFilterValue );
			if ( pMap && pMap->pszStrangePrefixLocKey )
			{
				m_loc_SecondaryRank = pLocalizationProvider->Find( pMap->pszStrangePrefixLocKey );
			}
		}
		else if (unFilterType == kStrangeEventRestriction_Competitive)
		{
			m_loc_SecondaryRank = pLocalizationProvider->Find( "TF_StrangeFilter_Prefix_Competitive" );
		}
#endif // PROJECT_TF
	}
}

// ---------------------------------------------------------------------------------------------------------------------------
void Econ_SetNameAsPaintkit( locchar_t( &out_pItemName )[MAX_ITEM_NAME_LENGTH], const CLocalizationProvider *pLocalizationProvider, CEconItemPaintKitDefinition *pPaintKit )
{
	if ( !pPaintKit )
		return;

	// Generate Paint kitted name
	// IE Purple Rain Sniper Rifle
	locchar_t tempName[MAX_ITEM_NAME_LENGTH];
	loc_scpy_safe( tempName, out_pItemName );
#ifndef GC
	//bool bAppendWeapon = wcsstr( pPaintKitStr, out_pItemName ) == NULL;
	g_pVGuiLocalize->ConstructString_safe( out_pItemName,
		LOCCHAR( "%s1" ),
		1,
		pLocalizationProvider->Find( pPaintKit->GetLocalizeName() ) );
#else
	// GC doesn't have g_pVGuiLocalize so we construct the painted gun string like this
	locchar_t *pPaintKitStr = pLocalizationProvider->Find( pPaintKit->GetLocalizeName() );
	loc_scpy_safe( out_pItemName, pPaintKitStr ? pPaintKitStr : LOCCHAR( "" ) );
#endif
}

// ---------------------------------------------------------------------------------------------------------------------------
void Econ_ConcatPaintKitName( locchar_t( &out_pItemName )[MAX_ITEM_NAME_LENGTH], const CLocalizationProvider *pLocalizationProvider, CEconItemPaintKitDefinition *pPaintKit )
{
	if ( !pPaintKit )
		return;

	// Check to see if the paintkit localized name already has the weapon name, if so do not add (Weapon)
	locchar_t *pPaintKitStr = pLocalizationProvider->FindSafe( pPaintKit->GetLocalizeName() );

	locchar_t tempName[MAX_ITEM_NAME_LENGTH];
	loc_scpy_safe( tempName, out_pItemName );

#ifndef GC
	bool bAppendWeapon = wcsstr( pPaintKitStr, out_pItemName ) == NULL;
	// Generate Paint kitted name
	// IE Purple Rain Sniper Rifle

	if ( bAppendWeapon )
	{
		g_pVGuiLocalize->ConstructString_safe( out_pItemName,
			LOCCHAR("%s1 (%s2)"),
			2,
			pPaintKitStr,
			tempName );
	}
	else
	{
		g_pVGuiLocalize->ConstructString_safe( out_pItemName,
			LOCCHAR("%s1"),
			1,
			pPaintKitStr
		);
	}
#else
	// GC doesn't have g_pVGuiLocalize so we construct the painted gun string like this
	bool bAppendWeapon = V_strstr( pPaintKitStr, out_pItemName ) == NULL;
	// Generate Paint kitted name
	// IE Purple Rain Sniper Rifle
	loc_scpy_safe( out_pItemName, pPaintKitStr ? pPaintKitStr : LOCCHAR( "" ) );
	if ( bAppendWeapon )
	{
		loc_scat_safe( out_pItemName, LOCCHAR( " " ) );
		loc_scat_safe( out_pItemName, tempName );
	}
#endif
}

// ---------------------------------------------------------------------------------------------------------------------------
void Econ_ConcatPaintKitWear( locchar_t( &out_pItemName )[MAX_ITEM_NAME_LENGTH], const CLocalizationProvider *pLocalizationProvider, float flWear )
{
	if ( flWear <= 0.0 )
		return;

#ifndef GC
	locchar_t tempName[MAX_ITEM_NAME_LENGTH];
	loc_scpy_safe( tempName, out_pItemName );

	g_pVGuiLocalize->ConstructString_safe( out_pItemName,
		LOCCHAR( "%s1 (%s2)" ),
		2,
		tempName,
		pLocalizationProvider->Find( GetWearLocalizationString( flWear ) ) 
	);
#else
	// GC doesn't have g_pVGuiLocalize so we construct the painted gun string like this
	locchar_t *pWearStr = pLocalizationProvider->Find( GetWearLocalizationString( flWear ) );
	loc_scat_safe( out_pItemName, LOCCHAR( " (" ) );
	loc_scat_safe( out_pItemName, pWearStr ? pWearStr : LOCCHAR( "" ) );
	loc_scat_safe( out_pItemName, LOCCHAR( ")" ) );
#endif
}
// ---------------------------------------------------------------------------------------------------------------------------
static bool GetLocalizedBaseItemName( locchar_t (&szItemName)[MAX_ITEM_NAME_LENGTH], const CLocalizationProvider *pLocalizationProvider, const CEconItemDefinition *pEconItemDefinition )
{
	if ( pEconItemDefinition->GetItemBaseName() )
	{
		const locchar_t *pLocalizedItemName = pLocalizationProvider->Find( pEconItemDefinition->GetItemBaseName() );
		if ( !pLocalizedItemName || !pLocalizedItemName[0] )
		{
			// Couldn't localize it, just use it raw
			pLocalizationProvider->ConvertUTF8ToLocchar( pEconItemDefinition->GetItemBaseName(), szItemName, ARRAYSIZE( szItemName ) );
		}
		else
		{
			loc_scpy_safe( szItemName, pLocalizedItemName );
		}

		return true;
	}
	
	return false;
}

// Given the item in pEconItem and the localization provider passed in, stuff the correct *localized*
// string into out_pItemName.
static void GenerateLocalizedFullItemName
(
	locchar_t (&out_pItemName)[MAX_ITEM_NAME_LENGTH],
	const CLocalizationProvider	*pLocalizationProvider,
	const IEconItemInterface	*pEconItem,
	EGenerateLocalizedFullItemNameFlag_t eFlagsMask,
	bool						bHashContextOff
)
{
	bool bUseProperName = bHashContextOff;
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static const locchar_t *s_pUnknownItemName = LOCCHAR("Unknown Item");

	const CEconItemDefinition *pEconItemDefinition = pEconItem->GetItemDefinition();
	if ( !pEconItemDefinition )
	{
		out_pItemName[0] = (locchar_t)0;
		return;
	}

	bool bIgnoreQualityAndWear = false;
	bool bIgnoreNameWithPaintkit = false;
	bool bHasCustomName = false;
	if ( eFlagsMask == k_EGenerateLocalizedFullItemName_Default )
	{
		bIgnoreQualityAndWear = pEconItem->GetCustomPainkKitDefinition() ? true : false;
	}

	if ( eFlagsMask == k_EGenerateLocalizedFullItemName_WithPaintkitNoItem )
	{
		bIgnoreNameWithPaintkit = pEconItem->GetCustomPainkKitDefinition() ? true : false;
		bIgnoreQualityAndWear = pEconItem->GetCustomPainkKitDefinition() ? true : false;
	}

	// Figure out which localization pattern we're using. By default we assume we're using the common "[Quality] [Item Name]"
	// format, but if we're a unique item with an article we'll change this later on.
	const char *pszLocalizationPattern = "ItemNameFormat";

	// Start with the base name.
	locchar_t szItemName[ MAX_ITEM_NAME_LENGTH ];

	static CSchemaAttributeDefHandle pAttrDef_ItemNameTextOverride( "item name text override" );
	CAttribute_String attrItemNameTextOverride;
	// Check if we ahve a item name override
	if ( pEconItem->FindAttribute( pAttrDef_ItemNameTextOverride, &attrItemNameTextOverride ) )
	{
		const locchar_t *pNameOverrideString = pLocalizationProvider->Find( attrItemNameTextOverride.value().c_str() );
		if ( pNameOverrideString )
		{
			loc_scpy_safe( szItemName, pNameOverrideString );
			bHasCustomName = true;
		}
	}
	else if( !GetLocalizedBaseItemName( szItemName, pLocalizationProvider, pEconItemDefinition ) )
	{
		loc_scpy_safe( szItemName, s_pUnknownItemName );
	}

	// Check for killstreak attribute
	enum { kKillStreakLength = 64, };
	locchar_t szKillStreak[ kKillStreakLength ] = LOCCHAR("");
	static CSchemaAttributeDefHandle pAttrDef_KillStreak( "killstreak tier" );
	uint32 nKillStreakValue;

	if ( pEconItem->FindAttribute( pAttrDef_KillStreak, &nKillStreakValue ) && !bIgnoreQualityAndWear )
	{
		nKillStreakValue = (float&)(nKillStreakValue);

		// if you have the eyeballs you are automatically higher tier
		static CSchemaAttributeDefHandle pAttrDef_KillStreakEyes( "killstreak effect" );
		static CSchemaAttributeDefHandle pAttrDef_KillStreakSheen( "killstreak idleeffect" );
		if ( pEconItem->FindAttribute( pAttrDef_KillStreakEyes ) )
		{
			nKillStreakValue = 3;	// professional
		}
		else if ( pEconItem->FindAttribute( pAttrDef_KillStreakSheen ) )
		{
			nKillStreakValue = 2;	// specialized
		}

		const locchar_t *pKillStreakLocalizedString = NULL;
		
		// All tier-1 killstreaks have idle effect 1
		if ( nKillStreakValue == 1 )
		{
			pKillStreakLocalizedString = pLocalizationProvider->Find( "ItemNameKillStreakv0" );
		}
		else if ( nKillStreakValue == 2 )
		{
			pKillStreakLocalizedString = pLocalizationProvider->Find( "ItemNameKillStreakv1" );
		}
		else // Tier-2's are things above 1
		{
			pKillStreakLocalizedString = pLocalizationProvider->Find( "ItemNameKillStreakv2" );
		}

		if ( pKillStreakLocalizedString )
		{
			loc_scpy_safe( szKillStreak, pKillStreakLocalizedString );
			//  If we're appending some sort of killstreak identifier, dont use the proper name
			bUseProperName = false;
		}
	}

	// Check to see if we have a quality text override attribute.  We can get this when a temporary item
	// comes in from a crafting recipe that needs to get its name generated, and wants to specify that it 
	// takes in any quality
	static CSchemaAttributeDefHandle pAttrDef_QualityTextOverride( "quality text override" );
	CAttribute_String attrQualityTextOverride;
	pEconItem->FindAttribute( pAttrDef_QualityTextOverride, &attrQualityTextOverride );

	// Generate our quality string.
	enum { kQualityLength = 128, };
	locchar_t szQuality[ kQualityLength ] = LOCCHAR("");

	// Unique names may have a prefix or not, and so use a different format. (This is less to deal
	// with the space after "The" and more to deal with foreign languages that want to display unique
	// and non-unique items differently.
	const uint8 unQuality = pEconItem->GetQuality();
	if ( unQuality == AE_SELFMADE || ( !bIgnoreQualityAndWear ) )
	{
		// It's possible to get in here with a quality of -1 if we're dealing with an item view that has no
		// associated item. In that case we're probably doing something like browsing the armory, and in any
		// event don't have an item and so don't have a quality and so we just don't show a quality string.
		// If we have a quality text override, use that.
		const char *pszQualityLocalizationString = attrQualityTextOverride.has_value() 
												 ? attrQualityTextOverride.value().c_str()
												 : EconQuality_GetLocalizationString( (EEconItemQuality)unQuality );

		if ( unQuality > 0 && pszQualityLocalizationString && unQuality != AE_PAINTKITWEAPON )
		{
			// Unique items use proper names, but not if we have a quality text override
			if ( unQuality == AE_UNIQUE && !attrQualityTextOverride.has_value() )
			{
				const locchar_t *pszArticleContent = NULL;				
				if ( bUseProperName && pEconItemDefinition->HasProperName() )
				{
					pszArticleContent = pLocalizationProvider->Find( "TF_Unique_Prepend_Proper" );
				}
				
				// If the language isn't supposed to have articles or we just haven't provided one yet, fall
				// back to the empty string.
				if ( !pszArticleContent )
				{
					pszArticleContent = LOCCHAR("");
				}

				loc_scpy_safe( szQuality, pszArticleContent );
			}
			// Any quality besides unique ignores "proper name" articles.
			else
			{
				const locchar_t *pQualityLocalizedString = pLocalizationProvider->Find( pszQualityLocalizationString );
				if ( pQualityLocalizedString )
				{
					loc_scpy_safe( szQuality, pQualityLocalizedString );
					loc_scat_safe( szQuality, LOCCHAR(" ") );
				}
			}
		}

		{
			static CSchemaAttributeDefHandle pAttrDef_HideStrangePrefix( "hide_strange_prefix" );
			if ( !pAttrDef_HideStrangePrefix || !pEconItem->FindAttribute( pAttrDef_HideStrangePrefix ) )
			{
				//
				CStrangeRankLocalizationGenerator RankGenerator( pLocalizationProvider, pEconItem, bHashContextOff );
				if ( RankGenerator.IsValid() )
				{
					// If the quality of this item is special (not just strange) persist and append that value
					// Otherwise the ranker will replace the 'strange' quality tag with a strange rank
					if ( unQuality == AE_STRANGE )
					{
						loc_scpy_safe( szQuality,
								   CConstructLocalizedString( LOCCHAR("%s1%s2 "),
															  RankGenerator.GetRankLocalized(),
															  RankGenerator.GetRankSecondaryLocalized() ? RankGenerator.GetRankSecondaryLocalized() : LOCCHAR("") ) );
					}
					else // Strange Unusual Something
					{
						loc_scpy_safe( szQuality,
								   CConstructLocalizedString( LOCCHAR("%s1%s2 %s3"),
															  RankGenerator.GetRankLocalized(),
															  RankGenerator.GetRankSecondaryLocalized() ? RankGenerator.GetRankSecondaryLocalized() : LOCCHAR(""),
															  szQuality) );
					}
				}
			}
		}
	}

	static CSchemaAttributeDefHandle pAttrDef_IsAustralium( "is australium item" );
	enum { kAustraliumLength = 64, };
	locchar_t szAustraliumSkin[ kAustraliumLength ] = LOCCHAR("");
	if ( pAttrDef_IsAustralium && pEconItem->FindAttribute( pAttrDef_IsAustralium ) )
	{
		const locchar_t *pAustraliumLocalizedString = pLocalizationProvider->Find( "ItemNameAustralium" );
		if ( pAustraliumLocalizedString )
		{
			loc_scpy_safe( szAustraliumSkin, pAustraliumLocalizedString );
		}
	}
	
	static CSchemaAttributeDefHandle pAttrDef_IsFestivized( "is_festivized" );
	enum { kFestiveLength = 64, };
	locchar_t szIsFestivized[kFestiveLength] = LOCCHAR( "" );
	if ( pAttrDef_IsFestivized && pEconItem->FindAttribute( pAttrDef_IsFestivized ) )
	{
		// TODO : update ItemNameFestive in tf_english to Festivized later to differentiate Festive vs Festivized
		const locchar_t *pFestivizedLocalizedString = pLocalizationProvider->Find( "ItemNameFestive" );
		if ( pFestivizedLocalizedString )
		{
			loc_scpy_safe( szIsFestivized, pFestivizedLocalizedString );
		}
	}

	const char* pszQualityFormat = ( !attrQualityTextOverride.has_value() && ( unQuality == AE_NORMAL || unQuality == AE_UNIQUE || unQuality == AE_PAINTKITWEAPON || bIgnoreQualityAndWear ) && unQuality != AE_SELFMADE ) 
								 ? "ItemNameNormalOrUniqueQualityFormat" 
								 : "ItemNameQualityFormat";

	// TODO : Make Generic
	// Journal Leveling
	uint32 unDuckBadgeLevel;
	static CSchemaAttributeDefHandle pAttrDef_DuckBadgeLevel( "duck rating" );
	enum { kDuckBadgeLength = 64, };
	locchar_t szDuckBadge[kDuckBadgeLength] = LOCCHAR("");
	{	//if ( pItem && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttr_DuckLevelBadge, &iDuckBadgeLevel ) )
		if ( pAttrDef_DuckBadgeLevel && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconItem, pAttrDef_DuckBadgeLevel, &unDuckBadgeLevel ) && unDuckBadgeLevel != 0 )
		{
			const CItemLevelingDefinition *pLevelDef = GetItemSchema()->GetItemLevelForScore( "Journal_DuckBadge", unDuckBadgeLevel );
			if ( pLevelDef )
			{
				loc_scpy_safe( szDuckBadge, pLocalizationProvider->Find( pLevelDef->GetNameLocalizationKey() ) );
				loc_scat_safe( szDuckBadge, LOCCHAR(" ") );
			}
		}
	}

	// Strange Unusual Festive Killstreak Australium ducks
	loc_scpy_safe( szQuality, CConstructLocalizedString( pLocalizationProvider->Find( pszQualityFormat ), szQuality, szIsFestivized, szKillStreak, szAustraliumSkin, szDuckBadge ) );

	enum { kLocalizedCrateSeriesLength = 128, };
	locchar_t szLocalizedCrateSeries[ kLocalizedCrateSeriesLength ] = LOCCHAR("");

#ifdef PROJECT_TF
	static CSchemaAttributeDefHandle pAttrDef_SupplyCrateSeries( "set supply crate series" );
	// do not display series number for crates that have a collection reference
	if ( pAttrDef_SupplyCrateSeries && pEconItemDefinition->GetItemClass() && !Q_stricmp( pEconItemDefinition->GetItemClass(), "supply_crate" ) && !pEconItemDefinition->GetCollectionReference() )
	{
		// It's a crate, find a series #
		uint32 unSupplyCrateSeries;
		float fSupplyCrateSeries;
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconItem, pAttrDef_SupplyCrateSeries, &fSupplyCrateSeries ) && fSupplyCrateSeries != 0.0f )
		{
			unSupplyCrateSeries = fSupplyCrateSeries;

			loc_scpy_safe( szLocalizedCrateSeries,
						   CConstructLocalizedString( pLocalizationProvider->Find( "ItemNameCraftSeries" ),
													  unSupplyCrateSeries ) );
		}
	}

	// This is not "crate series number"; this is "release series number", ie., "a series 3 chemistry kit".
	static CSchemaAttributeDefHandle pAttrDef_SeriesNumber( "series number" );
	if ( pAttrDef_SeriesNumber )
	{
		float flSeriesNumber = 0.0f;
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconItem, pAttrDef_SeriesNumber, &flSeriesNumber ) && flSeriesNumber != 0.0f )
		{
			uint32 unSeriesNumber = flSeriesNumber;

			loc_scpy_safe( szLocalizedCrateSeries,
						   CConstructLocalizedString( pLocalizationProvider->Find( "ItemNameCraftSeries" ),
													  unSeriesNumber ) );
		}
	}
#endif

	// Were we one of the first couple that were crafted? If so, output our craft number as well.
	locchar_t *pCraftNumberLocFormat = pLocalizationProvider->Find( "ItemNameCraftNumberFormat" );

	enum { kLocalizedCraftIndexLength = 128, };
	locchar_t szLocalizedCraftIndex[ kLocalizedCraftIndexLength ] = LOCCHAR("");

	if ( pCraftNumberLocFormat )
	{
		static CSchemaAttributeDefHandle pAttrDef_UniqueCraftIndex( "unique craft index" );

		uint32 unCraftIndex;
		if ( pEconItem->FindAttribute( pAttrDef_UniqueCraftIndex, &unCraftIndex ) &&
			 ShouldDisplayCraftCounterValue( unCraftIndex ) )
		{
			locchar_t szCraftNumber[ kLocalizedCraftIndexLength ];
			loc_sprintf_safe( szCraftNumber, LOCCHAR( "%i" ), unCraftIndex );
				
			ILocalize::ConstructString_safe( szLocalizedCraftIndex,
										pCraftNumberLocFormat,
										1,
										szCraftNumber );
		}
	}

	// Generate tool application string
	enum { kToolApplicationNameLength = 128, };
	locchar_t szToolTargetNameName[ kToolApplicationNameLength ] = LOCCHAR("");
	locchar_t szDynamicRecipeOutputName[ kToolApplicationNameLength ] = LOCCHAR("");

	static CSchemaAttributeDefHandle pAttribDef_ToolTarget( "tool target item" );
	if( pAttribDef_ToolTarget && pEconItem->GetItemDefinition()->GetItemClass() && !Q_stricmp( pEconItem->GetItemDefinition()->GetItemClass(), "tool" ) )
	{
		// It's a tool, see if it has a tool target item attribute
		float flItemDef;
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconItem, pAttribDef_ToolTarget, &flItemDef ) )
		{
			const item_definition_index_t unItemDef = flItemDef;

			locchar_t szTargetItemName[ MAX_ITEM_NAME_LENGTH ] = LOCCHAR("Unknown Item");

			// Get base name of target item
			const CEconItemDefinition *pEconTargetDef = GetItemSchema()->GetItemDefinition( unItemDef );
			if ( pEconTargetDef )
			{
				GetLocalizedBaseItemName( szTargetItemName, pLocalizationProvider, pEconTargetDef );
			}

			loc_scpy_safe( szToolTargetNameName,
					   CConstructLocalizedString( pLocalizationProvider->Find( "ItemNameToolTargetNameFormat" ),
					                              szTargetItemName ) );
		}
		else
		{
			CRecipeComponentMatchingIterator componentIterator( pEconItem, NULL );
			pEconItem->IterateAttributes( &componentIterator );

			// It only makes sense to mention the output if there's only 1 output
			if( componentIterator.GetMatchingComponentOutputs().Count() == 1 )
			{
				CAttribute_DynamicRecipeComponent attribValue;
				pEconItem->FindAttribute( componentIterator.GetMatchingComponentOutputs().Head(), &attribValue );

				CEconItem tempItem;
				if ( !DecodeItemFromEncodedAttributeString( attribValue, &tempItem ) )
				{
					AssertMsg2( 0, "%s: Unable to decode dynamic recipe output attribute on item %llu.", __FUNCTION__, pEconItem->GetID() );
				}
				else
				{
					locchar_t loc_ItemName[MAX_ITEM_NAME_LENGTH];
					GenerateLocalizedFullItemName( loc_ItemName, pLocalizationProvider, &tempItem, k_EGenerateLocalizedFullItemName_Default, false );
			
					loc_scpy_safe( szDynamicRecipeOutputName,
						   CConstructLocalizedString( pLocalizationProvider->Find( "ItemNameDynamicRecipeTargetNameFormat" ),
													  loc_ItemName ) );
				}
			}
		}
	}


	// PaintKit and Wear
	if ( !bHasCustomName )
	{
		CEconItemPaintKitDefinition *pPaintKit = pEconItem->GetCustomPainkKitDefinition();
		if ( pPaintKit )
		{
			if ( bIgnoreNameWithPaintkit )
			{
				Econ_SetNameAsPaintkit( szItemName, pLocalizationProvider, pPaintKit ); 
			}
			else
			{
				Econ_ConcatPaintKitName( szItemName, pLocalizationProvider, pPaintKit );
				if ( !bIgnoreQualityAndWear )
				{
					float flWear = 0;
					if ( pEconItem->GetCustomPaintKitWear( flWear ) )
					{
						Econ_ConcatPaintKitWear( szItemName, pLocalizationProvider, flWear );
					}
				}
			}
		}
	}

	locchar_t *pNameLocalizationFormat = pLocalizationProvider->Find( pszLocalizationPattern );

	if ( pNameLocalizationFormat )
	{
		ILocalize::ConstructString_safe( out_pItemName,
									pNameLocalizationFormat,
									6,
									szQuality,
									szItemName,
									szLocalizedCraftIndex,
									szLocalizedCrateSeries,
									szToolTargetNameName,
									szDynamicRecipeOutputName);
	}
	else
	{
		loc_scpy_safe( out_pItemName, s_pUnknownItemName );
	}
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::Generate_ItemName( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	// If this item has a custom name, use it instead of doing our crazy name compositing based on quality,
	// type, etc.
	const char *utf8_CustomName = pEconItem->GetCustomName();

	if ( utf8_CustomName && utf8_CustomName[0] )
	{
		locchar_t loc_CustomName[ MAX_ITEM_NAME_LENGTH ];
		pLocalizationProvider->ConvertUTF8ToLocchar( utf8_CustomName, loc_CustomName, sizeof( loc_CustomName ) );

		// Store it in the item name, wrapped in quotes to prevent item name spoofing
		// We use two single quotes, because the double quote isn't very visible in the TF2 font
		locchar_t loc_CustomNameWithQuotes[ MAX_ITEM_NAME_LENGTH ];
		loc_scpy_safe( loc_CustomNameWithQuotes, LOCCHAR("''") );
		loc_scat_safe( loc_CustomNameWithQuotes, loc_CustomName );
		loc_scat_safe( loc_CustomNameWithQuotes, LOCCHAR("''") );

		AddDescLine( loc_CustomNameWithQuotes, /* this will be ignored: */ ATTRIB_COL_LEVEL, kDescLineFlag_Name );
	}
	else
	{
		locchar_t loc_ItemName[MAX_ITEM_NAME_LENGTH];
		GenerateLocalizedFullItemName( loc_ItemName, pLocalizationProvider, pEconItem, k_EGenerateLocalizedFullItemName_WithPaintkitNoItem, m_pHashContext == NULL );

		AddDescLine( loc_ItemName, /* this will be ignored: */ ATTRIB_COL_LEVEL, kDescLineFlag_Name );
	}
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
const locchar_t *GetLocalizedStringForKillEaterTypeAttr( const CLocalizationProvider *pLocalizationProvider, uint32 unKillEaterEventType )
{
	Assert( pLocalizationProvider );
	
	// Generate localized string.
	const char *pszLocString = GetItemSchema()->GetKillEaterScoreTypeLocString( unKillEaterEventType );

	return pszLocString != NULL
		 ? pLocalizationProvider->Find( pszLocString )
		 : LOCCHAR("");
}

class CStrangeRestrictionAttrWrapper
{
public:
	CStrangeRestrictionAttrWrapper( const CLocalizationProvider *pLocalizationProvider, const locchar_t *loc_In )
		: m_str( loc_In ? pLocalizationProvider->Find( "ItemTypeDescStrangeFilterSubStr" ) : LOCCHAR(""), loc_In ? loc_In : LOCCHAR("") )
	{
		//
	}

	const locchar_t *operator *() const
	{
		return static_cast<const locchar_t *>( m_str );
	}

private:
	CConstructLocalizedString m_str;
};

const locchar_t *CEconItemDescription::GetLocalizedStringForStrangeRestrictionAttr( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem, int iAttrIndex ) const
{
	uint32 unRestrictionType;
	uint32 unRestrictionValue;
	if ( !pEconItem->FindAttribute( GetKillEaterAttr_Restriction( iAttrIndex ), &unRestrictionType ) ||
		 !pEconItem->FindAttribute( GetKillEaterAttr_RestrictionValue( iAttrIndex ), &unRestrictionValue ) ||
		 unRestrictionType == kStrangeEventRestriction_None )
	{
		return NULL;
	}

	switch ( unRestrictionType )
	{
#ifdef PROJECT_TF
	case kStrangeEventRestriction_Map:
	{
		const MapDef_t *pMap = GetItemSchema()->GetMasterMapDefByIndex( unRestrictionValue );
		if ( pMap )
			return pLocalizationProvider->Find( pMap->pszMapNameLocKey );
	}
	case kStrangeEventRestriction_Competitive:
	{
		return pLocalizationProvider->Find( "ItemTypeDescStrangeFilterCompetitive" );
	}
#endif // PROJECT_TF

	case kStrangeEventRestriction_VictimSteamAccount:
		return FindAccountPersonaName( unRestrictionValue );
	}

	return NULL;
}

bool CEconItemDescription::BGenerate_ItemLevelDesc_StrangeNameAndStats( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem, const locchar_t *locTypename )
{
	CStrangeRankLocalizationGenerator RankGenerator( pLocalizationProvider, pEconItem, m_pHashContext == NULL );
	if ( !RankGenerator.IsValid() )
		return false;
	
	// For Collection Items
	if ( pEconItem->GetCustomPainkKitDefinition() )
	{
		AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "Attrib_stattrakmodule" ), RankGenerator.GetRankLocalized() ), 
			ATTRIB_COL_STRANGE, 
			kDescLineFlag_Misc 
		);
		
		// Are we tracking alternate stats as well?
		for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
		{
			const CEconItemAttributeDefinition *pKillEaterAltAttrDef = GetKillEaterAttr_Score( i ),
				*pKillEaterAltScoreTypeAttrDef = GetKillEaterAttr_Type( i );
			if ( !pKillEaterAltAttrDef || !pKillEaterAltScoreTypeAttrDef )
				continue;

			uint32 unKillEaterAltScore;
			if ( !pEconItem->FindAttribute( pKillEaterAltAttrDef, &unKillEaterAltScore ) )
				continue;

			// Older items can optionally not specify a type attribute at all and have an implicit "I'm tracking
			// kills" zeroth attribute. We require a score type for any slot besides that.
			if ( i != 0 && !pEconItem->FindAttribute( pKillEaterAltScoreTypeAttrDef ) )
				continue;

			const uint32 unKillEaterAltType = GetScoreTypeForKillEaterAttr( pEconItem, pKillEaterAltScoreTypeAttrDef );

			AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "ItemTypeDescKillEaterAltv2" ),
				unKillEaterAltScore,
				GetLocalizedStringForKillEaterTypeAttr( pLocalizationProvider, unKillEaterAltType ),
				*CStrangeRestrictionAttrWrapper( pLocalizationProvider, GetLocalizedStringForStrangeRestrictionAttr( pLocalizationProvider, pEconItem, i ) ) ),
				ATTRIB_COL_LEVEL,
				kDescLineFlag_Misc );		// strange item scores past the first are not considered part of the type
		}

		return true;
	} // End Collection Items

	// Normal old way

	// Look for Limited Item Attr
	bool bLimitedQuantity = false;
	static CSchemaAttributeDefHandle pAttrDef_LimitedQuantityItem( "limited quantity item" );
	bLimitedQuantity = pEconItem->FindAttribute( pAttrDef_LimitedQuantityItem );

	AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "ItemTypeDescKillEater" ),
												RankGenerator.GetRankLocalized(),
												locTypename ? locTypename : LOCCHAR(""),
												RankGenerator.GetStrangeScore(),
												GetLocalizedStringForKillEaterTypeAttr( pLocalizationProvider, RankGenerator.GetStrangeType() ),
												*CStrangeRestrictionAttrWrapper( pLocalizationProvider, GetLocalizedStringForStrangeRestrictionAttr( pLocalizationProvider, pEconItem, RankGenerator.GetUsedStrangeSlot() ) ),
												RankGenerator.GetRankSecondaryLocalized() ? RankGenerator.GetRankSecondaryLocalized() : LOCCHAR(""), 
												bLimitedQuantity ? pLocalizationProvider->Find( "LimitedQualityDesc" ) : LOCCHAR("")
												),
					bLimitedQuantity ? ATTRIB_COL_LIMITED_QUANTITY : ATTRIB_COL_LEVEL,
					kDescLineFlag_Type );

	// Are we tracking alternate stats as well?
	for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
	{
		const CEconItemAttributeDefinition *pKillEaterAltAttrDef			= GetKillEaterAttr_Score(i),
										   *pKillEaterAltScoreTypeAttrDef	= GetKillEaterAttr_Type(i);
		if ( !pKillEaterAltAttrDef || !pKillEaterAltScoreTypeAttrDef )
			continue;

		uint32 unKillEaterAltScore;
		if ( !pEconItem->FindAttribute( pKillEaterAltAttrDef, &unKillEaterAltScore ) )
			continue;

		// Older items can optionally not specify a type attribute at all and have an implicit "I'm tracking
		// kills" zeroth attribute. We require a score type for any slot besides that.
		if ( i != 0 && !pEconItem->FindAttribute( pKillEaterAltScoreTypeAttrDef ) )
			continue;

		const uint32 unKillEaterAltType = GetScoreTypeForKillEaterAttr( pEconItem, pKillEaterAltScoreTypeAttrDef );
			
		// Skip if this is our primary stat and we already output it above.
		if ( unKillEaterAltType == RankGenerator.GetStrangeType() )
			continue;

		AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "ItemTypeDescKillEaterAlt" ),
												unKillEaterAltScore,
												GetLocalizedStringForKillEaterTypeAttr( pLocalizationProvider, unKillEaterAltType ),
												*CStrangeRestrictionAttrWrapper( pLocalizationProvider, GetLocalizedStringForStrangeRestrictionAttr( pLocalizationProvider, pEconItem, i ) ) ),
					 ATTRIB_COL_LEVEL,
					 kDescLineFlag_Misc );		// strange item scores past the first are not considered part of the type
	}

	return true;
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
uint32 GetItemDescriptionDisplayLevel( const IEconItemInterface *pEconItem )
{
	Assert( pEconItem );

	static CSchemaAttributeDefHandle pAttrDef_WideItemLevel( "wide item level" );

	uint32 unWideLevelValue;
	if ( pEconItem->FindAttribute( pAttrDef_WideItemLevel, &unWideLevelValue ) )
		return unWideLevelValue;

	return pEconItem->GetItemLevel();
}

void CEconItemDescription::Generate_ItemLevelDesc_Default( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem, const locchar_t *locTypename )
{
	// By default, items will only show the level if there is an item type to go along with it.
	// Combined, these will build a string like "Level 10 Shotgun". We allow a custom attribute
	// to force the level to be displayed by itself even if there is no item class ("Level 10").
	static CSchemaAttributeDefHandle pAttrDef_ForceLevelDisplay( "force_level_display" );

	item_definition_index_t usDefIndex = pEconItem->GetItemDefIndex();


#ifdef CLIENT_DLL
	const bool bIsStoreItem = IsStorePreviewItem( pEconItem );
	const bool bIsPreviewItem = pEconItem->GetFlags() & kEconItemFlagClient_Preview;

	// If the item doesn't have a valid itemID, we'll just use the locTypename for the item level description. 
	// We don't want to display "Level 0 Hat" in places like the Mann Co. Store and Armory. We'll just display "Hat".
	if ( bIsStoreItem || bIsPreviewItem || pEconItem->GetItemDefinition()->GetRarity() != k_unItemRarity_Any )
	{
		if ( locTypename && *locTypename )
		{
			AddDescLine( locTypename, ATTRIB_COL_LEVEL, kDescLineFlag_Type, NULL, usDefIndex );
		}
		return;
	}
#endif

	float fForceLevelDisplayValue;
	bool bForceLevelDisplay = FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconItem, pAttrDef_ForceLevelDisplay, &fForceLevelDisplayValue )
							&& fForceLevelDisplayValue > 0.0f;
		
	if ( ( locTypename && *locTypename ) || bForceLevelDisplay )
	{
		if ( locTypename )
		{
			// How are we going to format our level number and base type string?
			const locchar_t *pszFormatString = NULL;

#ifdef PROJECT_TF
			static CSchemaAttributeDefHandle pAttrDef_OverrideItemLevelDescString( CTFItemSchema::k_rchOverrideItemLevelDescStringAttribName );
			static const char *s_pszCustomItemLevelDescLocalizationTokens[] =
			{
				"ItemTypeDescCustomLevelString_MvMTour",
			};

			// ...are we going to use a custom format string specified in an attribute?
			uint32 unOverrideItemLevelDescString = 0;
			if ( pEconItem->FindAttribute( pAttrDef_OverrideItemLevelDescString, &unOverrideItemLevelDescString )
				&& unOverrideItemLevelDescString != 0
				&& unOverrideItemLevelDescString <= ARRAYSIZE( s_pszCustomItemLevelDescLocalizationTokens ) ) 
			{
				const char *pszLevelLocalizationToken = s_pszCustomItemLevelDescLocalizationTokens[ unOverrideItemLevelDescString - 1 ];
				Assert( pszLevelLocalizationToken );

				pszFormatString = pLocalizationProvider->Find( pszLevelLocalizationToken );
			}
#endif // PROJECT_TF

			// Either we didn't have a custom override attribute, or we did and it had an invalid value, or it had a valid
			// value but the localization system failed to find something for that key. In any event, we fall back to our default
			// format string here.
			if ( pszFormatString == NULL )
			{
				bool bLimitedQuantity = false;
				static CSchemaAttributeDefHandle pAttrDef_LimitedQuantityItem( "limited quantity item" );
				bLimitedQuantity = pEconItem->FindAttribute( pAttrDef_LimitedQuantityItem );

#if defined( TF_CLIENT_DLL )
				if ( pEconItem->GetItemDefinition()->GetItemClass() && V_strcmp( pEconItem->GetItemDefinition()->GetItemClass(), "map_token" ) == 0 )
				{
					// For map stamps on the client we can show how many hours they've played each map
					// And how many times they've donated to it instead of the generic "level"
					for ( int i = 0; i < GetItemSchema()->GetMapCount(); i++ )
					{
						const MapDef_t* pMap = GetItemSchema()->GetMasterMapDefByIndex( i );

						if ( pMap->mapStampDef != pEconItem->GetItemDefinition() )
							continue;

						int nItemLevel = MapInfo_GetDonationAmount( steamapicontext->SteamUser()->GetSteamID().GetAccountID(), pMap->pszMapName );

						MapStats_t &mapStats = GetMapStats( pMap->GetStatsIdentifier() );
						int nNumHours = ( mapStats.accumulated.m_iStat[TFMAPSTAT_PLAYTIME] ) / ( 60 /*sec*/ * 60 /*min*/ );

						AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "ItemTypeDescCustomLevelString_MapStamp" ), (uint32)nItemLevel, (uint32)nNumHours ), ATTRIB_COL_LEVEL, kDescLineFlag_Type );
						return;
					}
				}
				else 
#endif
				{
					if ( bLimitedQuantity )
					{
						// Limited Item Description
						pszFormatString = pLocalizationProvider->Find( "ItemTypeDescLimited" );
						AddDescLine( CConstructLocalizedString(
								pszFormatString,
								GetItemDescriptionDisplayLevel( pEconItem ),
								locTypename,
								pLocalizationProvider->Find( "LimitedQualityDesc" ) ),
							ATTRIB_COL_LIMITED_QUANTITY,
							kDescLineFlag_Type,
							NULL,
							usDefIndex
							);
						return;
					}
					pszFormatString = pLocalizationProvider->Find( "ItemTypeDesc" );
				}
			}

			// If we still don't have a format string here, it means our default also failed, but CConstructLocalizedString will
			// handle that safely.
			AddDescLine( CConstructLocalizedString( pszFormatString, GetItemDescriptionDisplayLevel( pEconItem ), locTypename ), ATTRIB_COL_LEVEL, kDescLineFlag_Type, NULL, usDefIndex );
		}
		else
		{
			Assert( bForceLevelDisplay );

			AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "ItemTypeDescNoLevel" ), GetItemDescriptionDisplayLevel( pEconItem ) ), ATTRIB_COL_LEVEL, kDescLineFlag_Type, NULL, usDefIndex );
		}
	}
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::Generate_ItemLevelDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const GameItemDefinition_t *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	const locchar_t *locTypename = pLocalizationProvider->Find( pItemDef->GetItemTypeName() );

	// Kill-eating weapons replace the standard weapon name/level line with a label
	// describing the current class of the item instead of the level. This overrides
	// even "force_level_display".
	if ( BGenerate_ItemLevelDesc_StrangeNameAndStats( pLocalizationProvider, pEconItem, locTypename ) )
		return;

	// Not strange, but if you are paint kitted or have a collection reference dont create this
	if ( pEconItem->GetCustomPainkKitDefinition() || pItemDef->GetCollectionReference() )
		return;

	// If we didn't generate a fancy strange name, we fall back to our default behavior.
	Generate_ItemLevelDesc_Default( pLocalizationProvider, pEconItem, locTypename );
}

#if defined( STAGING_ONLY ) && defined( CLIENT_DLL )
ConVar econ_include_debug_item_description( "econ_include_debug_item_description","0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE, "Controls display of the additional debug fields in CEconItemDescription (definition index, etc.)." );

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::Generate_DebugInformation( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	if ( !econ_include_debug_item_description.GetBool() )
		return;

#if TF_ANTI_IDLEBOT_VERIFICATION
	// Adding these extra description lines would mess with our GC/client sync.
	if ( m_pHashContext )
		return;
#endif // TF_ANTI_IDLEBOT_VERIFICATION

	AddDescLine( CConstructLocalizedString( LOCCHAR("([ Item ID: %s1 ])"), pEconItem->GetID() ), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
	AddDescLine( CConstructLocalizedString( LOCCHAR("([ Item Definition Index: %s1 ])"), (uint32)pEconItem->GetItemDefIndex() ), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
	AddDescLine( CConstructLocalizedString( LOCCHAR("([ In Use?: %s1 ])"), pEconItem->GetInUse() ? LOCCHAR("true") : LOCCHAR("false") ), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
	AddEmptyDescLine();

	class CDebugAttributeDisplayer : public IEconItemAttributeIterator
	{
	public:
		CDebugAttributeDisplayer( CEconItemDescription *pOut_Desc ) : m_pDesc( pOut_Desc ) { Assert( m_pDesc ); }

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, attrib_value_t value ) OVERRIDE
		{
			// Ugh.
			wchar_t wszAttrDef[ 256 ];
			ILocalize::ConvertANSIToUnicode( pAttrDef->GetDefinitionName(), &wszAttrDef[0], sizeof( wszAttrDef ) );

			m_pDesc->AddDescLine( CConstructLocalizedString( LOCCHAR("([ Attribute [%s1]: '%s2' ( %s3 | %s4 ) ])"),
															 (uint32)pAttrDef->GetDefinitionIndex(),
															 wszAttrDef,
															 *(uint32 *)&value,
															 *(float *)&value ), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );

			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, float value ) OVERRIDE
		{
			// Ugh.
			wchar_t wszAttrDef[ 256 ];
			ILocalize::ConvertANSIToUnicode( pAttrDef->GetDefinitionName(), &wszAttrDef[0], sizeof( wszAttrDef ) );

			m_pDesc->AddDescLine( CConstructLocalizedString( LOCCHAR("([ Attribute [%s1]: '%s2' ( %f ) ])"),
															 (uint32)pAttrDef->GetDefinitionIndex(),
															 wszAttrDef,
															 value ), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );

			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const uint64& value ) OVERRIDE
		{
			// Ugh.
			wchar_t wszAttrDef[ 256 ];
			ILocalize::ConvertANSIToUnicode( pAttrDef->GetDefinitionName(), &wszAttrDef[0], sizeof( wszAttrDef ) );

			m_pDesc->AddDescLine( CConstructLocalizedString( LOCCHAR("([ Attribute [%s1]: '%s2' ( %llu ) ])"),
															 (uint32)pAttrDef->GetDefinitionIndex(),
															 wszAttrDef,
															 value ), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );

			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_String& value ) OVERRIDE
		{
			// Ugh.
			wchar_t wszAttrDef[ 256 ];
			ILocalize::ConvertANSIToUnicode( pAttrDef->GetDefinitionName(), &wszAttrDef[0], sizeof( wszAttrDef ) );

			wchar_t wszAttrContents[ 1024 ];
			ILocalize::ConvertANSIToUnicode( value.value().c_str(), &wszAttrContents[0], sizeof( wszAttrContents ) );

			m_pDesc->AddDescLine( CConstructLocalizedString( LOCCHAR("([ Attribute [%s1]: '%s2' ( \"%s3\" ) ])"),
															 (uint32)pAttrDef->GetDefinitionIndex(),
															 wszAttrDef,
															 wszAttrContents ), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_DynamicRecipeComponent& value ) OVERRIDE
		{
			const char* pszItemName = GetItemSchema()->GetItemDefinition( value.def_index() )->GetItemBaseName();

			wchar_t wszItemQuality[ 256 ];
			ILocalize::ConvertANSIToUnicode( EconQuality_GetQualityString(EEconItemQuality(value.item_quality())), &wszItemQuality[0], sizeof( wszItemQuality ) );

			wchar_t wszAttrString[ 256 ];
			ILocalize::ConvertANSIToUnicode(  value.attributes_string().c_str(), &wszAttrString[0], sizeof( wszAttrString ) );

			wchar_t wszCount[ 64 ];
			ILocalize::ConvertANSIToUnicode( CFmtStr( "%d/%d", value.num_fulfilled(), value.num_required() ), &wszCount[0], sizeof( wszCount ) );

			locchar_t wszLocalizedItemName[ 128 ];
			const locchar_t *pLocalizedItemName = GLocalizationProvider()->Find( pszItemName );
			if ( pLocalizedItemName )
			{
				V_wcscpy_safe( wszLocalizedItemName, pLocalizedItemName );
			}
			else
			{
				// name wasn't found by Find(), so just convert the pszItemName
				ILocalize::ConvertANSIToUnicode( pszItemName, &wszLocalizedItemName[0], sizeof( wszLocalizedItemName ) );
			}

			m_pDesc->AddDescLine( CConstructLocalizedString( LOCCHAR( "\nItem: \"%s1\"\nQuality: %s2\nAttribs:%s3\nCount: %s4" ),
															 wszLocalizedItemName,
															 wszItemQuality,
															 wszAttrString,
															 wszCount ),
															 ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_ItemSlotCriteria& value ) OVERRIDE
		{
			// Ugh.
			wchar_t wszAttrDef[ 256 ];
			ILocalize::ConvertANSIToUnicode( pAttrDef->GetDefinitionName(), &wszAttrDef[0], sizeof( wszAttrDef ) );

			wchar_t wszAttrTags[ 256 ];
			ILocalize::ConvertANSIToUnicode( value.tags().c_str(), &wszAttrTags[0], sizeof( wszAttrTags ) );

			m_pDesc->AddDescLine( CConstructLocalizedString( LOCCHAR("([ Attribute [%s1]: '%s2'])\nTags: \"%s3\""),
															 (uint32)pAttrDef->GetDefinitionIndex(),
															 wszAttrDef,
															 wszAttrTags ),
															 ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_WorldItemPlacement& value ) OVERRIDE
		{
			wchar_t wszAttrDef[ 256 ];
			ILocalize::ConvertANSIToUnicode( pAttrDef->GetDefinitionName(), &wszAttrDef[0], sizeof( wszAttrDef ) );

			m_pDesc->AddDescLine( CConstructLocalizedString( LOCCHAR( "([ Attribute [%s1]: '%s2'])\n" ),
															 (uint32)pAttrDef->GetDefinitionIndex(),
															 wszAttrDef ),
															 ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
			return true;
		}

	private:
		CEconItemDescription *m_pDesc;
	};

	CDebugAttributeDisplayer DebugAttributeDisplayer( this );
	pEconItem->IterateAttributes( &DebugAttributeDisplayer );
}
#endif // defined( STAGING_ONLY ) && defined( CLIENT_DLL )

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::Generate_CraftTag( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaAttributeDefHandle pAttribDef_MakersMarkId( "makers mark id" );

	attrib_value_t value;
	if ( !pEconItem->FindAttribute( pAttribDef_MakersMarkId, &value ) )
		return;

	AddAttributeDescription( pLocalizationProvider, pAttribDef_MakersMarkId, value );
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::Generate_StyleDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const GameItemDefinition_t *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	const CEconStyleInfo *pStyle = pItemDef->GetStyleInfo( pEconItem->GetStyle() );
	if ( !pStyle )
		return;

	const locchar_t *loc_StyleName = pLocalizationProvider->Find( pStyle->GetName() );
	if ( !loc_StyleName )
		return;
	
	AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "#Econ_Style_Desc" ), loc_StyleName ), ATTRIB_COL_LEVEL, kDescLineFlag_Misc );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_HolidayRestriction( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const GameItemDefinition_t *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	const char *pszHolidayRestriction = pItemDef->GetHolidayRestriction();
	if ( !pszHolidayRestriction )
		return;

	// Report any special restrictions. We'll output in a different color depending on whether or not
	// the restriction currently prevents the item from showing up.
	LocalizedAddDescLine( pLocalizationProvider,
						  CFmtStr( "Econ_holiday_restriction_%s", pszHolidayRestriction ).Access(),
						  EconHolidays_IsHolidayActive( EconHolidays_GetHolidayForString( pszHolidayRestriction ), CRTime::RTime32TimeCur() ) ? ATTRIB_COL_LEVEL : ATTRIB_COL_NEGATIVE,
						  kDescLineFlag_Misc );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_QualityDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	// Does this item quality have additional description information that goes along with
	// besides the usual name/coloration changes?
	const char *pszQualityDescLocalizationKey = NULL;

	switch( pEconItem->GetQuality() )
	{
	case AE_SELFMADE:
		pszQualityDescLocalizationKey = "Attrib_Selfmade_Description";
		break;
	case AE_COMMUNITY:
		pszQualityDescLocalizationKey = "Attrib_Community_Description";
		break;
	}

	// We don't need to do anything special.
	if ( !pszQualityDescLocalizationKey )
		return;

	// If this item has a particle system attached but doesn't have the attribute that we usually use
	// to attach particles, we hack it and dump out an extra line to show the particle system description
	// as well.
	static CSchemaAttributeDefHandle pAttrDef_ParticleEffect( "attach particle effect" );
	static attachedparticlesystem_t *pSparkleSystem = GetItemSchema()->FindAttributeControlledParticleSystem( "community_sparkle" );

	// If the schema understands these properties...
	if ( pAttrDef_ParticleEffect && pSparkleSystem )
	{
		// ...and we don't have a real particle effect attribute attribute...
		if ( !pEconItem->FindAttribute( pAttrDef_ParticleEffect ) )
		{
			// check for Unusual Cap def index (1173)
			// We manually assign unusual effect to content author. No community sparkle
			if ( pEconItem->GetItemDefIndex() != 1173 )
			{
				// ...then manually add the description as if we did.
				float flSystemID = pSparkleSystem->nSystemID;
				AddAttributeDescription( pLocalizationProvider, pAttrDef_ParticleEffect, *(uint32*)&flSystemID );
			}
		}
	}

	LocalizedAddDescLine( pLocalizationProvider, pszQualityDescLocalizationKey, ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );
}

//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_ItemRarityDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	const CEconItemRarityDefinition* pItemRarity = GetItemSchema()->GetRarityDefinition( pEconItem->GetItemDefinition()->GetRarity() );
	if ( !pItemRarity )
		return;
	
	const GameItemDefinition_t *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	const char *pszTooltip = "TFUI_InvTooltip_Rarity";

	attrib_colors_t colorRarity = pItemRarity->GetAttribColor();

	const locchar_t *loc_RarityText = pLocalizationProvider->Find( pItemRarity->GetLocKey() );
	const locchar_t *locTypename = pLocalizationProvider->Find( pItemDef->GetItemTypeName() );
	const locchar_t *loc_WearText = LOCCHAR("");

	float flWear = 0;
	if ( pEconItem->GetCustomPaintKitWear( flWear ) )
	{
		loc_WearText = pLocalizationProvider->Find( GetWearLocalizationString( flWear ) );
	}
	else
	{
		pszTooltip = "TFUI_InvTooltip_RarityNoWear";
	}

	AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( pszTooltip ), loc_RarityText, locTypename, loc_WearText ), colorRarity, kDescLineFlag_Misc );
}


//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_WearAmountDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	if ( pEconItem->GetCustomPainkKitDefinition() == 0 )
		return;

	Assert( pLocalizationProvider );
	Assert( pEconItem );

	float flWear = 0;
	if ( pEconItem->GetCustomPaintKitWear( flWear ) )
	{
		locchar_t loc_WearText[MAX_ATTRIBUTE_DESCRIPTION_LENGTH];
		
		loc_scpy_safe( loc_WearText, pLocalizationProvider->Find( "#TFUI_InvTooltip_Wear" ) );
		loc_scat_safe( loc_WearText, LOCCHAR( " " ) );
		loc_scat_safe( loc_WearText, pLocalizationProvider->Find( GetWearLocalizationString( flWear ) ) );

		AddDescLine( loc_WearText, ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_ItemDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	// Show the custom description if it has one.
	const char *utf8_CustomDesc = pEconItem->GetCustomDesc();
	if ( utf8_CustomDesc && utf8_CustomDesc[0] )
	{
		locchar_t loc_CustomDesc[ MAX_ITEM_DESC_LENGTH ];
		pLocalizationProvider->ConvertUTF8ToLocchar( utf8_CustomDesc, loc_CustomDesc, sizeof( loc_CustomDesc ) );

		locchar_t loc_CustomDescWithQuotes[ MAX_ITEM_DESC_LENGTH ];
		loc_scpy_safe( loc_CustomDescWithQuotes, LOCCHAR("''") );
		loc_scat_safe( loc_CustomDescWithQuotes, loc_CustomDesc );
		loc_scat_safe( loc_CustomDescWithQuotes, LOCCHAR("''") );

		AddDescLine( loc_CustomDescWithQuotes, ATTRIB_COL_NEUTRAL, kDescLineFlag_Desc );
		return;
	}

	// No custom description -- see if the item has a default description as part of the definition.
	const GameItemDefinition_t *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	// Add any additional item description
	if ( pItemDef->GetItemDesc() )
	{
		LocalizedAddDescLine( pLocalizationProvider, pItemDef->GetItemDesc(), ATTRIB_COL_NEUTRAL, kDescLineFlag_Desc );
	}

	// If we're a store preview item, show the available styles in the tooltip so potential buyers
	// have more information.
	if ( IsStorePreviewItem( pEconItem ) )
	{
		if ( pItemDef && pItemDef->GetNumStyles() > 0 )
		{
			AddEmptyDescLine();
			LocalizedAddDescLine( pLocalizationProvider, "#Store_AvailableStyles_Header", ATTRIB_COL_LEVEL, kDescLineFlag_Misc );
			
			for ( int i = 0; i < pItemDef->GetNumStyles(); i++ )
			{
				LocalizedAddDescLine( pLocalizationProvider, pItemDef->GetStyleInfo( i )->GetName(), ATTRIB_COL_LEVEL, kDescLineFlag_Misc );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------

// If we have at least this many items in our bundle then display multiple entries
// per line. Otherwise display one item per line for clarity.
enum { kDescription_CompositeBundleEntriesCount = 15 };

void CEconItemDescription::Generate_Bundle( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const GameItemDefinition_t *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	const bundleinfo_t *pBundleInfo = pItemDef->GetBundleInfo();
	if ( !pBundleInfo )
		return;

	enum EBundleEntryDisplayStyle
	{
		kBundleDisplay_SingleEntry,			// one entry per line
		kBundleDisplay_PairEntry,			// "Some Item, Some Other Item," (with ending comma)
		kBundleDisplay_PairEntryFinal,		// "Some Item, Some Other Item" (with no ending comma)
	};

#ifdef GC_DLL
	AddEmptyDescLine();
#endif // GC_DLL

	CUtlVector< item_definition_index_t > vecPackBundlesAdded;

	FOR_EACH_VEC( pBundleInfo->vecItemDefs, i )
	{
		// Sanity check.
		const CEconItemDefinition *pBundleItemDef = pBundleInfo->vecItemDefs[i];
		if ( !pBundleItemDef )
			continue;

		// If the current item is part of a pack bundle, add the pack bundle to the description, rather than the individual item
#ifdef DOTA
		if ( pBundleItemDef->IsPackItem() )
		{
			const CUtlVector< CEconItemDefinition * > &vecPackBundleItemDefs = pBundleItemDef->GetOwningPackBundles();

			item_definition_index_t usPackBundleItemDefIndex = vecPackBundleItemDefs[i]->GetDefinitionIndex();
			if ( vecPackBundlesAdded.HasElement( usPackBundleItemDefIndex ) )
				continue;

			// Remember the def index so we don't add the reference to the pack bundle more than once
			vecPackBundlesAdded.AddToTail( usPackBundleItemDefIndex );

			// Now, point pBundleItemDef at the pack bundle itself and carry on
			pBundleItemDef = pPackBundleItemDef;
		}
#endif

		// Figure out which display style to use for this item. By default we put one item one each line...
		EBundleEntryDisplayStyle eDisplayStyle = kBundleDisplay_SingleEntry;
		
		// ...but if we have a whole bunch of items in a single bundle, we lump them together two per line to
		// save space. Only do this on the client. On the GC, use single lines so that link meta data can be passed
		// along per-line to the store bundle pages.
#if defined( CLIENT_DLL ) && !defined( TF_CLIENT_DLL )
		if ( pBundleInfo->vecItemDefs.Count() >= kDescription_CompositeBundleEntriesCount )
		{
			const int iRemainingItems = pBundleInfo->vecItemDefs.Count() - i;

			// We distinguish between "there are at least three entries left", which means we'll end the line
			// with a comma, etc.
			if ( iRemainingItems > 2 )
			{
				eDisplayStyle = kBundleDisplay_PairEntry;
			}
			// ...or if these are our very last two items, we list our last two items and that's it.
			else if ( iRemainingItems == 2 )
			{
				eDisplayStyle = kBundleDisplay_PairEntryFinal;
			}
		}
#endif

		if ( eDisplayStyle == kBundleDisplay_SingleEntry )
		{
			// pBundleItemDef will point at the pack bundle if pBundleItemDef is a pack item. In DotA, pack bundles *only* include pack items, whereas in TF, there are bundles which include some items where are individually for sale and others that are not. For example, the Scout Starter Bundle, etc.
#ifdef DOTA
			LocalizedAddDescLine( pLocalizationProvider, pBundleItemDef->GetItemBaseName(), ATTRIB_COL_BUNDLE_ITEM, kDescLineFlag_Misc, NULL, pBundleItemDef->GetDefinitionIndex() );
#else
			LocalizedAddDescLine( pLocalizationProvider, pBundleItemDef->GetItemBaseName(), pBundleItemDef->IsPackItem() ? ATTRIB_COL_NEUTRAL : ATTRIB_COL_BUNDLE_ITEM, kDescLineFlag_Misc, NULL, pBundleItemDef->IsPackItem() ? INVALID_ITEM_DEF_INDEX : pBundleItemDef->GetDefinitionIndex(), !pBundleItemDef->IsPackItem() );
#endif
		}
		else
		{
			Assert( eDisplayStyle == kBundleDisplay_PairEntry || eDisplayStyle == kBundleDisplay_PairEntryFinal );

			const CEconItemDefinition *pOtherBundleItem = pBundleInfo->vecItemDefs[i + 1];
			const char *pOtherBundleItemBaseName = pOtherBundleItem ? pOtherBundleItem->GetItemBaseName() : "";

			AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( eDisplayStyle == kBundleDisplay_PairEntryFinal ? "Econ_Bundle_Double" : "Econ_Bundle_DoubleContinued" ),
													pLocalizationProvider->Find( pBundleItemDef->GetItemBaseName() ),
													pLocalizationProvider->Find( pOtherBundleItemBaseName ) ),
						 ATTRIB_COL_BUNDLE_ITEM,
						 kDescLineFlag_Misc,
						 NULL,
						 pBundleItemDef->GetDefinitionIndex() );

			// We consumed a second element as well.
			i++;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_GiftedBy( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaAttributeDefHandle pAttrDef_GiftedBy( "gifter account id" );
	static CSchemaAttributeDefHandle pAttrDef_EventDate( "event date" );

	attrib_value_t val_GifterId;
	if ( pAttrDef_GiftedBy && pEconItem->FindAttribute( pAttrDef_GiftedBy, &val_GifterId ) )
	{
		// Who gifted us this present?
		AddAttributeDescription( pLocalizationProvider, pAttrDef_GiftedBy, val_GifterId );

		// Do we also have (optional) information about when it happened?
		attrib_value_t val_EventData;
		if ( pAttrDef_EventDate && pEconItem->FindAttribute( pAttrDef_EventDate, &val_EventData ) )
		{
			AddAttributeDescription( pLocalizationProvider, pAttrDef_EventDate, val_EventData );
		}
	}
}

#ifdef PROJECT_TF
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static bool IsDuelingMedal( const GameItemDefinition_t *pItemDef )
{
	static CSchemaItemDefHandle pAttrDef_DuelingMedals[] =
	{
		CSchemaItemDefHandle( "Duel Medal Bronze" ),	
		CSchemaItemDefHandle( "Duel Medal Silver" ),
		CSchemaItemDefHandle( "Duel Medal Gold" ),
		CSchemaItemDefHandle( "Duel Medal Plat" ),
	};

	Assert( pItemDef );

	for ( int i = 0; i < ARRAYSIZE( pAttrDef_DuelingMedals ); i++ )
		if ( pItemDef == pAttrDef_DuelingMedals[i] )
			return true;

	return false;
}

void CEconItemDescription::Generate_DuelingMedal( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaAttributeDefHandle pAttrDef_EventDate( "event date" );

	const GameItemDefinition_t *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	if ( !IsDuelingMedal( pItemDef ) )
		return;

	const CTFDuelSummary *pDuelSummary = FindAccountTypeCacheSingleton<CTFDuelSummary>( pEconItem->GetAccountID(), CTFDuelSummary::k_nTypeID );
	if ( !pDuelSummary )
		return;

	// Add the date received first.
	attrib_value_t value;
	if ( !pEconItem->FindAttribute( pAttrDef_EventDate, &value ) )
		return;

	// We feed our format-string parameters in via KeyValues.
	KeyValues *pKeyValues = new KeyValues( "DuelStrings" );

	CLocalizedRTime32 time = { pDuelSummary->Obj().last_duel_timestamp(), false, pLocalizationProvider TF_ANTI_IDLEBOT_VERIFICATION_ONLY_COMMA TF_ANTI_IDLEBOT_VERIFICATION_ONLY_ARG( m_pHashContext ) };

	TypedKeyValuesStringHelper<locchar_t>::Write( pKeyValues, "last_date",	 CLocalizedStringArg<CLocalizedRTime32>( time ).GetLocArg() );
	TypedKeyValuesStringHelper<locchar_t>::Write( pKeyValues, "wins",		 CLocalizedStringArg<uint32>( pDuelSummary->Obj().duel_wins() ).GetLocArg() );
	TypedKeyValuesStringHelper<locchar_t>::Write( pKeyValues, "last_target", FindAccountPersonaName( pDuelSummary->Obj().last_duel_account_id() ) );

	// What happened in our last duel? This will be used as a format string to wrap the above data.
	const char *pszTextFormat;
	switch ( pDuelSummary->Obj().last_duel_status() )
	{
	case kDuelStatus_Loss: 
		pszTextFormat = "#TF_Duel_Desc_Lost";
		break;
	case kDuelStatus_Tie:
		pszTextFormat = "#TF_Duel_Desc_Tied";
		break;
	case kDuelStatus_Win:
	default:
		pszTextFormat = "#TF_Duel_Desc_Won";
		break;
	}

	// Output our whole description.
	AddEmptyDescLine();
	AddAttributeDescription( pLocalizationProvider, pAttrDef_EventDate, value );
	AddEmptyDescLine();
	AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( pszTextFormat ), pKeyValues ), ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );

	pKeyValues->deleteThis();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_MapContributor( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaItemDefHandle pItemDef_WorldTraveler( "World Traveler" );
	if ( !pItemDef_WorldTraveler || pEconItem->GetItemDefinition() != pItemDef_WorldTraveler )
		return;

	GCSDK::CSharedObjectTypeCache *pTypeCache = FindAccountTypeCache( pEconItem->GetAccountID(), CTFMapContribution::k_nTypeID );
	if ( !pTypeCache )
		return;

	static const char *kDonationLevels[] =
	{
		"#TF_MapDonationLevel_Bronze",
		"#TF_MapDonationLevel_Silver",
		"#TF_MapDonationLevel_Gold",
		"#TF_MapDonationLevel_Platinum",
		"#TF_MapDonationLevel_Diamond",
		"#TF_MapDonationLevel_Australium1",
		"#TF_MapDonationLevel_Australium2",
		"#TF_MapDonationLevel_Australium3",
		"#TF_MapDonationLevel_Unobtainium"
	};
	const int kNumDonationLevels = ARRAYSIZE( kDonationLevels );
	const int kNumDonationsPerLevel = 25;

	CUtlVector<const CTFMapContribution *> vecContributionsPerLevel[ kNumDonationLevels ];

	for ( uint32 i = 0; i < pTypeCache->GetCount(); ++i )
	{
		CTFMapContribution *pMapContribution = (CTFMapContribution*)( pTypeCache->GetObject( i ) );
		const CEconItemDefinition *pMapItemDef = GetItemSchema()->GetItemDefinition( pMapContribution->Obj().def_index() );
		if ( pMapItemDef )
		{
			int iLevel = MIN( pMapContribution->Obj().contribution_level() / kNumDonationsPerLevel, kNumDonationLevels - 1 );
			vecContributionsPerLevel[iLevel].AddToTail( pMapContribution );
		}
	}
	for ( int i = 0; i < kNumDonationLevels; ++i )
	{
		const CUtlVector<const CTFMapContribution *>& vecContributions = vecContributionsPerLevel[i];
		if ( vecContributions.Count() > 0 )
		{
			// Add header like "Silver:" to show the level of contribution for each of the maps following.
			LocalizedAddDescLine( pLocalizationProvider, kDonationLevels[i], ATTRIB_COL_ITEMSET_NAME, kDescLineFlag_Misc );

			// Add a label showing the map names and number of contributions for each map.
			locchar_t tempDescription[MAX_ITEM_DESCRIPTION_LENGTH] = { 0 };
			FOR_EACH_VEC( vecContributions, j )
			{
				const CTFMapContribution *pMapContribution = vecContributions[j];
				const CEconItemDefinition *pMapItemDef = GetItemSchema()->GetItemDefinition( pMapContribution->Obj().def_index() );
				Assert( pMapItemDef );

				const char *pszMapNameLocalizationToken = pMapItemDef->GetDefinitionString( "map_name", NULL );
				if ( pszMapNameLocalizationToken )
				{
					loc_sncat( tempDescription,	
							   CConstructLocalizedString( pLocalizationProvider->Find( "#Attrib_MapDonation" ),
														  pLocalizationProvider->Find( pszMapNameLocalizationToken ),
														  (uint32)pMapContribution->Obj().contribution_level() ),
							   MAX_ITEM_DESCRIPTION_LENGTH );

					if ( j < ( vecContributions.Count() - 1 ) )
					{
						loc_sncat( tempDescription, LOCCHAR( ", " ), MAX_ITEM_DESCRIPTION_LENGTH );
					}
				}
			}

			if ( tempDescription[0] )
			{
				AddDescLine( tempDescription, ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_FriendlyHat( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaItemDefHandle pItemDef_FriendlyHat( "Friendly Item" );
	if ( !pItemDef_FriendlyHat || pEconItem->GetItemDefinition() != pItemDef_FriendlyHat )
		return;

	const CTFPlayerInfo *pPlayerInfo = FindAccountTypeCacheSingleton<CTFPlayerInfo>( pEconItem->GetAccountID(), CTFPlayerInfo::k_nTypeID );
	if ( !pPlayerInfo )
		return;

	AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "#Attrib_NewUsersHelped" ), (uint32)pPlayerInfo->Obj().num_new_users_helped() ), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_SaxxyAwardDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	// Don't display anything for items besides the Saxxy itself.
	static CSchemaItemDefHandle pItemDef_Saxxy( "Saxxy" );
	static CSchemaItemDefHandle pItemDef_MemoryMaker( "The Memory Maker" );
	if ( ( !pItemDef_Saxxy || pEconItem->GetItemDefinition() != pItemDef_Saxxy ) &&
		 ( !pItemDef_MemoryMaker || pEconItem->GetItemDefinition() != pItemDef_MemoryMaker ) )
	{
		return;
	}

	// Output our award category if present, or abort if absent.
	static CSchemaAttributeDefHandle pAttrDef_SaxxyAwardCategory( "saxxy award category" );
	static CSchemaAttributeDefHandle pAttrDef_EventDate( "event date" );

	uint32 unAwardCategory,
		   unEventDate;
	if ( !pEconItem->FindAttribute( pAttrDef_SaxxyAwardCategory, &unAwardCategory ) ||
		 !pEconItem->FindAttribute( pAttrDef_EventDate, &unEventDate ) )
	{
		return;
	}

	CRTime cTime( unEventDate );
	cTime.SetToGMT( false );

	const char *pszFormatString = "#Attrib_SaxxyAward";
	if ( pEconItem->GetItemDefinition() == pItemDef_MemoryMaker )
	{
		pszFormatString = "#Attrib_MemoryMakerAward";
	}

	AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( pszFormatString ),
											pLocalizationProvider->Find( CFmtStr( "Replay_Contest_Category%d", unAwardCategory ).Access() ),
											(uint32)cTime.GetYear() ),
			     ATTRIB_COL_POSITIVE,
				 kDescLineFlag_Misc );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_MvmChallenges( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	// Look for our "challenges completed" attribute. If we have this, we assume we're a badge
	// of some kind. If we don't, we don't display MvM information. This would be a little weird
	// for level 0 badges that have no completed challenges, but those are something that currently
	// exist.
	static CSchemaAttributeDefHandle pAttrDef_ChallengesCompleted( CTFItemSchema::k_rchMvMChallengeCompletedMaskAttribName );

	uint32 unMask = 0;
	if ( !pEconItem->FindAttribute( pAttrDef_ChallengesCompleted, &unMask ) )
		return;
	
	// Look through our list of MvM tours to figure out which badge this came from. The badge itself
	// doesn't know and we need this information to figure out which completion bits map to which
	// missions.
	const MvMTour_t *pTour = NULL;

	FOR_EACH_VEC( GetItemSchema()->GetMvmTours(), i )
	{
		const MvMTour_t& tour = GetItemSchema()->GetMvmTours()[i];

		if ( tour.m_pBadgeItemDef == pEconItem->GetItemDefinition() )
		{
			pTour = &tour;
			break;
		}
	}

	// Couldn't find a tour matching this badge? (This can happen if a client has a busted schema or if
	// we remove a tour for some reason.)
	if ( !pTour )
		return;

	const CUtlVector<MvMMission_t>& vecAllMissions = GetItemSchema()->GetMvmMissions();
	CUtlVector<int> vecCompletedMissions;

	FOR_EACH_VEC( pTour->m_vecMissions, i )
	{
		// Make sure our mission index is valid based on our current schema. If we're a client playing a
		// game during a GC roll, we could wind up looking at someone else's badge where they have a
		// mission that we don't understand.
		const int iMissionIndex = pTour->m_vecMissions[i].m_iMissionIndex;
		if ( !vecAllMissions.IsValidIndex( iMissionIndex ) )
			continue;

		const int iBadgeSlot = pTour->m_vecMissions[i].m_iBadgeSlot;
		if ( iBadgeSlot >= 0 && ((unMask & (1U << iBadgeSlot)) != 0) )
		{
			vecCompletedMissions.AddToTail( iMissionIndex );
		}
	}

	// Add a summary line for the number they have completed
	AddDescLine(
		CConstructLocalizedString(
			pLocalizationProvider->Find( "#Attrib_MvMChallengesCompletedSummary" ),
			uint32( vecCompletedMissions.Count() )
		),
		ATTRIB_COL_POSITIVE,
		kDescLineFlag_Misc
	);

	// Detail lines for each completed challenge
	FOR_EACH_VEC( vecCompletedMissions, i )
	{
		const MvMMission_t& mission = vecAllMissions[ vecCompletedMissions[i] ];
		const MvMMap_t& map = GetItemSchema()->GetMvmMaps()[ mission.m_iDisplayMapIndex ];
		const locchar_t *pszLocFmt = pLocalizationProvider->Find( "#Attrib_MvMChallengeCompletedDetail" );
		const locchar_t *pszLocMap = pLocalizationProvider->Find( map.m_sDisplayName.Get() );
		const locchar_t *pszLocChal = pLocalizationProvider->Find( mission.m_sDisplayName.Get() );
		if ( pszLocFmt && pszLocMap && pszLocChal )
		{
			CConstructLocalizedString locLine(
				pszLocFmt,
				pszLocMap,
				pszLocChal
			);
			AddDescLine(
				locLine,
				ATTRIB_COL_POSITIVE,
				kDescLineFlag_Misc
			);
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_SquadSurplusClaimedBy( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaAttributeDefHandle pAttrDef_SquadSurplusClaimer( "squad surplus claimer id" );
	static CSchemaAttributeDefHandle pAttrDef_EventDate( "event date" );

	attrib_value_t val_GifterId;
	if ( pAttrDef_SquadSurplusClaimer&& pEconItem->FindAttribute( pAttrDef_SquadSurplusClaimer, &val_GifterId ) )
	{
		// Who gifted us this present?
		AddAttributeDescription( pLocalizationProvider, pAttrDef_SquadSurplusClaimer, val_GifterId );

		// Do we also have (optional) information about when it happened?
		attrib_value_t val_EventData;
		if ( pAttrDef_EventDate && pEconItem->FindAttribute( pAttrDef_EventDate, &val_EventData ) )
		{
			AddAttributeDescription( pLocalizationProvider, pAttrDef_EventDate, val_EventData );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_DynamicRecipe( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	// Gather our attributes we care about
	CRecipeComponentMatchingIterator componentIterator( pEconItem, NULL );
	pEconItem->IterateAttributes( &componentIterator );

	// Nothing to say, bail!
	if( !componentIterator.GetMatchingComponentInputs().Count() && 
		!componentIterator.GetMatchingComponentOutputs().Count() )
	{
		return;
	}

	// Add the no partial complete tag if the attribute exists
	static CSchemaAttributeDefHandle pAttrib_NoPartialComplete( "recipe no partial complete" );
	if ( pEconItem->FindAttribute( pAttrib_NoPartialComplete ) )
	{
		LocalizedAddDescLine( pLocalizationProvider, "TF_ItemDynamic_Recipe_No_Partial_Completion", ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
	}

	AddEmptyDescLine();

	if ( componentIterator.GetMatchingComponentInputs().Count() )
	{
		// Print out item input header
		LocalizedAddDescLine( pLocalizationProvider, "TF_ItemDynamic_Recipe_Inputs", ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );
		// Print out inputs
		FOR_EACH_VEC( componentIterator.GetMatchingComponentInputs(), i )
		{
			CAttribute_DynamicRecipeComponent attribValue;
			pEconItem->FindAttribute( componentIterator.GetMatchingComponentInputs()[i], &attribValue );

			const GameItemDefinition_t *pItemDef = dynamic_cast<GameItemDefinition_t *>( GetItemSchema()->GetItemDefinition( attribValue.def_index() ) );
			if ( !pItemDef )
				continue;

			int nCount = attribValue.num_required() - attribValue.num_fulfilled();

			// This is a completed component.  We don't want to show it (for now)
			if( nCount == 0 )
				continue;

			CEconItem tempItem;
			if ( !DecodeItemFromEncodedAttributeString( attribValue, &tempItem ) )
			{
				AssertMsg2( 0, "%s: Unable to decode dynamic recipe input attribute on item %llu.", __FUNCTION__, pEconItem->GetID() );
				continue;
			}

			locchar_t lineItem[256];
			locchar_t loc_ItemName[MAX_ITEM_NAME_LENGTH];
			GenerateLocalizedFullItemName( loc_ItemName, pLocalizationProvider, &tempItem, k_EGenerateLocalizedFullItemName_Default, m_pHashContext == NULL );

			loc_sprintf_safe( lineItem, 
				              LOCCHAR("%s x %d"), 
							  loc_ItemName,
							  nCount 
			);

			AddDescLine( lineItem, ATTRIB_COL_ITEMSET_MISSING, kDescLineFlag_Misc );
		}

		AddEmptyDescLine();
	}

	// Print out outputs
	LocalizedAddDescLine( pLocalizationProvider, "TF_ItemDynamic_Recipe_Outputs", ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );
	FOR_EACH_VEC( componentIterator.GetMatchingComponentOutputs(), i )
	{
		CAttribute_DynamicRecipeComponent attribValue;
		pEconItem->FindAttribute( componentIterator.GetMatchingComponentOutputs()[i], &attribValue );

		CEconItem tempItem;
		if ( !DecodeItemFromEncodedAttributeString( attribValue, &tempItem ) )
		{
			AssertMsg2( 0, "%s: Unable to decode dynamic recipe output attribute on item %llu.", __FUNCTION__, pEconItem->GetID() );
			continue;
		}

		locchar_t loc_ItemName[MAX_ITEM_NAME_LENGTH];
		GenerateLocalizedFullItemName( loc_ItemName, pLocalizationProvider, &tempItem, k_EGenerateLocalizedFullItemName_Default, m_pHashContext == NULL );

		AddDescLine( loc_ItemName, /* this will be ignored: */ ATTRIB_COL_ITEMSET_MISSING, kDescLineFlag_Misc );

		// Iterate through the attributes on this temp item and have it store the attributes that should affect
		// this component's name.  Once we have that, have it fill out a temporary CEconItemDescription.
		CRecipeNameAttributeDisplayer recipeAttributeIterator;
		tempItem.IterateAttributes( &recipeAttributeIterator );
		recipeAttributeIterator.SortAttributes();
		CEconItemDescription tempDescription;
		recipeAttributeIterator.Finalize( &tempItem, &tempDescription, pLocalizationProvider );

		// Check if that temp CEconItemDescription has any attributes we want.  If so, steal them.
		if ( tempDescription.m_vecDescLines.Count() > 0 )
		{
			locchar_t loc_Attribs[MAX_ITEM_NAME_LENGTH] = LOCCHAR("");

			// Put the attributes on the next line in parenthesis
			loc_scat_safe( loc_Attribs, LOCCHAR("(") );

			// Put in each attribute
			FOR_EACH_VEC( tempDescription.m_vecDescLines, j )
			{
				// Comma separated
				if ( j > 0 )
				{
					loc_scat_safe( loc_Attribs, LOCCHAR(", ") );
				}

				loc_sprintf_safe( loc_Attribs,
								  LOCCHAR("%s%s"),
								  loc_Attribs,
								  tempDescription.m_vecDescLines[j].sText.Get() );
			}

			loc_scat_safe( loc_Attribs, LOCCHAR(")") );

			// Print out in the same color as the item name above
			AddDescLine( loc_Attribs, /* this will be ignored: */ ATTRIB_COL_ITEMSET_MISSING, kDescLineFlag_Misc );
		}
	}
}

//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_Leaderboard( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
#ifdef GC_DLL
	return;
#endif

#ifdef TF_CLIENT_DLL
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaAttributeDefHandle pAttrDef_DisplayDuckLeaderboard( "display duck leaderboard" );
	
	if ( pEconItem->FindAttribute( pAttrDef_DisplayDuckLeaderboard ) )
	{
		// Friend Board
		//locchar_t lineItem[256];
		//		
		//AddDescLine( pLocalizationProvider->Find( "#TF_DuckLeaderboard_Friends" ), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
		//
		//CUtlVector< LeaderboardEntry_t > scores;
		//Leaderboards_GetDuckLeaderboard( scores, g_szDuckLeaderboardNames[0] );

		//// Show max of top 10
		//for ( int i = 0; i < scores.Count() && i < 10; i++ )
		//{
		//	const locchar_t *pName = FindAccountPersonaName( scores[i].m_steamIDUser.GetAccountID() );
		//	uint32 iRank = scores[i].m_nGlobalRank;
		//	uint32 iScore = scores[i].m_nScore;
		//	
		//	AddDescLine(
		//		CConstructLocalizedString(
		//			pLocalizationProvider->Find( "#TF_DuckLeaderboard_Entry" ),
		//			iRank, pName, iScore
		//		),
		//		ATTRIB_COL_POSITIVE,
		//		kDescLineFlag_Misc
		//	);
		//}
	}
#endif // TF_CLIENT_DLL
}

#endif // PROJECT_TF

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const CEconItemDefinition *GetPaintItemDefinitionForPaintedItem( const IEconItemInterface *pEconItem )
{
	static CSchemaAttributeDefHandle pAttribDef_Paint( "set item tint RGB" );

	attrib_value_t unPaintRGBAttrBits;
	if ( !pAttribDef_Paint || !pEconItem->FindAttribute( pAttribDef_Paint, &unPaintRGBAttrBits ) )
		return NULL;

	const CEconItemSchema::ToolsItemDefinitionMap_t &toolDefs = GetItemSchema()->GetToolsItemDefinitionMap();

	FOR_EACH_MAP_FAST( toolDefs, i )
	{
		const CEconItemDefinition *pItemDef = toolDefs[i];

		// ignore everything that is not a paint can tool
		const IEconTool *pEconTool = pItemDef->GetEconTool();
		if ( pEconTool && !V_strcmp( pEconTool->GetTypeName(), "paint_can" ) ) 
		{
			attrib_value_t unPaintRGBAttrCompareBits;
			if ( FindAttribute( pItemDef, pAttribDef_Paint, &unPaintRGBAttrCompareBits ) && unPaintRGBAttrCompareBits == unPaintRGBAttrBits )
				return pItemDef;
		}
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Specify target (strangifiers, etc that can only be applied to specific items)
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_XifierToolTargetItem( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	// Make sure it's a tool of the appropriate type
	const CEconTool_Xifier *pTool = pEconItem->GetItemDefinition()->GetTypedEconTool<CEconTool_Xifier>();
	if ( pTool == NULL )
		return;

	// Make sure there is a specific target item
	static CSchemaAttributeDefHandle pAttribDef_ToolTargetItem( "tool target item" );
	float flItemDef;
	if( pAttribDef_ToolTargetItem && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconItem, pAttribDef_ToolTargetItem, &flItemDef ) )
	{
		locchar_t szTargetItemName[ MAX_ITEM_NAME_LENGTH ] = LOCCHAR("Unknown Item");

		// It's a tool, see if it has a tool target item attribute
		const item_definition_index_t unItemDef = flItemDef;
		const CEconItemDefinition *pEconTargetDef = GetItemSchema()->GetItemDefinition( unItemDef );

		// Start with the base name.
		if ( pEconTargetDef )
		{
			GetLocalizedBaseItemName( szTargetItemName, pLocalizationProvider, pEconTargetDef );
		}

		const char *pszDesc = pTool->GetItemDescToolTargetLocToken();
		AssertMsg( pszDesc && *pszDesc, "%s: missing 'item_desc_tool_target' key", pTool->GetTypeName() );
		AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( pszDesc ),
					 szTargetItemName ),
					 ATTRIB_COL_NEUTRAL,
					 kDescLineFlag_Desc );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_Painted( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaAttributeDefHandle pAttrDef_PaintEffect( "Paint Effect" );

	float fPaintEffectType;
	if ( pAttrDef_PaintEffect && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconItem, pAttrDef_PaintEffect, &fPaintEffectType ) )
	{
		if ( fPaintEffectType == 1 )
		{
			LocalizedAddDescLine( pLocalizationProvider, "Econ_Paint_Effect_Oscillating", ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );
		}
		else if ( fPaintEffectType == 2 )
		{
			LocalizedAddDescLine( pLocalizationProvider, "Econ_Paint_Effect_Position", ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );
		}
		else if ( fPaintEffectType == 3 )
		{
			LocalizedAddDescLine( pLocalizationProvider, "Econ_Paint_Effect_LowHealthWarning", ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );
		}
	}

	// Find the name of the paint we have applied in the least efficient way imaginable!
	const CEconItemDefinition *pItemDef = pEconItem->GetItemDefinition();
	static CSchemaAttributeDefHandle pAttrDef_ShowPaint( "show paint description" );
	if ( pItemDef && ( !pItemDef->IsTool() || FindAttribute( pEconItem, pAttrDef_ShowPaint ) ) )
	{
		const CEconItemDefinition *pTempDef = GetPaintItemDefinitionForPaintedItem( pEconItem );
		if ( pTempDef )
		{
			const locchar_t *locLocalizedPaintName = pLocalizationProvider->Find( pTempDef->GetItemBaseName() );

			if ( locLocalizedPaintName )
			{
				AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "Econ_Paint_Name" ),
							 locLocalizedPaintName ),
							 ATTRIB_COL_LEVEL,
							 kDescLineFlag_Misc );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEconItemDescription::Generate_Uses( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	// don't display a quantity if we have the unlimited quantity attribute
	static CSchemaAttributeDefHandle unlimitedQuantityAttribute( "unlimited quantity" );
	if ( pEconItem->FindAttribute( unlimitedQuantityAttribute ) )
		return;

	// Collection tools don't display this.
	const GameItemDefinition_t *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	const IEconTool *pEconTool = pItemDef->GetEconTool();
	if ( !pEconTool->ShouldDisplayQuantity( pEconItem ) )
		return;

	int iQuantity = pEconItem->GetQuantity();
	bool bIsTool = pItemDef->GetItemClass() && !Q_strcmp( pItemDef->GetItemClass(), "tool" );
	bool bIsConsumable = ( pItemDef->GetCapabilities() & ITEM_CAP_USABLE_GC ) != 0 && iQuantity != 0;	

	if ( bIsTool || bIsConsumable )
	{
		locchar_t wszQuantity[10];
		loc_sprintf_safe( wszQuantity, LOCCHAR( "%d" ), iQuantity );

		// Add an empty line before the usage display.
		AddEmptyDescLine();
		
		// Display our usage count.
		AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "#Attrib_LimitedUse" ), &wszQuantity[0] ), ATTRIB_COL_LIMITED_USE, kDescLineFlag_Misc );
	}
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::Generate_LootListDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const CEconItemDefinition *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	// Don't add this description if the item is a special crate type.
	const IEconTool *pEconTool = pItemDef->GetEconTool();
	const bool bIsRestrictedCrate = pEconTool && pEconTool->GetUsageRestriction()
								  ? !V_stricmp( pEconTool->GetUsageRestriction(), "winter" ) || !V_stricmp( pEconTool->GetUsageRestriction(), "summer" )
								  : false;

	if ( bIsRestrictedCrate )
		return;

	// Do we have a generation code we want to make public? We do this regardless of whether we're describing our
	// loot list contents in detail.
	{
		static CSchemaAttributeDefHandle pAttrDef_CrateGenerationCode( "crate generation code" );
		CAttribute_String sCrateGenerationCode;

		const locchar_t *pszCrateGenerationCodeLoc = pLocalizationProvider->Find( "Attrib_CrateGenerationCode" );

		if ( pEconItem->FindAttribute( pAttrDef_CrateGenerationCode, &sCrateGenerationCode ) && sCrateGenerationCode.value().length() > 0 )
		{
			CUtlConstStringBase<locchar_t> loc_sAttrValue;
			pLocalizationProvider->ConvertUTF8ToLocchar( sCrateGenerationCode.value().c_str(), &loc_sAttrValue );

			AddDescLine( CConstructLocalizedString( pszCrateGenerationCodeLoc, loc_sAttrValue.Get() ),
						 ATTRIB_COL_POSITIVE,
						 kDescLineFlag_Misc );
		}
	}

	// Grab the actual contents of our loot list.
	CCrateLootListWrapper LootListWrapper( pEconItem );
	const IEconLootList *pLootList = LootListWrapper.GetEconLootList();

	if ( pLootList == nullptr )
		return;

	// If our base loot list is set not to list contents, skip the header/footer as well and don't display anything.
	if ( !pLootList->BPublicListContents() )
		return;

	AddEmptyDescLine();

	if ( !pLootList->GetLootListCollectionReference() )
	{
		LocalizedAddDescLine( pLocalizationProvider, pLootList->GetLootListHeaderLocalizationKey(), ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );
	}
	else
	{

		int iCollectionIndex = GetItemSchema()->GetItemCollections().Find( pLootList->GetLootListCollectionReference() );
		if ( GetItemSchema()->GetItemCollections().IsValidIndex( iCollectionIndex ) )
		{
			LocalizedAddDescLine( pLocalizationProvider, (GetItemSchema()->GetItemCollections()[iCollectionIndex])->m_pszLocalizedDesc, ATTRIB_COL_NEUTRAL, kDescLineFlag_Misc );
		}
	}

	class CDescriptionLootListIterator : public IEconLootList::IEconLootListIterator
	{
	public:
		CDescriptionLootListIterator( CEconItemDescription *pThis, const CLocalizationProvider *pLocalizationProvider, bool bUseProperName )
			: m_pThis( pThis )
			, m_pLocalizationProvider( pLocalizationProvider )
			, m_bUseProperName( bUseProperName )
		{
		}

		virtual void OnIterate( item_definition_index_t unItemDefIndex ) OVERRIDE
		{
			const CEconItemDefinition *pItemDef = GetItemSchema()->GetItemDefinition( unItemDefIndex );
			if ( pItemDef )
			{
				// Check if this item is already owned
				bool bOwned = false;
				bool bUnusual = false;
#ifdef CLIENT_DLL
				CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
				if ( pLocalInv )
				{
					for ( int i = 0; i < pLocalInv->GetItemCount(); ++i )
					{
						CEconItemView *pItem = pLocalInv->GetItem( i );
						if ( pItem->GetItemDefinition() == pItemDef )
						{
							bOwned = true;
							// Check Quality
							if ( pItem->GetQuality() == AE_UNUSUAL )
							{
								bUnusual = true;
								break;
							}
						}
					}
				}
#endif
				const locchar_t * pCheckmark = bOwned ? m_pLocalizationProvider->Find( "TF_Checkmark" ) : m_pLocalizationProvider->Find( "TF_LackOfCheckmark" );
				if ( bOwned && bUnusual )
				{
					pCheckmark = m_pLocalizationProvider->Find( "TF_Checkmark_Unusual" );
				}

				attrib_colors_t colorRarity = ATTRIB_COL_RARITY_DEFAULT;
				const CEconItemRarityDefinition* pItemRarity = GetItemSchema()->GetRarityDefinition( pItemDef->GetRarity() );
				if ( pItemRarity )
				{
					colorRarity = pItemRarity->GetAttribColor();
				}

				m_pThis->AddDescLine(
					CConstructLocalizedString( LOCCHAR( "%s1%s2" ), pCheckmark,
					CEconItemLocalizedFullNameGenerator(
					m_pLocalizationProvider,
					pItemDef,
					m_bUseProperName
					).GetFullName() ),
					colorRarity,
					kDescLineFlag_Misc,
					NULL,
					pItemDef->GetDefinitionIndex()
					);
			}
		}

	private:
		CEconItemDescription *m_pThis;		// look at me I'm a lambda!
		const CLocalizationProvider *m_pLocalizationProvider;
		bool m_bUseProperName;
	};

	CDescriptionLootListIterator it( this, pLocalizationProvider, m_pHashContext == NULL );
	pLootList->EnumerateUserFacingPotentialDrops( &it );

	if ( pLootList->GetLootListFooterLocalizationKey() )
	{
		LocalizedAddDescLine( pLocalizationProvider, pLootList->GetLootListFooterLocalizationKey(), ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
	}
	else
	{
		const char *pszRareLootListFooterLocalizationKey = pItemDef->GetDefinitionString( "loot_list_rare_item_footer", "#Econ_Revolving_Loot_List_Rare_Item" );
		LocalizedAddDescLine( pLocalizationProvider, pszRareLootListFooterLocalizationKey, ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
	}
}

// --------------------------------------------------------------------------
void CEconItemDescription::Generate_EventDetail( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const CEconItemDefinition *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	// Check to see if we should append any extra description information
	const char *pszEventLocalizationKey = pItemDef->GetDefinitionString( "event_desc_footer", NULL );
	if ( pszEventLocalizationKey )
	{
		AddEmptyDescLine();
		LocalizedAddDescLine( pLocalizationProvider, pszEventLocalizationKey, ATTRIB_COL_POSITIVE, kDescLineFlag_Misc );
	}
}
// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
#ifdef CLIENT_DLL

static bool IsItemEquipped( uint32 unAccountID, const CEconItemDefinition *pSearchItemDef, const GameItemDefinition_t **ppFoundSetItemDef )
{
	Assert( pSearchItemDef );
	Assert( ppFoundSetItemDef );

	CPlayerInventory *pInv = InventoryManager()->GetInventoryForAccount( unAccountID );
	if ( !pInv )
		return false;

	for ( int i = 0; i < pInv->GetItemCount(); i++ )
	{
		const CEconItemView *pInvItem = pInv->GetItem( i );
		if ( !pInvItem )
			continue;

		// This code is client-only so we expect to always get back an item definition pointer.
		const GameItemDefinition_t *pInvItemDef = pInvItem->GetItemDefinition();
		Assert( pInvItemDef );

		if ( pInvItemDef->GetSetItemRemap() != pSearchItemDef->GetDefinitionIndex() )
			continue;

		if ( !pInvItem->IsEquipped() )
			continue;

		*ppFoundSetItemDef = pInvItemDef;
		return true;
	}

	return false;
}

#endif // CLIENT_DLL

void CEconItemDescription::Generate_ItemSetDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const GameItemDefinition_t *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	const CEconItemSetDefinition *pItemSetDef = pItemDef->GetItemSetDefinition();
	if ( !pItemSetDef )
		return;

	bool bAllItemsEquipped = true;		// filled in below when iterating over items

	// Some item sets are tagged to only appear on items at all if the entire set is visible. Rather than
	// walk the whole set multiple times checking for item equipped state, we build up a set of description lines
	// that we *will* display if we display anything at all. Later, we either submit all those lines for real or
	// return before adding any of them.
	{
		CUtlVector<econ_item_description_line_t> vecPotentialDescLines;

		AddEmptyDescLine( &vecPotentialDescLines );
		LocalizedAddDescLine( pLocalizationProvider, pItemSetDef->m_pszLocalizedName, ATTRIB_COL_ITEMSET_NAME, kDescLineFlag_Set | kDescLineFlag_SetName, &vecPotentialDescLines, pItemSetDef->m_iBundleItemDef );

		// Kyle says: Jon wants different formatting on the GC for sets.
#if defined( GC_DLL )
#if TF_ANTI_IDLEBOT_VERIFICATION
		if ( !m_pHashContext )
#endif // TF_ANTI_IDLEBOT_VERIFICATION
		{
			AddEmptyDescLine( &vecPotentialDescLines );
		}
#endif // defined( GC_DLL ) && 

		// Iterate over the items in the set. We'll output a line in different colors to show
		// the current state of this item. For normal item sets, the color is based on whether
		// the owner has the item in question equipped (except on the GC, where we always say
		// "it's not equipped" to avoid confusion). For collections, the color is based on whether
		// the item has been collected.
		FOR_EACH_VEC( pItemSetDef->m_iItemDefs, i )
		{
			const GameItemDefinition_t *pOtherSetItem = dynamic_cast<const GameItemDefinition_t *>( GetItemSchema()->GetItemDefinition( pItemSetDef->m_iItemDefs[i] ) );
			if ( !pOtherSetItem )
				continue;

			item_definition_index_t usLinkItemDefIndex = pOtherSetItem->GetDefinitionIndex();

#ifdef DOTA
			// If the current item is part of a pack bundle, add the pack bundle to the description, rather than the individual item
			if ( pOtherSetItem->IsPackItem() )
			{
				// Link to the pack bundle, not the individual pack item
				usLinkItemDefIndex = pOtherSetItem->GetOwningPackBundle()->GetDefinitionIndex();
			}
#endif

			// Only used on non-GC in case we have an item misrepresenting itself intentionally for set
			// grouping purposes. NULL elsewhere.
			const GameItemDefinition_t *pFoundSetItemDef = NULL;

			const bool bItemPresent =
#ifdef GC_DLL
									  false;													// the GC always treats set items as unequipped for clarity in trading
#else
#if TF_ANTI_IDLEBOT_VERIFICATION
									  m_pHashContext
									? false														// when generating descriptions for GC verification we treat item sets as unequipped to match the GC
#endif
									: IsItemEquipped( pEconItem->GetAccountID(), pOtherSetItem, &pFoundSetItemDef );	// non-GC display will find out whether the player in question has this item actively equipped
#endif

			AddDescLine( CEconItemLocalizedFullNameGenerator( 
				pLocalizationProvider, 
				pFoundSetItemDef ? pFoundSetItemDef : pOtherSetItem,
				m_pHashContext == NULL
			).GetFullName(), bItemPresent ? ATTRIB_COL_ITEMSET_EQUIPPED : ATTRIB_COL_ITEMSET_MISSING, kDescLineFlag_Set, &vecPotentialDescLines, usLinkItemDefIndex );

			bAllItemsEquipped &= bItemPresent;
		}

		// If the item set is set to be only displayed when the full set is equipped, give up here and
		// toss out our potential lines. Otherwise submit them for real.
		if ( pItemSetDef->m_bIsHiddenSet && !bAllItemsEquipped )
			return;

		FOR_EACH_VEC( vecPotentialDescLines, i )
		{
			AddDescLine( vecPotentialDescLines[i].sText.Get(), vecPotentialDescLines[i].eColor, vecPotentialDescLines[i].unMetaType, NULL, vecPotentialDescLines[i].unDefIndex );
		}
	}

	// Show the set only attributes if we have the entire set and we have bonus attributes to display.
	bool bHasVisible = false;
	FOR_EACH_VEC( pItemSetDef->m_iAttributes, i )
	{
		const CEconItemSetDefinition::itemset_attrib_t& attrib = pItemSetDef->m_iAttributes[i];
		const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinition( attrib.m_iAttribDefIndex );

		if ( !pAttrDef->IsHidden() )
		{
			bHasVisible = true;
			break;
		}
	}

	if ( !bHasVisible )
		return;

	AddEmptyDescLine();
	LocalizedAddDescLine( pLocalizationProvider, "#Econ_Set_Bonus", ATTRIB_COL_ITEMSET_NAME, kDescLineFlag_Set );

	FOR_EACH_VEC( pItemSetDef->m_iAttributes, i )
	{
		const CEconItemSetDefinition::itemset_attrib_t& attrib = pItemSetDef->m_iAttributes[i];
		const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinition( attrib.m_iAttribDefIndex );

		if ( pAttrDef )
		{
			// Add the attribute description. Override the color to be grayed out if we don't have the
			// full set equipped.
			AddAttributeDescription( pLocalizationProvider,
									 pAttrDef,
									 *(attrib_value_t *)&attrib.m_flValue,
									 bAllItemsEquipped ? /* "do not override": */ NUM_ATTRIB_COLORS : ATTRIB_COL_ITEMSET_MISSING );
		}
	}
}

// --------------------------------------------------------------------------
void CEconItemDescription::Generate_CollectionDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const CEconItemDefinition *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	const CEconItemCollectionDefinition *pCollection = pItemDef->GetItemCollectionDefinition();
	if ( !pCollection )
		return;

	// Collection Header .. 
	const locchar_t *loc_name = pLocalizationProvider->Find( pCollection->m_pszLocalizedName );
	
	// Add a bit of spacing, this is only for the market
	// Add empty line
	AddDescLine( LOCCHAR( " " ), ATTRIB_COL_NEUTRAL, kDescLineFlag_CollectionName | kDescLineFlag_Empty );
	AddDescLine( LOCCHAR( " " ), ATTRIB_COL_NEUTRAL, kDescLineFlag_CollectionName | kDescLineFlag_Empty );

	AddDescLine(
		CConstructLocalizedString( LOCCHAR( "%s1" ), loc_name ), 
		ATTRIB_COL_NEUTRAL, 
		kDescLineFlag_CollectionName 
	);
	
	FOR_EACH_VEC( pCollection->m_iItemDefs, index )
	{
		int eFlag = kDescLineFlag_Collection;
		const CEconItemDefinition *pTempItemDef = GetItemSchema()->GetItemDefinition( pCollection->m_iItemDefs[index] );
		if ( pTempItemDef )
		{
			// Check if this item is already owned
			bool bOwned = false;
			bool bUnusual = false;
			if ( pTempItemDef == pItemDef )
			{
				bOwned = true;
				eFlag |= kDescLineFlag_CollectionCurrentItem;
				if ( pEconItem->GetQuality() == AE_UNUSUAL )
				{
					bUnusual = true;
				}
			}
#ifdef CLIENT_DLL
			else 
			{
				CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
				if ( pLocalInv )
				{
					const CEconItemCollectionDefinition *pRefCollection = GetItemSchema()->GetCollectionByName( pTempItemDef->GetCollectionReference() );
					// if item has a collection reference, we are looking for all those items and this item
					if ( pRefCollection )
					{
						bOwned = true;
						FOR_EACH_VEC( pRefCollection->m_iItemDefs, iRefCollectionItem  )
						{
							const CEconItemView *pRefItem = pLocalInv->FindFirstItembyItemDef( pRefCollection->m_iItemDefs[ iRefCollectionItem ] );
							if ( !pRefItem )
							{
								bOwned = false;
								break;
							}
						}
					}
					else 
					{	
						// Normal Backpack scan
						for ( int i = 0; i < pLocalInv->GetItemCount(); ++i )
						{
							CEconItemView *pItem = pLocalInv->GetItem( i );
							if ( pItem->GetItemDefinition() == pTempItemDef ) 
							{
								bOwned = true;
								// Check Quality
								if ( pItem->GetQuality() == AE_UNUSUAL )
								{
									bUnusual = true;
									break;
								}
							}
						}
					}
				}
			}
#endif
			
			const locchar_t * pCheckmark = bOwned ? pLocalizationProvider->Find( "TF_Checkmark" ) : pLocalizationProvider->Find( "TF_LackOfCheckmark" );
			if ( bOwned && bUnusual )
			{
				pCheckmark = pLocalizationProvider->Find( "TF_Checkmark_Unusual" );
			}

			attrib_colors_t colorRarity = ATTRIB_COL_RARITY_DEFAULT;
			const CEconItemRarityDefinition* pItemRarity = GetItemSchema()->GetRarityDefinition( pTempItemDef->GetRarity() );
			if ( pItemRarity )
			{
				colorRarity = pItemRarity->GetAttribColor();
			}

			AddDescLine( 
				CConstructLocalizedString( LOCCHAR("%s1%s2"), pCheckmark,
					CEconItemLocalizedFullNameGenerator(
					pLocalizationProvider,
					pTempItemDef,
					m_pHashContext == NULL
				).GetFullName() ), 
				colorRarity,
				eFlag,
				NULL,
				pTempItemDef->GetDefinitionIndex()
			);
		}
	}
}
// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::Generate_ExpirationDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const CEconItemDefinition *pItemDef = pEconItem->GetItemDefinition();
	if ( !pItemDef )
		return;

	// Look for schema-specified static expiration date.
	RTime32 timeSchemaExpiration = pItemDef->GetExpirationDate();
	
	// Look also for a dynamic attribute -- this could come from item tryouts.
	static CSchemaAttributeDefHandle pAttrDef_ExpirationDate( "expiration date" );

	RTime32 timeAttrExpiration = 0;
	pEconItem->FindAttribute( pAttrDef_ExpirationDate, &timeAttrExpiration );		// if we don't have the attribute we'll use our starting value of 0
	
	// Which will have us expire first?
	RTime32 timeExpiration = MAX( timeSchemaExpiration, timeAttrExpiration );

	// If we still don't have an expiration date we don't display anything.
	if ( !timeExpiration )
		return;

	AddEmptyDescLine();

#ifdef TF_CLIENT_DLL
	// is this a loaner item?
	if ( GetAssociatedQuestItemID( pEconItem ) != INVALID_ITEM_ID )
	{
		AddDescLine( pLocalizationProvider->Find( "#Attrib_LoanerItemExpirationDate" ),
			ATTRIB_COL_NEGATIVE,
			kDescLineFlag_Misc );
	}
	else
#endif // TF_CLIENT_DLL
	{
		CLocalizedRTime32 time = { timeExpiration, false, pLocalizationProvider TF_ANTI_IDLEBOT_VERIFICATION_ONLY_COMMA TF_ANTI_IDLEBOT_VERIFICATION_ONLY_ARG( m_pHashContext ) };
		AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "#Attrib_ExpirationDate" ),
			time ),
			ATTRIB_COL_NEGATIVE,
			kDescLineFlag_Misc );
	}
}


void CEconItemDescription::Generate_DropPeriodDesc( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	static CSchemaAttributeDefHandle pAttr_EndDropDate( "end drop date" );

	// See if we have the drop date period end attribute
	CAttribute_String value;
	if ( !FindAttribute( pEconItem, pAttr_EndDropDate, &value ) )
		return;

	AddEmptyDescLine();

	// Convert the string value to an RTime32
	RTime32 endDate = CRTime::RTime32FromString( value.value().c_str() );
	// Is the time before or after now?  Use different strings for each
	const char* pszDropString =  endDate > CRTime::RTime32TimeCur()
							  ? "#Attrib_DropPeriodComing"
							  : "#Attrib_DropPeriodPast";

	CLocalizedRTime32 time = { endDate, false, pLocalizationProvider TF_ANTI_IDLEBOT_VERIFICATION_ONLY_COMMA TF_ANTI_IDLEBOT_VERIFICATION_ONLY_ARG( m_pHashContext ) };
	AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( pszDropString ),
											time ),
				 ATTRIB_COL_LEVEL,
				 kDescLineFlag_Misc );
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
#ifdef TF_CLIENT_DLL
	extern ConVar cl_showbackpackrarities;
	extern ConVar cl_show_market_data_on_items;
#endif 

void CEconItemDescription::Generate_MarketInformation( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	// Deprecated;
	// We now have right click go to market
	return;
//
//	Assert( pLocalizationProvider );
//	Assert( pEconItem );
//
//	// Early-out to avoid doing more expensive name lookups for items that can't possibly have
//	// entries.
//	if ( !pEconItem->IsMarketable() )
//		return;
//
//	// For now, Market information is only shown on clients, and even then only sometimes.
//#ifdef CLIENT_DLL
//#if TF_ANTI_IDLEBOT_VERIFICATION
//	// Don't generate this client-only information when we're trying to match GC output.
//	if ( m_pHashContext )
//		return;
//#endif // TF_ANTI_IDLEBOT_VERIFICATION
//
//#ifdef TF_CLIENT_DLL
//	if ( cl_show_market_data_on_items.GetInt() == 0 )
//		return;
//
//	if ( cl_show_market_data_on_items.GetInt() == 1 && cl_showbackpackrarities.GetInt() != 2 )
//		return;
//#endif // TF_CLIENT_DLL
//
//	steam_market_gc_identifier_t ident;
//	ident.m_unDefIndex = pEconItem->GetItemDefIndex();
//	ident.m_unQuality = pEconItem->GetQuality();
//	
//	const client_market_data_t *pClientMarketData = GetClientMarketData( ident );
//	if ( !pClientMarketData )
//		return;
//
//	locchar_t loc_Price[ kLocalizedPriceSizeInChararacters ];
//	MakeMoneyString( loc_Price, ARRAYSIZE( loc_Price ), pClientMarketData->m_unLowestPrice, EconUI()->GetStorePanel()->GetCurrency() );
//
//	AddEmptyDescLine();
//	AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "#Econ_MarketTooltipFormat" ),
//											pClientMarketData->m_unQuantityAvailable,
//											loc_Price ),
//				 ATTRIB_COL_POSITIVE,
//				 kDescLineFlag_Misc );
//#endif // CLIENT_DLL
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
struct localized_localplayer_line_t
{
	localized_localplayer_line_t( const char *pLocalizationKey, attrib_colors_t eAttribColor, const char *pLocalizationSubKey = NULL )
		: m_pLocalizationKey( pLocalizationKey )
		, m_pLocalizationSubKey( pLocalizationSubKey )
		, m_eAttribColor( eAttribColor )
	{
		//
	}

	const char *m_pLocalizationKey;
	const char *m_pLocalizationSubKey;
	attrib_colors_t m_eAttribColor;
};

void CEconItemDescription::Generate_FlagsAttributes( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	const CEconItemDefinition *pItemDef = pEconItem->GetItemDefinition();
	if ( pItemDef && pItemDef->GetEconTool() && pItemDef->GetEconTool()->ShouldDisplayQuantity( pEconItem ) )
	{
		AddEmptyDescLine();
		AddDescLine( CConstructLocalizedString( pLocalizationProvider->Find( "#Attrib_LimitedUse" ), (uint32)pEconItem->GetQuantity() ),
					 ATTRIB_COL_LIMITED_USE,
					 kDescLineFlag_LimitedUse );
	}
	
	CUtlVector<localized_localplayer_line_t> vecLines;

	// Is this item in use? (ie., being used as part of a cross-game trade)
	if ( pEconItem->GetInUse() )
	{
		vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_InUse", ATTRIB_COL_NEUTRAL ) );
	}

	static CSchemaAttributeDefHandle pAttrDef_TradableAfter( "tradable after date" );
	static CSchemaAttributeDefHandle pAttrDef_ToolEscrowUntil( "tool escrow until date" );
	static CSchemaAttributeDefHandle pAttrDef_AlwaysTradableAndUsableInCrafting( "always tradable" );

	uint32 unTradeTime = 0,
		   unEscrowTime = 0;
	const bool bHasTradableAfterDate = pEconItem->FindAttribute( pAttrDef_TradableAfter, &unTradeTime );
	const bool bHasToolEscrowUntilDate = pEconItem->FindAttribute( pAttrDef_ToolEscrowUntil, &unEscrowTime );
	const bool bHasExpiringTimer = bHasTradableAfterDate || bHasToolEscrowUntilDate;

#ifdef CLIENT_DLL
	const bool bIsStoreItem = IsStorePreviewItem( pEconItem );
	const bool bIsPreviewItem = pEconItem->GetFlags() & kEconItemFlagClient_Preview;

	if ( bIsStoreItem || bIsPreviewItem )
	{
#if TF_ANTI_IDLEBOT_VERIFICATION
		if ( !m_pHashContext )
#endif // TF_ANTI_IDLEBOT_VERIFICATION
		{
			// Does this item come with other packages on Steam?
			const econ_store_entry_t *pStoreEntry = GetEconPriceSheet() ? GetEconPriceSheet()->GetEntry( pItemDef->GetDefinitionIndex() ) : NULL;
			if ( pStoreEntry && pStoreEntry->GetGiftSteamPackageID() != 0 )
			{
				const char *pszSteamPackageLocalizationToken = GetItemSchema()->GetSteamPackageLocalizationToken( pStoreEntry->GetGiftSteamPackageID() );
				if ( pszSteamPackageLocalizationToken )
				{
					vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_Store_IncludesSteamGiftPackage", ATTRIB_COL_POSITIVE, pszSteamPackageLocalizationToken ) );
					vecLines.AddToTail( localized_localplayer_line_t( NULL, ATTRIB_COL_POSITIVE ) );
				}
			}
		
			// While the above apply to store *and* preview items, the below only apply to store items.
			if ( bIsStoreItem )
			{
				// Don't display this line for map stamps because they can't be traded.
				if ( pItemDef && pItemDef->GetItemClass() && !FStrEq( pItemDef->GetItemClass(), "map_token" ) )
				{
					static CSchemaAttributeDefHandle pAttrib_CannotTrade( "cannot trade" );
					Assert( pAttrib_CannotTrade );

					// Some items cannot ever be traded, so don't indicate to the users that they'll be tradeable after a few days.
					if ( !FindAttribute( pItemDef, pAttrib_CannotTrade ) )
					{
						vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_Store_TradableAfterDate", ATTRIB_COL_NEGATIVE ) );
					}

					if ( pItemDef->GetEconTool() && pItemDef->GetEconTool()->RequiresToolEscrowPeriod() )
					{
						vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_Store_ToolEscrowUntilDate", ATTRIB_COL_NEGATIVE ) );
					}
				}

				if ( !pItemDef || (pItemDef->GetCapabilities() & ITEM_CAP_CAN_BE_CRAFTED_IF_PURCHASED) == 0 )
				{
					if ( pItemDef->IsBundle() )
					{
						vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_CannotCraftWeapons", ATTRIB_COL_NEGATIVE ) );
					}
					else
					{
						vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_CannotCraft", ATTRIB_COL_NEGATIVE ) );
					}
				}
			}
		}
	}
	else
#endif // CLIENT_DLL	
	if ( bHasExpiringTimer )
	{
		if ( unTradeTime > CRTime::RTime32TimeCur() )
		{
			AddAttributeDescription( pLocalizationProvider, pAttrDef_TradableAfter, unTradeTime );
		}

		if ( unEscrowTime > CRTime::RTime32TimeCur() )
		{
			AddAttributeDescription( pLocalizationProvider, pAttrDef_ToolEscrowUntil, unEscrowTime );
		}

		if ( !pEconItem->IsUsableInCrafting() )
		{
			vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_CannotCraft", ATTRIB_COL_NEUTRAL ) );
		}
	}
	else if ( pEconItem->FindAttribute( pAttrDef_AlwaysTradableAndUsableInCrafting ) && pEconItem->IsTradable() )
	{
		// do nothing if we are always tradable or usable in crafting
		//
		// some items are marked as "always_tradable" in their itemDef but the specific item may have the 
		// "non_economy" flag, so we need to also check that this specific item is tradable before doing nothing 
	}
	else
	{
		const int32			  iQuality = pEconItem->GetQuality();
		const eEconItemOrigin eOrigin  = pEconItem->GetOrigin();

		if ( iQuality >= AE_COMMUNITY && iQuality <= AE_SELFMADE )
		{
			vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_SpecialItem", ATTRIB_COL_NEUTRAL ) );
		}
		else if ( eOrigin == kEconItemOrigin_Achievement )
		{
			vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_AchievementItem", ATTRIB_COL_NEUTRAL ) );
		}
		else if ( eOrigin == kEconItemOrigin_CollectionReward )
		{
			vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_CollectionReward", ATTRIB_COL_NEUTRAL ) );
		}
		else if ( eOrigin == kEconItemOrigin_PreviewItem )
		{
			vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_PreviewItem", ATTRIB_COL_NEUTRAL ) );
		}
		else if ( eOrigin == kEconItemOrigin_QuestLoanerItem )
		{
			vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_LoanerItem", ATTRIB_COL_NEUTRAL ) );
		}
		else if ( eOrigin == kEconItemOrigin_Invalid )
		{
			// do nothing, but skip the below "cannot trade/cannot craft" block below"
		}
		else if ( (pEconItem->GetFlags() & kEconItemFlag_NonEconomy) != 0 )
		{
			vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_NonEconomyItem", ATTRIB_COL_NEUTRAL ) );
		}
		else
		{
			const bool bIsTradable = pEconItem->IsTradable(),
					   bIsCraftable = pEconItem->IsUsableInCrafting();

			if ( !bIsTradable && !bIsCraftable )
			{
				vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_CannotTradeOrCraft", ATTRIB_COL_NEUTRAL ) );
			}
			else
			{
				if ( !bIsTradable )
				{
					vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_CannotTrade", ATTRIB_COL_NEUTRAL ) );
				}

				if ( !bIsCraftable )
				{
					vecLines.AddToTail( localized_localplayer_line_t( "#Attrib_CannotCraft", ATTRIB_COL_NEUTRAL ) );
				}
			}
		}
	}

	if ( vecLines.Count() > 0 )
	{
		const locchar_t *loc_AttribFormat_AdditionalNode = pLocalizationProvider->Find( "#AttribFormat_AdditionalNote" );
		if ( loc_AttribFormat_AdditionalNode )
		{
			AddEmptyDescLine();

			FOR_EACH_VEC( vecLines, i )
			{
				const char *pszLocalizationKey	  = vecLines[i].m_pLocalizationKey;
				const char *pszLocalizationSubKey = vecLines[i].m_pLocalizationSubKey;

				if ( pszLocalizationKey )
				{
					AddDescLine( pszLocalizationSubKey ?
									CConstructLocalizedString( pLocalizationProvider->Find( pszLocalizationKey ), pLocalizationProvider->Find( pszLocalizationSubKey ) ):	// has subtoken, doesn't use additional note format
									CConstructLocalizedString( loc_AttribFormat_AdditionalNode, pLocalizationProvider->Find( pszLocalizationKey ) ),						// no subtoken, uses base additional note format
								 vecLines[i].m_eAttribColor,
								 kDescLineFlag_Misc );
				}
				else
				{
					AddEmptyDescLine();
				}
			}
		}
	}
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------

bool CEconItemDescription::CVisibleAttributeDisplayer::OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, attrib_value_t value )
{
	if ( !pAttrDef->IsHidden() )
	{
		attrib_iterator_value_t attrVal = { pAttrDef, value };
		m_vecAttributes.AddToTail( attrVal );
	}

	return true;
}

void CEconItemDescription::CVisibleAttributeDisplayer::SortAttributes()
{
	// We need to make sure we process attributes in the same order when iterating on the GC and the client
	// when looking for agreement. We take advantage of this to also sort our attributes into a coherent
	// order for display -- first come neutral attributes, then positive, then negative. In the event of a
	// tie, we sort by attribute index, which is arbitrary but consistent across the client/GC.
	struct AttributeValueSorter
	{
		static int sSort( const attrib_iterator_value_t *pA, const attrib_iterator_value_t *pB )
		{
			const int iEffectTypeDelta = pA->m_pAttrDef->GetEffectType() - pB->m_pAttrDef->GetEffectType();
			if ( iEffectTypeDelta != 0 )
				return iEffectTypeDelta;

			return pA->m_pAttrDef->GetDefinitionIndex() - pB->m_pAttrDef->GetDefinitionIndex();
		}
	};

	m_vecAttributes.Sort( &AttributeValueSorter::sSort );
}

void CEconItemDescription::CVisibleAttributeDisplayer::Finalize( const IEconItemInterface *pEconItem, CEconItemDescription *pEconItemDescription, const CLocalizationProvider *pLocalizationProvider )
{
	// HACK so we dont show series number on select crates since they are self describing (Event Crates, Collection Crates)
	static CSchemaAttributeDefHandle pAttrDef_SupplyCrateSeries( "set supply crate series" );
	static CSchemaAttributeDefHandle pAttrDef_HideSeries( "hide crate series number" );

	FOR_EACH_VEC( m_vecAttributes, i )
	{
		if ( pEconItem && m_vecAttributes[i].m_pAttrDef == pAttrDef_SupplyCrateSeries && pEconItem->FindAttribute( pAttrDef_HideSeries ) )
			continue;

		pEconItemDescription->AddAttributeDescription( pLocalizationProvider, m_vecAttributes[i].m_pAttrDef, m_vecAttributes[i].m_value );
	}
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::Generate_VisibleAttributes( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
	Assert( pLocalizationProvider );
	Assert( pEconItem );

	CVisibleAttributeDisplayer AttributeDisplayer;
	pEconItem->IterateAttributes( &AttributeDisplayer );
	AttributeDisplayer.SortAttributes();
	AttributeDisplayer.Finalize( pEconItem, this, pLocalizationProvider );
}

// --------------------------------------------------------------------------
void CEconItemDescription::Generate_DirectX8Warning( const CLocalizationProvider *pLocalizationProvider, const IEconItemInterface *pEconItem )
{
#ifdef CLIENT_DLL
	static ConVarRef mat_dxlevel( "mat_dxlevel" );
	const CEconItemDefinition *pEconItemDefinition = pEconItem->GetItemDefinition();
	// If less than 90, we�re in DX8 mode. 
	// Display warning if you are looking at a painthit item or case
	if ( mat_dxlevel.GetInt() < 90 && pEconItemDefinition && ( pEconItemDefinition->GetItemCollectionDefinition() || pEconItemDefinition->GetCollectionReference() ) )
	{
		AddEmptyDescLine();
		AddDescLine( pLocalizationProvider->Find( "#Attrib_DirectX8Warning" ),
			ATTRIB_COL_NEGATIVE,
			kDescLineFlag_Misc );
	}

#endif
}


bool CEconItemDescription::CRecipeNameAttributeDisplayer::OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, attrib_value_t value )
{
	if ( pAttrDef->CanAffectRecipeComponentName() )
	{
		return CVisibleAttributeDisplayer::OnIterateAttributeValue( pAttrDef, value );
	}

	return true;
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
static attrib_colors_t GetAttributeDefaultColor( const CEconItemAttributeDefinition *pAttribDef )
{
	// positive attribute?
	switch ( pAttribDef->GetEffectType() )
	{
	case ATTRIB_EFFECT_NEUTRAL:			return ATTRIB_COL_NEUTRAL;
	case ATTRIB_EFFECT_POSITIVE:		return ATTRIB_COL_POSITIVE;
	case ATTRIB_EFFECT_NEGATIVE:		return ATTRIB_COL_NEGATIVE;
	case ATTRIB_EFFECT_STRANGE:			return ATTRIB_COL_STRANGE;
	case ATTRIB_EFFECT_UNUSUAL:			return ATTRIB_COL_UNUSUAL;
	}

	// hell if we know
	return ATTRIB_COL_NEUTRAL;
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconAttributeDescription::InternalConstruct
(
	const CLocalizationProvider *pLocalizationProvider,
	const CEconItemAttributeDefinition *pAttribDef,
	attrib_value_t value,
	TF_ANTI_IDLEBOT_VERIFICATION_ONLY_ARG( MD5Context_t *pHashContext ) TF_ANTI_IDLEBOT_VERIFICATION_ONLY_COMMA
	IAccountPersonaLocalizer *pOptionalAccountPersonaLocalizer
)
{
	Assert( pAttribDef != NULL );

	const float& value_as_float = (float&)value;
	const uint32& value_as_uint32 = (uint32&)value;

	// Calculate our color first -- if we don't know what to do, we'll wind up as neutral.
	m_eDefaultColor = GetAttributeDefaultColor( pAttribDef );

	// Early out abort if we don't have a localization string for this attribute.
	locchar_t *loc_String = pAttribDef->GetDescriptionString() && pLocalizationProvider
						  ? pLocalizationProvider->Find( pAttribDef->GetDescriptionString() )
						  : NULL;

	if ( !loc_String )
		return;

	char szAttrShortDescToken[MAX_PATH];
	V_sprintf_safe( szAttrShortDescToken, "%s%s", pAttribDef->GetDescriptionString(), "_shortdesc" );

	locchar_t *loc_ShortString = pLocalizationProvider 
							   ? pLocalizationProvider->Find( szAttrShortDescToken ) 
							   : NULL;

	// How do we format an attribute value of this type?
	switch ( pAttribDef->GetDescriptionFormat() )
	{
	case ATTDESCFORM_VALUE_IS_ADDITIVE_PERCENTAGE:
		m_loc_sValue = CLocalizedStringArg<float>( value_as_float * 100.0f ).GetLocArg();
		break;

	case ATTDESCFORM_VALUE_IS_ACCOUNT_ID:
#ifdef CLIENT_DLL
		// If this assert fires, it means that the client fed in an attribute that should be localized
		// as a Steam persona name but didn't feed it any way to get that information. The GC won't
		// assert, but also won't generate anything for the attribute text.
		//
		// It's still totally fine to pass in NULL for the persona localizer as long as you don't
		// expect to have any attributes that have account IDs.
		Assert( pOptionalAccountPersonaLocalizer );
#endif		
		if ( pOptionalAccountPersonaLocalizer )
		{
			m_loc_sValue = pOptionalAccountPersonaLocalizer->FindAccountPersonaName( value_as_uint32 );
		}
		break;

	case ATTDESCFORM_VALUE_IS_ADDITIVE:
		m_loc_sValue = pAttribDef->IsStoredAsFloat()
					 ? CLocalizedStringArg<float>( value_as_float ).GetLocArg()
					 : CLocalizedStringArg<uint32>( value_as_uint32 ).GetLocArg();
		break;

	case ATTDESCFORM_VALUE_IS_INVERTED_PERCENTAGE:
		if ( value_as_float < 1.0 )
		{
			m_loc_sValue = CLocalizedStringArg<float>( (1.0 - value_as_float) * 100.0f ).GetLocArg();
			break;
		}

		// We intentionally fall through when value_as_float >= 1.0f to treat it the same as "value as
		// percentage".
	case ATTDESCFORM_VALUE_IS_PERCENTAGE:
		m_loc_sValue = CLocalizedStringArg<float>( (value_as_float * 100.0f) - 100.0f ).GetLocArg();
		break;

	case ATTDESCFORM_VALUE_IS_DATE:
		{
			bool bUseGMT = false;

#ifdef PROJECT_TF
			static CSchemaAttributeDefHandle pAttribDef_SetEmployeeNumber( "custom employee number" );

			// only use GMT for custom employee number -- not doing this generated a bunch of support
			// tickets because items were granted based on GC time but would display local time, causing
			// people on the border to think they deserved a better badge, etc.
			bUseGMT = (pAttribDef == pAttribDef_SetEmployeeNumber);
#endif // PROJECT_TF

			CLocalizedRTime32 time = { value_as_uint32, bUseGMT, pLocalizationProvider TF_ANTI_IDLEBOT_VERIFICATION_ONLY_COMMA TF_ANTI_IDLEBOT_VERIFICATION_ONLY_ARG( pHashContext ) };
			m_loc_sValue = CLocalizedStringArg<CLocalizedRTime32>( time ).GetLocArg();
			break;
		}

	case ATTDESCFORM_VALUE_IS_PARTICLE_INDEX:
		{
			// This is a horrible, horrible line of code. It exists because old particle references are
			// ints stored as floats as float bit patterns and new particle references are ints stored
			// as ints all the way through.
			CUtlConstString utf8_ParticleKeyName( CFmtStr( "#Attrib_Particle%i", pAttribDef->IsStoredAsInteger() ? value_as_uint32 : (int)value_as_float ).Access() );	// this value is stored as a float but interpreted as an int (1.0 -> 1)
			if ( utf8_ParticleKeyName.IsEmpty() )
				return;

			m_loc_sValue = pLocalizationProvider->Find( utf8_ParticleKeyName.Get() );
			break;
		}

	case ATTDESCFORM_VALUE_IS_KILLSTREAKEFFECT_INDEX:
		{
			CUtlConstString utf8_KeyName( CFmtStr( "#Attrib_KillStreakEffect%i", (int)value_as_float ).Access() );	// this value is stored as a float but interpreted as an int (1.0 -> 1)
			if ( utf8_KeyName.IsEmpty() )
				return;

			m_loc_sValue = pLocalizationProvider->Find( utf8_KeyName.Get() );
			break;
		}

	case ATTDESCFORM_VALUE_IS_KILLSTREAK_IDLEEFFECT_INDEX:
		{
			CUtlConstString utf8_KeyName( CFmtStr( "#Attrib_KillStreakIdleEffect%i", (int)value_as_float ).Access() );	// this value is stored as a float but interpreted as an int (1.0 -> 1)
			if ( utf8_KeyName.IsEmpty() )
				return;

			m_loc_sValue = pLocalizationProvider->Find( utf8_KeyName.Get() );
			break;
		}
	// Don't output any value for bitmasks, but let the attribute text display.
	case ATTDESCFORM_VALUE_IS_OR:
		break;

	default:
#ifdef CLIENT_DLL
		// Only assert on the client -- the GC will just silently fail rather than crash if we ever run into
		// this case, but if we are adding a new display type this will help us catch a reason why it isn't
		// showing up.
		Assert( !"Unhandled attribute value display type in CEconAttributeDescription." );

		// Anywhere besides the client, we intentionally fall through to return immediately.
#endif
	case ATTDESCFORM_VALUE_IS_ITEM_DEF:			// referencing definitions is handled per-attribute
		return;

	case ATTDESCFORM_VALUE_IS_FROM_LOOKUP_TABLE:
		{
			const char *pszLocalizationToken = GetItemSchema()->FindStringTableEntry( pAttribDef->GetDefinitionName(), (int)value_as_float );
			if ( !pszLocalizationToken )
				return;

			const locchar_t *loc_Entry = pLocalizationProvider->Find( pszLocalizationToken );
			if ( !loc_Entry )
				return;

			m_loc_sValue = loc_Entry;
			break;
		}
	}

	// Some attributes have a short description for the upgrade 
	if ( loc_ShortString )
	{
		m_loc_sShortValue = CConstructLocalizedString( loc_ShortString, m_loc_sValue.Get() );
	}

	// Combine the value string we just generated with the localized display for that value. (ie., the value
	// might be "10" and the display would be "health is increased by 10%".)
	m_loc_sValue = CConstructLocalizedString( loc_String, m_loc_sValue.Get() );

	// Is this an attribute that needs a custom wrapper around the default attribute text? (ie.,
	// if our string was "Damage +10%" we want that to be "(only on Hightower: Damage +10%)")
	if ( pAttribDef->GetUserGenerationType() )
	{
		const locchar_t *locUGTLocalizationKey = pLocalizationProvider->Find( CFmtStr( "#Econ_Attrib_UserGeneratedWrapper_%i", pAttribDef->GetUserGenerationType() ).Get() );

		if ( locUGTLocalizationKey )
		{
			m_loc_sValue = CConstructLocalizedString( locUGTLocalizationKey, m_loc_sValue.Get() );
		}
	}

	// If there's no short description, just copy the normal one
	if ( !loc_ShortString )
	{
		m_loc_sShortValue = m_loc_sValue;
	}
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::AddAttributeDescription( const CLocalizationProvider *pLocalizationProvider, const CEconItemAttributeDefinition *pAttribDef, attrib_value_t value, attrib_colors_t eOverrideDisplayColor /* = NUM_ATTRIB_COLORS */ )
{
	Assert( pLocalizationProvider );
	Assert( pAttribDef );
	
	CEconAttributeDescription AttrDesc( pLocalizationProvider,
										pAttribDef,
										value,
										TF_ANTI_IDLEBOT_VERIFICATION_ONLY_ARG( m_pHashContext ) TF_ANTI_IDLEBOT_VERIFICATION_ONLY_COMMA
										this );

	if ( AttrDesc.GetDescription().IsEmpty() )
		return;

	// Is this an attribute that needs a custom wrapper around the default attribute text? (ie.,
	// if our string was "Damage +10%" we want that to be "(only on Hightower: Damage +10%)")
	attrib_colors_t eDefaultAttribColor = GetAttributeDefaultColor( pAttribDef );

#ifdef TF_CLIENT_DLL
	enum
	{
		kUserGeneratedAttributeType_None				= 0,
		kUserGeneratedAttributeType_MVMEngineering		= 1,
		kUserGeneratedAttributeType_HalloweenSpell		= 2
	};

	// On TF, these user-generated attributes can be from upgrade cards which only apply in MvM.
	// We then colorize them based on whether they'll be active, with the caveat that out-of-game
	// views always say yes (GC, loadout when not on a server, etc.).
	if ( pAttribDef->GetUserGenerationType() == kUserGeneratedAttributeType_MVMEngineering && TFGameRules() && !TFGameRules()->IsMannVsMachineMode() )
	{
		eDefaultAttribColor = ATTRIB_COL_ITEMSET_MISSING;
	}
	// They can also be from Halloween spells. These are intended to expire after Halloween in any
	// event, but for display purposes they'll appear in grey unless the holiday is active.
	else if ( pAttribDef->GetUserGenerationType() == kUserGeneratedAttributeType_HalloweenSpell && !EconHolidays_IsHolidayActive( kHoliday_Halloween, CRTime::RTime32TimeCur() ) )
	{
		eDefaultAttribColor = ATTRIB_COL_ITEMSET_MISSING;
	}
#endif // TF_CLIENT_DLL

	AddDescLine( AttrDesc.GetDescription().Get(),
				 eOverrideDisplayColor != NUM_ATTRIB_COLORS ?					// are we overriding the output color?
					eOverrideDisplayColor :										// we are
					eDefaultAttribColor,										// fall back to normal attribute color
				 kDescLineFlag_Attribute );
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::AddDescLine( const locchar_t *pString, attrib_colors_t eColor, uint32 unMetaType, CUtlVector<econ_item_description_line_t> *out_pOptionalDescLineDest /* = NULL */, item_definition_index_t unDefIndex /* = INVALID_ITEM_DEF_INDEX */, bool bIsItemForSale /*= true*/ )
{
	CUtlVector<econ_item_description_line_t>& vecTargetDescLines = out_pOptionalDescLineDest ? *out_pOptionalDescLineDest : m_vecDescLines;

	econ_item_description_line_t& line = vecTargetDescLines[ vecTargetDescLines.AddToTail() ];

	line.eColor		= eColor;
	line.unMetaType = unMetaType;
	line.sText		= pString;
	line.unDefIndex = unDefIndex;
	line.bIsItemForSale = bIsItemForSale;

#if TF_ANTI_IDLEBOT_VERIFICATION
	if ( m_pHashContext )
	{
		const int iLineCount = vecTargetDescLines.Count() + 1;

		char verboseStringBuf[ k_VerboseStringBufferSize ];
		TFDescription_HashDataMunge( m_pHashContext, iLineCount, m_bIsVerbose, BuildVerboseStrings( verboseStringBuf, m_bIsVerbose, "%d", iLineCount ) );			// which line did we just add?
		TFDescription_HashDataMunge( m_pHashContext, line.eColor, m_bIsVerbose, BuildVerboseStrings( verboseStringBuf, m_bIsVerbose,"%d", line.eColor ) );
		TFDescription_HashDataMunge( m_pHashContext, line.unMetaType, m_bIsVerbose, BuildVerboseStrings( verboseStringBuf, m_bIsVerbose, "%d", line.unMetaType ) );

#ifdef GC_DLL
		COMPILE_TIME_ASSERT( sizeof( locchar_t ) == sizeof( char ) );
		TFDescription_HashDataMungeContents( m_pHashContext, pString, StringFuncs<locchar_t>::Length( pString ) * sizeof( locchar_t ), m_bIsVerbose, pString );
#else
		COMPILE_TIME_ASSERT( sizeof( locchar_t ) == sizeof( wchar_t ) );

		CUtlConstString ansiString;
		GLocalizationProvider()->ConvertLoccharToANSI( pString, &ansiString );
		TFDescription_HashDataMungeContents( m_pHashContext, ansiString.Get(), StringFuncs<char>::Length( ansiString.Get() ) * sizeof( char ), m_bIsVerbose, ansiString.Get() );
#endif
	}
#endif // TF_ANTI_IDLEBOT_VERIFICATION
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::AddEmptyDescLine( CUtlVector<econ_item_description_line_t> *out_pOptionalDescLineDest )
{
	AddDescLine( LOCCHAR(" "), ATTRIB_COL_NEUTRAL, kDescLineFlag_Empty, out_pOptionalDescLineDest );
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
void CEconItemDescription::LocalizedAddDescLine( const CLocalizationProvider *pLocalizationProvider, const char *pLocalizationToken, attrib_colors_t eColor, uint32 unMetaType, CUtlVector<econ_item_description_line_t> *out_pOptionalDescLineDest /* = NULL */, item_definition_index_t unDefIndex /* = INVALID_ITEM_DEF_INDEX */, bool bIsItemForSale /* = true */ )
{
	Assert( pLocalizationToken );

	const locchar_t *pTextToAdd = pLocalizationProvider->Find( pLocalizationToken );

	if ( pTextToAdd )
	{
		AddDescLine( pTextToAdd, eColor, unMetaType, out_pOptionalDescLineDest, unDefIndex, bIsItemForSale );
	}
	else if ( pLocalizationToken && (pLocalizationToken[0] != '#') )
	{
		// If we couldn't localize correctly, we might be a string literal like "My temp item desc.". In
		// this case, we use that string as-is.
		CUtlConstStringBase<locchar_t> loc_sText;
		pLocalizationProvider->ConvertUTF8ToLocchar( pLocalizationToken, &loc_sText );
		AddDescLine( loc_sText.Get(), eColor, unMetaType, out_pOptionalDescLineDest, unDefIndex, bIsItemForSale );
	}
	else
	{
		// We couldn't localize this token, but also don't think it was a string meant to be user-facing so
		// just silently fail.
	}

#if TF_ANTI_IDLEBOT_VERIFICATION
	if ( m_pHashContext )
	{
		TFDescription_HashDataMungeContents( m_pHashContext, pLocalizationToken, V_strlen( pLocalizationToken ), m_bIsVerbose, pLocalizationToken );
	}
#endif // TF_ANTI_IDLEBOT_VERIFICATION
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
class CGameItemDefinition_EconItemInterfaceWrapper : public CMaterialOverrideContainer< IEconItemInterface >
{
public:
	CGameItemDefinition_EconItemInterfaceWrapper( const CEconItemDefinition *pEconItemDefinition, entityquality_t eQuality )
		: m_pEconItemDefinition( pEconItemDefinition )
		, m_eQuality( eQuality )
	{
		Assert( m_pEconItemDefinition );
	}

	virtual const GameItemDefinition_t *GetItemDefinition() const { return assert_cast<const GameItemDefinition_t *>( m_pEconItemDefinition ); }

	virtual itemid_t		GetID() const { return INVALID_ITEM_ID; }
	virtual uint32			GetAccountID() const { return 0; }
	virtual int32			GetQuality() const { return m_eQuality; }
	virtual style_index_t	GetStyle() const { return INVALID_STYLE_INDEX; }
	virtual uint8			GetFlags() const { return 0; }
	virtual eEconItemOrigin GetOrigin() const { return kEconItemOrigin_Invalid; }
	virtual int				GetQuantity() const { return 1; }
	virtual uint32			GetItemLevel() const { return 0; }
	virtual bool			GetInUse() const { return false; }

	virtual const char	   *GetCustomName() const { return NULL; }
	virtual const char	   *GetCustomDesc() const { return NULL; }

	virtual CEconItemPaintKitDefinition *GetCustomPainkKitDefinition( void ) const { return GetItemDefinition()->GetCustomPainkKitDefinition(); }

	// IEconItemInterface attribute iteration interface. This is not meant to be used for
	// attribute lookup! This is meant for anything that requires iterating over the full
	// attribute list.
	virtual void IterateAttributes( class IEconItemAttributeIterator *pIterator ) const OVERRIDE
	{
		Assert( pIterator );

		m_pEconItemDefinition->IterateAttributes( pIterator );
	}

private:
	const CEconItemDefinition *m_pEconItemDefinition;
	entityquality_t m_eQuality;
};

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
CEconItemLocalizedFullNameGenerator::CEconItemLocalizedFullNameGenerator( const CLocalizationProvider *pLocalizationProvider, const CEconItemDefinition *pItemDef, bool bUseProperName, entityquality_t eQuality )
{
	Assert( pItemDef );

	CGameItemDefinition_EconItemInterfaceWrapper EconItemDefinitionWrapper( pItemDef, eQuality );
	GenerateLocalizedFullItemName( m_loc_LocalizedItemName, pLocalizationProvider, &EconItemDefinitionWrapper, k_EGenerateLocalizedFullItemName_Default, bUseProperName );
}

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
class CMarketNameGenerator_EconItemInterfaceWrapper : public IEconItemInterface
{
public:
	CMarketNameGenerator_EconItemInterfaceWrapper( CEconItem *pItem )
		: m_pItem( pItem )
	{
		Assert( m_pItem );
	}

	virtual const GameItemDefinition_t *GetItemDefinition() const { return m_pItem->GetItemDefinition(); }

	virtual itemid_t		GetID() const { return m_pItem->GetID(); }
	virtual uint32			GetAccountID() const { return 0; }
	virtual int32			GetQuality() const { return m_pItem->GetQuality(); }
	virtual style_index_t	GetStyle() const { return INVALID_STYLE_INDEX; }
	virtual uint8			GetFlags() const { return 0; }
	virtual eEconItemOrigin GetOrigin() const { return kEconItemOrigin_Invalid; }
	virtual int				GetQuantity() const { return 1; }
	virtual uint32			GetItemLevel() const { return 0; }
	virtual bool			GetInUse() const { return false; }

	virtual const char	   *GetCustomName() const { return NULL; }
	virtual const char	   *GetCustomDesc() const { return NULL; }

	virtual CEconItemPaintKitDefinition *GetCustomPainkKitDefinition( void ) const { return m_pItem->GetCustomPainkKitDefinition(); }
	virtual bool GetCustomPaintKitWear( float &flWear ) const { return m_pItem->GetCustomPaintKitWear( flWear ); }

	virtual IMaterial	   *GetMaterialOverride( int iTeam ) OVERRIDE { return m_pItem->GetMaterialOverride( iTeam ); }

	// IEconItemInterface attribute iteration interface. This is not meant to be used for
	// attribute lookup! This is meant for anything that requires iterating over the full
	// attribute list.
	virtual void IterateAttributes( class IEconItemAttributeIterator *pIterator ) const OVERRIDE
	{
		Assert( pIterator );

		// Wrap their iterator in our iterator that will selectively let specific attributes
		// get iterated on by the wrapped iterator.
		CMarketNameGenerator_SelectiveAttributeIterator iteratorWrapper( pIterator );
		m_pItem->IterateAttributes( &iteratorWrapper );
	}

private:

	CEconItem *m_pItem;

	// Iterator class that wraps another iterator and selectively allows specific attributes to be
	// iterated by the passed in iterator
	class CMarketNameGenerator_SelectiveAttributeIterator : public IEconItemAttributeIterator
	{
	public:
		CMarketNameGenerator_SelectiveAttributeIterator( IEconItemAttributeIterator* pIterator )
			: m_pIterator( pIterator )
		{}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, attrib_value_t value ) OVERRIDE
		{
			if( pAttrDef->CanAffectMarketName() )
			{
				m_pIterator->OnIterateAttributeValue( pAttrDef, value );
			}

			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, float value ) OVERRIDE
		{
			if( pAttrDef->CanAffectMarketName() )
			{
				m_pIterator->OnIterateAttributeValue( pAttrDef, value );
			}

			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const uint64& value ) OVERRIDE
		{
			if( pAttrDef->CanAffectMarketName() )
			{
				m_pIterator->OnIterateAttributeValue( pAttrDef, value );
			}

			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_String& value ) OVERRIDE
		{
			if( pAttrDef->CanAffectMarketName() )
			{
				m_pIterator->OnIterateAttributeValue( pAttrDef, value );
			}

			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_DynamicRecipeComponent& value ) OVERRIDE
		{
			if( pAttrDef->CanAffectMarketName() )
			{
				m_pIterator->OnIterateAttributeValue( pAttrDef, value );
			}

			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_ItemSlotCriteria& value ) OVERRIDE
		{
			if( pAttrDef->CanAffectMarketName() )
			{
				m_pIterator->OnIterateAttributeValue( pAttrDef, value );
			}

			return true;
		}

		virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_WorldItemPlacement& value ) OVERRIDE
		{
			if ( pAttrDef->CanAffectMarketName() )
			{
				m_pIterator->OnIterateAttributeValue( pAttrDef, value );
			}

			return true;
		}

	private:

		IEconItemAttributeIterator *m_pIterator;
	};
};

// --------------------------------------------------------------------------
// Purpose:
// --------------------------------------------------------------------------
CEconItemLocalizedMarketNameGenerator::CEconItemLocalizedMarketNameGenerator( const CLocalizationProvider *pLocalizationProvider, CEconItem *pItem, bool bUseProperName )
{
	Assert( pItem );

	CMarketNameGenerator_EconItemInterfaceWrapper EconItemWrapper( pItem );
	GenerateLocalizedFullItemName( m_loc_LocalizedItemName, pLocalizationProvider, &EconItemWrapper, k_EGenerateLocalizedFullItemName_WithPaintWear, bUseProperName );
}

#endif // BUILD_ITEM_NAME_AND_DESC