tf2/tf2_src/game/client/tf/tf_streams.cpp

//========= Copyright (C) 1996-2013, Valve Corporation, All rights reserved. ============//
//
// Purpose: Helper for access to news
//
// $NoKeywords: $
//=============================================================================//

#include "cbase.h"

#include "gc_clientsystem.h"
#include "filesystem.h"
#include "workshop/ugc_utils.h"
#include "econ/econ_controls.h"

#include "ienginevgui.h"
#include "vgui/ISystem.h"
#include "vgui_controls/ImagePanel.h"
#include "vgui_bitmapimage.h"
#include "bitmap/bitmap.h"
#include "imageutils.h"

#include "tier2/fileutils.h"

#include "checksum_sha1.h"
//#include "matchmaking/imatchframework.h"
//#include "engine/inetsupport.h"

#include "rtime.h"

#include "tf_streams.h"

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

// GC hello information
//extern CMsgGCCStrike15_v2_MatchmakingGC2ClientHello g_GC2ClientHello;

ConVar cl_streams_request_url( "cl_streams_request_url",
	"https://api.twitch.tv/kraken/streams?game=Team%20Fortress%202&limit=5"
	, FCVAR_DEVELOPMENTONLY, "Number of streams requested for display" );
ConVar cl_streams_request_accept( "cl_streams_request_accept", "application/vnd.twitchtv.v3+json", FCVAR_DEVELOPMENTONLY, "Header for api request" );
ConVar cl_streams_image_sfurl( "cl_streams_image_sfurl",
	"img://loadjpeg:(320x200):"
	, FCVAR_DEVELOPMENTONLY, "Format of Scaleform image representing the stream" );

ConVar cl_streams_request_count( "cl_streams_request_count", "6", FCVAR_DEVELOPMENTONLY, "How many streams are displayed in main menu" );

ConVar cl_streams_refresh_interval( "cl_streams_refresh_interval", "60", FCVAR_DEVELOPMENTONLY, "How often to refresh streams list" );
ConVar cl_streams_write_response_file( "cl_streams_write_response_file", "", FCVAR_DEVELOPMENTONLY, "When set will save streams info file for diagnostics" );
ConVar cl_streams_override_global_version( "cl_streams_override_global_version", "", FCVAR_DEVELOPMENTONLY, "When set will override global API version" );

ConVar cl_streams_mytwitchtv_nolink( "cl_streams_mytwitchtv_nolink", "https://www.twitch.tv/settings/connections", FCVAR_DEVELOPMENTONLY, "Twitch.tv account linking URL" );
ConVar cl_streams_mytwitchtv_channel( "cl_streams_mytwitchtv_channel", "https://www.twitch.tv/", FCVAR_DEVELOPMENTONLY, "Twitch.tv account channel URL" );

static const char *s_pszCacheImagePath = "streams";


//////////////////////////////////////////////////////////////////////////
//
// Files downloader
//

class CHelperStreamDownloadUrlToLocalFile;

static CUtlVector< CHelperStreamDownloadUrlToLocalFile * > s_arrDeleteCHelperStreamDownloadUrlToLocalFile;

class CHelperStreamDownloadUrlToLocalFile
{
public:
	CHelperStreamDownloadUrlToLocalFile( char const *szUrlGet, char const *szLocalFile, long lTimeStampLocal, CTFStreamPanel *pStreamPanel )
	{
		m_sUrlGet = szUrlGet;
		m_sLocalFile = szLocalFile;
		m_lTimestampLocal = lTimeStampLocal;

		m_hHTTPRequestHandle = steamapicontext->SteamHTTP()->CreateHTTPRequest( k_EHTTPMethodGET, m_sUrlGet.Get() );

		SteamAPICall_t hCall = NULL;
		if ( m_hHTTPRequestHandle && steamapicontext->SteamHTTP()->SendHTTPRequest( m_hHTTPRequestHandle, &hCall ) && hCall )
		{
			m_CallbackOnHTTPRequestCompleted.Set( hCall, this, &CHelperStreamDownloadUrlToLocalFile::Steam_OnHTTPRequestCompleted );
		}
		else
		{
			if ( m_hHTTPRequestHandle )
				steamapicontext->SteamHTTP()->ReleaseHTTPRequest( m_hHTTPRequestHandle );
			m_hHTTPRequestHandle = NULL;
		}

		m_hStreamPanel = pStreamPanel;
	}

private:
	CUtlString m_sUrlGet;
	CUtlString m_sLocalFile;
	long m_lTimestampLocal;
	HTTPRequestHandle m_hHTTPRequestHandle;
	CCallResult< CHelperStreamDownloadUrlToLocalFile, HTTPRequestCompleted_t > m_CallbackOnHTTPRequestCompleted;

