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

#include "cbase.h"
#include "quest_log_panel.h"
#include "ienginevgui.h"
#include "c_tf_gamestats.h"
#include "store/store_panel.h"
#include "econ/econ_ui.h"
#include "clientmode_tf.h"
#include "tf_hud_mainmenuoverride.h"
#include "vgui_int.h"
#include "IGameUIFuncs.h" // for key bindings
#include <vgui_controls/AnimationController.h>
#include "tf_item_inventory.h"
#include "vgui/IInput.h"
#include "item_ad_panel.h"
#include "vgui_controls/ProgressBar.h"

// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
															 
void AddSubKeyNamed( KeyValues *pKeys, const char *pszName );

static CItemModelPanelToolTip* g_spItemTooltip = NULL;
CQuestTooltip* g_spTextTooltip = NULL;

CQuestLogPanel *GetQuestLog()
{
	CQuestLogPanel *pQuestLogPanel = (CQuestLogPanel*)gViewPortInterface->FindPanelByName( PANEL_QUEST_LOG );
	return pQuestLogPanel;
}

//-------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CScrollableQuestList::CScrollableQuestList( vgui::Panel *parent, const char *pszPanelName ) 
	: EditablePanel( parent, pszPanelName )
	, m_pCompletingPanel( NULL )
	, m_bQuestsLayoutDirty( false )
	, m_pszNoQuests( NULL )
	, m_pszNeedAPass( NULL )
	, m_pszNotPossible( NULL )
{
	m_pContainer = new EditablePanel( this, "Container" );
	m_vecQuestItemPanels.SetSize( 2 );

	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		m_vecQuestItemPanels[ i ] = new CQuestItemPanel( m_pContainer, "QuestItemPanel", NULL, this );
	}
}

CScrollableQuestList::~CScrollableQuestList()
{
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrollableQuestList::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	BaseClass::ApplySchemeSettings( pScheme );

	const char *pszResFile = "Resource/UI/econ/ScrollableQuestList.res";

	// Check if the operation wants to override our default res file
	const auto& mapOperations = GetItemSchema()->GetOperationDefinitions();
	FOR_EACH_MAP_FAST( mapOperations, i )
	{
		CEconOperationDefinition* pCurrentOperation = mapOperations[i];
		// Take the first active operation's res file that's different than default
		if ( pCurrentOperation->IsActive() && pCurrentOperation->GetQuestListOverrideResFile() )
		{
			// Use the first found for now
			pszResFile = pCurrentOperation->GetQuestListOverrideResFile();
			break;
		}
	}

	LoadControlSettings( pszResFile );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrollableQuestList::ApplySettings( KeyValues *inResourceData )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	BaseClass::ApplySettings( inResourceData );

	m_pszNoQuests		= inResourceData->GetString( "no_quests", "#QuestLog_NoQuests" );
	m_pszNeedAPass		= inResourceData->GetString( "need_a_pass", "#QuestLog_NeedPassForContracts" );
	m_pszNotPossible	= inResourceData->GetString( "not_possible", "#QuestLog_NoContractsPossible" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrollableQuestList::PerformLayout( void ) 
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	BaseClass::PerformLayout();	

	m_pContainer->InvalidateLayout( true );

	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		m_vecQuestItemPanels[ i ]->InvalidateLayout( true, true );
		m_vecQuestItemPanels[ i ]->SetZPos( 1 + i );
	}

	PositionQuestItemPanels();

	UpdateEmptyMessage();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrollableQuestList::OnThink()
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	if ( m_bQuestsLayoutDirty )
	{
		m_bQuestsLayoutDirty = false;

		PositionQuestItemPanels();
	}

	// Conditionally turn mouse input on/off based on where the mouse is
	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		m_vecQuestItemPanels[i]->SetMouseInputEnabled( m_vecQuestItemPanels[i]->IsCursorOverMainContainer() );
	}
}

void CScrollableQuestList::OnCommand( const char *command )
{
	if ( FStrEq( command, "deselect_all" ) )
	{
		SetSelected( NULL, false );
	}

	BaseClass::OnCommand( command );
}

