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

#include "cbase.h"
#include "tf_quest_editor_panel.h"
#include "econ_item_tools.h"
#include "tier2/p4helpers.h"
#include "tier2/fileutils.h"
#include "vgui/IInput.h"

#ifdef STAGING_ONLY

using namespace vgui;

ConVar tf_quest_editor_element_height( "tf_quest_editor_element_height", "20", FCVAR_ARCHIVE );
ConVar tf_quest_editor_indent_width( "tf_quest_editor_indent_width", "20", FCVAR_ARCHIVE );
ConVar tf_quest_editor_entry_inset( "tf_quest_editor_entry_inset", "120" );

static const char *g_skItemNameFormat = "quest%d";
static const char *g_skNameTokenFormat = "#quest%dname%d";
static const char *g_skDescTokenFormat = "#quest%ddesc%d";
static const char *g_skObjectiveDescTokenFormat = "#quest%dobjectivedesc%d";
static const char *g_skLocalizationFile = "resource/tf_quests_english.txt";
static const char *g_skQuestDefFile = "tf/scripts/items/unencrypted/_items_quests.txt";
static const char *g_skQuestObjectivesConditionsDefFile = "tf/scripts/items/unencrypted/_items_quest_objective_definitions.txt";
static const char *g_skQuestObjectivesHouseKeepingFile = "items_quest_objective_housekeeping.csv";
static const int g_nkFirstQuestDef = 25000;

static const char* g_skQuestPrefabs[] = { "quest_prefab_1st_operation_pauling"
										, "quest_prefab_halloween_2015"
										, "quest_prefab_2nd_operation_pauling" };

#define FLAGS_NONE 0
#define FLAG_HIDDEN 1<<0
#define FLAG_COLLAPSED 1<<1
#define FLAG_COLLAPSABLE 1<<2
#define FLAG_MUST_BE_LAST 1<<3
#define FLAG_NOT_DELETABLE 1<<4
#define FLAG_OUTPUT_LAST 1<<5
#define FLAG_DELETED 1<<6
#define FLAG_HIGHLIGHT_MOUSEOVER 1<<7
#define FLAG_DONT_EXPORT 1<<8

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static CQuestEditorPanel* g_pQuestEditor = NULL;
static void cc_tf_quest_editor()
{
	g_pQuestEditor = new CQuestEditorPanel( NULL, "QuestEditor" );
	g_pQuestEditor->MakeReadyForUse();
	g_pQuestEditor->Deploy();
}
ConCommand tf_quest_editor( "tf_quest_editor", cc_tf_quest_editor );


//-----------------------------------------------------------------------------
// Purpose:	Writes out all of the localization data for each quest intro "resource/tf_quests_english.txt"
//-----------------------------------------------------------------------------
void WriteLocalizationData()
{
	char szQuestEnglishFile[MAX_PATH];
	if ( !GenerateFullPath( g_skLocalizationFile, "MOD", szQuestEnglishFile, ARRAYSIZE( szQuestEnglishFile ) ) )
	{
		Warning( "Failed to GenerateFullPath %s\n", g_skLocalizationFile );
		return;
	}
	
	FOR_EACH_VEC( ILocalizationEditorParamAutoList::AutoList(), i )
	{
		CLocalizationEditorParam* pLocalizationEntry = static_cast< CLocalizationEditorParam* >( ILocalizationEditorParamAutoList::AutoList()[i] );
		// We set the filename to "deleted" for deleted entries so that they don't get written out
		// into tf_quests_english.txt
		const char* pszFile = pLocalizationEntry->IsFlagSet( FLAG_DELETED, true ) ? "deleted" : szQuestEnglishFile;

		wchar_t wszLocalizedValue[MAX_QUEST_DESC_LENGTH];
		g_pVGuiLocalize->ConvertANSIToUnicode( pLocalizationEntry->GetLocalizationValue(), wszLocalizedValue, sizeof( wszLocalizedValue ) );
		
		const char *pszTokenName = pLocalizationEntry->GetValue();
		if ( pszTokenName[0] == '#' )
		{
			pszTokenName++;
		}
		g_pVGuiLocalize->AddString( pszTokenName, wszLocalizedValue, pszFile );
	}

	// Get the name of the file and p4 check it out
	char szCorrectCaseFilePath[MAX_PATH];
	g_pFullFileSystem->GetCaseCorrectFullPath( szQuestEnglishFile, szCorrectCaseFilePath );
	CP4AutoEditFile a( szCorrectCaseFilePath );

	g_pVGuiLocalize->SaveToFile( szQuestEnglishFile );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditorObject::IEditorObject( EditorObjectInitStruct init )
	: EditablePanel( init.pParent, init.m_pszKeyName )
	, m_Flags( init.nFlags )
	, m_pOwningEditable( NULL )
	, m_bHasChanges( false )
{
	memset( m_szKeyName, 0, sizeof( m_szKeyName ) );
	if ( init.m_pszKeyName )
	{
		V_sprintf_safe( m_szKeyName, "%s", init.m_pszKeyName );
	}

	SetWide( init.pParent->GetWide() );

	SetAutoResize( Panel::PIN_TOPLEFT, Panel::AUTORESIZE_RIGHT, 6, 6, -6, -6 );
}

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

	SetTall( GetContentTall() );
}

void IEditorObject::OnSizeChanged( int newWide, int newTall )
{
	BaseClass::OnSizeChanged( newWide, newTall );

	GetParent()->InvalidateLayout();
}