	DHANDLE<CTFStreamPanel> m_hStreamPanel;
	
	void Steam_OnHTTPRequestCompleted( HTTPRequestCompleted_t *p, bool bError )
	{
		if ( !m_hHTTPRequestHandle || ( p->m_hRequest != m_hHTTPRequestHandle ) )
			return;

		uint32 unBytes = 0;
		if ( !bError && p && steamapicontext->SteamHTTP()->GetHTTPResponseBodySize( p->m_hRequest, &unBytes ) && unBytes != 0 )
		{
			DevMsg( "Request for '%s' succeeded (code: %u, size: %u)...\n", m_sUrlGet.Get(), p ? p->m_eStatusCode : 0, unBytes );

			CUtlBuffer bufFile;
			bufFile.EnsureCapacity( unBytes );
			if ( steamapicontext->SteamHTTP()->GetHTTPResponseBodyData( p->m_hRequest,(uint8*)bufFile.Base(), unBytes ) )
			{
				bufFile.SeekPut( bufFile.SEEK_HEAD, unBytes );

				g_pFullFileSystem->WriteFile( m_sLocalFile.Get(), "GAME", bufFile );
				UGC_SetFileTime( m_sLocalFile.Get(), m_lTimestampLocal );
			}

			if ( m_hStreamPanel.Get() )
			{
				m_hStreamPanel.Get()->InvalidateLayout();
			}
		}
		else
		{
			DevMsg( "Request for '%s' failed '%s' (code: %u, size: %u)...\n", m_sUrlGet.Get(), bError ? "error" : "ok", p ? p->m_eStatusCode : 0, unBytes );
		}

		steamapicontext->SteamHTTP()->ReleaseHTTPRequest( p->m_hRequest );
		m_hHTTPRequestHandle = NULL;

		s_arrDeleteCHelperStreamDownloadUrlToLocalFile.AddToTail( this );
	}
};


//////////////////////////////////////////////////////////////////////////
//
// Helper functions
//

static long Helper_ParseUpdatedTimestamp( char const *pchParseUpdatedAt )
{
	// Twitch.tv format: "2013-03-04T05:27:27Z"
	return CRTime::RTime32FromRFC3339UTCString( pchParseUpdatedAt );
}