int QuestSort_AcquiredTime( CQuestItemPanel* const* p1, CQuestItemPanel* const* p2 )
{
	if ( !(*p1)->GetItem() )
		return -1;

	if ( !(*p2)->GetItem() )
		return 1;

	// Newest items first
	return (*p1)->GetItem()->GetID() - (*p2)->GetItem()->GetID();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrollableQuestList::PositionQuestItemPanels()
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	// We dont do anything when a quest is completing
	if ( m_pCompletingPanel != NULL )
		return;

	int nVisible = 0;
	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		CQuestItemPanel* pPanel = m_vecQuestItemPanels[i];
		if ( pPanel )
		{
			pPanel->SetVisible( pPanel->GetItem() );

			if ( pPanel->GetItem() )
			{
				++nVisible;
			}
		}
	}

	CExLabel *pLabel = FindControl<CExLabel>( "EmptyLabel", true );
	if ( pLabel )
	{
		pLabel->SetVisible( nVisible == 0 );
	}

	// Check for a selected panel
	const CQuestItemPanel* pSelected = NULL;
	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		if ( m_vecQuestItemPanels[i]->IsSelected() )
		{
			Assert( pSelected == NULL );
			pSelected = m_vecQuestItemPanels[i];
		}
	}

	struct FolderCommands_t
	{
		const char* m_pszSelected;
		const char* m_pszOtherIsSelected;
		const char* m_pszNoneSelected;
	};

	const FolderCommands_t folderCommands[] = { { "QuestItem_Back_Selected", "QuestItem_Back_OtherSelected", "QuestItem_Back_NoneSelected" }
											  , { "QuestItem_Front_Selected", "QuestItem_Front_OtherSelected", "QuestItem_Front_NoneSelected" } };

	// Update the positions
	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		// This is the selected panel
		if ( pSelected == m_vecQuestItemPanels[ i ] )
		{
			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( m_vecQuestItemPanels[ i ], folderCommands[i].m_pszSelected );	
		}
		else if ( pSelected )	// Some other panel is selected
		{
			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( m_vecQuestItemPanels[ i ], folderCommands[i].m_pszOtherIsSelected );	
		}
		else // No panel is selected
		{
			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( m_vecQuestItemPanels[ i ], folderCommands[i].m_pszNoneSelected );	
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrollableQuestList::SetSelected( CQuestItemPanel *pItem, bool bImmediately )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		m_vecQuestItemPanels[ i ]->SetSelected( m_vecQuestItemPanels[ i ] == pItem, bImmediately );
	}

	PositionQuestItemPanels();
}