bool IEditorObject::IsFlagSet( int nFlag, bool bCheckUpTree ) const
{ 
	bool bIsFlagSet = m_Flags & nFlag;
	if ( !bIsFlagSet && bCheckUpTree )
	{
		IEditorObject* pParent = dynamic_cast< IEditorObject* >( const_cast<IEditorObject*>(this)->GetParent() );
		if ( pParent )
		{
			bIsFlagSet |= pParent->IsFlagSet( nFlag, bCheckUpTree );
		}
	}
	return bIsFlagSet;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditorObject::ESerializeAction IEditorObject::ShouldWrite( const IEditableDataType* pCallingEditable ) const
{
	if ( IsFlagSet( FLAG_DONT_EXPORT ) )
		return SKIP_THIS_AND_CHILDREN;

	if ( IsFlagSet( FLAG_DELETED ) )
		return SKIP_THIS_AND_CHILDREN;

	if ( GetOwningEditable() != pCallingEditable )
		return SKIP_THIS_AND_CONTINUE;
		
	return WRITE_THIS_AND_CONTINUE;
}

//-----------------------------------------------------------------------------
// Purpose: If we're set to highlight on mouseover, do so!
//-----------------------------------------------------------------------------
void IEditorObject::OnThink()
{
	if ( IsFlagSet( FLAG_HIGHLIGHT_MOUSEOVER, false ) )
	{
		if ( IsCursorOver() )
		{
			SetBgColor( Color( 100, 150, 100, 30 ) );
		}
		else
		{
			SetBgColor( Color( 235, 226, 202, 2 ) );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEditorObjectNode::CEditorObjectNode( EditorObjectInitStruct init )
	: BaseClass( init )
{
	m_pToggleCollapseButton = new Button( this, "togglecollapse", "-", this, "togglecollapse" );
	m_pToggleCollapseButton->SetVisible( false );
	m_pToggleCollapseButton->SetWide( 20 );
	m_pToggleCollapseButton->SetZPos( 100 );

	m_pDeleteButton = new Button( this, "deletebutton", "x", this, "delete" );
	m_pDeleteButton->SetWide( 20 );
	m_pDeleteButton->SetTall( 20 );

	CEditorObjectNode* pNode = dynamic_cast< CEditorObjectNode* >( init.pParent );
	if ( pNode )
	{
		pNode->AddChild( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEditorObjectNode::~CEditorObjectNode()
{
	CEditorObjectNode* pEditorPanel = dynamic_cast<CEditorObjectNode*>( GetParent() );
	if ( pEditorPanel )
	{
		pEditorPanel->RemoveChild( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const IEditableDataType* IEditorObject::GetOwningEditable() const
{
	const IEditableDataType* pOwningEditable = NULL;
	const IEditorObject* pPanel = this;
	
	do 
	{
		pOwningEditable = pPanel->m_pOwningEditable;
		pPanel = dynamic_cast< const IEditorObject* >( const_cast< IEditorObject* >( pPanel )->GetParent() ); // Good lord, VGUI.  GetParent() isn't const?  Really?
	} 
	while ( pOwningEditable == NULL && pPanel != NULL );

	Assert( pOwningEditable != NULL );
		
	return pOwningEditable;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObject::InvalidateChain()
{
	InvalidateLayout();
		
	Panel* pParent = this;

	do
	{
		pParent = pParent->GetParent();
		pParent->InvalidateLayout();
	}
	while( dynamic_cast< IEditorObject* >( pParent ) );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObject::ClearPendingChangesFlag()
{
	m_bHasChanges = false;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::AddChild( IEditorObject* pChild )
{
	m_bHasChanges = true;
	m_vecChildren.AddToTail( pChild );
	if ( !IsFlagSet( FLAG_HIDDEN ) && IsFlagSet( FLAG_COLLAPSABLE ) )
	{
		m_pToggleCollapseButton->SetVisible( true );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::RemoveChild( IEditorObject* pChild )
{
	FOR_EACH_VEC( m_vecChildren, i )
	{
		if ( m_vecChildren[i] == pChild )
		{
			m_vecChildren.Remove( i );
			if ( m_vecChildren.Count() == 0 )
			{
				m_pToggleCollapseButton->SetVisible( false );
			}

			m_bHasChanges = true;

			return;
		}
	}

	Assert( !"Couldn't find child to remove!" );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CEditorObjectNode::GetNextAvailableKeyNumber() const
{
	int nNextAvailable = 0;

	FOR_EACH_VEC( m_vecChildren, i )
	{
		if ( !m_vecChildren[i]->IsFlagSet( FLAG_DONT_EXPORT ) )
		{
			nNextAvailable = Max( nNextAvailable, atoi( m_vecChildren[i]->GetName() ) );
		}
	}

	return nNextAvailable;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEditorObjectNode::HasChanges( bool bCheckChildren ) const
{
	bool bHasChanges = m_bHasChanges;

	if ( bCheckChildren )
	{
		FOR_EACH_VEC( m_vecChildren, i )
		{
			bHasChanges |= m_vecChildren[i]->HasChanges( bCheckChildren );
		}
	}

	return bHasChanges;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CEditorObjectNode::GetContentTall() const
{
	// Hidden panels have 0 height
	int nTall = IsFlagSet( FLAG_HIDDEN ) ? 0 : tf_quest_editor_element_height.GetInt();

	// Collapsed panels just return their height.
	if ( IsFlagSet( FLAG_COLLAPSED ) )
		return nTall;

	FOR_EACH_VEC( m_vecChildren, i )
	{
		nTall += m_vecChildren[i]->GetContentTall();
	}

	return nTall;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::SerializeToKVs( KeyValues* pKV, const IEditableDataType* pCallingEditable ) const
{
	m_bHasChanges = false;

	// End of the Line if deleted
	if ( IsFlagSet( FLAG_DELETED ) )
		return;

	ESerializeAction action = ShouldWrite( pCallingEditable );
	if ( action == SKIP_THIS_AND_CHILDREN )
		return;

	if ( action != SKIP_THIS_AND_CONTINUE )
	{
		pKV = pKV->CreateNewKey();
		pKV->SetName( GetKeyName() );
	}

	CUtlVector< IEditorObject* > vecLastOutputs;

	FOR_EACH_VEC( m_vecChildren, i )
	{
		if ( m_vecChildren[ i ]->IsFlagSet( FLAG_OUTPUT_LAST ) )
		{
			vecLastOutputs.AddToTail( m_vecChildren[i] );
			continue;
		}

		m_vecChildren[i]->SerializeToKVs( pKV, pCallingEditable );

	}

	FOR_EACH_VEC( vecLastOutputs, i )
	{
		vecLastOutputs[ i ]->SerializeToKVs( pKV, pCallingEditable );
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::PerformLayout() 
{
	m_pDeleteButton->SetVisible( m_vecChildren.Count() > 0 && !IsFlagSet( FLAG_HIDDEN ) && !IsFlagSet( FLAG_NOT_DELETABLE ) );
	m_pDeleteButton->SetPos( 470, 0 );

	BaseClass::PerformLayout();

	int nTall = IsFlagSet( FLAG_HIDDEN ) ? 0 : tf_quest_editor_element_height.GetInt();

	CUtlVector< IEditorObject* > vecLastParams;

	FOR_EACH_VEC( m_vecChildren, i )
	{
		if ( IsFlagSet( FLAG_MUST_BE_LAST ) )
		{
			vecLastParams.AddToTail( m_vecChildren[i] );
			continue;
		}

		m_vecChildren[i]->SetPos( IsFlagSet( FLAG_HIDDEN ) ? 0 : tf_quest_editor_indent_width.GetInt(), nTall );
		nTall += m_vecChildren[i]->GetContentTall();
	}

	FOR_EACH_VEC( vecLastParams, i )
	{
		vecLastParams[i]->SetPos( IsFlagSet( FLAG_HIDDEN ) ? 0 : tf_quest_editor_indent_width.GetInt(), nTall );
		nTall += vecLastParams[i]->GetContentTall();
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEditorObjectNode::OnCommand( const char *command )
{
	if ( V_stricmp( "togglecollapse", command ) == 0 )
	{
		if ( IsFlagSet( FLAG_COLLAPSED ) )
		{
			m_pToggleCollapseButton->SetText( "-" );
		}
		else
		{
			m_pToggleCollapseButton->SetText( "+" );
		}		

		SetFlag( FLAG_COLLAPSED, !IsFlagSet( FLAG_COLLAPSED ) );
		InvalidateChain();

		return;
	}
	if ( V_stricmp( command, "delete" ) == 0 )
	{
		RemoveNode();
		return;
	}

	BaseClass::OnCommand( command );
}

void CEditorObjectNode::MarkForDeletion()
{
	BaseClass::MarkForDeletion();

	FOR_EACH_VEC( m_vecChildren, i )
	{
		m_vecChildren[i]->MarkForDeletion();
	}
}

void CEditorObjectNode::RemoveNode()
{
	MarkForDeletion();

	InvalidateChain();	
}

void CEditorObjectNode::ClearPendingChangesFlag()
{
	BaseClass::ClearPendingChangesFlag();

	FOR_EACH_VEC( m_vecChildren, i )
	{
		m_vecChildren[ i ]->ClearPendingChangesFlag();
	}
}

IEditorObjectParameter::IEditorObjectParameter( EditorObjectInitStruct init, const char *pszLabelText )
	: BaseClass( init )
{
	memset( m_szSavedValueBuff, 0, sizeof( m_szSavedValueBuff ) );

	SetTall( tf_quest_editor_element_height.GetInt() );

	m_pLabel = new Label( this, "paramlabel", pszLabelText );
	m_pLabel->SetWide( 100 );
	m_pLabel->SetPos( 20, 0 );
	m_pLabel->SetVisible( pszLabelText != NULL );

	CEditorObjectNode* pNode = dynamic_cast< CEditorObjectNode* >( init.pParent );
	if ( pNode )
	{
		pNode->AddChild( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditorObjectParameter::~IEditorObjectParameter()
{
	CEditorObjectNode* pEditorPanel = dynamic_cast<CEditorObjectNode*>( GetParent() );
	if ( pEditorPanel )
	{
		pEditorPanel->RemoveChild( this );
	}
}

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

	m_pLabel->SetPos( 20, 0 );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObjectParameter::SerializeToKVs( KeyValues* pKV, const IEditableDataType* pCallingEditable ) const
{
	m_bHasChanges = false;

	if ( ShouldWrite( pCallingEditable ) == WRITE_THIS_AND_CONTINUE )
	{
		KeyValues* pKVStomp = pKV->FindKey( GetKeyName() );
		if ( pKVStomp )
		{
			AssertMsg2( false, "STOMPING existing key: %s with %s\n", pKVStomp->GetName(), GetValue() );
			KeyValuesDumpAsDevMsg( pKVStomp );
		}

		pKV->SetString( GetKeyName(), GetValue() );

		UpdateSavedValue( GetValue() );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObjectParameter::UpdateSavedValue( const char* pszNewValue ) const
{
	// Update saved string
	memset( m_szSavedValueBuff, 0, sizeof( m_szSavedValueBuff ) );
	V_sprintf_safe( m_szSavedValueBuff, "%s", pszNewValue );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IEditorObjectParameter::OnTextChanged( KeyValues *data )
{
	m_bHasChanges = CheckForChanges();

	IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
	Color labelNormalFGColor = GetSchemeColor("Label.TextColor", Color(0, 0, 0, 255), pScheme);
	Color labelChangesFGColor = GetSchemeColor("RichText.SelectedBgColor", Color(0, 0, 0, 255), pScheme);

	m_pLabel->SetFgColor( m_bHasChanges ? labelChangesFGColor : labelNormalFGColor );

	g_pQuestEditor->CheckForChanges();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool IEditorObjectParameter::CheckForChanges() const
{
	return !FStrEq( GetValue(), m_szSavedValueBuff );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTextEntryEditorParam::CTextEntryEditorParam( EditorObjectInitStruct init, const char *pszLabelText, const char *pszValue )
	: BaseClass( init, pszLabelText )
{
	UpdateSavedValue( pszValue );

	SetTall( tf_quest_editor_element_height.GetInt() );
	m_pTextEntry = new TextEntry( this, "entry" );
	m_pTextEntry->SetPos( tf_quest_editor_entry_inset.GetInt(), 0 );
	m_pTextEntry->SetWide( 400 );
	m_pTextEntry->SetTall( tf_quest_editor_element_height.GetInt() );
	m_pTextEntry->SetMultiline( true );
	m_pTextEntry->SetCatchEnterKey( true );
	SetTextEntryValue( pszValue );
}

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

	m_pTextEntry->SetPos( tf_quest_editor_entry_inset.GetInt(), 0 );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTextEntryEditorParam::GetContentTall() const
{
	return IsFlagSet( FLAG_HIDDEN ) ? 0 : m_pTextEntry->GetTall();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTextEntryEditorParam::SetTextEntryValue( const char* pszValue )
{
	m_pTextEntry->SetText( pszValue );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CTextEntryEditorParam::GetValue() const 
{
	m_pTextEntry->GetText( m_szValueBuff, sizeof( m_szValueBuff ) );
	return m_szValueBuff;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IMPLEMENT_AUTO_LIST( ILocalizationEditorParamAutoList );
CLocalizationEditorParam::CLocalizationEditorParam( EditorObjectInitStruct init, const char *pszLabelText, const char *pszLocalizationToken )
	: BaseClass( init, pszLabelText, NULL )
{
	char szBuff[MAX_QUEST_DESC_LENGTH];
	memset( szBuff, 0, sizeof( szBuff ) );
	g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pszLocalizationToken ), szBuff, sizeof( szBuff ) );
	SetTextEntryValue( szBuff );
	UpdateSavedValue( szBuff );

	V_sprintf_safe( m_szLocalizationToken, "%s", pszLocalizationToken );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CLocalizationEditorParam::GetValue() const
{
	// Always return the localization token
	return m_szLocalizationToken;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CLocalizationEditorParam::GetLocalizationValue() const
{
	return BaseClass::GetValue();
}

bool CLocalizationEditorParam::CheckForChanges() const
{
	return !FStrEq( m_szSavedValueBuff, GetLocalizationValue() );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CComboBoxEditorParam::CComboBoxEditorParam( EditorObjectInitStruct init, const char *pszLabelText )
	: BaseClass( init, pszLabelText )
	, m_pComboBox( NULL )
{
	m_pComboBox = new ComboBox( this, "combobox", 10, false );
	m_pComboBox->AddActionSignalTarget( this );
}

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

	m_pComboBox->SetWide( 350 );
	m_pComboBox->SetPos( tf_quest_editor_entry_inset.GetInt(), 0 );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CComboBoxEditorParam::GetContentTall() const 
{
	return IsFlagSet( FLAG_HIDDEN ) ? 0 : m_pComboBox->GetTall();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* CComboBoxEditorParam::GetValue() const 
{
	return m_pComboBox->GetActiveItemUserData()->GetString( "write" );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CComboBoxEditorParam::AddComboBoxEntry( const char* pszText, bool bSelected, const char* pszWriteValue, const char* pszCommand )
{
	KeyValues *pKVData = new KeyValues( "data" );
	pKVData->SetString( "write", pszWriteValue );
	pKVData->SetString( "command", pszCommand );

	int nIndex = m_pComboBox->AddItem( pszText, pKVData );

	if ( bSelected )
	{
		m_pComboBox->SilentActivateItemByRow( nIndex );
		UpdateSavedValue( pszWriteValue );
	}

	if ( pszWriteValue == NULL )
	{
		pszWriteValue = pszText;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CComboBoxEditorParam::OnTextChanged( KeyValues *data )
{
	Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );
	vgui::ComboBox *pComboBox = dynamic_cast<vgui::ComboBox *>( pPanel );

	if ( pComboBox == m_pComboBox )
	{
		CQuestObjectiveRestrictionNode* pParent = dynamic_cast< CQuestObjectiveRestrictionNode* >( GetParent() );
		if ( pParent )
		{
			// What to do
			const char* pszCommand = m_pComboBox->GetActiveItemUserData()->GetString( "command" );
			// What to write
			const char* pszWriteValue = m_pComboBox->GetActiveItemUserData()->GetString( "write" );
			if ( V_stricmp( pszCommand, "changetype" ) == 0 )
			{
				pParent->SetNewType( pszWriteValue );
			}
			else if ( V_stricmp( pszCommand, "changeevent" ) == 0 )
			{
				pParent->SetNewEvent( pszWriteValue );
			}
		}
	}

	BaseClass::OnTextChanged( data );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CNewQuestObjectiveParam::CNewQuestObjectiveParam( EditorObjectInitStruct init, const char *pszLabelText )
	: BaseClass( init, NULL )
{
	SetFlag( FLAG_DONT_EXPORT, true );

	m_pAddButton = new Button( this, "add", "Add New Filter", this, "add" );
	m_pAddButton->SetTall( 20 );
	m_pComboBox->SetVisible( false );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNewQuestObjectiveParam::PerformLayout()
{
	BaseClass::PerformLayout();
	m_pAddButton->SetWide( 200 );
	m_pAddButton->SetPos( tf_quest_editor_indent_width.GetInt(), 0 );
	m_pAddButton->SetContentAlignment( Label::a_center );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CNewQuestObjectiveParam::OnCommand( const char *command )
{
	if ( FStrEq( command, "add" ) )
	{
		CQuestObjectiveRestrictionNode *pObjectiveParent = dynamic_cast< CQuestObjectiveRestrictionNode* >( GetParent() );
		Assert( pObjectiveParent );
		if ( pObjectiveParent )
		{
			const char *pszWriteValue = m_pComboBox->GetActiveItemUserData()->GetString( "write" );
			CTFQuestCondition *pNewCondition = pObjectiveParent->GetCondition()->AddChildByName( pszWriteValue );
			if ( pNewCondition )
			{
				new CQuestObjectiveRestrictionNode( { GetParent(), CFmtStr( "%d", pObjectiveParent->GetNextAvailableKeyNumber() ), FLAGS_NONE }, pNewCondition );
				InvalidateChain();
			}
		}
	}

	BaseClass::OnCommand( command );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IOptionalExpandableBlock::IOptionalExpandableBlock( EditorObjectInitStruct init, const char* pszButtonText )
	: BaseClass( init )
{ 
	m_pAddButton = new Button( this, "add", pszButtonText, this, "add" );
}

void IOptionalExpandableBlock::InitControls( KeyValues* pKVBlock )
{
	int nNumControlsCreated = 0;
	if ( pKVBlock )
	{
		FOR_EACH_TRUE_SUBKEY( pKVBlock, pKVKey )
		{
			CreateNewControl( pKVKey );
			++nNumControlsCreated;
		}
	}

	while( nNumControlsCreated < GetMinCount() )
	{
		CreateNewDefaultControl();
		++nNumControlsCreated;
	}

	InvalidateChain();
}

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

	m_pAddButton->SetPos( 0, 0 );
	m_pAddButton->SetWide( 200 );
	m_pAddButton->SetContentAlignment(Label::a_center);
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void IOptionalExpandableBlock::OnCommand( const char *command )
{
	if ( FStrEq( "add", command ) )
	{
		CreateNewDefaultControl();
		InvalidateChain();
		return;
	}

	BaseClass::OnCommand( command );
}

void IOptionalExpandableBlock::CreateNewControl( KeyValues* pKV )
{
	SetFlag( FLAG_DONT_EXPORT, false );
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CQuestObjectiveNode::CQuestObjectiveNode( CEditorObjectNode* pParentNode, KeyValues* pKVObjective )
	: BaseClass( { pParentNode, pKVObjective->GetName(), FLAG_COLLAPSABLE } )
	, m_pDefIndexComboBox( NULL )
	, m_pSelectObjectiveButton( NULL )
{
	// Create the description field
	new CLocalizationEditorParam( { this, "description_string", FLAGS_NONE }, "Objective Desc:", pKVObjective->GetString( "description_string" ) );
	new CTextEntryEditorParam( { this, "defindex", FLAG_HIDDEN }, "Defindex", pKVObjective->GetString( "defindex" ) );

	CComboBoxEditorParam * pOptionalComboBox = new CComboBoxEditorParam( { this, "optional", FLAGS_NONE }, "Optional:" );
	pOptionalComboBox->AddComboBoxEntry( "False", !pKVObjective->GetBool( "optional", false ), "0", NULL );
	pOptionalComboBox->AddComboBoxEntry( "True", pKVObjective->GetBool( "optional", false ), "1", NULL );

	CComboBoxEditorParam * pAdvancedComboBox = new CComboBoxEditorParam( { this, "advanced", FLAGS_NONE }, "Advanced:" );
	pAdvancedComboBox->AddComboBoxEntry( "False", !pKVObjective->GetBool( "advanced", false ), "0", NULL );
	pAdvancedComboBox->AddComboBoxEntry( "True", pKVObjective->GetBool( "advanced", false ), "1", NULL );

	CTextEntryEditorParam *pPointsNode = new CTextEntryEditorParam( { this, "points", FLAGS_NONE }, "Points:", CFmtStr( "%d", pKVObjective->GetInt( "points", 1 ) ) );
	pPointsNode->GetTextEntry()->SetAllowNumericInputOnly( true );

	// The condition def index this objective wants to use
	ObjectiveConditionDefIndex_t nConditionsDefIndex = pKVObjective->GetInt( "conditions_def_index", INVALID_QUEST_OBJECTIVE_CONDITIONS_INDEX );
	Assert( nConditionsDefIndex != INVALID_QUEST_OBJECTIVE_CONDITIONS_INDEX );

	m_pDefIndexComboBox = new CComboBoxEditorParam( { this, "conditions_def_index", FLAGS_NONE }, "Conditions:" );
	m_pDefIndexComboBox->GetComboBox()->AddActionSignalTarget( this );
	

	m_pSelectObjectiveButton = new Button( m_pDefIndexComboBox, "selectobjective", "Pick", this, "selectobjective" );
	m_pSelectObjectiveButton->AddActionSignalTarget( this );
	

	PopulateAndSelectConditionsCombobox( nConditionsDefIndex );
}

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

	m_pSelectObjectiveButton->SetPos( m_pDefIndexComboBox->GetComboBox()->GetXPos() + m_pDefIndexComboBox->GetComboBox()->GetWide(), 0 );
	m_pSelectObjectiveButton->SetWide( 36 );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveNode::PopulateAndSelectConditionsCombobox( int nSelectedDefIndex )
{
	// Clean out oldies
	m_pDefIndexComboBox->GetComboBox()->RemoveAll();

	// Go through all of the current data and fill out our combo box with all of the objective conditions
	const CUtlVector< IEditableDataType* >& vecEditableData = g_pQuestEditor->GetEditableData();
	FOR_EACH_VEC( vecEditableData, i )
	{
		IEditableDataType* pEditable = vecEditableData[i];
		if ( pEditable->GetType() == IEditableDataType::TYPE_OBJECTIVE_CONDITIONS && !g_pQuestEditor->IsOpenForEdit( pEditable ) )
		{
			KeyValues* pKVData = pEditable->GetLiveData();
			bool bSelected = atoi( pKVData->GetName() ) == nSelectedDefIndex;
			m_pDefIndexComboBox->AddComboBoxEntry( CFmtStr( "\t%s", pKVData->GetString( "name", "ERROR" ) ), bSelected, pKVData->GetName(), NULL );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveNode::OnCommand( const char *command )
{
	if ( FStrEq( "selectobjective", command ) )
	{
		KeyValues* pKV = new KeyValues( "SelectQuestObjective" );
		pKV->SetPtr( "panel", this );

		PostMessage( g_pQuestEditor, pKV );
	}

	BaseClass::OnCommand( command );
}

//-----------------------------------------------------------------------------
// Purpose: Pump the command from the menu panel into us as a command
//-----------------------------------------------------------------------------
void CQuestObjectiveNode::OnTextChanged( KeyValues *data )
{
	Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );

	ComboBox *pComboBox = dynamic_cast<ComboBox*>( pPanel );
	if ( pComboBox )
	{
		if ( pComboBox == m_pDefIndexComboBox->GetComboBox() )
		{
			KeyValues* pKVUserData = pComboBox->GetActiveItemUserData();
			OnCommand( pKVUserData->GetString( "command" ) );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestObjectiveNode::OnObjectiveSelected( KeyValues *data )
{
	int nDesiredDefIndex = data->GetInt( "defindex", INVALID_ITEM_DEF_INDEX );
	Assert( nDesiredDefIndex != INVALID_ITEM_DEF_INDEX );

	ComboBox* pComboBox = m_pDefIndexComboBox->GetComboBox();
	if ( pComboBox )
	{
		for( int i=0; i < pComboBox->GetItemCount(); ++i )
		{
			KeyValues* pKVUserData = pComboBox->GetItemUserData( i );
			int nDefIndex = pKVUserData->GetInt( "write", INVALID_ITEM_DEF_INDEX );

			if ( nDefIndex == nDesiredDefIndex )
			{
				pComboBox->ActivateItemByRow( i );
				return;
			}
		}
	}

	// Didn't find the matching defindex!
	Assert( false );
}

void CQuestDescriptionNode::CreateNewControl( KeyValues* pKV )
{
	CEditorObjectNode* pNode = new CEditorObjectNode( EditorObjectInitStruct{ this, pKV->GetName(), FLAGS_NONE } );
	CLocalizationEditorParam *pLocParam = new CLocalizationEditorParam( { pNode, "token", FLAGS_NONE }, "Description:", pKV->GetString( "token" ) );
	pLocParam->GetTextEntry()->SetTall( 200 );
	pLocParam->SetTall( 200 );
	pLocParam->GetTextEntry()->SetVerticalScrollbar( true );

	BaseClass::CreateNewControl( pKV );
}

void CQuestDescriptionNode::CreateNewDefaultControl()
{
	int nDefindex = GetNextAvailableKeyNumber() + 1;
	int nObjectDefIndex = atoi( GetOwningEditable()->GetLiveData()->GetName() );

	KeyValuesAD pKVDesc( CFmtStr( "%d", nDefindex ) );
	pKVDesc->SetString( "token", CFmtStr( g_skDescTokenFormat, nObjectDefIndex, nDefindex ) );
	
	CreateNewControl( pKVDesc );
}

void CQuestNameNode::CreateNewControl( KeyValues* pKV )
{
	CEditorObjectNode* pNode = new CEditorObjectNode( EditorObjectInitStruct{ this, pKV->GetName(), FLAGS_NONE } );
	new CLocalizationEditorParam( { pNode, "token", FLAGS_NONE }, "Name:", pKV->GetString( "token" ) );

	BaseClass::CreateNewControl( pKV );
}

void CQuestNameNode::CreateNewDefaultControl()
{
	int nDefindex = GetNextAvailableKeyNumber() + 1;
	int nObjectDefIndex = atoi( GetOwningEditable()->GetLiveData()->GetName() );

	KeyValuesAD pKVName( CFmtStr( "%d", nDefindex ) );
	pKVName->SetString( "token", CFmtStr( g_skNameTokenFormat, nObjectDefIndex, nDefindex ) );

	CreateNewControl( pKVName );
}


CComboBoxEditorParam* CreateWeaponComboBox( EditorObjectInitStruct init, const char* pszLabelText, item_definition_index_t defIndexSelect )
{
	CComboBoxEditorParam* pCombo = new CComboBoxEditorParam( init, pszLabelText );
	pCombo->GetComboBox()->SetEditable( true ); // Allow for typing in the combo box.  There's a lot of stuff

	CUtlDict< item_definition_index_t > weaponDict;
	const CEconItemSchema::SortedItemDefinitionMap_t& mapItemDefs = GetItemSchema()->GetSortedItemDefinitionMap();
	FOR_EACH_MAP( mapItemDefs, i )
	{
		CTFItemDefinition* pDef = (CTFItemDefinition*)mapItemDefs[i];

		int iSlot = pDef->GetDefaultLoadoutSlot();
		if ( pDef->GetEquipType() == EEquipType_t::EQUIP_TYPE_ACCOUNT )
			continue;

		if ( !( iSlot == LOADOUT_POSITION_PRIMARY
		     || iSlot == LOADOUT_POSITION_SECONDARY 
		     || iSlot == LOADOUT_POSITION_MELEE 
		     || iSlot == LOADOUT_POSITION_PDA
		     || iSlot == LOADOUT_POSITION_PDA2
		     || iSlot == LOADOUT_POSITION_BUILDING ) )
			continue;

		// sort weapon by name by adding to weaponDict
		weaponDict.Insert( pDef->GetDefinitionName(), pDef->GetDefinitionIndex() );
	}

	// add sorted weapon to the combobox
	FOR_EACH_DICT( weaponDict, i )
	{
		item_definition_index_t weaponDefIndex = weaponDict.Element( i );
		bool bSelect = defIndexSelect == weaponDefIndex;
		pCombo->AddComboBoxEntry( weaponDict.GetElementName( i ), bSelect, CFmtStr( "%d", weaponDefIndex ), NULL );
	}

	return pCombo;
}

void CRequiredItemsParam::CreateNewControl( KeyValues* pKV )
{
	CEditorObjectNode* pRoot = new CEditorObjectNode( EditorObjectInitStruct{ this, pKV->GetName(), FLAGS_NONE } );

	item_definition_index_t defIndexCurrent = (item_definition_index_t)pKV->GetInt( "loaner_defindex", INVALID_ITEM_DEF_INDEX );
	CreateWeaponComboBox( { pRoot, "loaner_defindex", FLAG_NOT_DELETABLE }, "Loaner Item:", defIndexCurrent );

	CQualifyingItemsParam* pQualifying = new CQualifyingItemsParam( EditorObjectInitStruct{ pRoot, "qualifying_items", FLAG_NOT_DELETABLE } );
	pQualifying->InitControls( pKV->FindKey( "qualifying_items" ) );

	BaseClass::CreateNewControl( pKV );
}

void CRequiredItemsParam::CreateNewDefaultControl()
{
	int nDefindex = GetNextAvailableKeyNumber() + 1;
	int nObjectDefIndex = atoi( GetOwningEditable()->GetLiveData()->GetName() );

	KeyValuesAD pKVName( CFmtStr( "%d", nDefindex ) );
	pKVName->SetString( "token", CFmtStr( g_skNameTokenFormat, nObjectDefIndex, nDefindex ) );
	CreateNewControl( pKVName );
}


void CQualifyingItemsParam::CreateNewControl( KeyValues* pKV )
{
	CEditorObjectNode* pNode = new CEditorObjectNode( EditorObjectInitStruct{ this, pKV->GetName(), FLAGS_NONE } );

	item_definition_index_t defIndexCurrent = (item_definition_index_t)pKV->GetInt( "defindex", INVALID_ITEM_DEF_INDEX );
	CreateWeaponComboBox( { pNode, "defindex", FLAGS_NONE }, "Qualifying Item:", defIndexCurrent );

	BaseClass::CreateNewControl( pKV );
}

void CQualifyingItemsParam::CreateNewDefaultControl()
{
	int nDefindex = GetNextAvailableKeyNumber() + 1;

	KeyValuesAD pKVQualifying( CFmtStr( "%d", nDefindex ) );
	pKVQualifying->SetInt( "defindex", 0 );

	CreateNewControl( pKVQualifying );
}

void CObjectiveExpandable::CreateNewControl( KeyValues* pKV )
{
	new CQuestObjectiveNode( this, pKV );
}

void CObjectiveExpandable::CreateNewDefaultControl()
{
	int nDefindex = GetNextAvailableKeyNumber() + 1;

	KeyValuesAD pKVObjective( CFmtStr( "%d", nDefindex ) );
	pKVObjective->SetInt( "description_string", 0 );

	const int nQuestDefIndex = atoi( GetOwningEditable()->GetLiveData()->GetName() );
	const int nObjDefIndex = ( ( nQuestDefIndex - g_nkFirstQuestDef ) + 1 ) * 100 + nDefindex;
	pKVObjective->SetInt( "defindex", nObjDefIndex );
	pKVObjective->SetString( "description_string", CFmtStr( g_skObjectiveDescTokenFormat, nQuestDefIndex, nDefindex ) );
	pKVObjective->SetBool( "optional", false );
	pKVObjective->SetInt( "conditions_def_index", INVALID_QUEST_OBJECTIVE_CONDITIONS_INDEX );
	pKVObjective->SetInt( "advanced", 0 );

	CreateNewControl( pKVObjective );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CQuestObjectiveRestrictionNode::CQuestObjectiveRestrictionNode( EditorObjectInitStruct init, CTFQuestCondition *pCondition )
	: BaseClass( { init.pParent, init.m_pszKeyName, init.nFlags | FLAG_HIGHLIGHT_MOUSEOVER } )
	, m_pCondition( pCondition )
	, m_pNewCondition( NULL )
{
	CreateControlsForCondition();
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveRestrictionNode::CreateControlsForCondition()
{
	CComboBoxEditorParam* pTypeParam = new CComboBoxEditorParam( { this, "type", FLAGS_NONE }, "Type:" );

	CUtlVector< const char* > vecValidChildren;
	m_pCondition->GetValidTypes( vecValidChildren );
	FOR_EACH_VEC( vecValidChildren, i )
	{
		bool bSelected = FStrEq( m_pCondition->GetConditionName(), vecValidChildren[ i ] );
		pTypeParam->AddComboBoxEntry( vecValidChildren[ i ], bSelected, vecValidChildren[ i ], "changetype" );
	}

	// Parameters for this node
	KeyValuesAD KVParams( "params" );
	m_pCondition->GetRequiredParamKeys( KVParams );

	KeyValuesAD outputKey( "output" );
	m_pCondition->GetOutputKeyValues( outputKey );

	FOR_EACH_TRUE_SUBKEY( KVParams, params )
	{
		const char *pszParamEnglishName = params->GetString( "english_name", NULL );
		const char *pszParamName = params->GetName();
		const char *pszLabelText = pszParamEnglishName ? pszParamEnglishName : pszParamName;
		const char *pszAction = FStrEq( pszParamName, "event_name" ) ? "changeevent" : NULL;

		const char* pszControlType = params->GetString( "control_type", "combo_box" );	// Default to combobox

		if ( FStrEq( "text_entry", pszControlType ) )
		{
			const char *pszOutput = outputKey->GetString( pszParamName, "" );
			new CTextEntryEditorParam( { this, params->GetName(), FLAGS_NONE }, pszLabelText, pszOutput );
		}
		else if ( FStrEq( "combo_box", pszControlType ) )
		{
			CComboBoxEditorParam* pNewParam = new CComboBoxEditorParam( { this, params->GetName(), FLAGS_NONE }, pszLabelText );
	
			const char *pszOutput = outputKey->GetString( pszParamName, "" );

			pNewParam->ClearComboBoxEntries();
		
			FOR_EACH_TRUE_SUBKEY( params, pChoiceKey )
			{
				const char *pszChoiceName = pChoiceKey->GetName();
				const char *pszChoiceEnglishName = pChoiceKey->GetString( "english_name", NULL );

				bool bSelect = FStrEq( pszOutput, pszChoiceName ) || pChoiceKey == params->GetFirstTrueSubKey();

				pNewParam->AddComboBoxEntry( pszChoiceEnglishName ? pszChoiceEnglishName : pszChoiceName, bSelect, pszChoiceName, pszAction );
			}

			// Hide parameters where there's only 1 option
			pNewParam->SetFlag( FLAG_HIDDEN, pNewParam->GetComboBox()->GetItemCount() <= 1 );
		}
	}

	// Children of this node
	CUtlVector< CTFQuestCondition* > vecChildConditions;
	m_pCondition->GetChildren( vecChildConditions );
	FOR_EACH_VEC( vecChildConditions, iChild )
	{
		CTFQuestCondition* pChildCondition = vecChildConditions[ iChild ];
		new CQuestObjectiveRestrictionNode( { this, CFmtStr( "%d", iChild ), FLAGS_NONE }, pChildCondition );
	}

	CreateAddOpportunityParam();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveRestrictionNode::CreateAddOpportunityParam()
{
	int nChildCount = 0;
	FOR_EACH_VEC( GetChildren(), i )
	{
		if ( dynamic_cast< CQuestObjectiveRestrictionNode* >( GetChildren()[i] ) )
		{
			++nChildCount;
		}
	}

	bool bShowAddOpportunity = m_pCondition && nChildCount < m_pCondition->GetMaxInputCount() ;
	if ( m_pNewCondition && !bShowAddOpportunity )
	{
		delete m_pNewCondition;
		m_pNewCondition = NULL;
	}
	else if ( !m_pNewCondition && bShowAddOpportunity )
	{
		// Add empty potential node
		CUtlVector< const char* > vecValidChildren;
		m_pCondition->GetValidChildren( vecValidChildren );
		if ( vecValidChildren.Count() )
		{
			m_pNewCondition = new CNewQuestObjectiveParam( { this, NULL, FLAGS_NONE }, NULL );
			FOR_EACH_VEC( vecValidChildren, i )
			{
				m_pNewCondition->AddComboBoxEntry( vecValidChildren[ i ], false, vecValidChildren [ i ], NULL );
			}
		}
	}
}

void CQuestObjectiveRestrictionNode::RemoveNode()
{
	// tell parent to remove me and my children
	if ( m_pCondition )
	{
		CTFQuestCondition *pParentCondition = m_pCondition->GetParent();
		if ( pParentCondition )
		{
			pParentCondition->RemoveAndDeleteChild( m_pCondition );
		}
	}

	m_pCondition = NULL;

	BaseClass::RemoveNode();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveRestrictionNode::SetNewType( const char *pszType )
{
	// Delete all children
	FOR_EACH_VEC_BACK( m_vecChildren, i )
	{
		m_vecChildren[i]->MarkForDeletion();
	}

	m_pNewCondition = NULL;


	// Create new restriction
	CTFQuestCondition* pParent = m_pCondition->GetParent();
	if ( pParent && pParent->RemoveAndDeleteChild( m_pCondition ) )
	{
		m_pCondition = pParent->AddChildByName( pszType );
	}
	else
	{
		delete m_pCondition;
		m_pCondition = CreateEvaluatorByName( pszType, NULL );
	}

	CreateControlsForCondition();
	InvalidateChain();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestObjectiveRestrictionNode::SetNewEvent( const char *pszEvent )
{
	// We only have to blow up everything if we're an evaluator
	if ( !m_pCondition->IsEvaluator() )
	{
		return;
	}

	// Delete all children
	FOR_EACH_VEC_BACK( m_vecChildren, i )
	{
		m_vecChildren[i]->MarkForDeletion();
	}

	m_pNewCondition = NULL;

	char szType[256];
	V_sprintf_safe( szType, "%s", m_pCondition->GetConditionName() );

	// Create new restriction
	CTFQuestCondition* pParent = m_pCondition->GetParent();
	if ( pParent && pParent->RemoveAndDeleteChild( m_pCondition ) )
	{
		m_pCondition = pParent->AddChildByName( szType );
	}
	else
	{
		delete m_pCondition;
		m_pCondition = CreateEvaluatorByName( szType, NULL );
	}

	V_sprintf_safe( m_szEventName, "%s", pszEvent );

	m_pCondition->SetEventName( m_szEventName );
	CreateControlsForCondition();
	InvalidateChain();
}

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

	CreateAddOpportunityParam();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEditorQuest::CEditorQuest( KeyValues *pKV, Panel* pParent, const IEditableDataType* pEditable )
	: CEditorObjectNode( EditorObjectInitStruct{ pParent, pKV->GetName(), FLAGS_NONE }  )
{
	SetOwningEditable( pEditable );

	new CTextEntryEditorParam( { this, "name", FLAG_HIDDEN }, "Item Def Name:", pKV->GetString( "name" ) );
	new CLocalizationEditorParam( { this, "item_name", FLAGS_NONE }, "Item Name:", pKV->GetString( "item_name" ) );

	CComboBoxEditorParam *pPrefabParam = new CComboBoxEditorParam( { this, "prefab", FLAGS_NONE }, "Prefab:" );
	int nChosenIndex = -1;
	for( int i=0; i < ARRAYSIZE( g_skQuestPrefabs ); ++i )
	{
		if ( FStrEq( g_skQuestPrefabs[i], pKV->GetString( "prefab" ) ) )
		{
			nChosenIndex = i;
		}

		bool bSelect = nChosenIndex == i || ( nChosenIndex == -1 && i == 0 );
		pPrefabParam->AddComboBoxEntry( g_skQuestPrefabs[i], bSelect, g_skQuestPrefabs[i], NULL );
	}

	// Get the quest keys
	KeyValues *pKVQuest = pKV->FindKey( "quest" );

	// Create the panels to hold the quest def
	CEditorObjectNode *pQuestNode = new CEditorObjectNode( EditorObjectInitStruct{ this, "quest", FLAG_HIDDEN } );

	CQuestNameNode* pNameNode = new CQuestNameNode( EditorObjectInitStruct{ pQuestNode, "names", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE } );
	pNameNode->InitControls( pKVQuest->FindKey( "names" ) );

	new CTextEntryEditorParam( { pQuestNode, "max_standard_points", FLAGS_NONE }, "Max Standard Points:", pKVQuest->GetString( "max_standard_points" ) );
	new CTextEntryEditorParam( { pQuestNode, "max_bonus_points", FLAGS_NONE }, "Max Bonus Points:", pKVQuest->GetString( "max_bonus_points" ) );
	new CTextEntryEditorParam( { pQuestNode, "reward", FLAGS_NONE }, "Reward:", pKVQuest->GetString( "reward" ) );
	new CTextEntryEditorParam( { pQuestNode, "objectives_to_roll", FLAGS_NONE }, "Objectives to roll:", pKVQuest->GetString( "objectives_to_roll" ) );
	new CTextEntryEditorParam( { pQuestNode, "mm_map", FLAGS_NONE }, "Casual MM Map:", pKVQuest->GetString( "mm_map" ) );
	CComboBoxEditorParam *pThemeParam = new CComboBoxEditorParam( { pQuestNode, "theme", FLAGS_NONE }, "Theming:" ); 
	nChosenIndex = -1;
	{
		const auto& mapThemes = GetItemSchema()->GetQuestThemes();
		FOR_EACH_MAP( mapThemes, i )
		{
			if ( FStrEq( mapThemes[i]->GetName(), pKVQuest->GetString( "theme" ) ) )
			{
				nChosenIndex = i;
			}

			bool bSelect = nChosenIndex == i || ( nChosenIndex == -1 && i == 0 );
			pThemeParam->AddComboBoxEntry( mapThemes[i]->GetName(), bSelect, mapThemes[i]->GetName(), NULL );
		}
	}

	CComboBoxEditorParam *pCorrespondingOperation = new CComboBoxEditorParam( { pQuestNode, "operation", FLAGS_NONE }, "Operation:" ); 
	nChosenIndex = -1;
	{
		const auto& mapOperations = GetItemSchema()->GetOperationDefinitions();
		FOR_EACH_MAP( mapOperations, i )
		{
			if ( FStrEq( mapOperations[i]->GetName(), pKVQuest->GetString( "operation" ) ) )
			{
				nChosenIndex = i;
			}

			bool bSelect = nChosenIndex == i || ( nChosenIndex == -1 && i == 0 );
			pCorrespondingOperation->AddComboBoxEntry( mapOperations[i]->GetName(), bSelect, mapOperations[i]->GetName(), NULL );
		}
	}

	CQuestDescriptionNode* pDescNode = new CQuestDescriptionNode( EditorObjectInitStruct{ pQuestNode, "descriptions", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE | FLAG_COLLAPSED } );
	pDescNode->InitControls( pKVQuest->FindKey( "descriptions" ) );

	CRequiredItemsParam* pRequiredExpandable = new CRequiredItemsParam( EditorObjectInitStruct{ pQuestNode, "required_items", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE | FLAG_DONT_EXPORT } );
	pRequiredExpandable->InitControls( pKVQuest->FindKey( "required_items" ) );

	CObjectiveExpandable* pObjectiveExpandable = new CObjectiveExpandable( EditorObjectInitStruct{ pQuestNode, "objectives", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE } );
	pObjectiveExpandable->InitControls( pKVQuest->FindKey( "objectives" ) );

	// Gets the scrollbar to be the right height
	pParent->InvalidateLayout();
}


CEditorQuest::~CEditorQuest()
{}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditableDataType::IEditableDataType( KeyValues* pKVData )
	: m_pKVLiveData( pKVData->MakeCopy() )
	, m_pKVSavedData( pKVData->MakeCopy() )
	, m_pCurrentObject( NULL )
	, m_bHasUnsavedChanges( false )
{}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEditableDataType::~IEditableDataType()
{
	// We own the keys
	if ( m_pKVLiveData )
	{
		m_pKVLiveData->deleteThis();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Create the panels and store a pointer to them
//-----------------------------------------------------------------------------
void IEditableDataType::CreatePanels( Panel* pParent )
{
	Assert( m_pCurrentObject == NULL );
	m_pCurrentObject = CreateEditableObject_Internal( pParent );
	m_pCurrentObject->ClearPendingChangesFlag();

	UpdateButton();
}

void IEditableDataType::DestroyPanels()
{
	if ( m_pCurrentObject )
	{
		m_pCurrentObject->MarkForDeletion();
		m_pCurrentObject = NULL;
	}

	UpdateButton();
}


//-----------------------------------------------------------------------------
// Purpose: Given a type and a name, see if we match
//-----------------------------------------------------------------------------
bool IEditableDataType::MatchesCriteria( EType type, const char* pszName ) const
{
	return GetType() == type && FStrEq( pszName, m_pKVLiveData->GetName() );
}

class CKeyValuesDumpToString : public IKeyValuesDumpContextAsText
{
public:
	// Overrides developer level to dump in DevMsg, zero to dump as Msg
	CKeyValuesDumpToString()	{}

public:

	virtual bool KvWriteValue( KeyValues *val, int nIndentLevel ) OVERRIDE
	{
		if ( !val )
		{
			return
				KvWriteIndent( nIndentLevel ) &&
				KvWriteText( "<< NULL >>\n" );
		}

		if ( !KvWriteIndent( nIndentLevel ) )
			return false;

		if ( !KvWriteText( val->GetName() ) )
			return false;

		if ( !KvWriteText( " " ) )
			return false;

		if ( !KvWriteText( val->GetString() ) )
					return false;

		return KvWriteText( "\n" );
	}

	virtual bool KvWriteText( char const *szText ) OVERRIDE
	{
		m_strDump.Append( szText );
		return true;
	}

	CUtlString m_strDump;
};

//-----------------------------------------------------------------------------
// Purpose: Saves any changes that have been made with the controls.  Does NOT write to disk.
//-----------------------------------------------------------------------------
void IEditableDataType::SaveEdits()
{
	// Get the new keys
	KeyValues* tempKV = new KeyValues( "edits" );
	tempKV->AddSubKey( m_pKVLiveData->MakeCopy() );

	WriteObjectToKeyValues( false, tempKV );

	// Update the live keys
	m_pKVLiveData->deleteThis();
	m_pKVLiveData = tempKV->GetFirstTrueSubKey()->MakeCopy();

	CKeyValuesDumpToString dumpOrig;
	CKeyValuesDumpToString dumpNew;
	
	// Dump into strings
	m_pKVLiveData->Dump( &dumpNew, 0, true );
	m_pKVSavedData->Dump( &dumpOrig, 0, true );

	// Compare the strings to check for a difference
	m_bHasUnsavedChanges = !FStrEq( dumpOrig.m_strDump, dumpNew.m_strDump );

	if ( m_bHasUnsavedChanges )
	{
		ConColorMsg( Color( 0, 173, 53, 255 ), "Old:\n%s", dumpOrig.m_strDump.String() );
		ConColorMsg( Color( 218, 128, 56, 255 ), "New:\n%s", dumpNew.m_strDump.String() );
	}

	tempKV->deleteThis();

	UpdateButton();
}

void IEditableDataType::UpdateButton()
{
	Button* pButton = g_pQuestEditor->GetButtonForEditable( this );
	if ( pButton )
	{
		IScheme *pScheme = vgui::scheme()->GetIScheme( pButton->GetScheme() );
		Color buttonBGColor = pButton->GetSchemeColor("Button.BgColor", Color(0, 0, 0, 255), pScheme);
		Color buttonFGColor = pButton->GetSchemeColor("Button.FGColor", Color(0, 0, 0, 255), pScheme);

		if ( m_pCurrentObject )
		{
			buttonBGColor[0] = Min( buttonBGColor[0] + 70, 255 );
			buttonBGColor[1] = Min( buttonBGColor[1] + 70, 255 );
			buttonBGColor[2] = Min( buttonBGColor[2] + 70, 255 );
		}

		if ( m_bHasUnsavedChanges )
		{
			buttonFGColor[0] = Min( buttonFGColor[0] + 150, 255 );	// Lil more red
		}

		pButton->SetDefaultColor( buttonFGColor, buttonBGColor );
		pButton->SetArmedColor( buttonFGColor, pButton->GetButtonArmedBgColor() );

		if ( GetType() == IEditableDataType::TYPE_QUEST )
		{
			char szItemName[256];
			g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( m_pKVLiveData->GetString( "item_name" ) ), szItemName, sizeof( szItemName ) );
			pButton->SetText( CFmtStr( "%s: %s", m_pKVLiveData->GetName(), szItemName ) );
		}
		else
		{
			pButton->SetText( CFmtStr( "%s: %s", m_pKVLiveData->GetName(), m_pKVLiveData->GetString( "name" ) ) );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Serialize our object and save changes to disk
//-----------------------------------------------------------------------------
void IEditableDataType::SaveChangesToDisk()
{
	SaveEdits();

	WriteDataToDisk( false );

	// Clean out old save data and copy the new keys
	if ( m_pKVSavedData )
	{
		m_pKVSavedData->deleteThis();
	}

	m_pKVSavedData = m_pKVLiveData->MakeCopy();

	UpdateButton();
}

//-----------------------------------------------------------------------------
// Purpose: Remove our entry from any file we exist in.  Remove our panels.
//			Delete our button that activates us.
//-----------------------------------------------------------------------------
void IEditableDataType::DeleteEntry()
{
	WriteDataToDisk( true );

	if ( m_pCurrentObject )
	{
		m_pCurrentObject->SetFlag( FLAG_DELETED, true );
		WriteLocalizationData();
	}

	UpdateButton();
}

void IEditableDataType::RevertChanges()
{
	Assert( m_pCurrentObject );
	if ( !m_pCurrentObject )
		return;

	// Delete old panels
	Panel* pCurrentParent = m_pCurrentObject->GetParent();
	m_pCurrentObject->MarkForDeletion();
	m_pCurrentObject = NULL;

	// Delete live keys, and copy over the saved ones to live
	m_pKVLiveData->deleteThis();
	m_pKVLiveData = m_pKVSavedData->MakeCopy();

	// Recreate panels
	CreatePanels( pCurrentParent );
	CheckForChanges();
}

void IEditableDataType::CheckForChanges()
{
	if ( m_pCurrentObject )
	{
		m_bHasUnsavedChanges = m_pCurrentObject->HasChanges( true );
		UpdateButton();
	}
}

void IEditableDataType::WriteObjectToKeyValues( bool bDelete, KeyValues* pKVExistingFileData )
{
	KeyValuesAD tempKV( "temp" );
	m_pCurrentObject->SerializeToKVs( tempKV, this );

	FOR_EACH_SUBKEY( tempKV, pNewObjectKey )
	{
		KeyValues *pCurrentObjectKey = pKVExistingFileData->FindKey( pNewObjectKey->GetName() );
		if ( pCurrentObjectKey )
		{
			if ( bDelete )
			{
				pCurrentObjectKey->deleteThis();
			}
			else
			{
				// copy all elems
				pCurrentObjectKey->Clear();
				FOR_EACH_SUBKEY( pNewObjectKey, pElem )
				{
					pCurrentObjectKey->AddSubKey( pElem->MakeCopy() );
				}
			}
		}
		else
		{
			pKVExistingFileData->AddSubKey( pNewObjectKey->MakeCopy() );
		}
	}
}


int Sort_DefIndex( KeyValues* const* p1, KeyValues* const* p2 )
{
	int n1 = atoi( (*p1)->GetName() );
	int n2 = atoi( (*p2)->GetName() );

	return n1 - n2;
}

//-----------------------------------------------------------------------------
// Purpose: Write quest data to "tf/scripts/items/unencrypted/_items_quests.txt"
//-----------------------------------------------------------------------------
void CEditableQuestDataType::WriteDataToDisk( bool bDelete )
{
	// Wrap all of the quest in a "quests" keyvalue
	CUtlBuffer bufRawData;
	bufRawData.SetBufferType( true, true );
	bufRawData.PutString( CFmtStr( "\"%s\"\n{\n", "quests") );
	
	bool bReadFileOK = g_pFullFileSystem->ReadFile( g_skQuestDefFile, NULL, bufRawData );
	if ( !bReadFileOK )
	{
		AssertMsg1( false, "Couldn't load file %s for saving!", g_skQuestDefFile );
		return;
	}

	bufRawData.PutString( "\n}" );
	
	// Load the buffer into keyvalues
	KeyValuesAD pKVQuestItemData( "quests" );
	pKVQuestItemData->LoadFromBuffer( NULL, bufRawData );

	WriteObjectToKeyValues( bDelete, pKVQuestItemData );

	// Sort by defindex
	CUtlVector< KeyValues* > vecQuests;
	FOR_EACH_SUBKEY( pKVQuestItemData, pItemKey )
	{
		vecQuests.AddToTail( pItemKey );
	}
	vecQuests.Sort( &Sort_DefIndex );


	// Write housekeeping CSV file
	FileHandle_t fileHandle = g_pFullFileSystem->Open( g_skQuestObjectivesHouseKeepingFile, "wt" );

	// Write them out in order
	CUtlBuffer buffer;
	FOR_EACH_VEC( vecQuests, i )
	{
		// Write a row as we go through each quest item
		KeyValues* pKVQuestBlock = vecQuests[i]->FindKey( "quest" );
		if ( pKVQuestBlock )
		{
			KeyValues* pKVObjectives = pKVQuestBlock->FindKey( "objectives" );
			if ( pKVObjectives )
			{
				FOR_EACH_TRUE_SUBKEY( pKVObjectives, pKVEntry )
				{	
					char szDesc[256];
					g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pKVEntry->GetString( "description_string" ) ), szDesc, sizeof( szDesc ) );
					g_pFullFileSystem->FPrintf( fileHandle, "%d,%d,%d,%s,\n", pKVEntry->GetInt( "DefIndex" ), pKVEntry->GetInt( "points" ), pKVEntry->GetInt( "advanced" ), szDesc );
				}
			}
		}

		vecQuests[i]->RecursiveSaveToFile( buffer, 0, false, true );
	}

	g_pFullFileSystem->Close( fileHandle );

	char szCorrectCaseFilePath[MAX_PATH];
	g_pFullFileSystem->GetCaseCorrectFullPath( g_skQuestDefFile, szCorrectCaseFilePath );
	CP4AutoEditFile a( szCorrectCaseFilePath );

	if ( !g_pFullFileSystem->WriteFile( szCorrectCaseFilePath, NULL, buffer ) )
	{
		Warning( "Failed to write data to %s", g_skQuestDefFile );
	}
}

IEditorObject* CEditableQuestDataType::CreateEditableObject_Internal( Panel* pParent ) const
{
	CEditorQuest* pNewQuest = new CEditorQuest( m_pKVLiveData, pParent, this );
	return pNewQuest;
}

//-----------------------------------------------------------------------------
// Purpose: Write quest data to "tf/scripts/items/unencrypted/_items_quest_objective_definitions.txt"
//-----------------------------------------------------------------------------
void CEditableObjectiveConditionDataType::WriteDataToDisk( bool bDelete )
{
	// Wrap all of the quest in a "quests" keyvalue
	CUtlBuffer bufRawData;
	bufRawData.SetBufferType( true, true );

	bool bReadFileOK = g_pFullFileSystem->ReadFile( g_skQuestObjectivesConditionsDefFile, NULL, bufRawData );
	if ( !bReadFileOK )
	{
		AssertMsg1( false, "Couldn't load file %s for saving!", g_skQuestObjectivesConditionsDefFile );
		return;
	}

	// Load the buffer into keyvalues
	KeyValuesAD pKVQuestObjectivesData( "quest_objective_conditions" );
	pKVQuestObjectivesData->LoadFromBuffer( NULL, bufRawData );

	WriteObjectToKeyValues( bDelete, pKVQuestObjectivesData );

	// Sort by defindex
	CUtlVector< KeyValues* > vecQuestObjectives;
	FOR_EACH_SUBKEY( pKVQuestObjectivesData, pItemKey )
	{
		vecQuestObjectives.AddToTail( pItemKey );
	}
	vecQuestObjectives.Sort( &Sort_DefIndex );

	KeyValuesAD pKVSorted( "quest_objective_conditions" );

	// Write them out in order
	FOR_EACH_VEC( vecQuestObjectives, i )
	{
		pKVSorted->AddSubKey( vecQuestObjectives[i]->MakeCopy() );
	}

	// Write the definitions
	{
		CUtlBuffer buffer;
		pKVSorted->RecursiveSaveToFile( buffer, 0, false, true );

		char szCorrectCaseFilePath[MAX_PATH];
		g_pFullFileSystem->GetCaseCorrectFullPath( g_skQuestObjectivesConditionsDefFile, szCorrectCaseFilePath );
		CP4AutoEditFile a( szCorrectCaseFilePath );

		if ( !g_pFullFileSystem->WriteFile( szCorrectCaseFilePath, NULL, buffer ) )
		{
			Warning( "Failed to write data to %s", g_skQuestObjectivesConditionsDefFile );
		}
	}
}

IEditorObject* CEditableObjectiveConditionDataType::CreateEditableObject_Internal( Panel* pParent ) const
{
	CEditorObjectNode *pConditionDef = new CEditorObjectNode( EditorObjectInitStruct{ pParent, m_pKVLiveData->GetName(), FLAG_HIDDEN } );
	pConditionDef->SetOwningEditable( this );

	new CTextEntryEditorParam( { pConditionDef, "name", FLAGS_NONE }, "Conditions name:", m_pKVLiveData->GetString( "name" ) );

	CRequiredItemsParam* pRequiredExpandable = new CRequiredItemsParam( EditorObjectInitStruct{ pConditionDef, "required_items", FLAG_NOT_DELETABLE | FLAG_COLLAPSABLE | FLAG_DONT_EXPORT } );
	pRequiredExpandable->InitControls( m_pKVLiveData->FindKey( "required_items" ) );

	KeyValues* pKVConditionLogic = m_pKVLiveData->FindKey( "condition_logic" );

	const char *pszType = pKVConditionLogic->GetString( "type" );
	CTFQuestCondition *pCondition = CreateEvaluatorByName( pszType, NULL );
		
	if ( !pCondition->BInitFromKV( pKVConditionLogic, NULL ) )
	{
		Assert( false );
	}

	new CQuestObjectiveRestrictionNode( { pConditionDef, "condition_logic", FLAGS_NONE }, pCondition );

	return pConditionDef;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CQuestEditorPanel::CQuestEditorPanel( Panel *pParent, const char *pszName )
	: Frame( pParent, pszName )
	, m_pCurrentOpenEdit( NULL )
	, m_eCurrentSelectionMode( SELECTION_MODE_NONE )
{
	SetTitle( "Quest Editor", true );

	memset( m_pButtonsFilterTextEntry, NULL, sizeof( m_pButtonsFilterTextEntry ) );
	m_pEditingPanel = new CExScrollingEditablePanel( this, "EditingPanel" );
	m_pButtonsContainers[ IEditableDataType::TYPE_QUEST ] = new CExScrollingEditablePanel( this, "QuestListContainer" );
	m_pButtonsContainers[ IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ] = new CExScrollingEditablePanel( this, "QuestObjectiveConditionsContainer" );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::Deploy()
{
	PopulateExistingQuests();

	SetVisible( true );
	MakePopup();
	MoveToFront();
	SetKeyBoardInputEnabled(true);
	SetMouseInputEnabled(true);
	InvalidateLayout( true, true );

	// Center it, keeping requested size
	int x, y, ww, wt, wide, tall;
	vgui::surface()->GetWorkspaceBounds( x, y, ww, wt );
	GetSize(wide, tall);
	SetPos(x + ((ww - wide) / 2), y + ((wt - tall) / 2));
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::ApplySchemeSettings( IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );

	LoadControlSettings( "Resource/UI/econ/QuestEditor.res" );

	m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_QUEST ] = FindControl< TextEntry >( "QuestsFilter" );
	if ( m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_QUEST ] )
	{
		m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_QUEST ]->AddActionSignalTarget( this );
	}
	m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ] = FindControl< TextEntry >( "ConditionsFilter" );
	if ( m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ] )
	{
		m_pButtonsFilterTextEntry[ IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ]->AddActionSignalTarget( this );
	}

	Label *pP4Warning = FindControl< Label >( "P4Warning" );
	if ( pP4Warning )
	{
		pP4Warning->SetVisible( p4 == NULL );
	}

	Button* pSaveButton = FindControl< Button >( "SaveButton" );
	if ( pSaveButton )
	{
		pSaveButton->SetEnabled( p4 != NULL );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::ApplySettings( KeyValues *inResourceData )
{
	BaseClass::ApplySettings( inResourceData );
}


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

	for ( int nType = 0; nType < IEditableDataType::NUM_TYPES; ++nType )
	{
		UpdateButtons( (IEditableDataType::EType)nType );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::UpdateButtons( IEditableDataType::EType eType )
{
	m_pButtonsContainers[ eType ]->ResetScrollAmount();

	// Get the text out of the text entry
	char szFilterText[256];
	m_pButtonsFilterTextEntry[ eType ]->GetText( szFilterText, sizeof( szFilterText ) );
	Q_strlower( szFilterText );

	int yPos = 5;
	FOR_EACH_VEC( m_vecEditableButtons[ eType ], i )
	{
		Button* pButton = m_vecEditableButtons[ eType ][ i ];

		// Get the text out of the button
		char szButtonText[256];
		pButton->GetText( szButtonText, sizeof( szButtonText ) );
		Q_strlower( szButtonText );

		// Substring search for the text entry text in the button text
		if ( V_strstr( szButtonText, szFilterText ) == NULL )
		{
			pButton->SetVisible( false );
			continue;
		}

		pButton->SetVisible( true );

		float flWideScale = 1.f;
		pButton->SetWide( pButton->GetParent()->GetWide() * flWideScale );
		pButton->SetTall( 20 );
		pButton->SetPos( 0, yPos );
		yPos += pButton->GetTall() + 5 ;
	}

	m_pButtonsContainers[ eType ]->InvalidateLayout();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::OnCommand( const char *command )
{
	if ( Q_strnicmp( "select", command, 6 ) == 0 )
	{	
		// comes in the form "select(type) (name)"
		const char* pszType = command + 6;
		IEditableDataType::EType eType = (IEditableDataType::EType)atoi( pszType );
		// Jump past the first ' ' and grab whatever is left as the name
		const char* pszName = strchr( pszType, ' ' ) + 1;

		if ( m_eCurrentSelectionMode == SELECTION_MODE_QUEST_OBJECTIVE && eType == IEditableDataType::TYPE_OBJECTIVE_CONDITIONS )
		{
			m_eCurrentSelectionMode = SELECTION_MODE_NONE;

			Panel* pSelectionpanel = m_hSelectionPanel.Get();
			if ( pSelectionpanel )
			{
				PostMessage( pSelectionpanel, new KeyValues( "ObjectiveSelected", "defindex", pszName ) );
			}
		}
		else
		{
			if ( m_pCurrentOpenEdit )
			{
				// This the one that's already open?  Don't do anything
				if ( FStrEq( pszName, m_pCurrentOpenEdit->GetLiveData()->GetName() ) )
				{
					return;
				}

				// We have something open.  Close it down, saving live edits
				CloseEdit( m_pCurrentOpenEdit );
				m_pCurrentOpenEdit = NULL;
			}

			m_pEditingPanel->ResetScrollAmount();
			m_pCurrentOpenEdit = OpenForEdit( eType, pszName, m_pEditingPanel );
			m_pEditingPanel->InvalidateLayout();
		}

		return;
	}
	else if ( Q_stricmp( "revert", command ) == 0 )
	{
		if ( m_pCurrentOpenEdit )
		{
			m_pCurrentOpenEdit->RevertChanges();
		}

		ResetQuestSelectionState();
	}
	else if ( Q_stricmp( "save", command ) == 0 )
	{
		WriteLocalizationData();

		FOR_EACH_VEC( m_vecOpenEdits, i )
		{
			m_vecOpenEdits[ i ]->SaveChangesToDisk();
		}

		ResetQuestSelectionState();

		return;
	}
	else if ( Q_stricmp( "newquest", command ) == 0 )
	{
		CloseEdit( m_pCurrentOpenEdit );
		m_pEditingPanel->ResetScrollAmount();
		IEditableDataType* pNewEditable = CreateNewQuest();
		m_pCurrentOpenEdit = OpenForEdit( IEditableDataType::TYPE_QUEST, CFmtStr( "%s", pNewEditable->GetLiveData()->GetName() ), m_pEditingPanel );
		ResetQuestSelectionState();
	}
	else if ( Q_stricmp( "newobjcond", command ) == 0 )
	{
		CloseEdit( m_pCurrentOpenEdit );
		m_pEditingPanel->ResetScrollAmount();
		IEditableDataType* pNewEditable = CreateNewObjectiveCondition();
		m_pCurrentOpenEdit = OpenForEdit( IEditableDataType::TYPE_OBJECTIVE_CONDITIONS, CFmtStr( "%s", pNewEditable->GetLiveData()->GetName() ), m_pEditingPanel );
		ResetQuestSelectionState();
	}
	else if ( Q_stricmp( "delete", command ) == 0 )
	{
		if ( m_pCurrentOpenEdit )
		{
			m_pCurrentOpenEdit->DeleteEntry();
			CloseEdit( m_pCurrentOpenEdit );

			Button* pButton = GetButtonForEditable( m_pCurrentOpenEdit );
			Assert( pButton );
			// Delete the button associated with this editable
			if( pButton )
			{
				if ( !m_vecEditableButtons[ m_pCurrentOpenEdit->GetType() ].FindAndRemove( pButton ) )
				{
					AssertMsg( false, "Could not find button to remove when deleting editable!" );
				}
				pButton->MarkForDeletion();
				InvalidateLayout();
			}

			// Remove this editable from the list
			if ( !m_vecEditableData.FindAndRemove( m_pCurrentOpenEdit ) )
			{
				AssertMsg( false, "Could not find editable to remove when deleting editable!" );
			}

			delete m_pCurrentOpenEdit;
			m_pCurrentOpenEdit = NULL;
		}
		ResetQuestSelectionState();
	}
	else if ( Q_stricmp( "open_edit_context", command ) == 0 )
	{
		OpenEditContextMenu();
		ResetQuestSelectionState();
	}

	BaseClass::OnCommand( command );
}

void CQuestEditorPanel::OnThink()
{
	FOR_EACH_VEC( m_vecOpenEdits, i )
	{
		engine->Con_NPrintf( i, CFmtStr( "%s %s", m_vecOpenEdits[i]->GetType() == IEditableDataType::TYPE_OBJECTIVE_CONDITIONS ? "Condition" : "Quest", m_vecOpenEdits[i]->GetLiveData()->GetName() ) );
	}

	BaseClass::OnThink();
}

//-----------------------------------------------------------------------------
// Purpose: Try to find the right editable to open
//-----------------------------------------------------------------------------
IEditableDataType* CQuestEditorPanel::OpenForEdit( IEditableDataType::EType type, const char* pszName, Panel* pParent )
{
	FOR_EACH_VEC( m_vecEditableData, i )
	{
		if ( m_vecEditableData[i]->MatchesCriteria( type, pszName ) )
		{
			m_vecEditableData[i]->CreatePanels( pParent );

			FOR_EACH_VEC( m_vecOpenEdits, j )
			{
				if ( m_vecOpenEdits[j] == m_vecEditableData[i] )
				{
					AssertMsg1( false, "Editable with name %s was already open for edit!", m_vecEditableData[i]->GetLiveData()->GetName() );
					m_vecOpenEdits.Remove( j );
				}
			}

			m_vecOpenEdits.AddToTail( m_vecEditableData[i] );
			return m_vecEditableData[i];
		}
	}

	Assert( !"Failed to find editable for edit!" );
	return NULL;
}

void CQuestEditorPanel::CloseEdit( IEditableDataType* pEditable )
{
	if ( !pEditable )
		return;

	FOR_EACH_VEC( m_vecOpenEdits, i )
	{
		if ( m_vecOpenEdits[i] == pEditable )
		{
			m_vecOpenEdits.Remove( i );
			pEditable->SaveEdits();
			pEditable->DestroyPanels();
			return;
		}
	}

	AssertMsg1( false, "Editable with name %s wasn't open for edit!", pEditable->GetLiveData()->GetName() );
}

bool CQuestEditorPanel::IsOpenForEdit( const IEditableDataType* pEditable ) const
{
	Assert( pEditable );
	if ( !pEditable )
		return false;

	FOR_EACH_VEC( m_vecOpenEdits, i )
	{
		if ( m_vecOpenEdits[i] == pEditable )
		{
			return true;
		}
	}

	return false;
}

Button* CQuestEditorPanel::GetButtonForEditable( const IEditableDataType* pEditable ) const
{
	IEditableDataType::EType eType = pEditable->GetType();

	auto& vecButtons = m_vecEditableButtons[ eType ];
	FOR_EACH_VEC( vecButtons, i )
	{
		if ( vecButtons[i] == pEditable->GetButton() )
		{
			return vecButtons[i];
		}
	}

	return NULL;
}

template< typename T >
IEditableDataType* CQuestEditorPanel::AddNewEditableKVData( KeyValues* pKVData, const char* pszName )
{
	IEditableDataType* pNewEditable = new T( pKVData );
	IEditableDataType::EType eType = pNewEditable->GetType();
	m_vecEditableData.AddToTail( pNewEditable );

	Button *pButton = new Button( m_pButtonsContainers[ eType ]
								, "objectivebutton"
								, CFmtStr( "%s: %s", pKVData->GetName(), pszName )
								, this
								, CFmtStr( "select%d %s", eType, pKVData->GetName() ) );

	pNewEditable->SetButton( pButton );
	m_vecEditableButtons[ eType ].AddToTail( pButton );

	InvalidateLayout();

	return pNewEditable;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CQuestEditorPanel::PopulateExistingQuests()
{
	m_vecEditableData.PurgeAndDeleteElements();

	// Quest data
	{
		// Quests are a little strange.  In the quest file, there is no root key because quests
		// are items and are spliced right into the middle of all the other items.  To handle this
		// We add "quests"
		//		  {
		//				<< all the stuff from the file >>
		//		  }
		// To make parsing easier
		CUtlBuffer bufRawData;
		bufRawData.SetBufferType( true, true );
		bufRawData.PutString( "\"quests\"\n{\n" );
		bool bReadFileOK = g_pFullFileSystem->ReadFile( g_skQuestDefFile, NULL, bufRawData );
		if ( !bReadFileOK )
		{
			AssertMsg1( false, "Couldn't load quest file %s for saving!", g_skQuestDefFile );
			return;
		}
		bufRawData.PutString( "\n}" );

		// Load quest data from file
		KeyValuesAD pKVQuestDefinitions( "quests" );
		pKVQuestDefinitions->LoadFromBuffer( NULL, bufRawData );

		// Create editable objects and buttons for each
		FOR_EACH_TRUE_SUBKEY( pKVQuestDefinitions, pKVQuest )
		{
			char szItemName[256];
			g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pKVQuest->GetString( "item_name" ) ), szItemName, sizeof( szItemName ) );

			AddNewEditableKVData< CEditableQuestDataType >( pKVQuest, szItemName );
		}
	}

	// Objective data
	{
		CUtlBuffer bufRawData;
		bufRawData.SetBufferType( true, true );

		// Now go read the objective conditions file
		bool bReadFileOK = g_pFullFileSystem->ReadFile( g_skQuestObjectivesConditionsDefFile, NULL, bufRawData );
		if ( !bReadFileOK )
		{
			AssertMsg1( false, "Couldn't load quest file %s for saving!", g_skQuestObjectivesConditionsDefFile );
			return;
		}

		// Load objective data from file
		KeyValuesAD pKVObjectiveConditions( "objectives" );
		pKVObjectiveConditions->LoadFromBuffer( NULL, bufRawData );

		// Create editable objects and buttons for each
		FOR_EACH_TRUE_SUBKEY( pKVObjectiveConditions, pKVCondition )
		{
			AddNewEditableKVData< CEditableObjectiveConditionDataType >( pKVCondition, pKVCondition->GetString( "name" ) );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Create a new quest with the next available itemdefindex
//-----------------------------------------------------------------------------
IEditableDataType* CQuestEditorPanel::CreateNewQuest()
{
	// Find the next item def to use
	int nNextQuestDefIndex = 0;
	FOR_EACH_VEC( m_vecEditableData, i )
	{
		IEditableDataType* pData = m_vecEditableData[ i ];
		if ( pData->GetType() == IEditableDataType::TYPE_QUEST )
		{
			nNextQuestDefIndex = Max( nNextQuestDefIndex, atoi( pData->GetLiveData()->GetName() ) );
		}
	}

	++nNextQuestDefIndex;
	
	// Create keyvalues to describe a default quest
	KeyValuesAD pKVNewQuest( CFmtStr( "%d", nNextQuestDefIndex ) );
	pKVNewQuest->SetString( "name", CFmtStr( g_skItemNameFormat, nNextQuestDefIndex ) );
	pKVNewQuest->SetString( "item_name", CFmtStr( g_skNameTokenFormat, nNextQuestDefIndex ) );
	pKVNewQuest->SetString( "prefab", g_skQuestPrefabs[0] );

	// Tool keys
	KeyValues *pKeyQuestBlock = pKVNewQuest->CreateNewKey();	pKeyQuestBlock->SetName( "quest" );
	pKeyQuestBlock->SetInt( "max_standard_points", 100 );
	pKeyQuestBlock->SetInt( "max_bonus_points", 30 );
	pKeyQuestBlock->SetInt( "objectives_to_roll", 1 );
	pKeyQuestBlock->SetString( "reward", "contract_lootlist_1" );
	pKeyQuestBlock->SetString( "theme", GetItemSchema()->GetQuestThemes()[0]->GetName() );
	KeyValues *pKeyObjectiveBlock = pKeyQuestBlock->CreateNewKey(); pKeyObjectiveBlock->SetName( "objectives" );

	return AddNewEditableKVData< CEditableQuestDataType >( pKVNewQuest, pKVNewQuest->GetString( "name" ) );
}

//-----------------------------------------------------------------------------
// Purpose: Create a new conditions with the next available defindex
//-----------------------------------------------------------------------------
IEditableDataType* CQuestEditorPanel::CreateNewObjectiveCondition()
{
	int nNextDefIndex = 0;
	FOR_EACH_VEC( m_vecEditableData, i )
	{
		IEditableDataType* pData = m_vecEditableData[ i ];
		if ( pData->GetType() == IEditableDataType::TYPE_OBJECTIVE_CONDITIONS )
		{
			nNextDefIndex = Max( nNextDefIndex, atoi( pData->GetLiveData()->GetName() ) );
		}
	}

	++nNextDefIndex;

	KeyValuesAD pKVNewObjCond( CFmtStr( "%d", nNextDefIndex ) );
	pKVNewObjCond->SetString( "name", "*** New Objective ***" );

	KeyValues* pKVConditionsBlock = pKVNewObjCond->CreateNewKey(); 
	pKVConditionsBlock->SetName( "condition_logic" );
	pKVConditionsBlock->SetString( "event_name", "player_score_changed" );
	pKVConditionsBlock->SetString( "score_key_name", "delta" );
	pKVConditionsBlock->SetString( "type", "event_listener" );

	return AddNewEditableKVData< CEditableObjectiveConditionDataType >( pKVNewObjCond, pKVNewObjCond->GetString( "name" ) );
}

//-----------------------------------------------------------------------------
// Purpose: Open up a context menu with actions for the editing item
//-----------------------------------------------------------------------------
void CQuestEditorPanel::OpenEditContextMenu()
{
	Menu *pContextMenu = new Menu( this, "ContextMenu" );

	pContextMenu->AddMenuItem( "Save", this, new KeyValues( "save" ) );
	pContextMenu->AddMenuItem( "Revert", this, new KeyValues( "revert" ) );
	pContextMenu->AddSeparator();
	pContextMenu->AddMenuItem( "Delete", this, new KeyValues( "delete" ) );
	
	// 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);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestEditorPanel::OnTextChanged( KeyValues *data )
{
	Panel *pPanel = reinterpret_cast< vgui::Panel* >( data->GetPtr( "panel" ) );

	for ( int nType = 0; nType < IEditableDataType::NUM_TYPES; ++nType )
	{
		if ( pPanel == m_pButtonsFilterTextEntry[ nType ] )
		{
			UpdateButtons( (IEditableDataType::EType)nType );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestEditorPanel::OnSelectQuestObjective( KeyValues *data )
{
	m_hSelectionPanel = reinterpret_cast< vgui::Panel* >( data->GetPtr( "panel" ) );
	m_eCurrentSelectionMode = SELECTION_MODE_QUEST_OBJECTIVE;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CQuestEditorPanel::CheckForChanges()
{
	FOR_EACH_VEC( m_vecEditableData, i )
	{
		m_vecEditableData[i]->CheckForChanges();
	}
}

#endif // STAGING_ONLY