static void Helper_ConfigureStreamInfoPreviewImages( CStreamInfo &info, CTFStreamPanel *pStreamPanel )
{
	// store global name for the info in the panel to ask for it when the image is ready to be displayed
	pStreamPanel->SetGlobalName( info.m_sGlobalName );

	char chPreviewImageLocal[ 2*MAX_PATH + 1 ] = {};
	char *pchLocalCur = chPreviewImageLocal, *pchLocalEnd = chPreviewImageLocal + Q_ARRAYSIZE( chPreviewImageLocal ) - 1;
	for ( char const *pch = info.m_sPreviewImage.Get(); *pch; ++ pch )
	{
		if ( pchLocalEnd - pchLocalCur < 4 )
			break;
		if ( ( ( pch[0] >= 'a' ) && ( pch[0] <= 'z' ) ) ||
			( ( pch[0] >= 'A' ) && ( pch[0] <= 'Z' ) ) ||
			( ( pch[0] >= '0' ) && ( pch[0] <= '9' ) ) ||
			( pch[0] == '-' ) || ( pch[0] == '.' ) )
		{
			* ( pchLocalCur ++ ) = *pch;
		}
		else
		{
			* ( pchLocalCur ++ ) = '_';
			int iHigh = ( ( ( unsigned char )( *pch ) & 0xF0u ) >> 4 ) & 0xF;
			if ( iHigh >= 0 && iHigh <= 9 )
				* ( pchLocalCur ++ ) = '0' + iHigh;
			else
				* ( pchLocalCur ++ ) = 'A' + iHigh;
			int iLow = ( ( ( unsigned char )( *pch ) & 0xFu ) );
			if ( iLow >= 0 && iLow <= 9 )
				* ( pchLocalCur ++ ) = '0' + iLow;
			else if ( iLow >= 10 && iLow <= 15 )
				* ( pchLocalCur ++ ) = 'A' + iLow - 10;
			* ( pchLocalCur ++ ) = '_';
		}
	}
	if ( chPreviewImageLocal[0] )
	{
		// We might need to download the file, so make sure directory structure is valid
		static bool s_bCreateDirHierarchyDone = false;
		if ( !s_bCreateDirHierarchyDone )
		{
			s_bCreateDirHierarchyDone = true;
				
			// Cleanup old cached files
			if ( long lDirectoryTime = g_pFullFileSystem->GetFileTime( s_pszCacheImagePath, "GAME" ) )
			{
				FileFindHandle_t hFind = NULL;
				int numRemove = 0;
				for ( char const *szFileName = g_pFullFileSystem->FindFirst( CFmtStr( "%s/*", s_pszCacheImagePath ), &hFind );
					szFileName && *szFileName; szFileName = g_pFullFileSystem->FindNext( hFind ) )
				{
					if ( !Q_strcmp( ".", szFileName ) || !Q_strcmp( "..", szFileName ) ) continue;
					CFmtStr fmtFilename( "%s/%s", s_pszCacheImagePath, szFileName );
					long lFileTime = g_pFullFileSystem->GetFileTime( fmtFilename, "GAME" );
					if ( ( lFileTime >= lDirectoryTime - 72*3600 ) && ( lFileTime <= lDirectoryTime + 72*3600 ) )
					{
						// DevMsg( "Keeping file %s (%u : %u)\n", fmtFilename.Access(), lFileTime, lDirectoryTime );
						continue;
					}
					else
					{
						++ numRemove;
						g_pFullFileSystem->RemoveFile( fmtFilename, "GAME" );
					}
				}
				DevMsg( 2, "Streams preview cache evicted %u files\n", numRemove );
				g_pFullFileSystem->FindClose( hFind );
			}

			g_pFullFileSystem->CreateDirHierarchy( s_pszCacheImagePath, "GAME" );
		}
			
		//
		// Work with the file cache
		//
		CFmtStr fmtLocalFile( "%s/%s", s_pszCacheImagePath, chPreviewImageLocal );
		info.m_sPreviewImageLocalFile = fmtLocalFile.Access();
		
		CFmtStr fmtPreviewSF( "%sstreams/%s", cl_streams_image_sfurl.GetString(), chPreviewImageLocal );
		info.m_sPreviewImageSF = fmtPreviewSF.Access();

		// See if we need to download that file
		long lFileTime = g_pFullFileSystem->GetFileTime( fmtLocalFile.Access(), "GAME" );
		// Parse "updated_at" attribute:
		long lUpdatedAtStamp = Helper_ParseUpdatedTimestamp( info.m_sUpdatedAtStamp.Get() );
		if ( lFileTime != lUpdatedAtStamp )
		{
			// Redownload the file
			DevMsg( 2, "%s -- Requesting download of preview image (%ld != %ld): %s -> %s\n", info.m_sGlobalName.Get(), lFileTime, lUpdatedAtStamp, info.m_sPreviewImage.Get(), info.m_sPreviewImageLocalFile.Get() );
			new CHelperStreamDownloadUrlToLocalFile( info.m_sPreviewImage.Get(), info.m_sPreviewImageLocalFile.Get(), lUpdatedAtStamp, pStreamPanel );
		}
		else
		{
			DevMsg( 2, "%s -- Preview image is up to date (%ld): %s -> %s\n", info.m_sGlobalName.Get(), lUpdatedAtStamp, info.m_sPreviewImage.Get(), info.m_sPreviewImageLocalFile.Get() );
			pStreamPanel->InvalidateLayout();
		}
	}
	else
	{
		DevMsg( 2, "%s -- No preview image\n", info.m_sGlobalName.Get() );
		info.m_sPreviewImageSF = cl_streams_image_sfurl.GetString();
	}
}


//////////////////////////////////////////////////////////////////////////
//
//

static CTFStreamManager g_streamManager;
CTFStreamManager* StreamManager()
{
	return &g_streamManager;
}

CTFStreamManager::CTFStreamManager()
{
	m_dblTimeStampLastUpdate = 0;
	m_hHTTPRequestHandle = NULL;
	m_hHTTPRequestHandleTwitchTv = NULL;
	m_pLoadingAccount = NULL;
}


CTFStreamManager::~CTFStreamManager()
{
	m_vecTwitchTvAccounts.PurgeAndDeleteElements();
}


bool CTFStreamManager::Init()
{
	RequestTopStreams();

	return true;
}


