//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Dialog for selecting game configurations
//
//=====================================================================================//
#include "cbase.h"

#include <vgui/IVGui.h>
#include <vgui/IInput.h>
#include <vgui/ISystem.h>
#include <vgui/ISurface.h>
#include <vgui_controls/Button.h>
#include <vgui_controls/TextEntry.h>
#include <vgui_controls/MessageBox.h>
#include <vgui_controls/ImagePanel.h>
#include <vgui_controls/FileOpenDialog.h>
#include "vgui_bitmappanel.h"
#include <KeyValues.h>
#include "imageutils.h"
#include "bsp_utils.h"

#include "icommandline.h"
#include "publish_file_dialog.h"
#include "workshop/ugc_utils.h"

#ifdef TF_CLIENT_DLL
#include "../server/tf/workshop/maps_workshop.h"
#endif // TF_CLIENT_DLL

#include "steam/steam_api.h"

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

static CUtlString g_MapFilename;
static CUtlString g_PreviewFilename;

ConVar publish_file_last_dir( "publish_file_last_dir", "", FCVAR_ARCHIVE | FCVAR_CLIENTDLL | FCVAR_HIDDEN | FCVAR_DONTRECORD );

CFilePublishDialog *g_pSteamFilePublishDialog = NULL;

#define WORKSHOP_TEMP_UPLOAD_DIR "workshop/upload"

class CPrepareFileThread : public CThread
{
public:
	CPrepareFileThread( const char *pszInputFile, const char *pszOutputFile )
		: m_strInput( pszInputFile )
		, m_strOutput( pszOutputFile )
		{}

	// Return 0 for success
	virtual int Run()
	{
		if ( V_strcasecmp( V_GetFileExtension( m_strInput.Get() ), "bsp" ) == 0 )
		{
			return BSP_SyncRepack( m_strInput.Get(), m_strOutput.Get() ) ? 0 : 1;
		}
		else
		{
			// Just copy file to prepared location
			return engine->CopyLocalFile( m_strInput.Get(), m_strOutput.Get() ) ? 0 : 1;
		}
	}

private:
	CUtlString m_strInput;
	CUtlString m_strOutput;
};


//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CFilePublishDialog::CFilePublishDialog( Panel *parent, const char *name, PublishedFileDetails_t *pDetails ) : BaseClass( parent, name )
{
	m_pPrepareFileThread = NULL;

	g_pSteamFilePublishDialog = this;

	// These must be supplied
	m_bValidFile = false;
	m_bValidJpeg = false;

	vgui::ivgui()->AddTickSignal( GetVPanel(), 0 );

	// Save this for later
	if ( pDetails != NULL )
	{
		m_FileDetails = *pDetails;
		m_bAddingNewFile = false;
		g_MapFilename = m_FileDetails.lpszFilename;
		m_nFileID = m_FileDetails.publishedFileDetails.m_nPublishedFileId;
	}
	else
	{
		// Clear it out
		m_FileDetails.lpszFilename = NULL;
		m_FileDetails.publishedFileDetails.m_eVisibility = k_ERemoteStoragePublishedFileVisibilityPublic;
		m_FileDetails.publishedFileDetails.m_hFile = k_UGCHandleInvalid;
		m_FileDetails.publishedFileDetails.m_hPreviewFile = k_UGCHandleInvalid;
		m_FileDetails.publishedFileDetails.m_nConsumerAppID = k_uAppIdInvalid;
		m_FileDetails.publishedFileDetails.m_nCreatorAppID = k_uAppIdInvalid;
		m_FileDetails.publishedFileDetails.m_nPublishedFileId = 0; // FIXME: Need a real "invalid" value
		m_FileDetails.publishedFileDetails.m_rtimeCreated = 0;
		m_FileDetails.publishedFileDetails.m_rtimeUpdated = 0;
		m_FileDetails.publishedFileDetails.m_ulSteamIDOwner = 0; // FIXME: Need a real "invalid" value
		memset( m_FileDetails.publishedFileDetails.m_rgchDescription, 0, k_cchPublishedDocumentDescriptionMax );
		memset( m_FileDetails.publishedFileDetails.m_rgchTitle, 0, k_cchPublishedDocumentTitleMax );

		m_bAddingNewFile = true;
		g_MapFilename = "";
		m_nFileID = k_PublishedFileIdInvalid;
	}

	m_nFileDetailsChanges = 0;

	m_fileOpenMode = FILEOPEN_NONE;

	// Setup our image panel
	m_pCroppedTextureImagePanel = new CBitmapPanel( this, "PreviewImage" );
	m_pCroppedTextureImagePanel->SetSize( DesiredPreviewWidth(), DesiredPreviewHeight() );
	m_pCroppedTextureImagePanel->SetVisible( true );

	m_pStatusBox = NULL;

	// Start downloading our preview image
	m_bPreviewDownloadPending = false;
	DownloadPreviewImage();
}

