//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Client side stat tracking
//
//=============================================================================//

#include "cbase.h"
#include "c_tf_gamestats.h"
#include <vgui_controls/Controls.h>
#include "vgui/ISystem.h"
#include "steam/steam_api.h"
#include "steamworks_gamestats.h"
#include "c_tf_player.h"
#include "tf_hud_statpanel.h"
#include "econ_item_system.h"
#include "econ_ui.h"

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

// Must run with -gamestats to be able to turn on/off stats with ConVar below.
static ConVar tf_stats_track( "tf_stats_track",
#ifdef _DEBUG
							 "0",
#else
							 "1",
#endif
							 FCVAR_DEVELOPMENTONLY, "Turn on//off tf stats tracking." );

ConVar tf_matchmaking_ogs_odds( "tf_matchmaking_ogs_odds", "0.05", FCVAR_HIDDEN, "Percentage (0...1) of quickplay queries that will report to OGS" );

const char *g_ItemEventNames[] =
{
	// STORE EVENTS
	"store_entered",
	"store_exited",
	"store_tab_changed",
	"store_item_selected",
	"store_item_previewed",
	"store_item_added_to_cart",
	"store_item_removed_from_cart",
	"store_checkout_attempt",
	"store_checkout_failure",
	"store_checkout_success",
	"store_checkout_item",

	// LOADOUT EVENTS
	"loadout_entered",
	"loadout_exited",

	// TRADE EVENTS
	"trading_entered",
	"trading_exited",
	"trading_went_to_armory",
	"trading_returned_from_armory",
	"trading_request_sent",
	"trading_request_received",
	"trading_request_rejected",
	"trading_request_accepted",
	"trading_trade_negotiated",
	"trading_trade_success",
	"trading_trade_failure",
	"trading_item_given",
	"trading_item_received",
	"trading_item_gifted",

	// CRAFTING EVENTS
	"crafting_entered",
	"crafting_exited",
	"crafting_went_to_armory",
	"crafting_returned_from_armory",
	"crafting_view_blueprints",
	"crafting_timeout",
	"crafting_failure",
	"crafting_success",
	"crafting_no_recipe_match",
	"crafting_attempt",
	"crafting_recipe_found",

	// ARMORY EVENTS
	"armory_entered",
	"armory_exited",
	"armory_select_item",
	"armory_browse_wiki",
	"armory_change_filter",

	// GENERAL EVENTS
	"item_received",
	"item_discarded",
	"item_deleted",
	"item_used_tool",
	"item_used_consumable",
	"item_removed_attrib",
	"item_changed_style"

	// NEW STORE EVENTS
	"store2_entered",	// This gets written *in addition* to IE_STORE_ENTERED

	// THESE STORED AS INTEGERS IN THE DATABASE SO THESE ARE NEW
	"item_reset_counters",
	"item_put_into_collection",

	""	// IE_COUNT
};

COMPILE_TIME_ASSERT( ARRAYSIZE( g_ItemEventNames ) == IE_COUNT );

C_CTFGameStats C_CTF_GameStats;