void CTFStreamManager::Update( float frametime )
{
	// Cleanup downloaders
	if ( s_arrDeleteCHelperStreamDownloadUrlToLocalFile.Count() )
	{
		FOR_EACH_VEC( s_arrDeleteCHelperStreamDownloadUrlToLocalFile, iDownloader )
		{
			delete s_arrDeleteCHelperStreamDownloadUrlToLocalFile[iDownloader];
		}
		s_arrDeleteCHelperStreamDownloadUrlToLocalFile.RemoveAll();
	}

	UpdateTwitchTvAccounts();
}

void CTFStreamManager::RequestTopStreams()
{
	// Check if it's time to update
	if ( !m_dblTimeStampLastUpdate || ( Plat_FloatTime() - m_dblTimeStampLastUpdate > cl_streams_refresh_interval.GetFloat() ) )
	{
		m_dblTimeStampLastUpdate = Plat_FloatTime();

		if ( !m_hHTTPRequestHandle && steamapicontext && steamapicontext->SteamHTTP() )
		{
			//
			// Create HTTP download job
			//
			m_hHTTPRequestHandle = steamapicontext->SteamHTTP()->CreateHTTPRequest( k_EHTTPMethodGET, cl_streams_request_url.GetString() );
			steamapicontext->SteamHTTP()->SetHTTPRequestHeaderValue( m_hHTTPRequestHandle, "Accept", cl_streams_request_accept.GetString() );
			steamapicontext->SteamHTTP()->SetHTTPRequestHeaderValue( m_hHTTPRequestHandle, "Client-ID", "b7816vx0i8sng8bwy9es0dirdcsy3im" );
			DevMsg( "Requesting twitch.tv streams update...\n" );

			SteamAPICall_t hCall = NULL;
			if ( m_hHTTPRequestHandle && steamapicontext->SteamHTTP()->SendHTTPRequest( m_hHTTPRequestHandle, &hCall ) && hCall )
			{
				m_CallbackOnHTTPRequestCompleted.Set( hCall, this, &CTFStreamManager::Steam_OnHTTPRequestCompletedStreams );
			}
			else
			{
				if ( m_hHTTPRequestHandle )
					steamapicontext->SteamHTTP()->ReleaseHTTPRequest( m_hHTTPRequestHandle );
				m_hHTTPRequestHandle = NULL;
			}
		}	
	}
}


static int Helper_SortStreamsByViewersCount( const CStreamInfo *a, const CStreamInfo *b )
{
	if ( a->m_numViewers != b->m_numViewers )
		return ( a->m_numViewers > b->m_numViewers ) ? -1 : 1;
	
	return Q_stricmp( a->m_sGlobalName.Get(), b->m_sGlobalName.Get() );
}

static void Helper_ConvertLanguageToCountryCode( CUtlString &s )
{
	if ( !Q_stricmp(s, "en") )
		s = "gb";
}