//-----------------------------------------------------------------------------
// Destructor 
//-----------------------------------------------------------------------------
CFilePublishDialog::~CFilePublishDialog()
{
	//delete m_pConfigCombo;
	g_pSteamFilePublishDialog = NULL;

	// We should be in a modal dialog when this is running, not closable
	Assert( !m_pPrepareFileThread );
	if ( m_pPrepareFileThread )
	{
		m_pPrepareFileThread->Stop();
		delete m_pPrepareFileThread;
		m_pPrepareFileThread = NULL;
	}
}

void CFilePublishDialog::ErrorMessage( ErrorCode_t errorCode, KeyValues *pkvTokens  )
{
	switch ( errorCode )
	{
	case kFailedToPublishFile:
		ErrorMessage( "Failed to publish file!" );
		break;
	case kFailedToUpdateFile:
		ErrorMessage( "Failed to update file!" );
		break;
	case kFailedToPrepareFile:
		ErrorMessage( "Failed to prepare file!" );
		break;
	case kSteamCloudNotAvailable:
		ErrorMessage( "Steam Cloud is not available." );
		break;
	case kSteamExceededCloudQuota:
		ErrorMessage( "Exceed Steam Cloud quota." );
		break;
	case kFailedToWriteToSteamCloud:
		ErrorMessage( "Failed to write to Steam cloud!" );
		break;
	case kFileNotFound:
		ErrorMessage( "File not found!" );
		break;
	case kNeedTitleAndDescription:
		ErrorMessage( "Need to have a title and description!" );
		break;
	case kFailedFileValidation:
		ErrorMessage( "File failed to validate!" );
		break;
	case kFailedUserModifiedFile:
		ErrorMessage( "File was manually modified after verifying process" );
		break;
	case kInvalidMapName:
		ErrorMessage( "Invalid name for map. Map names must be lowercase and of the form cp_foo.bsp." );
		break;
	default:
		Assert( false ); // Unhandled enum value
		break;
	}
	if ( pkvTokens )
	{
		pkvTokens->deleteThis();
	}
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
void CFilePublishDialog::ErrorMessage( const char *lpszText )
{
	vgui::MessageBox *pBox = new vgui::MessageBox( "", lpszText, this );
	pBox->SetPaintBorderEnabled( false );
	pBox->SetPaintBackgroundEnabled( true );
	pBox->SetBgColor( Color(0,0,0,255) ); 
	pBox->DoModal();
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
const char* CFilePublishDialog::GetStatusString( StatusCode_t statusCode )
{
	switch ( statusCode )
	{
	case kPublishing:
		return "Publishing, please wait...";
		break;
	case kUpdating:
		return "Publishing, please wait...";
		break;
	}
	return "";
}

//-----------------------------------------------------------------------------
// Purpose: Show our modal status window to cover asynchronous tasks
// TODO: Pull this out into a more generalized solution across dialogs
//-----------------------------------------------------------------------------
void CFilePublishDialog::ShowStatusWindow( StatusCode_t statusCode )
{
	// Throw up our status box
	if ( m_pStatusBox )
	{
		m_pStatusBox->CloseModal();
		m_pStatusBox = NULL; // FIXME: Does this clear up the memory?
	}

	const char *lpszText = GetStatusString( statusCode );

	// Pop a message to the user so they know to wait
	m_pStatusBox = new vgui::MessageBox( "", lpszText, this );
	m_pStatusBox->SetPaintBorderEnabled( false );
	m_pStatusBox->SetPaintBackgroundEnabled( true );
	m_pStatusBox->SetBgColor( Color(0,0,0,255) ); 
	m_pStatusBox->SetOKButtonVisible( false );
	m_pStatusBox->DoModal();
}

//-----------------------------------------------------------------------------
// Purpose: Hide our modal status window
// TODO: Pull this out into a more generalized solution across dialogs
//-----------------------------------------------------------------------------
void CFilePublishDialog::HideStatusWindow( void )
{
	m_pStatusBox->CloseModal();
	m_pStatusBox = NULL;
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
void CFilePublishDialog::DownloadPreviewImage( void )
{
	// TODO: We need a generic "no image" image
	if ( m_bAddingNewFile )
		return;

	// Start off our download
	char szTargetFilename[MAX_PATH];
	V_snprintf( szTargetFilename, sizeof(szTargetFilename), "%llu_thumb.jpg", m_FileDetails.publishedFileDetails.m_nPublishedFileId );
	m_UGCPreviewFileRequest.StartDownload( m_FileDetails.publishedFileDetails.m_hPreviewFile, "downloads", szTargetFilename );
	m_bPreviewDownloadPending = true;
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
void CFilePublishDialog::OnTick( void )
{
	BaseClass::OnTick();

	if ( m_pPrepareFileThread )
	{
		if ( !m_pPrepareFileThread->IsAlive() )
		{
			// Finished, trigger handler
			int result = m_pPrepareFileThread->GetResult();
			delete m_pPrepareFileThread;
			m_pPrepareFileThread = NULL;
			OnFilePrepared( result == 0 );
		}
	}

	if ( m_bPreviewDownloadPending )
	{
		UGCFileRequestStatus_t ugcStatus = m_UGCPreviewFileRequest.Update();
		switch ( ugcStatus )
		{
		case UGCFILEREQUEST_ERROR:
			Warning("An error occurred while attempting to download a file from the UGC server!\n");
			m_bPreviewDownloadPending = false;
			break;

		case UGCFILEREQUEST_FINISHED:
			// Update our image preview
			char szLocalFilename[MAX_PATH];
			m_UGCPreviewFileRequest.GetLocalFileName( szLocalFilename, sizeof(szLocalFilename) );
			char szLocalPath[ _MAX_PATH ];
			g_pFullFileSystem->GetLocalPath( szLocalFilename, szLocalPath, sizeof(szLocalPath) );
			SetPreviewImage( szLocalPath );
			m_bPreviewDownloadPending = false;
			break;

		default:
			// Working, continue to wait...
			return;
			break;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
void CFilePublishDialog::SetPreviewImage( const char *lpszFilename )
{
	if ( lpszFilename == NULL )
		return;

	// Retain this
	g_PreviewFilename = lpszFilename;

	m_bValidJpeg = false;

	ConversionErrorType nErrorCode = ImgUtl_LoadBitmap( lpszFilename, m_imgSource );
	if ( nErrorCode != CE_SUCCESS )
	{
	}
	else
	{
		m_bValidJpeg = true;
		PerformSquarize();
		m_pCroppedTextureImagePanel->SetBitmap( GetPreviewBitmap() );
	}

	// Update the state of our publish button
	SetPublishButtonState();
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
void CFilePublishDialog::PerformSquarize()
{
	if ( !BForceSquarePreviewImage() )
		return;

	const Bitmap_t *pResizeSrc = &m_imgSource;
	if ( !IsSourceImageSquare() )
	{
		// Select the smaller dimension as the size
		int nSize = MIN( m_imgSource.Width(), m_imgSource.Height() );

		// Crop it.
		// Yeah, the crop and resize could be done all in one step.
		// And...I don't care.
		int x0 = ( m_imgSource.Width() - nSize ) / 2;
		int y0 = ( m_imgSource.Height() - nSize ) / 2;
		m_imgTemp.Crop( x0, y0, nSize, nSize, &m_imgSource );

		pResizeSrc = &m_imgTemp;
	}

	// resize
	ImgUtl_ResizeBitmap( m_imgSquare, DesiredPreviewWidth(), DesiredPreviewHeight(), pResizeSrc );
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
Bitmap_t &CFilePublishDialog::GetPreviewBitmap()
{
	return BForceSquarePreviewImage() ? m_imgSquare : m_imgSource;
}

//-----------------------------------------------------------------------------
// Purpose:	Setup our edit fields with the appropriate information
//-----------------------------------------------------------------------------
void CFilePublishDialog::PopulateEditFields( void )
{
	m_pFileTitle->SetText( m_FileDetails.publishedFileDetails.m_rgchTitle );
	m_pFileDescription->SetText( m_FileDetails.publishedFileDetails.m_rgchDescription );

	if ( m_FileDetails.lpszFilename && !FStrEq( m_FileDetails.lpszFilename, "" ) )
	{
		char szShortName[ MAX_PATH ];
		Q_FileBase( m_FileDetails.lpszFilename, szShortName, sizeof(szShortName) );
		const char *szExt = Q_GetFileExtension( m_FileDetails.lpszFilename );
		Q_SetExtension( szShortName, CFmtStr( ".%s", szExt ).Access(), sizeof(szShortName ) );
		m_pFilename->SetText( szShortName );
	}
}

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

	LoadControlSettings( GetResFile() );

	m_pFileTitle = dynamic_cast< vgui::TextEntry * >( FindChildByName( "FileTitle" ) );
	if ( m_pFileTitle )
	{
		m_pFileTitle->AddActionSignalTarget( this );
	}

	m_pFileDescription = dynamic_cast< vgui::TextEntry * >( FindChildByName( "FileDesc" ) );
	if ( m_pFileDescription )
	{
		m_pFileDescription->SetMultiline( true );
		m_pFileDescription->SetCatchEnterKey( true );
		m_pFileDescription->SetVerticalScrollbar( true );
	}

	m_pFilename = dynamic_cast< vgui::Label * >( FindChildByName( "SourceFile" ) );
	if ( !g_MapFilename.IsEmpty() )
	{
		m_pFilename->SetText( g_MapFilename );
	}

	m_pPublishButton = dynamic_cast< vgui::Button * >( FindChildByName( "ButtonPublish" ) );

	// If we're updating, change the context of the button
	if ( !m_bAddingNewFile )
	{
		m_pPublishButton->SetText( "Update" );
		m_pPublishButton->SetCommand( "Update" );
	}

	// Setup our initial state for the edit fields
	PopulateEditFields();
	SetPublishButtonState();
}

//-----------------------------------------------------------------------------
// Purpose: Helper to build thumbnail name
//-----------------------------------------------------------------------------
void CFilePublishDialog::GetPreviewFilename( char *szOut, size_t outLen )
{
	char szMapShortName[MAX_PATH];
	Q_FileBase( g_MapFilename, szMapShortName, sizeof(szMapShortName) );
	Q_snprintf( szOut, outLen, "%s_thumb.jpg", szMapShortName );
}

//-----------------------------------------------------------------------------
// Purpose: Callback when our create item has completed. Need to do initial update.
//-----------------------------------------------------------------------------
void CFilePublishDialog::Steam_OnCreateItem( CreateItemResult_t *pResult, bool bError )
{
	bError = bError || pResult->m_eResult != k_EResultOK;
	m_nFileID = pResult->m_nPublishedFileId;

	if ( bError )
	{
		HideStatusWindow();
		ErrorMessage( kFailedToPublishFile );
		if ( m_nFileID != k_PublishedFileIdInvalid )
		{
			// TODO ISteamUGC is conspicuously missing a delete call, but shares IDs with SteamRemoteStorage.
			//      Once this is fixed in steam, this call should probably be moved
			steamapicontext->SteamRemoteStorage()->DeletePublishedFile( m_nFileID );
			m_nFileID = k_PublishedFileIdInvalid;
		}
	}
	else
	{
		StartPrepareFile();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Callback from our map compression thread finishing
//-----------------------------------------------------------------------------
void CFilePublishDialog::OnFilePrepared( bool bSucceeded )
{
	if ( bSucceeded )
	{
		// Move on to final publishing
		bSucceeded = UpdateFileInternal();
	}

	if ( bSucceeded )
	{
		// Done, waiting on file publish callback
		return;
	}

	// Failure

	// This is after OnCreateItem for new files, so cleanup the incomplete item on failure from either the compress or
	// kicking off the update.
	if ( m_bAddingNewFile && m_nFileID != k_PublishedFileIdInvalid )
	{
		// TODO ISteamUGC is conspicuously missing a delete call, but shares IDs with SteamRemoteStorage.
		//      Once this is fixed in steam, this call should probably be moved
		steamapicontext->SteamRemoteStorage()->DeletePublishedFile( m_nFileID );
		m_nFileID = k_PublishedFileIdInvalid;
	}

	HideStatusWindow();
	ErrorMessage( kFailedToUpdateFile );
}

//-----------------------------------------------------------------------------
// Purpose: Callback when our publish call has completed
//-----------------------------------------------------------------------------
void CFilePublishDialog::Steam_OnPublishFile( SubmitItemUpdateResult_t *pResult, bool bError )
{
	// Remove prepared map
	char szPreparedMap[MAX_PATH] = { 0 };
	V_ComposeFileName( WORKSHOP_TEMP_UPLOAD_DIR, V_GetFileName( g_MapFilename ),
	                   szPreparedMap, sizeof( szPreparedMap ) );
	g_pFullFileSystem->RemoveFile( szPreparedMap, UGC_PATHID );

	// Remove local thumbnail
	CUtlBuffer bufData;
	char szPreviewFilename[MAX_PATH];
	GetPreviewFilename( szPreviewFilename, sizeof( szPreviewFilename ) );
	g_pFullFileSystem->RemoveFile( szPreviewFilename, UGC_PATHID );

	HideStatusWindow();

	if ( bError || pResult->m_eResult != k_EResultOK )
	{
		if ( m_bAddingNewFile && m_nFileID != k_PublishedFileIdInvalid )
		{
			// TODO ISteamUGC is conspicuously missing a delete call, but shares IDs with SteamRemoteStorage.
			//      Once this is fixed in steam, this call should probably be moved
			steamapicontext->SteamRemoteStorage()->DeletePublishedFile( m_nFileID );
			m_nFileID = k_PublishedFileIdInvalid;
		}
		ErrorMessage( kFailedToPublishFile );
	}
	else
	{
		EUniverse universe = GetUniverse();
		switch ( universe )
		{
		case k_EUniversePublic:
			steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( CFmtStrMax( "http://steamcommunity.com/sharedfiles/filedetails/?id=%llu&requirelogin=true", m_nFileID ) );
			break;
		case k_EUniverseBeta:
			steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( CFmtStrMax( "http://beta.steamcommunity.com/sharedfiles/filedetails/?id=%llu&requirelogin=true", m_nFileID ) );
			break;
		case k_EUniverseDev:
			steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( CFmtStrMax( "http://localhost/community/sharedfiles/filedetails/?id=%llu&requirelogin=true", m_nFileID ) );
			break;
		}

		// Tell our parent what happened
		KeyValues *pkvActionSignal = new KeyValues( "ChangedFile" );
		pkvActionSignal->SetUint64( "nPublishedFileID", m_nFileID );
		PostActionSignal( pkvActionSignal );

		// Close down the window
		CloseModal();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Share the file with Steam Cloud and return the handle for later usage
//-----------------------------------------------------------------------------
bool CFilePublishDialog::PublishFile()
{
	// Must be a valid file
	ErrorCode_t errorCode = ValidateFile( g_MapFilename );
#ifdef TF_CLIENT_DLL
	const char *pExt = V_GetFileExtension( g_MapFilename );
	if ( errorCode == kNoError && pExt && V_strcmp( pExt, "bsp" ) == 0 )
	{
		if ( !CTFMapsWorkshop::IsValidOriginalFileNameForMap( CUtlString( V_GetFileName( g_MapFilename ) ) ) )
		{
			errorCode = kInvalidMapName;
		}
	}
#endif
	if ( errorCode != kNoError )
	{
		ErrorMessage( errorCode );
		return false;
	}

	ShowStatusWindow( kPublishing );

	EWorkshopFileType eFileType = WorkshipFileTypeForFile( g_MapFilename );

	// Create file on UGC
	SteamAPICall_t hSteamAPICall = steamapicontext->SteamUGC()->CreateItem( GetTargetAppID(), eFileType );

	// Set the callback
	m_callbackCreateItem.Set( hSteamAPICall, this, &CFilePublishDialog::Steam_OnCreateItem );

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Kick off the map compression thread
//-----------------------------------------------------------------------------
void CFilePublishDialog::StartPrepareFile( void )
{
	// Ensure temp dir exists
	g_pFullFileSystem->CreateDirHierarchy( WORKSHOP_TEMP_UPLOAD_DIR, UGC_PATHID );

	char szOutPath[MAX_PATH] = { 0 };
	V_ComposeFileName( WORKSHOP_TEMP_UPLOAD_DIR, V_GetFileName( g_MapFilename ),
	                   szOutPath, sizeof( szOutPath ) );

	// Ensure this file isn't leftover in output dir
	g_pFullFileSystem->RemoveFile( szOutPath, UGC_PATHID );

	// Start thread
	Assert( !m_pPrepareFileThread );
	m_pPrepareFileThread = new CPrepareFileThread( g_MapFilename, szOutPath );
	m_pPrepareFileThread->Start();
}

//-----------------------------------------------------------------------------
// Purpose: Parse commands coming in from the VGUI dialog
//-----------------------------------------------------------------------------
void CFilePublishDialog::SetPublishButtonState( void )
{
	if ( m_bAddingNewFile )
	{
		if ( m_bValidFile && m_bValidJpeg )
		{
			m_pPublishButton->SetEnabled( true );
		}
		else
		{
			m_pPublishButton->SetEnabled( false );
		}
	}
	else // Updating a previous entry
	{
		// m_pPublishButton->SetEnabled( (m_nFileDetailsChanges!=0) );
		m_pPublishButton->SetEnabled( true ); // For now, always allow it. Worst case it's a no-op
	}
}

//-----------------------------------------------------------------------------
// Purpose: Parse commands coming in from the VGUI dialog
//-----------------------------------------------------------------------------
bool CFilePublishDialog::UpdateFile( void )
{
	// We should have been created for an existing file or published already, both of which set our ID.
	Assert( m_nFileID != k_PublishedFileIdInvalid );
	ShowStatusWindow( kUpdating );

	if ( m_bAddingNewFile || m_nFileDetailsChanges & PFILE_FIELD_FILE )
	{
		StartPrepareFile();
	}
	else
	{
		// Not updating map, go straight to update step
		if ( !UpdateFileInternal() )
		{
			HideStatusWindow();
			ErrorMessage( kFailedToUpdateFile );
		}
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Update a file, used by the create and update pathways to fill in a UGC item
//-----------------------------------------------------------------------------
bool CFilePublishDialog::UpdateFileInternal()
{
	ISteamUGC *pUGC = steamapicontext->SteamUGC();

	UGCUpdateHandle_t hItem = pUGC->StartItemUpdate( GetTargetAppID(), m_nFileID );
	if ( hItem == k_UGCUpdateHandleInvalid )
	{
		UGCWarning( "StartItemUpdate failed\n" );
		return false;
	}

	bool bError = false;

	// create thumbnail
	CUtlBuffer bufData;
	char szPreviewFilename[MAX_PATH];
	GetPreviewFilename( szPreviewFilename, sizeof( szPreviewFilename ) );

	if ( !bError && ImgUtl_SaveBitmapToBuffer( bufData, GetPreviewBitmap(), kImageFileFormat_JPG ) == CE_SUCCESS )
	{
		bError = !g_pFullFileSystem->WriteFile( szPreviewFilename, UGC_PATHID, bufData );

		// Get full path to give steam
		g_pFullFileSystem->RelativePathToFullPath( szPreviewFilename, UGC_PATHID, szPreviewFilename, sizeof( szPreviewFilename ) );
	}
	else
	{
		bError = true;
	}

	// Get the compressed map out of the upload directory
	char szPreparedMap[MAX_PATH] = { 0 };
	char szFullPreparedPath[MAX_PATH] = { 0 };
	if ( m_bAddingNewFile || m_nFileDetailsChanges & PFILE_FIELD_FILE )
	{
		V_ComposeFileName( WORKSHOP_TEMP_UPLOAD_DIR, V_GetFileName( g_MapFilename ),
		                   szPreparedMap, sizeof( szPreparedMap ) );

		g_pFullFileSystem->RelativePathToFullPath( szPreparedMap, UGC_PATHID,
		                                           szFullPreparedPath,
		                                           sizeof( szFullPreparedPath ) );

		bError |= !*szFullPreparedPath;
	}

	if ( !bError )
	{
		// Set title
		char szTitle[k_cchPublishedDocumentTitleMax];
		m_pFileTitle->GetText( szTitle, sizeof(szTitle) );
		Q_AggressiveStripPrecedingAndTrailingWhitespace( szTitle );

		bError |= !pUGC->SetItemTitle( hItem, szTitle );

		// Set descriptor
		char szDesc[k_cchPublishedDocumentDescriptionMax];
		m_pFileDescription->GetText( szDesc, sizeof(szDesc) );
		Q_AggressiveStripPrecedingAndTrailingWhitespace( szDesc );

		bError |= !pUGC->SetItemDescription( hItem, szDesc );

		// Set thumbnail
		if ( m_bAddingNewFile || m_nFileDetailsChanges & PFILE_FIELD_PREVIEW )
		{
			bError |= !pUGC->SetItemPreview( hItem, szPreviewFilename );
		}

		// Set file
		if ( m_bAddingNewFile || m_nFileDetailsChanges & PFILE_FIELD_FILE )
		{
			if ( *szFullPreparedPath )
			{
				bError |= !pUGC->SetItemContent( hItem, szFullPreparedPath );
				// Metadata for our files is just the original filename, since they are currently all single files
				bError |= !pUGC->SetItemMetadata( hItem, V_GetFileName( g_MapFilename.Get() ) );
			}
			else
			{
				UGCWarning( "Prepared map does not appear to exist\n" );
				bError = true;
			}
		}

		// Tags
		SteamParamStringArray_t strArray;
		PopulateTags( strArray );
		bError |= !pUGC->SetItemTags( hItem, &strArray );

		// Visibility
		bError |= !pUGC->SetItemVisibility( hItem, k_ERemoteStoragePublishedFileVisibilityPublic );
	}
	else
	{
		bError = true;
	}

	if ( !bError )
	{
		SteamAPICall_t hSteamAPICall = steamapicontext->SteamUGC()->SubmitItemUpdate( hItem, NULL );
		m_callbackPublishFile.Set( hSteamAPICall, this, &CFilePublishDialog::Steam_OnPublishFile );
		return true;
	}

	// Failed, cleanup prepared map
	g_pFullFileSystem->RemoveFile( szPreparedMap, UGC_PATHID );

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CFilePublishDialog::PerformLayout()
{
	BaseClass::PerformLayout();
}

//-----------------------------------------------------------------------------
// Purpose: Parse commands coming in from the VGUI dialog
//-----------------------------------------------------------------------------
void CFilePublishDialog::OnCommand( const char *command )
{
	if ( Q_stricmp( command, "Publish" ) == 0 )
	{
		// Verify they've filled everything out properly
		bool bHasTitle = ( m_pFileTitle->GetTextLength() > 0 );
		bool bHasDesc = ( m_pFileDescription->GetTextLength() > 0 );
		if ( !bHasTitle || !bHasDesc )
		{
			ErrorMessage( kNeedTitleAndDescription );
			return;
		}

		// Get our title
		char szTitle[k_cchPublishedDocumentTitleMax];
		m_pFileTitle->GetText( szTitle, sizeof(szTitle) );
		Q_AggressiveStripPrecedingAndTrailingWhitespace( szTitle );

		// Get our descriptor
		char szDesc[k_cchPublishedDocumentDescriptionMax];
		m_pFileDescription->GetText( szDesc, sizeof(szDesc) );
		Q_AggressiveStripPrecedingAndTrailingWhitespace( szDesc );

		bHasTitle = Q_strlen( szTitle ) != 0;
		bHasDesc = Q_strlen( szDesc ) != 0;
		if ( !bHasTitle || !bHasDesc )
		{
			ErrorMessage( kNeedTitleAndDescription );
			return;
		}

		PublishFile();
	}
	else if ( Q_stricmp( command, "Update" ) == 0 )
	{
		UpdateFile();
	}
	else if ( Q_stricmp( command, "MainFileMaps" ) == 0 )
	{
		m_fileOpenMode = FILEOPEN_MAIN_FILE;

		// Create a new dialog
		vgui::FileOpenDialog *pDlg = new vgui::FileOpenDialog( NULL, "Select File", true );
		pDlg->AddFilter( GetFileTypes( IMPORT_FILTER_MAP ), GetFileTypeDescriptions( IMPORT_FILTER_MAP ), true );
		if ( !FStrEq( publish_file_last_dir.GetString(), "" ) )
		{
			pDlg->SetStartDirectory( publish_file_last_dir.GetString() );
		}

		char textBuffer[1024];
		m_pFilename->GetText( textBuffer, sizeof( textBuffer ) );

		char szFilePath[MAX_PATH];
		g_pFullFileSystem->GetCurrentDirectory( szFilePath, sizeof(szFilePath) );

		strcat( szFilePath, "/" );
		strcat( szFilePath, textBuffer );

		// Get the currently set dir and use that as the start
		// pDlg->ExpandTreeToPath( szFilePath );
		pDlg->MoveToCenterOfScreen();
		pDlg->AddActionSignalTarget( this );
		pDlg->SetDeleteSelfOnClose( true );
		pDlg->DoModal();
		pDlg->Activate();
	}
	else if ( Q_stricmp( command, "MainFileOther" ) == 0 )
	{
		m_fileOpenMode = FILEOPEN_MAIN_FILE;

		// Create a new dialog
		vgui::FileOpenDialog *pDlg = new vgui::FileOpenDialog( NULL, "Select File", true );
		pDlg->AddFilter( GetFileTypes( IMPORT_FILTER_OTHER ), GetFileTypeDescriptions( IMPORT_FILTER_OTHER ), true );
		if ( !FStrEq( publish_file_last_dir.GetString(), "" ) )
		{
			pDlg->SetStartDirectory( publish_file_last_dir.GetString() );
		}

		char textBuffer[1024];
		m_pFilename->GetText( textBuffer, sizeof( textBuffer ) );

		char szFilePath[MAX_PATH];
		g_pFullFileSystem->GetCurrentDirectory( szFilePath, sizeof( szFilePath ) );

		strcat( szFilePath, "/" );
		strcat( szFilePath, textBuffer );

		// Get the currently set dir and use that as the start
		// pDlg->ExpandTreeToPath( szFilePath );
		pDlg->MoveToCenterOfScreen();
		pDlg->AddActionSignalTarget( this );
		pDlg->SetDeleteSelfOnClose( true );
		pDlg->DoModal();
		pDlg->Activate();
	}
	else if ( Q_stricmp( command, "PreviewBrowse" ) == 0 )
	{
		m_fileOpenMode = FILEOPEN_PREVIEW;
		
		// Create a new dialog
		vgui::FileOpenDialog *pDlg = new vgui::FileOpenDialog( NULL, "Select File", true );
		pDlg->AddFilter( GetPreviewFileTypes(), GetPreviewFileTypeDescriptions(), true );
		if ( !FStrEq( publish_file_last_dir.GetString(), "" ) )
		{
			pDlg->SetStartDirectory( publish_file_last_dir.GetString() );
		}

		char szFilePath[MAX_PATH];
		g_pFullFileSystem->GetCurrentDirectory( szFilePath, sizeof(szFilePath) );

		strcat( szFilePath, "/" );
		strcat( szFilePath, g_PreviewFilename );

		// Get the currently set dir and use that as the start
		// pDlg->ExpandTreeToPath( szFilePath );
		pDlg->MoveToCenterOfScreen();
		pDlg->AddActionSignalTarget( this );
		pDlg->SetDeleteSelfOnClose( true );
		pDlg->DoModal();
		pDlg->Activate();
	}
	else
	{
		BaseClass::OnCommand( command );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Take a filename, shorten it for display but retain the full path internally
//-----------------------------------------------------------------------------
CFilePublishDialog::ErrorCode_t CFilePublishDialog::ValidateFile( const char *lpszFilename )
{
	return kNoError;
}

//-----------------------------------------------------------------------------
// Purpose: Take a filename, shorten it for display but retain the full path internally
//-----------------------------------------------------------------------------
void CFilePublishDialog::SetFile( const char *lpszFilename, bool bImported )
{
	// Must be a valid file
	ErrorCode_t errorCode = ValidateFile( lpszFilename );
	if ( errorCode != kNoError )
	{
		ErrorMessage( errorCode );
		return;
	}

	m_bValidFile = true;
	g_MapFilename = lpszFilename;
	char szShortName[ MAX_PATH ];
	Q_FileBase( g_MapFilename, szShortName, sizeof(szShortName) );
	const char *szExt = Q_GetFileExtension( lpszFilename );
	Q_SetExtension( szShortName, CFmtStr( ".%s", szExt ).Access(), sizeof(szShortName ) );
	m_pFilename->SetText( szShortName );

	// Notify of the change
	m_nFileDetailsChanges |= PFILE_FIELD_FILE;

	SetPublishButtonState();
}

//-----------------------------------------------------------------------------
// Purpose: Notify us that the directory dialog has returned a new entry
//-----------------------------------------------------------------------------
void CFilePublishDialog::OnFileSelected( const char *fullPath )
{
	char basepath[ MAX_PATH ];
	Q_ExtractFilePath( fullPath, basepath, sizeof( basepath ) );
	publish_file_last_dir.SetValue( basepath );

	if ( m_fileOpenMode == FILEOPEN_MAIN_FILE )
	{
		SetFile( fullPath );
	}
	else if ( m_fileOpenMode == FILEOPEN_PREVIEW )
	{
		// Notify of the change
		m_nFileDetailsChanges |= PFILE_FIELD_PREVIEW;

		SetPreviewImage( fullPath );
	}
}