bool DoesLootlistDropQuests( const CEconLootListDefinition* pLootList )
{
	FOR_EACH_VEC( pLootList->GetLootListContents(), j )
	{
		const CEconLootListDefinition::drop_item_t& item = pLootList->GetLootListContents()[j];
		// 0 and greater means item.  Less than 0 means nested lootlist
		if( item.m_iItemOrLootlistDef >= 0 )
		{
			const GameItemDefinition_t* pItemDef = assert_cast<const GameItemDefinition_t *>( GetItemSchema()->GetItemDefinition( item.m_iItemOrLootlistDef ) );
			if( pItemDef )
			{
				return pItemDef->GetQuestDef();
			}
		}
		else
		{
			// Get the nested lootlist
			int iLLIndex = (item.m_iItemOrLootlistDef * -1) - 1;
			const CEconLootListDefinition *pNestedLootList = GetItemSchema()->GetLootListByIndex( iLLIndex );
			Assert( pNestedLootList );
			if ( !pNestedLootList )
				continue;

			// Dig through all of this lootlist's entries
			return DoesLootlistDropQuests( pNestedLootList );
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Update what message we show when we have no quests
//-----------------------------------------------------------------------------
void CScrollableQuestList::UpdateEmptyMessage()
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );

	CCyclingAdContainerPanel* pPassStoreAd = FindControl< CCyclingAdContainerPanel >( "ItemAd", true );
	if ( !pPassStoreAd )
		return;

	pPassStoreAd->SetVisible( false );
	SetDialogVariable( "noquests", "" );

	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		// Case 1 above
		if ( m_vecQuestItemPanels[ i ]->GetItem() )
			return;
	}

	// By default, there's no operations going on, and there's no ad to show
	const char *pszNoQuestsText = m_pszNotPossible;

	// Find any active quest-dropping operations
	const auto& mapOperations = GetItemSchema()->GetOperationDefinitions();
	FOR_EACH_MAP_FAST( mapOperations, iOperation )
	{
		CEconOperationDefinition *pOperation = mapOperations[ iOperation ];
		const CSchemaLootListDefHandle pOperationLootlist( pOperation->GetOperationLootlist() );
		// Must still be dropping, and be dropping quests
		if ( CRTime::RTime32TimeCur() < pOperation->GetStopGivingToPlayerDate() && pOperationLootlist && DoesLootlistDropQuests( pOperationLootlist ) )
		{
			// If there's a required item and a gateway item
			if ( pOperation->GetRequiredItemDefIndex() != INVALID_ITEM_DEF_INDEX && pOperation->GetGatewayItemDefIndex() != INVALID_ITEM_DEF_INDEX )
			{
				// And the user doesn't have the required item
				if ( TFInventoryManager()->GetLocalTFInventory()->FindFirstItembyItemDef( pOperation->GetRequiredItemDefIndex() ) == NULL )
				{
					// The user needs to get the item
					pszNoQuestsText = m_pszNeedAPass;

					bool bStoreIsReady = EconUI()->GetStorePanel() && EconUI()->GetStorePanel()->GetPriceSheet() && EconUI()->GetStorePanel()->GetCart() && steamapicontext && steamapicontext->SteamUser();
					bool bGatewayItemInStore = false;
					// Check if the gateway item is in the Mann Co Store
					if ( bStoreIsReady )
					{
						bGatewayItemInStore = EconUI()->GetStorePanel()->GetPriceSheet()->GetEntry( pOperation->GetGatewayItemDefIndex() ) != NULL;
					}

					CEconItemDefinition* pGatewayItemDef = GetItemSchema()->GetItemDefinition( pOperation->GetGatewayItemDefIndex() );
					Assert( pGatewayItemDef );
					if ( !pGatewayItemDef )
						return;

					// Cook up KVs for this item ad
					KeyValuesAD pKVItemAd( "items" ); // The panel will copy these
					KeyValues* pKVItem = pKVItemAd->CreateNewKey();
					pKVItem->SetName( "0" );
					pKVItem->SetString( "item", pGatewayItemDef->GetDefinitionName() );
					pKVItem->SetInt( "show_market", bGatewayItemInStore ? 0 : 1 );

					pPassStoreAd->SetVisible( true );
					pPassStoreAd->SetItemKVs( pKVItemAd );

					// This is the most important thing to communicate.  Don't let other operations stomp it.
					break;
				}
			}
	
			pszNoQuestsText = m_pszNoQuests;
			// Don't break.  Give more important operations a chance to present
		}
	}

	SetDialogVariable( "noquests", g_pVGuiLocalize->Find( pszNoQuestsText ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrollableQuestList::PopulateQuestLists()
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	// We dont do anything when a quest is completing
	if ( m_pCompletingPanel != NULL )
		return;

	DirtyQuestLayout();

	CUtlVector< CEconItemView * > vecQuestItems;
	TFInventoryManager()->GetAllQuestItems( &vecQuestItems );

	CUtlVector< CQuestItemPanel* > vecAvailablePanels;

	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		bool bFound = false;
		if ( m_vecQuestItemPanels[ i ]->GetItem() )
		{
			FOR_EACH_VEC_BACK( vecQuestItems, j )
			{
				// See if the item in the panel is still in the list of items we own
				if ( m_vecQuestItemPanels[ i ]->GetItem()->GetOriginalID() == vecQuestItems[ j ]->GetOriginalID() )
				{
					// Refresh it
					m_vecQuestItemPanels[ i ]->InvalidateLayout();
					vecQuestItems.Remove( j );
					bFound = true;
					break;
				}
			}
		}

		// Didn't find it.  Clear it out
		if ( !bFound )
		{
			if ( m_vecQuestItemPanels[ i ]->GetItem() )
			{
				m_vecQuestItemPanels[ i ]->SetItem( NULL );
			}

			if ( m_vecQuestItemPanels[ i ]->IsSelected() )
			{
				SetSelected( m_vecQuestItemPanels[ i ], false );
			}

			vecAvailablePanels.AddToTail( m_vecQuestItemPanels[ i ] );
		}
	}

	for ( int i = 0 ; i < vecQuestItems.Count(); ++i )
	{
		CEconItemView *pItem = vecQuestItems[i];

		if ( i < vecAvailablePanels.Count() )
		{
			vecAvailablePanels[ i ]->SetItem( pItem );
		}
		else if ( i >= m_vecQuestItemPanels.Count() )
		{
			Assert( !"Ran out of quest panels!" );
		}
	}

	// Sort the panels to make sure they're in order
	m_vecQuestItemPanels.Sort( &QuestSort_AcquiredTime );

	// Sorting is done manually
	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		m_vecQuestItemPanels[ i ]->SetZPos( i + 1 );
	}

	PositionQuestItemPanels();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrollableQuestList::QuestCompletedResponse()
{
	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		m_vecQuestItemPanels[i]->QuestCompletedResponse();
	}

//	PopulateQuestLists();
}

//-----------------------------------------------------------------------------
// Purpose: Return true if any quest item panels are in the passed in state
//-----------------------------------------------------------------------------
bool CScrollableQuestList::AnyQuestItemPanelsInState( CQuestItemPanel::EItemPanelState_t eState ) const
{
	FOR_EACH_VEC( m_vecQuestItemPanels, i )
	{
		if ( m_vecQuestItemPanels[i]->GetState() == eState )
			return true;
	}

	return false;
}