void CTFStreamManager::Steam_OnHTTPRequestCompletedStreams( HTTPRequestCompleted_t *p, bool bError )
{
	if ( !m_hHTTPRequestHandle || ( p->m_hRequest != m_hHTTPRequestHandle ) )
		return;

	uint32 unBytes = 0;
	if ( !bError && p && steamapicontext->SteamHTTP()->GetHTTPResponseBodySize( p->m_hRequest, &unBytes ) && unBytes != 0 )
	{
		DevMsg( "Request for twitch.tv streams succeeded (code: %u, size: %u)...\n", p ? p->m_eStatusCode : 0, unBytes );

		CUtlVector< CStreamInfo > arrStreamInfos;
		CUtlBuffer bufFile;
		bufFile.EnsureCapacity( unBytes );
		if ( steamapicontext->SteamHTTP()->GetHTTPResponseBodyData( p->m_hRequest,(uint8*)bufFile.Base(), unBytes ) )
		{
			bufFile.SeekPut( bufFile.SEEK_HEAD, unBytes );

			if ( cl_streams_write_response_file.GetString()[0] )
			{
				g_pFullFileSystem->WriteFile( cl_streams_write_response_file.GetString(), "GAME", bufFile );
			}
			
			// Parse JSON from the received file
			GCSDK::CWebAPIValues *pValues = GCSDK::CWebAPIValues::ParseJSON( bufFile );
			if ( pValues )
			{
				if ( GCSDK::CWebAPIValues *pvStreams = pValues->FindChild( "streams" ) )
				{
					for ( GCSDK::CWebAPIValues *pvStream = pvStreams->GetFirstChild(); pvStream; pvStream = pvStream->GetNextChild() )
					{
#if 0	// this is the code to print JSON output as DevMsgs to figure out which element is where in the response
						DevMsg( "----STREAM----\n" );
						for ( GCSDK::CWebAPIValues *pTest = pvStream->GetFirstChild(); pTest; pTest = pTest->GetNextChild() )
						{
							CUtlString sValueText;
							pTest->GetStringValue( sValueText );
							DevMsg( "child: %s = (%u) %s\n", pTest->GetName(), pTest->GetUInt32Value(), sValueText.Get() );

							for ( GCSDK::CWebAPIValues *pTest2 = pTest->GetFirstChild(); pTest2; pTest2 = pTest2->GetNextChild() )
							{
								pTest2->GetStringValue( sValueText );
								DevMsg( "     child2: %s = (%u) %s\n", pTest2->GetName(), pTest2->GetUInt32Value(), sValueText.Get() );
							}
						}
#endif

						CStreamInfo info;
						info.m_numViewers = pvStream->GetChildUInt32Value( "viewers" );
						if ( GCSDK::CWebAPIValues *pChannel = pvStream->FindChild( "channel" ) )
						{
							pChannel->GetChildStringValue( info.m_sGlobalName, "name", "" );
							pChannel->GetChildStringValue( info.m_sDisplayName, "display_name", "" );
							pChannel->GetChildStringValue( info.m_sTextDescription, "status", "" );
							pChannel->GetChildStringValue( info.m_sLanguage, "language", "" );		// MISSING
							Helper_ConvertLanguageToCountryCode( info.m_sLanguage );
							info.m_sCountry = info.m_sLanguage;			// MISSING
							pChannel->GetChildStringValue( info.m_sUpdatedAtStamp, "updated_at", "" );
							if ( GCSDK::CWebAPIValues *pPreview = pvStream->FindChild( "preview" ) )
							{
								if ( pPreview->GetType() == GCSDK::k_EWebAPIValueType_String )
									pPreview->GetStringValue( info.m_sPreviewImage );
								else
									pPreview->GetChildStringValue( info.m_sPreviewImage, "medium", "" );
							}
							pChannel->GetChildStringValue( info.m_sVideoFeedUrl, "url", "" );
						}
						if ( ( info.m_numViewers > 0 ) &&
							!info.m_sGlobalName.IsEmpty() &&
							!info.m_sDisplayName.IsEmpty() &&
							!info.m_sTextDescription.IsEmpty() &&
							!info.m_sVideoFeedUrl.IsEmpty() )
						{
							//DevMsg( 2, "Channel: %s (%s, %u viewers) -- %s [[%s]]\n", info.m_sGlobalName.Get(), info.m_sDisplayName.Get(), info.m_numViewers, info.m_sTextDescription.Get(), info.m_sVideoFeedUrl.Get() );

							arrStreamInfos.AddToTail( info );
						}
					}
				}
			}

			delete pValues;
		}

		if ( arrStreamInfos.Count() )
		{
			arrStreamInfos.Sort( Helper_SortStreamsByViewersCount );
			if ( arrStreamInfos.Count() > cl_streams_request_count.GetInt() )
				arrStreamInfos.SetCountNonDestructively( cl_streams_request_count.GetInt() );

			m_streamInfoVec.Swap( arrStreamInfos );	// Set the new information live and notify all systems

			IGameEvent *event = gameeventmanager->CreateEvent( "top_streams_request_finished" );
			if ( event )
			{
				gameeventmanager->FireEventClientSide( event );
			}
		}
	}
	else
	{
		DevMsg( "Request for twitch.tv streams failed: %s (code: %u, size: %u)...\n",
			bError ? "error" : "ok", p ? p->m_eStatusCode : 0, unBytes );
	}

	steamapicontext->SteamHTTP()->ReleaseHTTPRequest( p->m_hRequest );
	m_hHTTPRequestHandle = NULL;
	m_dblTimeStampLastUpdate = Plat_FloatTime(); // push the update counter to not update for a little bit
}

CStreamInfo* CTFStreamManager::GetStreamInfoByName( char const *szName )
{
	if ( !szName )
		return NULL;
	
	for ( int idx = 0; idx < m_streamInfoVec.Count(); ++ idx )
	{
		if ( !V_strcmp( szName, m_streamInfoVec[idx].m_sGlobalName.Get() ) )
			return &m_streamInfoVec[idx];
	}

	return NULL;
}