static bool WeaponInfoLessFunc( const int& e1, const int&e2 )
{
	return e1 < e2;
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
// Input  :  - 
//-----------------------------------------------------------------------------
C_CTFGameStats::C_CTFGameStats()
{
	m_ulExperimentValue = (uint64) ~0;

	gamestats = this;
	Clear();	

	m_mapWeaponInfo.SetLessFunc( WeaponInfoLessFunc );
}

//-----------------------------------------------------------------------------
// Purpose: Destructor
// Input  :  - 
//-----------------------------------------------------------------------------
C_CTFGameStats::~C_CTFGameStats()
{
}

//-----------------------------------------------------------------------------
// Purpose: Sets all game stats to their default value
// Input  :  - 
//-----------------------------------------------------------------------------
void C_CTFGameStats::Clear( void )
{
	V_strncpy( m_szCountryCode, "unknown", ARRAYSIZE( m_szCountryCode ) );
	V_strncpy( m_szAudioLanguage, "unknown", ARRAYSIZE( m_szAudioLanguage ) );
	V_strncpy( m_szTextLanguage, "unknown", ARRAYSIZE( m_szTextLanguage ) );

	m_bRoundActive = false;
	m_bIsDisconnecting = false;
}

//-----------------------------------------------------------------------------
// Purpose: Adds our data to the gamestats data that gets uploaded.
//			Returns true if we added data, false if we didn't
//-----------------------------------------------------------------------------
bool C_CTFGameStats::AddDataForSend( KeyValues *pKV, StatSendType_t sendType )
{
	// we only have data to send at level shutdown
	if ( sendType != STATSEND_APPSHUTDOWN || 0 == tf_stats_track.GetInt() )
	{
		return false;
	}

	KeyValues *pKVData = new KeyValues( "tf_configdata" );

	if ( NULL == pKVData )
	{
		Clear();
		return false;
	}

	static ConVarRef sb_quick_list_bit_field( "sb_quick_list_bit_field" );
	if ( sb_quick_list_bit_field.IsValid() )
	{
		pKVData->SetInt( "QuickListBitField", sb_quick_list_bit_field.GetInt() );
	}
	else
	{
		pKVData->SetInt( "QuickListBitField", -1 );
	}
	pKVData->SetString( "TextLanguage", m_szTextLanguage );
	pKVData->SetString( "AudioLanguage", m_szAudioLanguage );
	pKVData->SetString( "CountryCode", m_szCountryCode );

	// Add our tf_configdata as a subkey to the main stat key
	pKV->AddSubKey( pKVData );

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Since this is a very lean client stat reporter, we can grab all the info
//			that we need right in the init call
//-----------------------------------------------------------------------------
bool C_CTFGameStats::Init( void )
{
	// If we are on the PC and have access to all the interfaces we need
	if ( !IsX360() && engine && vgui::system() && steamapicontext && steamapicontext->SteamUtils() )
	{
		// We want to track the country code to help with localization. The countrycode is empty when testing on SteamBeta, so we won't get
		// data until users in the wild play
		const char * countryCode = steamapicontext->SteamUtils()->GetIPCountry();
		if ( countryCode != NULL )
		{
			V_strncpy( m_szCountryCode, countryCode, ARRAYSIZE( m_szCountryCode ) );
		}

		// Now lets get the text language that Steam is in (If the game supports the language, then the UI is changed to that language).
		engine->GetUILanguage( m_szTextLanguage, sizeof( m_szTextLanguage ) );
		
		V_strcpy_safe( m_szAudioLanguage, steamapicontext->SteamApps()->GetCurrentGameLanguage() );

		m_currentSession.m_SessionStart = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();

		ListenForGameEvent( "server_spawn" );
//		ListenForGameEvent( "host_quit" );
		ListenForGameEvent( "player_stats_updated" );
		ListenForGameEvent( "teamplay_round_win" );
		ListenForGameEvent( "teamplay_round_active" );
		ListenForGameEvent( "player_changeclass" );
		ListenForGameEvent( "player_hurt" );
		ListenForGameEvent( "client_disconnect" );

		// A client session lasts from when the application starts to when it is exited.
		GetSteamWorksSGameStatsUploader().StartSession();
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: This system is shutting down.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Shutdown()
{
	if ( !steamapicontext )
		return;
	
	if ( !steamapicontext->SteamUser() )
		return;

	SW_GameStats_WriteClientSessionSummary();
	SW_GameStats_WriteClientWeapons();

	GetSteamWorksSGameStatsUploader().EndSession();
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_LevelInit( void )
{
	m_currentMap.Init( engine->GetLevelName(), engine->GetLevelVersion(), 0, 0, GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );
	m_currentRound.m_iNumRounds = 0;
	m_currentSession.m_iMapsPlayed++;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_LevelShutdown( float flElapsed )
{
	if ( !m_bIsDisconnecting )
	{
		SW_GameStats_WriteClientRound( 0, 0, RE_SERVER_MAP_CHANGE );
	}

	SW_GameStats_WriteClientMap();
}

//-----------------------------------------------------------------------------
// Purpose: Called when the server shuts down or the client disconnects from the server.
//-----------------------------------------------------------------------------
void C_CTFGameStats::ClientDisconnect( int iReason )
{
	m_bIsDisconnecting = true;
	SW_GameStats_WriteClientRound( 0, 0, iReason );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void C_CTFGameStats::FireGameEvent( IGameEvent *event )
{
	const char *pEventName = event->GetName();
	if ( FStrEq( "server_spawn", pEventName ) )
	{
		if ( m_currentSession.m_FirstConnect == 0 )
		{
			m_currentSession.m_FirstConnect = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
		}

		// In case we join a round that is active, stuff the current time as the round start time.
		m_currentRound.m_iRoundStartTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
		m_currentMap.m_iRoundStartTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();

		m_bIsDisconnecting = false;
	}
	else if ( FStrEq( "host_quit", pEventName ) )
	{
		// We need this event because client_disconnect is called after the level unloads
		// when we're dealing with the client-host of a listen server. Frustrating exception to
		// the normal disconnect/shutdown rules.
		ClientDisconnect( RE_CLIENT_QUIT );
	}
	else if ( FStrEq( "client_disconnect", pEventName ) )
	{
		ClientDisconnect( RE_CLIENT_DISCONNECT );
	}
	else if ( FStrEq( "teamplay_round_win", pEventName ) )
	{
		int winningTeam = event->GetInt( "team" );
		float roundTime = event->GetFloat( "round_time" );
		int fullRound = event->GetInt( "full_round" );
		Event_RoundEnd( winningTeam, roundTime, fullRound );
	}
	else if ( FStrEq( "teamplay_round_active", pEventName ) )
	{
		Event_RoundActive();
	}
	else if ( FStrEq( "player_changeclass", pEventName ) )
	{
		int userid = event->GetInt( "userid" );
		int classid = event->GetInt( "class" );
		Event_PlayerChangeClass( userid, classid );
	}
	else if ( FStrEq( "player_hurt", pEventName ) )
	{
		Event_PlayerHurt( event );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_RoundActive()
{
	m_currentRound.m_iRoundStartTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
	m_currentMap.m_iRoundStartTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
	m_bRoundActive = true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_RoundEnd( int winningTeam, float roundTime, int fullRound )
{
	SW_GameStats_WriteClientRound( winningTeam, fullRound, RE_ROUND_END );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_PlayerChangeClass( int userid, int classid )
{
	C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pTFPlayer )
		return;

	if ( pTFPlayer != UTIL_PlayerByIndex( engine->GetPlayerForUserID( userid ) ) )
		return;

	m_currentSession.m_ClassesPlayed.Set( classid );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_PlayerHurt( IGameEvent* event /*player_hurt*/ )
{
	C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pTFPlayer )
		return;

	int attackerid = event->GetInt( "attacker" );
	if ( pTFPlayer != UTIL_PlayerByIndex( engine->GetPlayerForUserID( attackerid ) ) )
		return;

	if ( !m_bRoundActive )
		return;

	// My kingdom for a proper damage effects system.
	// We need to ignore DOTS in some stats.
	int custom = event->GetInt( "custom" );
	bool bIsDamageOverTime = IsDOTDmg( custom );
	bool bIsTauntDamage = IsTauntDmg( custom );

	// Update weapon info with this hit.
	int weaponid = event->GetInt( "weaponid" );
	int damageamount = event->GetInt( "damageamount" );

	TF_Gamestats_WeaponInfo_t info;

	int idx = m_mapWeaponInfo.Find( weaponid );
	if ( idx == m_mapWeaponInfo.InvalidIndex() )
	{
		info.weaponID = weaponid;
		idx = m_mapWeaponInfo.Insert( weaponid, info );
	}
	else
	{
		info = m_mapWeaponInfo[idx];
	}

	info.totalDamage += damageamount;

	if ( !bIsDamageOverTime && !bIsTauntDamage && (gpGlobals->curtime != info.lastUpdateTime) )
	{
		bool crit = event->GetInt( "crit" );
		if ( crit )
		{
			info.critHits++;
		}
		info.shotsHit++;
		info.shotsMissed--;
	}

	if ( info.shotsHit )
	{
		info.avgDamage = info.totalDamage / info.shotsHit;
	}
	else
	{
		info.avgDamage = 0;
	}

	info.lastUpdateTime = gpGlobals->curtime;

	m_mapWeaponInfo[idx] = info;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_PlayerFiredWeapon( C_TFPlayer *pPlayer, bool bCritical )
{
	C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pPlayer || (pTFPlayer != pPlayer) )
		return;

	if ( !m_bRoundActive )
		return;

	CTFWeaponBase *pTFWeapon = pPlayer->GetActiveTFWeapon();
	if ( pTFWeapon )
	{
		// all shots are assumed to be misses until they hit
		int iWeaponID = pTFWeapon->GetWeaponID();

		TF_Gamestats_WeaponInfo_t info;

		int idx = m_mapWeaponInfo.Find( iWeaponID );
		if ( idx == m_mapWeaponInfo.InvalidIndex() )
		{
			info.weaponID = iWeaponID;
			idx = m_mapWeaponInfo.Insert( iWeaponID, info );
		}
		else
		{
			info = m_mapWeaponInfo[idx];
		}

		info.shotsFired++;
		info.shotsMissed++;
		if ( bCritical )
		{
			info.critsFired++;
		}

		m_mapWeaponInfo[idx] = info;
	}
}

//-----------------------------------------------------------------------------
// Purpose: New Steamworks Database Client Data
// Sends the client's session summary report.
//-----------------------------------------------------------------------------
void C_CTFGameStats::SW_GameStats_WriteClientSessionSummary()
{
#if !defined(NO_STEAM)
	KeyValues* pKVData = new KeyValues( "TF2ClientSessionDetails" );

	pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );

	RTime32 currentClock = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();

	pKVData->SetInt( "StartTime", m_currentSession.m_SessionStart );
	pKVData->SetInt( "EndTime", currentClock );

	if ( GetSteamWorksSGameStatsUploader().GetNumServerConnects() > 0 )
	{
		pKVData->SetInt( "ServerConnects", GetSteamWorksSGameStatsUploader().GetNumServerConnects() );
	}

	ConVarRef sb_firstopentime( "sb_firstopentime" );

	if ( m_currentSession.m_FirstConnect > 0 )
	{
		int iTimeFromStartToJoin = m_currentSession.m_FirstConnect - m_currentSession.m_SessionStart;
		pKVData->SetInt( "TimeFromStartToJoin", iTimeFromStartToJoin );
	}

	if ( sb_firstopentime.GetInt() > 0 &&
		 m_currentSession.m_FirstConnect > 0 )
	{
		int iTimeFromBrowseToJoin = m_currentSession.m_FirstConnect - sb_firstopentime.GetInt();
		if ( iTimeFromBrowseToJoin > 0 )
		{
			pKVData->SetInt( "TimeFromBrowseToJoin", iTimeFromBrowseToJoin );
		}
	}

	if ( sb_firstopentime.GetInt() > 0 )
	{
		int iTimeFromStartToBrowse = sb_firstopentime.GetInt() - m_currentSession.m_SessionStart;
		pKVData->SetInt( "TimeFromStartToBrowse", iTimeFromStartToBrowse );
	}

	ConVarRef sb_numtimesopened( "sb_numtimesopened" );
	pKVData->SetInt( "TimesOpenedServerBrowser", sb_numtimesopened.GetInt() );

	int iClassesPlayed = 0;
	for ( int i=TF_FIRST_NORMAL_CLASS; i<TF_LAST_NORMAL_CLASS; ++i )
	{
		if ( m_currentSession.m_ClassesPlayed.IsBitSet( i ) )
		{
			iClassesPlayed++;
		}
	}

	if ( iClassesPlayed > 0 )
	{
		pKVData->SetInt( "ClassesPlayed", iClassesPlayed );
	}

	if ( m_currentSession.m_iMapsPlayed > 0 )
	{
		pKVData->SetInt( "MapsPlayed", m_currentSession.m_iMapsPlayed );
	}

	if ( m_currentSession.m_iRoundsPlayed > 0 )
	{
		pKVData->SetInt( "RoundsPlayed", m_currentSession.m_iRoundsPlayed );
	}

	/*
	FavoriteClass
	FavoriteWeapon
	FavoriteMap
	*/

	if ( m_currentSession.m_Summary.iKills > 0 )
	{
		pKVData->SetInt( "Kills", m_currentSession.m_Summary.iKills );
	}

	if ( m_currentSession.m_Summary.iDeaths > 0 )
	{
		pKVData->SetInt( "Deaths", m_currentSession.m_Summary.iDeaths );
	}

	if ( m_currentSession.m_Summary.iSuicides > 0 )
	{
		pKVData->SetInt( "Suicides", m_currentSession.m_Summary.iSuicides );
	}

	if ( m_currentSession.m_Summary.iAssists > 0 )
	{
		pKVData->SetInt( "Assists", m_currentSession.m_Summary.iAssists );
	}

	if ( m_currentSession.m_Summary.iBuildingsBuilt > 0 )
	{
		pKVData->SetInt( "BuildingsBuilt", m_currentSession.m_Summary.iBuildingsBuilt );
	}

	if ( m_currentSession.m_Summary.iBuildingsDestroyed > 0 )
	{
		pKVData->SetInt( "BuildingsDestroyed", m_currentSession.m_Summary.iBuildingsDestroyed );
	}

	if ( m_currentSession.m_Summary.iHeadshots > 0 )
	{
		pKVData->SetInt( "Headshots", m_currentSession.m_Summary.iHeadshots );
	}

	if ( m_currentSession.m_Summary.iDominations > 0 )
	{
		pKVData->SetInt( "Dominations", m_currentSession.m_Summary.iDominations );
	}

	if ( m_currentSession.m_Summary.iRevenges > 0 )
	{
		pKVData->SetInt( "Revenges", m_currentSession.m_Summary.iRevenges );
	}

	if ( m_currentSession.m_Summary.iInvulns > 0 )
	{
		pKVData->SetInt( "Invulns", m_currentSession.m_Summary.iInvulns );
	}

	if ( m_currentSession.m_Summary.iTeleports > 0 )
	{
		pKVData->SetInt( "Teleports", m_currentSession.m_Summary.iTeleports );
	}

	if ( m_currentSession.m_Summary.iDamageDone > 0 )
	{
		pKVData->SetInt( "DamageDone", m_currentSession.m_Summary.iDamageDone );
	}

	if ( m_currentSession.m_Summary.iHealingDone > 0 )
	{
		pKVData->SetInt( "HealingDone", m_currentSession.m_Summary.iHealingDone );
	}

	if ( m_currentSession.m_Summary.iCrits > 0 )
	{
		pKVData->SetInt( "Crits", m_currentSession.m_Summary.iCrits );
	}

	if ( m_currentSession.m_Summary.iBackstabs > 0 )
	{
		pKVData->SetInt( "Backstabs", m_currentSession.m_Summary.iBackstabs );
	}

	if ( m_currentSession.m_Summary.iAchievementsEarned > 0 )
	{
		pKVData->SetInt( "AchievementsEarned", m_currentSession.m_Summary.iAchievementsEarned );
	}

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
#endif
}

extern CBaseGameStats_Driver CBGSDriver;

//-----------------------------------------------------------------------------
// Purpose: New Steamworks Database Client Map Data
//-----------------------------------------------------------------------------
void C_CTFGameStats::SW_GameStats_WriteClientMap()
{
#if !defined(NO_STEAM)
	KeyValues* pKVData = new KeyValues( "TF2ClientMaps" );

	pKVData->SetInt( "MapIndex", m_currentSession.m_iMapsPlayed );
	pKVData->SetInt( "StartTime", m_currentMap.m_iMapStartTime );
	pKVData->SetInt( "EndTime", GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );
	pKVData->SetString( "MapID", m_currentMap.m_Header.m_szMapName );

	const char* pszGameTypeID = GetGameTypeID();
	if ( pszGameTypeID )
	{
		pKVData->SetString( "GameTypeID", pszGameTypeID  );
	}

	pKVData->SetInt( "RoundsPlayed", m_currentMap.m_Header.m_iRoundsPlayed );
	pKVData->SetInt( "MapVersion", m_currentMap.m_Header.m_nMapRevision );

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: New Steamworks Database Client Round Data
//-----------------------------------------------------------------------------
void C_CTFGameStats::SW_GameStats_WriteClientRound( int winningTeam, int fullRound, int endReason )
{
	if ( !m_bRoundActive )
		return;

	m_bRoundActive = false;

	m_currentSession.m_iRoundsPlayed++;
	m_currentMap.m_Header.m_iRoundsPlayed++;

#if !defined(NO_STEAM)
	KeyValues* pKVData = new KeyValues( "TF2ClientRounds" );

	C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( !pTFPlayer )
		return;

	localplayerscoring_t *pData = pTFPlayer->m_Shared.GetRoundScoringData();
	if ( !pData )
		return;

 	pKVData->SetInt( "MapIndex", m_currentSession.m_iMapsPlayed );
	pKVData->SetInt( "RoundIndex", m_currentMap.m_Header.m_iRoundsPlayed );
	pKVData->SetInt( "StartTime", m_currentRound.m_iRoundStartTime );
	pKVData->SetInt( "EndTime", GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch() );

	pKVData->SetString( "EndReason", ClampedArrayElement( g_aRoundEndReasons, endReason ) );

	winningTeam = clamp( winningTeam, 0, TF_TEAM_COUNT - 1 );
	pKVData->SetString( "WinningTeam", ClampedArrayElement( g_aTeamNames, winningTeam ) );

	if ( fullRound > 0 )
	{
		pKVData->SetInt( "FullRound", fullRound );
	}

	if ( pData->m_iPoints > 0 )
	{
		pKVData->SetInt( "PointsScored", pData->m_iPoints );
	}

	if ( pData->m_iBonusPoints > 0 )
	{
		pKVData->SetInt( "BonusPointsScored", pData->m_iBonusPoints );
	}

	if ( pData->m_iKills > 0 )
	{
		pKVData->SetInt( "Kills", pData->m_iKills );
	}

	if ( pData->m_iDeaths > 0 )
	{
		pKVData->SetInt( "Deaths", pData->m_iDeaths );
	}

	if ( pData->m_iSuicides > 0 )
	{
		pKVData->SetInt( "Suicides", pData->m_iSuicides );
	}

	if ( pData->m_iKillAssists > 0 )
	{
		pKVData->SetInt( "Assists", pData->m_iKillAssists );
	}

	if ( pData->m_iBuildingsBuilt > 0 )
	{
		pKVData->SetInt( "BuildingsBuilt", pData->m_iBuildingsBuilt );
	}

	if ( pData->m_iBuildingsDestroyed > 0 )
	{
		pKVData->SetInt( "BuildingsDestroyed", pData->m_iBuildingsDestroyed );
	}

	if ( pData->m_iHeadshots > 0 )
	{
		pKVData->SetInt( "Headshots", pData->m_iHeadshots );
	}

	if ( pData->m_iDominations > 0 )
	{
		pKVData->SetInt( "Dominations", pData->m_iDominations );
	}

	if ( pData->m_iRevenge > 0 )
	{
		pKVData->SetInt( "Revenges", pData->m_iRevenge );
	}

	if ( pData->m_iInvulns > 0 )
	{
		pKVData->SetInt( "Invulns", pData->m_iInvulns );		
	}

	if ( pData->m_iTeleports > 0 )
	{
		pKVData->SetInt( "Teleports", pData->m_iTeleports );
	}

	if ( pData->m_iDamageDone > 0 )
	{
		pKVData->SetInt( "DamageDone", pData->m_iDamageDone );
	}

	if ( pData->m_iHealPoints > 0 )
	{
		pKVData->SetInt( "HealingDone", pData->m_iHealPoints );
	}

	if ( pData->m_iCrits > 0 )
	{
		pKVData->SetInt( "Crits", pData->m_iCrits );
	}

	if ( pData->m_iBackstabs > 0 )
	{
		pKVData->SetInt( "Backstabs", pData->m_iBackstabs );
	}

	// Add totals to the current session.
	m_currentSession.m_Summary.iKills += pData->m_iKills;
	m_currentSession.m_Summary.iDeaths += pData->m_iDeaths;
	m_currentSession.m_Summary.iSuicides += pData->m_iSuicides;
	m_currentSession.m_Summary.iAssists += pData->m_iKillAssists;
	m_currentSession.m_Summary.iBuildingsBuilt += pData->m_iBuildingsBuilt;
	m_currentSession.m_Summary.iBuildingsDestroyed += pData->m_iBuildingsDestroyed;
	m_currentSession.m_Summary.iHeadshots += pData->m_iHeadshots;
	m_currentSession.m_Summary.iDominations += pData->m_iDominations;
	m_currentSession.m_Summary.iRevenges += pData->m_iRevenge;
	m_currentSession.m_Summary.iInvulns += pData->m_iInvulns;
	m_currentSession.m_Summary.iTeleports += pData->m_iTeleports;
	m_currentSession.m_Summary.iDamageDone += pData->m_iDamageDone;
	m_currentSession.m_Summary.iHealingDone += pData->m_iHealPoints;
	m_currentSession.m_Summary.iCrits += pData->m_iCrits;
	m_currentSession.m_Summary.iBackstabs += pData->m_iBackstabs;

	m_currentRound.Reset(); // Not used anymore?

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: New Steamworks Database Weapons Data
//-----------------------------------------------------------------------------
void C_CTFGameStats::SW_GameStats_WriteClientWeapons()
{
#if !defined(NO_STEAM)
	for ( unsigned int i=0; i<m_mapWeaponInfo.Count(); ++i )
	{
		KeyValues* pKVData = new KeyValues( "TF2ClientWeapons" );

		TF_Gamestats_WeaponInfo_t info = m_mapWeaponInfo[i];

		pKVData->SetString( "WeaponID", ClampedArrayElement( g_aWeaponNames, info.weaponID ) );

		if ( info.shotsFired > 0 )
		{
			pKVData->SetInt( "ShotsFired", info.shotsFired );
		}

		if ( info.shotsHit > 0 )
		{
			pKVData->SetInt( "ShotsHit", info.shotsHit );
		}

		if ( info.shotsMissed > 0 )
		{
			pKVData->SetInt( "ShotsMissed", info.shotsMissed );
		}

		if ( info.critsFired > 0 )
		{
			pKVData->SetInt( "CritsFired", info.critsFired );
		}

		if ( info.critHits > 0 )
		{
			pKVData->SetInt( "CritHits", info.critHits );
		}

		if ( info.avgDamage > 0 )
		{
			pKVData->SetInt( "AvgDamage", info.avgDamage );
		}

		if ( info.totalDamage > 0 )
		{
			pKVData->SetInt( "TotalDamage", info.totalDamage );
		}

		GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Records client achievement events for reporting to steam.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_AchievementProgress( int achievementID, const char* achievementName )
{
	TF_Gamestats_AchievementEvent_t event( achievementID, achievementName );
	m_vecAchievementEvents.AddToTail( event );

	m_currentSession.m_Summary.iAchievementsEarned++;

	KeyValues* pKVData = new KeyValues( "TF2ClientAchievements" );
	pKVData->SetInt( "TimeEarned", event.eventTime );
	pKVData->SetInt( "AchievementNum", event.achievementNum );
	pKVData->SetString( "AchievementID", event.achievementID );
	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}

//-----------------------------------------------------------------------------
// Purpose: Weapon stats
//-----------------------------------------------------------------------------
TF_Gamestats_WeaponInfo_t::TF_Gamestats_WeaponInfo_t()
{
	weaponID = 0;
	critsFired = 0;
	shotsFired = 0;
	shotsHit = 0;
	shotsMissed = 0;
	avgDamage = 0;
	totalDamage = 0;
	critHits = 0;
	lastUpdateTime = 0;
}

//-----------------------------------------------------------------------------
// Purpose: Achievement progress recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_AchievementEvent_t::TF_Gamestats_AchievementEvent_t( int in_achievementNum, const char* in_achievementID )
{
	eventTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
	achievementNum = in_achievementNum;
	achievementID = in_achievementID;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
TF_Gamestats_ClientSession_t::TF_Gamestats_ClientSession_t()
{
	Reset();
}

//-----------------------------------------------------------------------------
// Purpose: Reset the client session data.
//-----------------------------------------------------------------------------
void TF_Gamestats_ClientSession_t::Reset()
{
	Q_memset( &m_Summary, 0, sizeof( m_Summary ) );
	m_SessionStart = 0;
	m_FirstConnect = 0;
	m_iMapsPlayed = 0;
	m_iRoundsPlayed = 0;
	m_ClassesPlayed.ClearAll();
}

//-----------------------------------------------------------------------------
// Purpose: Item event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_ItemEvent::TF_Gamestats_ItemEvent( int in_eventNum, CEconItemView* in_item )
{
	static CSchemaAttributeDefHandle pAttrDef_SupplyCrateSeries( "set supply crate series" );

	bUseNameBuf = false;

	eventTime = GetSteamWorksSGameStatsUploader().GetTimeSinceEpoch();
	eventNum = in_eventNum;
	eventID = g_ItemEventNames[eventNum];

	if ( in_item )
	{
		itemDefIndex = in_item->GetItemDefIndex();
		itemID = in_item->GetItemID();
		itemName = in_item->GetStaticData()->GetDefinitionName();

		// If this is a crate, quality is the series.
		float fSeries;
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( in_item, pAttrDef_SupplyCrateSeries, &fSeries ) )
		{
			bUseNameBuf = true;
			Q_snprintf( itemNameBuf, sizeof( itemNameBuf ), "%s, Series %i", itemName, (int)fSeries );
		}
	}
	else
	{
		itemDefIndex = 0;
		itemID = 0;
		itemName = NULL;
	}
}

//----------------------------------------------------------------------------
// Purpose: Records a catalog event for reporting.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_Catalog( int eventID, const char* filter, CEconItemView* item )
{
	TF_Gamestats_CatalogEvent event( eventID, item, filter );
	m_vecCatalogEvents.AddToTail( event );

	KeyValues* pKVData = new KeyValues( "TF2ClientCatalogEvents" );
	pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
	pKVData->SetInt( "EventCount", m_vecCatalogEvents.Count() );
	pKVData->SetInt( "EventTime", event.eventTime );
	pKVData->SetString( "ItemEventID", event.eventID );
	if ( event.catalogFilter )
	{
		pKVData->SetString( "CatFilterID", event.catalogFilter );
	}
	if ( event.itemID > 0 )
	{
		pKVData->SetUint64( "GlobalIndex", event.itemID );
	}
	if ( event.itemDefIndex > 0 )
	{
		pKVData->SetInt( "DefIndex", event.itemDefIndex );
	}
	if ( event.GetItemName() != NULL )
	{
		pKVData->SetString( "ItemNameID", event.GetItemName() );
	}

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}

//-----------------------------------------------------------------------------
// Purpose: Catalog event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_CatalogEvent::TF_Gamestats_CatalogEvent( int in_eventNum, CEconItemView* in_item, const char* filter )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
	catalogFilter = filter;
}

//----------------------------------------------------------------------------
// Purpose: Records a catalog event for reporting.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_Crafting( int eventID, CEconItemView* item, int numAttempts, int recipeFound )
{
	TF_Gamestats_CraftingEvent event( eventID, item, numAttempts, recipeFound );
	m_vecCraftingEvents.AddToTail( event );

	KeyValues* pKVData = new KeyValues( "TF2ClientCraftingEvents" );
	pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
	pKVData->SetInt( "EventCount", m_vecCraftingEvents.Count() );
	pKVData->SetInt( "EventTime", event.eventTime );
	pKVData->SetString( "ItemEventID", event.eventID );

	if ( event.itemID > 0 )
	{
		pKVData->SetUint64( "GlobalIndex", event.itemID );
	}
	if ( event.itemDefIndex > 0 )
	{
		pKVData->SetInt( "DefIndex", event.itemDefIndex );
	}
	if ( event.GetItemName() != NULL )
	{
		pKVData->SetString( "ItemNameID", event.GetItemName() );
	}

	if ( event.numAttempts > 0 )
	{
		pKVData->SetInt( "CraftAttemptNum", event.numAttempts );
	}

	if ( event.recipeFound > 0 )
	{
		pKVData->SetInt( "RecipeFound", event.recipeFound );
	}

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}

//-----------------------------------------------------------------------------
// Purpose: Crafting event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_CraftingEvent::TF_Gamestats_CraftingEvent( int in_eventNum, CEconItemView* in_item, int in_numAttempts, int in_recipe )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
	numAttempts = in_numAttempts;
	recipeFound = in_recipe;
}

//----------------------------------------------------------------------------
// Purpose: Records a store event for reporting.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_Store( int eventID, CEconItemView* item, const char* panelName, int classId, 
								 const cart_item_t* cartItem, int checkoutAttempts, const char* storeError, int totalPrice, int currencyCode )
{
	TF_Gamestats_StoreEvent event( eventID, item, panelName, classId, cartItem, checkoutAttempts, storeError, totalPrice, currencyCode );
	m_vecStoreEvents.AddToTail( event );

	KeyValues* pKVData = new KeyValues( "TF2ClientStoreEvents" );
	pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
	pKVData->SetInt( "EventCount", m_vecStoreEvents.Count() );
	pKVData->SetInt( "EventTime", event.eventTime );
	pKVData->SetString( "ItemEventID", event.eventID );

	if ( event.eventNum == IE_STORE_ENTERED || event.eventNum == IE_STORE2_ENTERED )
	{
		if ( m_ulExperimentValue != ((int64) ~0) )
		{
			pKVData->SetUint64( "GlobalIndex", m_ulExperimentValue );
		}
	}
	else
	{
		if ( event.itemID > 0 )
		{
			pKVData->SetUint64( "GlobalIndex", event.itemID );
		}
	}

	if ( event.itemDefIndex > 0 )
	{
		pKVData->SetInt( "DefIndex", event.itemDefIndex );
	}
	if ( event.GetItemName() != NULL )
	{
		pKVData->SetString( "ItemNameID", event.GetItemName() );
	}

	if ( event.panelName != NULL )
	{
		pKVData->SetString( "StorePanelID", event.panelName );
	}
	if ( event.classId > 0 )
	{
		int iClass = clamp( event.classId, 0, TF_CLASS_COUNT-1 );
		pKVData->SetString( "ClassID", g_aPlayerClassNames_NonLocalized[iClass] );
	}
	if ( event.cartQuantity > 0 )
	{
		pKVData->SetInt( "NewQuantity", event.cartQuantity );
	}
	if ( event.cartItemCost > 0 )
	{
		pKVData->SetInt( "Price", event.cartItemCost );
	}
	if ( event.currencyCode > 0 )
	{
		pKVData->SetInt( "CurrencyCode", event.currencyCode-1 );
	}
	if ( event.checkoutAttempt > 0 )
	{
		pKVData->SetInt( "CheckoutAttemptNum", event.checkoutAttempt );
	}
	if ( event.storeError != NULL )
	{
		pKVData->SetString( "StoreErrorID", event.storeError );
	}

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}

//-----------------------------------------------------------------------------
// Purpose: Store event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_StoreEvent::TF_Gamestats_StoreEvent( int in_eventNum, CEconItemView* in_item, const char* in_panelName, int in_classId, 
												 const cart_item_t* in_cartItem, int in_checkoutAttempts, const char* in_storeError, int in_totalPrice, int in_currencyCode )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
	classId = in_classId;

	checkoutAttempt = in_checkoutAttempts;

	storeError = NULL;
	if ( in_storeError )
	{
		storeError = in_storeError;
	}

	panelName = NULL;
	if ( in_panelName )
	{
		panelName = in_panelName;
	}

	cartQuantity = 0;
	cartItemCost = 0;
	currencyCode = in_currencyCode;

	if ( in_cartItem )
	{
		CEconItemDefinition *pItemDef = ItemSystem()->GetStaticDataForItemByDefIndex( in_cartItem->pEntry->GetItemDefinitionIndex() );
		if ( pItemDef )
		{
			itemDefIndex = in_cartItem->pEntry->GetItemDefinitionIndex();
			itemName = pItemDef->GetDefinitionName();
			cartQuantity = in_cartItem->iQuantity;
			cartItemCost = in_cartItem->pEntry->GetCurrentPrice( (ECurrency)in_currencyCode );
		}
	}

	if ( in_eventNum == IE_STORE_CHECKOUT_SUCCESS && in_totalPrice > 0 )
	{
		cartItemCost = in_totalPrice;
	}
}

//----------------------------------------------------------------------------
// Purpose: Records a general item transaction event.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_ItemTransaction( int eventID, CEconItemView* item, const char* pszReason, int iQuality )
{
	TF_Gamestats_ItemTransactionEvent event( eventID, item, pszReason, iQuality );
	m_vecItemTransactionEvents.AddToTail( event );

	KeyValues* pKVData = new KeyValues( "TF2ClientItemTransactionEvents" );
	pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
	pKVData->SetInt( "EventCount", m_vecItemTransactionEvents.Count() );
	pKVData->SetInt( "EventTime", event.eventTime );
	pKVData->SetString( "ItemEventID", event.eventID );
	if ( event.itemID > 0 )
	{
		pKVData->SetUint64( "GlobalIndex", event.itemID );
	}
	if ( event.itemDefIndex > 0 )
	{
		pKVData->SetInt( "DefIndex", event.itemDefIndex );
	}
	if ( event.GetItemName() != NULL )
	{
		pKVData->SetString( "ItemNameID", event.GetItemName() );
	}
	if ( event.reason )
	{
		pKVData->SetString( "ItemTransReasonID", event.reason );
	}

	if ( event.itemQuality > 0 )
	{
		pKVData->SetInt( "ItemQuality", event.itemQuality );
	}

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}

//-----------------------------------------------------------------------------
// Purpose: Transaction event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_ItemTransactionEvent::TF_Gamestats_ItemTransactionEvent( int in_eventNum, CEconItemView* in_item, const char* in_reason, int in_quality )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
	static CSchemaAttributeDefHandle pAttrDef_SupplyCrateSeries( "set supply crate series" );

	reason = in_reason;
	if ( in_item )
	{
		itemQuality = in_item->GetItemQuality();

		// If this is a crate, quality is the series.
		float fSeries;
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( in_item, pAttrDef_SupplyCrateSeries, &fSeries ) )
		{
			in_quality = fSeries;
		}
	}

	if ( in_quality > 0 )
	{
		// For crates, indicates the series.
		itemQuality = in_quality;
	}
}

void C_CTFGameStats::Event_Trading( TF_Gamestats_TradeEvent& event )
{
	KeyValues* pKVData = new KeyValues( "TF2ClientTradeEvents" );
	pKVData->SetUint64( "AccountID", steamapicontext->SteamUser()->GetSteamID().ConvertToUint64() );
	pKVData->SetInt( "EventCount", m_vecTradeEvents.Count() );
	pKVData->SetInt( "EventTime", event.eventTime );
	pKVData->SetString( "ItemEventID", event.eventID );

	if ( event.itemID > 0 )
	{
		pKVData->SetUint64( "GlobalIndex", event.itemID );
	}
	if ( event.itemDefIndex > 0 )
	{
		pKVData->SetInt( "DefIndex", event.itemDefIndex );
	}
	if ( event.GetItemName() != NULL )
	{
		pKVData->SetString( "ItemNameID", event.GetItemName() );
	}

	if ( event.localPlayerPartyMatters )
	{
		pKVData->SetInt( "IsLocalPlayerPartyA", event.localPlayerIsPartyA );
	}

	if ( event.steamIDPartyA > 0 )
	{
		pKVData->SetUint64( "SteamIDPartyA", event.steamIDPartyA );
	}

	if ( event.steamIDPartyB > 0 )
	{
		pKVData->SetUint64( "SteamIDPartyB", event.steamIDPartyB );
	}

	if ( event.steamIDRequested > 0 )
	{
		pKVData->SetUint64( "RequestedTradeWithSteamID", event.steamIDRequested );
	}

	if ( event.tradeRequests > 0 )
	{
		pKVData->SetInt( "TradeRequestIndex", event.tradeRequests );
	}

	if ( event.tradeAttempts > 0 )
	{
		pKVData->SetInt( "TradeAttemptIndex", event.tradeAttempts );
	}

	if ( event.reason )
	{
		pKVData->SetString( "TradeReasonID", event.reason );
	}

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}

//----------------------------------------------------------------------------
// Purpose: Records an item trade event.
//-----------------------------------------------------------------------------
void C_CTFGameStats::Event_Trading( int eventID, CEconItemView* item, bool localPlayerIsPartyA,
								   uint64 steamIDPartyA, uint64 steamIDPartyB, int iTradeRequests, int iTradeAttempts )
{
	TF_Gamestats_TradeEvent event( eventID, item, localPlayerIsPartyA, 
		steamIDPartyA, steamIDPartyB, iTradeRequests, iTradeAttempts );
	m_vecTradeEvents.AddToTail( event );

	Event_Trading( event );
}

void C_CTFGameStats::Event_Trading( int eventID, uint64 steamIDRequested, int iTradeRequests, int iTradeAttempts )
{
	TF_Gamestats_TradeEvent event( eventID, steamIDRequested, iTradeRequests, iTradeAttempts );
	m_vecTradeEvents.AddToTail( event );

	Event_Trading( event );
}

void C_CTFGameStats::Event_Trading( int eventID, int iTradeRequests, const char* reason, int iTradeAttempts )
{
	TF_Gamestats_TradeEvent event( eventID, iTradeRequests, reason, iTradeAttempts );
	m_vecTradeEvents.AddToTail( event );

	Event_Trading( event );
}

//-----------------------------------------------------------------------------
// Purpose: Trade event recorder.
//-----------------------------------------------------------------------------
TF_Gamestats_TradeEvent::TF_Gamestats_TradeEvent( int in_eventNum, CEconItemView* in_item, bool in_localPlayerIsPartyA,
												 uint64 in_steamIDPartyA, uint64 in_steamIDPartyB, 
												 int in_tradeRequests, int in_tradeAttempts )
: TF_Gamestats_ItemEvent( in_eventNum, in_item )
{
	localPlayerPartyMatters = true;
	localPlayerIsPartyA = in_localPlayerIsPartyA;
	steamIDPartyA = in_steamIDPartyA;
	steamIDPartyB = in_steamIDPartyB;

	steamIDRequested = 0;
	tradeRequests = in_tradeRequests;
	tradeAttempts = in_tradeAttempts;

	reason = NULL;
}

TF_Gamestats_TradeEvent::TF_Gamestats_TradeEvent( int in_eventNum, uint64 in_steamIDRequested, 
												 int in_tradeRequests, int in_tradeAttempts )
: TF_Gamestats_ItemEvent( in_eventNum, NULL )
{
	localPlayerPartyMatters = false;
	localPlayerIsPartyA = false;
	steamIDPartyA = 0;
	steamIDPartyB = 0;

	steamIDRequested = in_steamIDRequested;
	tradeRequests = in_tradeRequests;
	tradeAttempts = in_tradeAttempts;

	reason = NULL;
}

TF_Gamestats_TradeEvent::TF_Gamestats_TradeEvent( int in_eventNum, int in_tradeRequests, const char* in_reason, int in_tradeAttempts )
: TF_Gamestats_ItemEvent( in_eventNum, NULL )
{
	localPlayerPartyMatters = false;
	localPlayerIsPartyA = false;
	steamIDPartyA = 0;
	steamIDPartyB = 0;

	steamIDRequested = 0;
	tradeRequests = in_tradeRequests;
	tradeAttempts = in_tradeAttempts;

	reason = in_reason;
}

//-----------------------------------------------------------------------------
// Purpose: Interface stats recorder.
//-----------------------------------------------------------------------------

static const bool g_bRecordClientInterfaceEventsToOGS = false;

/*static*/ void C_CTFGameStats::ImmediateWriteInterfaceEvent( const char *pszEventType, const char *pszEventDesc )
{
	if ( !g_bRecordClientInterfaceEventsToOGS )
		return;

	static uint32 s_unEventCount = 0;

	KeyValues* pKVData = new KeyValues( "TF2UIEvents" );
	pKVData->SetInt( "EventCounter", s_unEventCount++ );
	
	if ( pszEventType )
	{
		pKVData->SetString( "EventTypeID", pszEventType );
	}
	if ( pszEventDesc )
	{
		pKVData->SetString( "EventDescID", pszEventDesc );
	}

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
}

//-----------------------------------------------------------------------------
// Purpose: post results from first step of quickplay
//-----------------------------------------------------------------------------

int g_iQuickplaySessionIndex = 0;

void C_CTFGameStats::QuickplayResults( const TF_Gamestats_QuickPlay_t &info )
{

	// Update index
	++g_iQuickplaySessionIndex;

	// Determine sampling rate
	float odds = tf_matchmaking_ogs_odds.GetFloat();
	Assert( odds >= 0.0f && odds <= 1.0f );
	if ( GetUniverse() != k_EUniversePublic )
	{
		odds = 1.0f;
	}

	// Send full or abbreviated stats?
	float r = RandomFloat();
	int iDetailLevel = ( r < odds ) ? TF_Gamestats_QuickPlay_t::k_Server_Ineligible : TF_Gamestats_QuickPlay_t::k_Server_Pinged;

	// Count up servers that meet various criteria
	int nServersResponded = info.m_vecServers.Count();
	int nServersEligible = 0;
	int nServersSentToGC = 0;
	int nServersScoredByGC = 0;
	int nServersPinged = 0;
	for ( int i = 0 ; i < info.m_vecServers.Count() ; ++i )
	{
		const TF_Gamestats_QuickPlay_t::eServerStatus &s = info.m_vecServers[i].m_eStatus;
		if ( s >= TF_Gamestats_QuickPlay_t::k_Server_Eligible )
		{
			++nServersEligible;
		}
		if ( s >= TF_Gamestats_QuickPlay_t::k_Server_RequestedScore )
		{
			++nServersSentToGC;
		}
		if ( s >= TF_Gamestats_QuickPlay_t::k_Server_Scored && info.m_vecServers[i].m_fScoreGC > -999.0f )
		{
			++nServersScoredByGC;
		}
		if ( s >= TF_Gamestats_QuickPlay_t::k_Server_Pinged )
		{
			++nServersPinged;
		}
	}

	KeyValues* pKVData = new KeyValues( "TF2QuickPlaySession" );
	pKVData->SetInt( "QuickPlaySessionID", g_iQuickplaySessionIndex );
	pKVData->SetFloat( "UserHoursPlayed", info.m_fUserHoursPlayed );
	pKVData->SetString( "TF2GameModeIDSearched", info.m_sUserGameMode );
	pKVData->SetInt( "Result", info.m_eResultCode );
	pKVData->SetInt( "ReportDetail", iDetailLevel );
	pKVData->SetFloat( "SearchTime", info.m_fSearchTime );
	pKVData->SetInt( "ExperimentGroup", info.m_iExperimentGroup );
	pKVData->SetInt( "ServersResponded", nServersResponded );
	pKVData->SetInt( "ServersEligible", nServersEligible );
	pKVData->SetInt( "ServersSentToGC", nServersSentToGC );
	pKVData->SetInt( "ServersScoredByGC", nServersScoredByGC );
	pKVData->SetInt( "ServersPinged", nServersPinged );

	GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );

	for ( int i = 0 ; i < info.m_vecServers.Count() ; ++i )
	{
		const TF_Gamestats_QuickPlay_t::Server_t &s = info.m_vecServers[i];

		// Check if he's not important enough to report
		if ( s.m_eStatus < iDetailLevel )
		{
			continue;
		}

		pKVData = new KeyValues( "TF2QuickPlayResult" );
		pKVData->SetInt( "QuickPlaySessionID", g_iQuickplaySessionIndex );
		pKVData->SetInt( "ServerIP", s.m_ip );
		pKVData->SetInt( "ServerPort", s.m_port );
		pKVData->SetInt( "Status", s.m_eStatus );
		pKVData->SetInt( "ServerIsRegistered", s.m_bRegistered ? 1 : 0 );
		pKVData->SetInt( "ServerIsValve", s.m_bValve ? 1 : 0  );
		pKVData->SetInt( "ServerMapIsNewUserFriendly", s.m_bMapIsNewUserFriendly ? 1 : 0  );
		pKVData->SetInt( "ServerMapIsQuickPlayOK", s.m_bMapIsQuickPlayOK ? 1 : 0  );
		pKVData->SetInt( "ServerIsSecure", s.m_bSecure ? 1 : 0  );
		pKVData->SetInt( "ServerPlayers", s.m_nPlayers );
		pKVData->SetInt( "ServerMaxPlayers", s.m_nMaxPlayers );
		pKVData->SetString( "MapID", s.m_sMapName );
		pKVData->SetInt( "Ping", s.m_iPing );
		pKVData->SetFloat( "ScoreServer", s.m_fScoreServer );
		pKVData->SetFloat( "ScoreClient", s.m_fScoreClient );
		if ( s.m_eStatus >= TF_Gamestats_QuickPlay_t::k_Server_Scored && s.m_fScoreGC > -999.0f )
		{
			pKVData->SetFloat( "ScoreGC", s.m_fScoreGC );
		}
		pKVData->SetString( "TF2ServerTagsID", s.m_sTags );
		GetSteamWorksSGameStatsUploader().AddStatsForUpload( pKVData );
	}
}