//-------------------------------------------------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CQuestLogPanel::CQuestLogPanel( IViewPort *pViewPort )
		: EditablePanel( NULL, PANEL_QUEST_LOG )
		, m_bWaitingForComplete( false )
		, m_pQuestList( NULL )
		, m_bInventoryDirty( true )
		, m_iQuestLogKey( BUTTON_CODE_INVALID )
{
	if (g_pVGuiLocalize)
	{
		g_pVGuiLocalize->AddFile( "resource/tf_quests_%language%.txt" );
	}

	vgui::HScheme scheme = vgui::scheme()->LoadSchemeFromFileEx( enginevgui->GetPanel( PANEL_CLIENTDLL ), "resource/ClientScheme.res", "ClientScheme");
	SetScheme(scheme);
	SetProportional( true );

	ListenForGameEvent( "inventory_updated" );
	ListenForGameEvent( "gameui_hidden" );
	ListenForGameEvent( "gc_connected" );

	// Create the item model panel tooltip
	m_pMouseOverItemPanel = new CItemModelPanel( this, "mouseoveritempanel" );
	m_pMouseOverTooltip = new CItemModelPanelToolTip( this );
	m_pMouseOverTooltip->SetupPanels( this, m_pMouseOverItemPanel );

	// Create the text tooltip
	m_pToolTip = new CQuestTooltip( this );
	m_pToolTipEmbeddedPanel = new vgui::EditablePanel( this, "TooltipPanel" );
	m_pToolTipEmbeddedPanel->SetKeyBoardInputEnabled( false );
	m_pToolTipEmbeddedPanel->SetMouseInputEnabled( false );
//	m_pToolTipEmbeddedPanel->MakePopup();
	m_pToolTip->SetEmbeddedPanel( m_pToolTipEmbeddedPanel );
	m_pToolTip->SetTooltipDelay( 0 );

	EditablePanel *pMainContainer = new EditablePanel( this, "MainContainer" );
	m_pQuestList = new CScrollableQuestList( pMainContainer, "QuestList" );

	m_pProgressPanel = new EditablePanel( this, "ProgressPanel" );

	m_pDebugButton = new CExButton( pMainContainer, "Options", "Options", this, "open_debug_menu" );
}

//-----------------------------------------------------------------------------
// Purpose: Look into the moused-over panel and take "tiptext" from its dialog
//			variables and set it as our own.
//-----------------------------------------------------------------------------
void CQuestTooltip::ShowTooltip( Panel *pCurrentPanel )
{
	EditablePanel* pEditableCurrentPanel = dynamic_cast< EditablePanel* >( pCurrentPanel );
	if ( pEditableCurrentPanel )
	{
		KeyValues* pKVVariables = pEditableCurrentPanel->GetDialogVariables();
		const wchar_t *pwszTipText = pKVVariables->GetWString( "tiptext", L"" );
		m_pEmbeddedPanel->SetDialogVariable( "tiptext", pwszTipText );
	}

	BaseClass::ShowTooltip( pCurrentPanel );
}