TwitchTvAccountInfo_t* CTFStreamManager::GetTwitchTvAccountInfo( uint64 uiSteamID )
{
	TwitchTvAccountInfo_t *pInfo = NULL;
	FOR_EACH_VEC( m_vecTwitchTvAccounts, i )
	{
		if ( m_vecTwitchTvAccounts[i]->m_uiSteamID == uiSteamID )
		{
			pInfo = m_vecTwitchTvAccounts[i];

			// Uncomment this if we really need to keep checking twitch status
			// info needs update if it's been longer than 300 secs from the last update
			/*if ( pInfo->m_dblTimeStampTwitchTvUpdate && ( Plat_FloatTime() - pInfo->m_dblTimeStampTwitchTvUpdate > 300 ) )
			{
				m_vecTwitchTvAccounts.Remove( i );
				pInfo = NULL;
			}*/

			break;
		}
	}

	// add one if not already on the list
	if ( !pInfo )
	{
		pInfo = new TwitchTvAccountInfo_t;
		if ( pInfo )
		{
			pInfo->m_uiSteamID = uiSteamID;
			pInfo->m_eTwitchTvState = k_ETwitchTvState_None;
			pInfo->m_dblTimeStampTwitchTvUpdate = 0;
			pInfo->m_uiTwitchTvUserId = 0;
			pInfo->m_sTwitchTvChannel = cl_streams_mytwitchtv_nolink.GetString();
			m_vecTwitchTvAccounts.AddToTail( pInfo );
		}
	}

	return pInfo;
}


void CTFStreamManager::UpdateTwitchTvAccounts()
{
	if ( m_pLoadingAccount )
		return;

	// find the new account in the list to load
	FOR_EACH_VEC( m_vecTwitchTvAccounts, i )
	{
		if ( m_vecTwitchTvAccounts[i]->m_eTwitchTvState == k_ETwitchTvState_None )
		{
			m_pLoadingAccount = m_vecTwitchTvAccounts[i];
			break;
		}
	}

	// nothing needs to be loaded
	if ( !m_pLoadingAccount )
		return;

	// When requesting a refresh reset all known linking state
	m_pLoadingAccount->m_eTwitchTvState = k_ETwitchTvState_Loading;
	m_pLoadingAccount->m_dblTimeStampTwitchTvUpdate = Plat_FloatTime();

	Assert( !m_hHTTPRequestHandleTwitchTv );
	if ( m_hHTTPRequestHandleTwitchTv ) return;
	//
	// Create HTTP download job
	//
	m_hHTTPRequestHandleTwitchTv = steamapicontext->SteamHTTP()->CreateHTTPRequest( k_EHTTPMethodGET, CFmtStr( "http://api.twitch.tv/api/steam/%llu", m_pLoadingAccount->m_uiSteamID ) );
	steamapicontext->SteamHTTP()->SetHTTPRequestHeaderValue( m_hHTTPRequestHandleTwitchTv, "Accept", cl_streams_request_accept.GetString() );
	DevMsg( "Requesting twitch.tv account link...\n" );

	SteamAPICall_t hCall = NULL;
	if ( m_hHTTPRequestHandleTwitchTv && steamapicontext->SteamHTTP()->SendHTTPRequest( m_hHTTPRequestHandleTwitchTv, &hCall ) && hCall )
	{
		m_CallbackOnHTTPRequestCompletedTwitchTv.Set( hCall, this, &CTFStreamManager::Steam_OnHTTPRequestCompletedMyTwitchTv );
	}
	else
	{
		if ( m_hHTTPRequestHandleTwitchTv )
			steamapicontext->SteamHTTP()->ReleaseHTTPRequest( m_hHTTPRequestHandleTwitchTv );
		m_hHTTPRequestHandleTwitchTv = NULL;
	}
}