//-----------------------------------------------------------------------------
// Purpose: Position ourselves down and to the right as far as posible
//-----------------------------------------------------------------------------
void CQuestTooltip::PositionWindow( Panel *pTipPanel )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	int iTipW, iTipH;
	pTipPanel->GetSize( iTipW, iTipH );

	int cursorX, cursorY;
	vgui::input()->GetCursorPos(cursorX, cursorY);

	int px, py, wide, tall;
	ipanel()->GetAbsPos( m_pEmbeddedPanel->GetParent()->GetVPanel(), px, py );
	m_pEmbeddedPanel->GetParent()->GetSize(wide, tall);

	if ( !m_pEmbeddedPanel->IsPopup() )
	{
		// Move the cursor into our parent space
		cursorX -= px;
		cursorY -= py;
	}

	// Dangle as far down and as far right as possible
	int nXPos = cursorX - Max( 0, ( ( iTipW + cursorX ) - wide ) );
	int nYPos = ( cursorY + 20 )- Max( 0, ( ( iTipH + cursorY + 20 ) - tall ) ) ;

	pTipPanel->SetPos( nXPos, nYPos );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CQuestLogPanel::~CQuestLogPanel()
{
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::AttachToGameUI( void )
{
	C_CTFGameStats::ImmediateWriteInterfaceEvent( "interface_open",	"quest_log_panel" );

	if ( GetClientModeTFNormal()->GameUI() )
	{
		GetClientModeTFNormal()->GameUI()->SetMainMenuOverride( GetVPanel() );
	}

	SetKeyBoardInputEnabled( true );
	SetMouseInputEnabled( true );
	SetCursor(dc_arrow);
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CQuestLogPanel::GetName( void )
{
	return PANEL_QUEST_LOG;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::ApplySchemeSettings( IScheme *pScheme )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	BaseClass::ApplySchemeSettings( pScheme );

	const char *pszResFile = "Resource/UI/econ/QuestLogPanel.res";

	// Check if the operation wants to override our default res file
	const auto& mapOperations = GetItemSchema()->GetOperationDefinitions();
	FOR_EACH_MAP_FAST( mapOperations, i )
	{
		CEconOperationDefinition* pOperation = mapOperations[i];
		if ( pOperation->IsActive() && pOperation->IsCampaign() )
		{
			// Use the first found for now
			if ( pOperation->GetQuestLogOverrideResFile() )
			{
				pszResFile = pOperation->GetQuestLogOverrideResFile();
			}
			break;
		}
	}

	LoadControlSettings( pszResFile );

	g_spItemTooltip = m_pMouseOverTooltip;
	g_spTextTooltip = m_pToolTip;

	// The outer dim / close button
	{
		Button* pButton = FindControl<Button>( "OutsideCloseButton" );
		if ( pButton )
		{
			pButton->AddActionSignalTarget( this );
			pButton->SetPaintBackgroundEnabled( false );
		}
	}

	m_pQuestList->InvalidateLayout( false, true );

	Assert( m_pQuestList );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::PerformLayout()
{
	BaseClass::PerformLayout();

	if ( GetUniverse() != k_EUniversePublic )
	{
		int x, y;
		m_pDebugButton->GetParent()->GetPos( x, y );
		int w, h;
		m_pDebugButton->GetParent()->GetSize( w, h );
		m_pDebugButton->SizeToContents();
		m_pDebugButton->SetVisible( true );
		m_pDebugButton->SetPos( x + w - m_pDebugButton->GetWide() - 60, y + 15 );
		m_pDebugButton->SetZPos( 1000 );
	}
	else
	{
		m_pDebugButton->SetVisible( false );
	}

	UpdateQuestsItemPanels();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::OnCommand( const char *pCommand )
{
	if ( FStrEq( pCommand, "close" ) )
	{
		if ( enginevgui->IsGameUIVisible() )
		{
			ShowPanel( false );
		}
		else
		{
			IViewPortPanel *pQuestLog = ( gViewPortInterface->FindPanelByName( PANEL_QUEST_LOG ) );
			if ( pQuestLog )
			{
				gViewPortInterface->ShowPanel( pQuestLog, false );
			}
		}
	}
	else if ( Q_stricmp( "open_debug_menu", pCommand ) == 0 )
	{
		if ( GetUniverse() == k_EUniverseBeta || GetUniverse() == k_EUniverseDev )
		{
			const char *pszContextMenuBorder = "NotificationDefault";
			const char *pszContextMenuFont = "HudFontMediumSecondary";

			Menu *pContextMenu = new Menu( this, "ContextMenu" );
			pContextMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
			pContextMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
		

			MenuBuilder contextMenuBuilder( pContextMenu, this );

			const auto& mapOperations = GetItemSchema()->GetOperationDefinitions();
			FOR_EACH_MAP_FAST( mapOperations, iOperation )
			{
				bool bHasAnyQuests = false;
				Menu* pOperationSubMenu = NULL;

				CEconOperationDefinition *pOperation = mapOperations[ iOperation ];
				const CEconLootListDefinition *pLootListDef = GetItemSchema()->GetLootListByName( pOperation->GetOperationLootlist() );
				if ( pLootListDef )
				{
					auto& vecContents = pLootListDef->GetLootListContents();
					FOR_EACH_VEC( vecContents, i )
					{
						if ( vecContents[i].m_iItemOrLootlistDef > 0 )
						{
							const GameItemDefinition_t* pItemDef = (GameItemDefinition_t*)GetItemSchema()->GetItemDefinition( vecContents[i].m_iItemOrLootlistDef );
							if ( pItemDef && pItemDef->GetQuestDef() )
							{
								if ( !bHasAnyQuests )
								{
									bHasAnyQuests = true;

									pOperationSubMenu = new Menu( this, "OperationSubMenu" );
									pOperationSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
									pOperationSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );

									contextMenuBuilder.AddCascadingMenuItem( pOperation->GetName(), pOperationSubMenu, "operations" );
								}

								pOperationSubMenu->AddMenuItem( pItemDef->GetItemBaseName(), CFmtStr( "give%s", pItemDef->GetDefinitionName() ), this );
							}
						}
					}
				}
			}

			bool bHasAnyQuests = false;
			Menu* pAllSubMenu = NULL;

			FOR_EACH_MAP_FAST( GetItemSchema()->GetItemDefinitionMap(), i )
			{
				const GameItemDefinition_t* pItemDef = (GameItemDefinition_t*)GetItemSchema()->GetItemDefinitionMap()[ i ];
				if ( pItemDef->GetQuestDef() )
				{
					if ( !bHasAnyQuests )
					{
						bHasAnyQuests = true;

						pAllSubMenu = new Menu( this, "AllSubMenu" );
						pAllSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
						pAllSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );

						contextMenuBuilder.AddCascadingMenuItem( "all", pAllSubMenu, "all" );
					}

					pAllSubMenu->AddMenuItem( pItemDef->GetItemBaseName(), CFmtStr( "give%s", pItemDef->GetDefinitionName() ), this );
				}
			}

			// Position to the cursor's position
			int nX, nY;
			g_pVGuiInput->GetCursorPosition( nX, nY );
			pContextMenu->SetPos( nX - 1, nY - 1 );
	
			pContextMenu->SetVisible(true);
			pContextMenu->AddActionSignalTarget(this);
		}
	}
	else if ( Q_strnicmp( "give", pCommand, 4 ) == 0 )
	{
		if ( GetUniverse() != k_EUniversePublic )
		{
			if ( !steamapicontext || !steamapicontext->SteamUser() )
			{
				Msg("Not connected to Steam.\n");
				return;
			}

			CSteamID steamIDForPlayer = steamapicontext->SteamUser()->GetSteamID();
			if ( !steamIDForPlayer.IsValid() )
			{
				Msg("Failed to find a valid steamID for the local player.\n");
				return;
			}

			const char* pszItemToGive = pCommand + 4;
			Msg( "Sending request to generate '%s' for Local Player (%llu)\n", pszItemToGive, steamIDForPlayer.ConvertToUint64() );

			CItemSelectionCriteria criteria;

			GCSDK::CProtoBufMsg<CMsgDevNewItemRequest> msg( k_EMsgGCDev_NewItemRequest );
			msg.Body().set_receiver( steamIDForPlayer.ConvertToUint64() );

			criteria.SetIgnoreEnabledFlag( true );
			if ( !criteria.BAddCondition( "name", k_EOperator_String_EQ, pszItemToGive, true ) ||
				!criteria.BSerializeToMsg( *msg.Body().mutable_criteria() ) )
			{
				Msg( "Failed to add condition and/or serialize item grant request. This is probably caused by having a string that's too long.\n" );
				return;
			}
			GCClientSystem()->BSendMessage( msg );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::FireGameEvent( IGameEvent *event )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	// Listen for inventory updates in case our item gets changed while the user
	// is looking at us.  We want to re-do our entire layout since a quest might
	// have been equipped / destroyed / completed and we need to re-categorize
	// all the user's quests.
	if ( FStrEq( event->GetName(), "inventory_updated" ) && !m_bWaitingForComplete )
	{
		m_bInventoryDirty = true;

		if ( IsVisible() )
		{
			if ( m_pQuestList )
			{
				m_pQuestList->PopulateQuestLists();
				m_pQuestList->UpdateEmptyMessage();
			}

			UpdateQuestsItemPanels();
		}
	}
	else if ( FStrEq( event->GetName(), "gameui_hidden" ) )
	{
		ShowPanel( false );
		return;
	}
	else if ( FStrEq( event->GetName(), "gc_connected" ) )
	{
		m_bInventoryDirty = true;
		InvalidateLayout( false, true );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::ShowPanel( bool bShow )
{
	// Snag this so we know what to listen for
	m_iQuestLogKey = gameuifuncs->GetButtonCodeForBind( "show_quest_log" );

	if ( m_pQuestList && bShow )
	{
		m_pQuestList->SetSelected( NULL, true );
		m_pQuestList->DirtyQuestLayout();
	}

	SetVisible( bShow );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::OnKeyCodePressed( KeyCode code )
{
	if ( code == m_iQuestLogKey || code == STEAMCONTROLLER_B )
	{
		ShowPanel( false );
		return;
	}

	BaseClass::OnKeyCodePressed( code );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::OnKeyCodeTyped( KeyCode code )
{
	if ( code == KEY_ESCAPE )
	{
		if ( IsVisible() )
		{
			SetVisible( false );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::SetVisible( bool bState ) 
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	// Default to showing the active quests upon opening
	if ( bState == true )
	{
		UpdateQuestsItemPanels();

		IGameEvent *event = gameeventmanager->CreateEvent( "questlog_opened" );
		if ( event )
		{
			gameeventmanager->FireEventClientSide( event );
		}

		if ( enginevgui->IsGameUIVisible() )
		{
			AttachToGameUI();
		}
		else
		{
			ipanel()->SetParent( GetVPanel(), VGui_GetClientDLLRootPanel() );

			MakePopup( false, true );
			SetKeyBoardInputEnabled( true );
			SetMouseInputEnabled( true );
			MoveToFront();
		}

		engine->ClientCmd_Unrestricted( "gameui_preventescapetoshow\n" );
		vgui::surface()->PlaySound( "ui/panel_open.wav" );
	}
	else if ( IsVisible() )
	{
		// Detach from the GameUI when we hide
		IViewPortPanel *pMMOverride = gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE );
		if ( pMMOverride )
		{
			((CHudMainMenuOverride*)pMMOverride)->AttachToGameUI();	
		}

		engine->ClientCmd_Unrestricted( "gameui_allowescapetoshow\n" );
		vgui::surface()->PlaySound( "ui/panel_close.wav" );
	}

	BaseClass::SetVisible( bState );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::QuestCompletedResponse()
{
	m_bWaitingForComplete = false;
	m_bInventoryDirty = true;

	if ( m_pQuestList )
		m_pQuestList->QuestCompletedResponse();

	//UpdateQuestsItemPanels();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::UpdateQuestsItemPanels()
{
	UpdateBadgeProgressPanels();

	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	if ( m_bInventoryDirty )
	{
		m_pQuestList->QuestCompletedResponse();

		if ( m_pQuestList )
		{
			m_pQuestList->PopulateQuestLists();
			m_pQuestList->UpdateEmptyMessage();
		}
	}

	m_bInventoryDirty = false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::MarkQuestsDirty()
{
	m_bInventoryDirty = true;

	if ( IsVisible() )
	{
		UpdateQuestsItemPanels();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Return true if any quest item panels are in the passed in state
//-----------------------------------------------------------------------------
bool CQuestLogPanel::AnyQuestItemPanelsInState( CQuestItemPanel::EItemPanelState_t eState ) const
{
	return m_pQuestList->AnyQuestItemPanelsInState( eState );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::OnCompleteQuest( void )
{
	m_bWaitingForComplete = true;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestLogPanel::UpdateBadgeProgressPanels()
{
	CEconOperationDefinition *pCurrentOperation = NULL;
	const auto& mapOperations = GetItemSchema()->GetOperationDefinitions();
	FOR_EACH_MAP_FAST( mapOperations, i )
	{
		CEconOperationDefinition* pOperation = mapOperations[i];
		if ( pOperation->IsActive() && pOperation->IsCampaign() )
		{
			pCurrentOperation = pOperation;
			break;
		}
	}

	if ( pCurrentOperation )
	{
		CEconItemView *pCoin = TFInventoryManager()->GetLocalTFInventory()->FindFirstItembyItemDef( pCurrentOperation->GetRequiredItemDefIndex() );
		if ( pCoin )
		{
			m_pProgressPanel->SetVisible( true );
			CItemModelPanel *pCoinPanel = m_pProgressPanel->FindControl< CItemModelPanel >( "CoinModelPanel" );
			if ( pCoinPanel )
			{
				pCoinPanel->SetItem( pCoin );
			}

			uint32 nNumCompletedContracts = 0;
			{
				uint32 nCompletedContractsTemp = 0;
				GetKilleaterValueByEvent( pCoin, kKillEaterEvent_CosmeticOperationContractsCompleted, nCompletedContractsTemp );
				nNumCompletedContracts = Max( nNumCompletedContracts, nCompletedContractsTemp );
				// Halloween has it's own thing for whatever reason
				GetKilleaterValueByEvent( pCoin, kKillEaterEvent_HalloweenContractsCompleted, nCompletedContractsTemp );
				nNumCompletedContracts = Max( nNumCompletedContracts, nCompletedContractsTemp );
				Assert( pCurrentOperation->GetMaxDropCount() > 0 );
			}

			uint32 nNumContractPoints = 0;
			{
				uint32 nContractsPointsTemp = 0;
				GetKilleaterValueByEvent( pCoin, kKillEaterEvent_CosmeticOperationContractsPoints, nContractsPointsTemp );
				nNumContractPoints = Max( nContractsPointsTemp, nNumContractPoints );
				// Halloween has it's own thing for whatever reason
				GetKilleaterValueByEvent( pCoin, kKillEaterEvent_HalloweenSouls, nContractsPointsTemp );
				nNumContractPoints = Max( nContractsPointsTemp, nNumContractPoints );
			}

			EditablePanel *pBadgeContainer = m_pProgressPanel->FindControl< EditablePanel >( "BadgeMeterContainer" );
			if ( pBadgeContainer )
			{
				ContinuousProgressBar *pBadgeProgressBar = pBadgeContainer->FindControl< ContinuousProgressBar >( "BadgeProgressMeter" );
				if ( pBadgeProgressBar )
				{
					const char *pszLevelingDataName = GetItemSchema()->GetKillEaterScoreTypeLevelingDataName( kKillEaterEvent_HalloweenSouls );
					Assert( pszLevelingDataName );

					const CUtlVector<CItemLevelingDefinition> *pLevelingData = GetItemSchema()->GetItemLevelingData( pszLevelingDataName );
					Assert( pLevelingData );

					int nRequiredPointsToNextRank = 0;
					int nRequiredPointsToCurrentRank = 0;
					const char *pszCurrentLevelName = NULL;
					FOR_EACH_VEC( (*pLevelingData), i )
					{
						pszCurrentLevelName = (*pLevelingData)[i].GetNameLocalizationKey();

						const uint32 nRank = (*pLevelingData)[i].GetRequiredScore();
						if ( nNumContractPoints < nRank )
						{
							nRequiredPointsToNextRank = nRank;
							break;
						}
						else
						{
							nRequiredPointsToCurrentRank = nRank;
						}
					}

					// if no next level, just use max points
					if ( nRequiredPointsToNextRank == 0 )
					{
						// assuming each contract's worth 130 (100 point + 30 bonus)
						nRequiredPointsToNextRank = pCurrentOperation->GetMaxDropCount() * 130;
					}

					float flProgress = (float)( nNumContractPoints - nRequiredPointsToCurrentRank ) / (float)( nRequiredPointsToNextRank - nRequiredPointsToCurrentRank );
					pBadgeProgressBar->SetProgress( flProgress );

					CExLabel *pLabel = m_pProgressPanel->FindControl< CExLabel >( "BadgeProgressLabel" );
					if ( pLabel )
					{
						pLabel->SetText( CConstructLocalizedString( g_pVGuiLocalize->Find( "QuestLog_BadgeProgress" ), g_pVGuiLocalize->Find( pszCurrentLevelName ) ) );
					}

					CExLabel *pScoreLabel = pBadgeContainer->FindControl< CExLabel >( "BadgeProgressMeterText" );
					if ( pScoreLabel )
					{
						pScoreLabel->SetText( CFmtStr( "%d/%d", nNumContractPoints, nRequiredPointsToNextRank ) );
					}
				}
			}

			EditablePanel *pContractContainer = m_pProgressPanel->FindControl< EditablePanel >( "ContractMeterContainer" );
			if ( pContractContainer )
			{
				ContinuousProgressBar *pContractProgressBar = pContractContainer->FindControl< ContinuousProgressBar >( "ContractsCompletedProgressMeter" );
				if ( pContractProgressBar )
				{
					pContractProgressBar->SetProgress( (float)nNumCompletedContracts / (float)pCurrentOperation->GetMaxDropCount() );

					CExLabel *pLabel = pContractContainer->FindControl< CExLabel >( "ContractsCompletedProgressMeterText" );
					if ( pLabel )
					{
						pLabel->SetText( CFmtStr( "%d", nNumCompletedContracts ) );
					}
				}
			}			
		}
		else
		{
			m_pProgressPanel->SetVisible( false );
		}
	}
	else
	{
		m_pProgressPanel->SetVisible( false );
	}
}


//-----------------------------------------------------------------------------
// Purpose: GC Msg handler for when a quest has been completed
//-----------------------------------------------------------------------------
class CGCCompleteQuestCompleteResponse : public GCSDK::CGCClientJob
{
public:
	CGCCompleteQuestCompleteResponse( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		GCSDK::CGCMsg<MsgGCStandardResponse_t> msg( pNetPacket );

		itemid_t nNewToolID = 0;
		if( !msg.BReadUint64Data( &nNewToolID ) )
			return true;

		CQuestLogPanel *pQuestLog = GetQuestLog();
		if ( pQuestLog )
		{
			pQuestLog->QuestCompletedResponse();
		}

		return true;
	}
};

GC_REG_JOB( GCSDK::CGCClient, CGCCompleteQuestCompleteResponse, "CGCCompleteQuestCompleteResponse", k_EMsgGCQuestCompleted, GCSDK::k_EServerTypeGCClient );


#ifdef STAGING_ONLY
static void cc_tf_quest_log_reload()
{
	CQuestLogPanel *pQuestLog = GetQuestLog();
	if ( pQuestLog )
	{
		pQuestLog->MarkQuestsDirty();
		pQuestLog->InvalidateLayout( true, true );
		gViewPortInterface->ShowPanel( pQuestLog, true );
	}
}
ConCommand tf_quest_log_reload( "tf_quest_log_reload", cc_tf_quest_log_reload );
#endif