void CTFStreamManager::Steam_OnHTTPRequestCompletedMyTwitchTv( HTTPRequestCompleted_t *p, bool bError )
{
	if ( !m_hHTTPRequestHandleTwitchTv || ( p->m_hRequest != m_hHTTPRequestHandleTwitchTv ) )
		return;

	Assert( m_pLoadingAccount->m_eTwitchTvState == k_ETwitchTvState_Loading );
	m_pLoadingAccount->m_eTwitchTvState = k_ETwitchTvState_Error;
	m_pLoadingAccount->m_sTwitchTvChannel.Clear();
	m_pLoadingAccount->m_uiTwitchTvUserId = 0ull;

	uint32 unBytes = 0;
	if ( !bError && p && steamapicontext->SteamHTTP()->GetHTTPResponseBodySize( p->m_hRequest, &unBytes ) && unBytes != 0 )
	{
		DevMsg( "Request for twitch.tv account link succeeded (code: %u, size: %u)...\n", p ? p->m_eStatusCode : 0, unBytes );

		CUtlBuffer bufFile;
		bufFile.EnsureCapacity( unBytes );
		if ( steamapicontext->SteamHTTP()->GetHTTPResponseBodyData( p->m_hRequest,(uint8*)bufFile.Base(), unBytes ) )
		{
			bufFile.SeekPut( bufFile.SEEK_HEAD, unBytes );

			if ( cl_streams_write_response_file.GetString()[0] )
			{
				g_pFullFileSystem->WriteFile( cl_streams_write_response_file.GetString(), "GAME", bufFile );
			}
			
			// Parse JSON from the received file
			GCSDK::CWebAPIValues *pValues = GCSDK::CWebAPIValues::ParseJSON( bufFile );
			if ( pValues )
			{
				pValues->GetChildStringValue( m_pLoadingAccount->m_sTwitchTvChannel, "name", "" );
				m_pLoadingAccount->m_uiTwitchTvUserId = pValues->GetChildUInt64Value( "_id" );

				if ( m_pLoadingAccount->m_sTwitchTvChannel.IsEmpty() )
				{
					m_pLoadingAccount->m_sTwitchTvChannel = cl_streams_mytwitchtv_nolink.GetString();
					m_pLoadingAccount->m_eTwitchTvState = k_ETwitchTvState_NoLink;
				}
				else
				{
					m_pLoadingAccount->m_sTwitchTvChannel = CFmtStr( "%s%s", cl_streams_mytwitchtv_channel.GetString(), m_pLoadingAccount->m_sTwitchTvChannel.Get() );
					m_pLoadingAccount->m_eTwitchTvState = k_ETwitchTvState_Linked;
				}
			}

			delete pValues;
		}
	}
	else
	{
		DevMsg( "Request for twitch.tv account link failed: %s (code: %u, size: %u)...\n",
			bError ? "error" : "ok", p ? p->m_eStatusCode : 0, unBytes );
	}

	steamapicontext->SteamHTTP()->ReleaseHTTPRequest( p->m_hRequest );
	m_hHTTPRequestHandleTwitchTv = NULL;
	m_pLoadingAccount->m_dblTimeStampTwitchTvUpdate = Plat_FloatTime(); // push the update counter to not update for a little bit

	// done loading
	m_pLoadingAccount = NULL;
}


CTFStreamPanel::CTFStreamPanel( Panel *parent, const char *panelName ) : EditablePanel( parent, panelName )
{
	vgui::HScheme scheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme");
	SetScheme(scheme);

	m_pPreviewImage = new ImagePanel( this, "PreviewImage" );
}

void CTFStreamPanel::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	LoadControlSettings( "Resource/UI/StreamPanel.res" );
}

void CTFStreamPanel::PerformLayout()
{
	BaseClass::PerformLayout();

	UpdatePanels();
}

void CTFStreamPanel::OnCommand( const char *command )
{
	if ( FStrEq( command, "stream" ) )
	{
		CStreamInfo *pInfo = GetStreamInfo();
		if ( pInfo )
		{
			vgui::system()->ShellExecute( "open", CFmtStr( "%s%s", cl_streams_mytwitchtv_channel.GetString(), pInfo->m_sDisplayName.Get() ) );
		}
	}
	else
	{
		BaseClass::OnCommand( command );
	}
}

CStreamInfo *CTFStreamPanel::GetStreamInfo() const
{
	if ( m_strStreamInfoGlobalName.IsEmpty() )
		return NULL;

	return g_streamManager.GetStreamInfoByName( m_strStreamInfoGlobalName.Get() );
}

void CTFStreamPanel::UpdatePanels()
{
	CStreamInfo *pInfo = GetStreamInfo();
	if ( pInfo )
	{
		SetDialogVariable( "display_name", pInfo->m_sDisplayName.Get() );
		SetDialogVariable( "viewer_count", CFmtStr( "%d viewers", pInfo->m_numViewers ) );
		SetDialogVariable( "text_description", pInfo->m_sTextDescription.Get() );

		SetPreviewImage( pInfo->m_sPreviewImageLocalFile.Get() );

		Panel* pLoadingPanel = FindChildByName( "LoadingPanel" );
		if ( pLoadingPanel )
		{
			pLoadingPanel->SetVisible( false );
		}
	}
	else
	{
		SetDialogVariable( "display_name", "" );
		SetDialogVariable( "viewer_count", "" );
		SetDialogVariable( "text_description", "" );

		SetPreviewImage( NULL );
	}

	Panel* pStreamButton = FindChildByName( "Stream_URLButton" );
	if ( pStreamButton )
	{
		pStreamButton->SetEnabled( pInfo != NULL );
	}
	
}

void CTFStreamPanel::SetPreviewImage( const char *pszPreviewImageFile )
{
	// clean up old image if there's one
	m_pPreviewImage->EvictImage();

	if ( !pszPreviewImageFile )
	{
		m_pPreviewImage->SetImage( (vgui::IImage *)0 );
		return;
	}

	char szImageAbsPath[MAX_PATH];
	if ( !GenerateFullPath( pszPreviewImageFile, "MOD", szImageAbsPath, ARRAYSIZE( szImageAbsPath ) ) )
	{
		Warning( "Failed to GenerateFullPath %s\n", pszPreviewImageFile );
		return;
	}

	Bitmap_t image;
	ConversionErrorType nErrorCode = ImgUtl_LoadBitmap( szImageAbsPath, image );
	if ( nErrorCode != CE_SUCCESS )
	{
		m_pPreviewImage->SetImage( (vgui::IImage *)0 );
		return;
	}

	int wide, tall;
	BitmapImage *pBitmapImage = new BitmapImage;
	pBitmapImage->SetBitmap( image );
	pBitmapImage->GetSize( wide, tall );

	// The ImagePanel needs to know the scaling factor for the BitmapImage, to
	// center it when it's going to be rendered, and then the BitmapImage needs
	// to know how big it should be rendered.
	float flPanelWidthScale = static_cast<float>( m_pPreviewImage->GetWide() ) / wide;
	m_pPreviewImage->SetShouldCenterImage( false );
	m_pPreviewImage->SetShouldScaleImage( true );
	m_pPreviewImage->SetScaleAmount( flPanelWidthScale );

	float flSubRectWidthScale = static_cast<float>( wide ) / image.Width();
	//float flSubRectHeightScale = static_cast<float>( tall ) / image.Height();
	pBitmapImage->SetRenderSize( flSubRectWidthScale * m_pPreviewImage->GetWide(), flSubRectWidthScale * flPanelWidthScale * tall );

	m_pPreviewImage->SetImage( pBitmapImage );

	float flPanelHeightScale = static_cast<float>( image.Height() ) / image.Width();
	m_pPreviewImage->SetSize( m_pPreviewImage->GetWide(), flPanelHeightScale * m_pPreviewImage->GetWide() );
}


CTFStreamListPanel::CTFStreamListPanel( Panel *parent, const char *panelName ) : EditablePanel( parent, panelName )
{
	for ( int i=0; i<ARRAYSIZE( m_arrStreamPanels ); ++i )
	{
		m_arrStreamPanels[i] = new CTFStreamPanel( this, CFmtStr( "Stream%d", i + 1 ) );
	}

	ListenForGameEvent( "top_streams_request_finished" );
}

void CTFStreamListPanel::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	LoadControlSettings( "Resource/UI/StreamListPanel.res" );
}

void CTFStreamListPanel::OnThink()
{
	// this will fire "top_streams_request_finished" event when the job is done
	g_streamManager.RequestTopStreams();
}

void CTFStreamListPanel::OnCommand( const char *command )
{
	if ( FStrEq( command, "hide_streams" ) )
	{
		SetVisible( false );
	}
	else if ( FStrEq( command, "view_more" ) )
	{
		vgui::system()->ShellExecute( "open", "https://www.twitch.tv/directory/game/Team%20Fortress%202" );
	}
	else
	{
		BaseClass::OnCommand( command );
	}
}

void CTFStreamListPanel::FireGameEvent( IGameEvent *event )
{
	const char *pszEventName = event->GetName();
	if ( FStrEq( pszEventName, "top_streams_request_finished" ) )
	{
		// update each stream panel
		for ( int i=0; i<ARRAYSIZE( m_arrStreamPanels ); ++i )
		{
			bool bVisible = i < g_streamManager.GetStreamInfoVec().Count();
			m_arrStreamPanels[i]->SetVisible( bVisible );
			if ( bVisible )
			{
				Helper_ConfigureStreamInfoPreviewImages( g_streamManager.GetStreamInfoVec()[i], m_arrStreamPanels[i] );
			}
		}
	}
}