/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Class representing a project.

*

*/

#include "../inc/CATProject.h"

#include "../inc/CATModule2.h"

#include "../inc/CATParseTraceFile.h"

#include "../inc/CATDatParser.h"

//dbghelp.dll version function.

extern int showDbgHelpVersionInfo( bool showVersion );

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

// CATProject::CATProject()

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

CATProject::CATProject()

{

	LOG_FUNC_ENTRY("CATProject::CATProject");

	m_bUninstrumented = true;

	m_bAbldTest = false;

	// Use windows api to acquire current directory info.

	GetCurrentDirectory( MAX_LINE_LENGTH, m_cCurrentDir );

	m_eBuildSystem = SBS_V1;

	m_eBuildType = UDEB;

	m_eLoggingMode = TRACE;

	m_eMode = NOT_DEFINED;

	m_iLoggingLevel = 3;

	m_pAnalyzer = 0;

	m_sBinaryTarget = "";

	m_sBuildCommand = "";

	m_sDataFile = "";

	m_sDataFileOutput = "";

	m_sDataFileTemp = "";

	m_sEpocRoot = "\\";

	m_sMakeFile = "";

	m_sPlatform = "";

	m_sS60FileName = "";

	m_sTargetModule = "";

	m_sVariant = "";

	m_vRomSymbolFiles.clear();

	m_vModules.clear();

	m_vStaticLibraries.clear();

	m_vTargetModules.clear();

	m_vUnsupportedModules.clear();

}

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

// CATProject::~CATProject()

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

CATProject::~CATProject()

{

	LOG_FUNC_ENTRY("CATProject::~CATProject");

	CleanModuleVectors();

	// Delete analyzer

	if ( m_pAnalyzer )

		delete m_pAnalyzer;

	// Temporary datafile

	if ( !m_sDataFileTemp.empty() )

	{

		if ( FileExists( m_sDataFileTemp.c_str() ) )

			FileDelete( m_sDataFileTemp, false );

	}

}

bool CATProject::SetArguments( ARGUMENTS& arguments )

{

	LOG_FUNC_ENTRY("CATProject::SetArguments");

	bool bRet = true;

	//Project mode.

	if( arguments.eHookSwitch == HOOK_INTERNAL )

	{

		SetMode( CATProject::COMPILE );

		SetLoggingMode( CATProject::FILE );

	}

	else if ( arguments.eHookSwitch == HOOK_EXTERNAL )

	{

		SetMode( CATProject::COMPILE );

		SetLoggingMode( CATProject::TRACE );

	}

	else if ( arguments.eHookSwitch == HOOK_EXTERNAL_FAST )

	{

		SetMode( CATProject::COMPILE );

		SetLoggingMode( CATProject::TRACE_FAST );

	}

	/* Extension*/

	else if ( arguments.eHookSwitch == HOOK_EXTENSION_INTERNAL )

	{

		SetMode( CATProject::INSTRUMENT );

		SetLoggingMode( CATProject::FILE );

	}

	else if ( arguments.eHookSwitch == HOOK_EXTENSION_EXTERNAL )

	{

		SetMode( CATProject::INSTRUMENT );

		SetLoggingMode( CATProject::TRACE );

	}

	else if ( arguments.eHookSwitch == HOOK_EXTENSION_EXTERNAL_FAST )

	{

		SetMode( CATProject::INSTRUMENT );

		SetLoggingMode( CATProject::TRACE_FAST );

	}

	else if ( arguments.eHookSwitch == HOOK_EXTENSION_UNINSTRUMENT )

	{

		SetMode( CATProject::UNINSTRUMENT );

	}

	else if ( arguments.eHookSwitch == HOOK_EXTENSION_FAILED )

	{

		SetMode( CATProject::UNINSTRUMENT_FAILED );

	}

	//Return if uninstrumenting because no other arguments are set.

    if ( GetMode() == CATProject::UNINSTRUMENT

		|| GetMode() == CATProject::UNINSTRUMENT_FAILED )

	{

		return bRet;

	}

	// No build / instrument.

	if ( arguments.HOOK.bNoBuild )

		SetMode( CATProject::INSTRUMENT_CONSOLE );

	// Call stack sizes

	SetAllocCallStackSize( arguments.HOOK.iAllocCallStackSize );

	SetFreeCallStackSize( arguments.HOOK.iFreeCallStackSize );

	//Build system.

	if ( arguments.HOOK.iBuildSystem == 1 )

		SetBuildSystem( CATProject::SBS_V1 );

	else if ( arguments.HOOK.iBuildSystem == 2 )

		SetBuildSystem( CATProject::SBS_V2 );

	//Test module build only

	if ( arguments.HOOK.bAbldTest == true )

		m_bAbldTest = true;

	//Platform.

	if ( !_stricmp( arguments.HOOK.sPlatform.c_str(), "armv5" ) )

		SetPlatform( arguments.HOOK.sPlatform );

	else if ( !_stricmp( arguments.HOOK.sPlatform.c_str(), "gcce" ) )

		SetPlatform( arguments.HOOK.sPlatform );

	else if ( !_stricmp( arguments.HOOK.sPlatform.c_str(), "winscw" ) )

		SetPlatform( arguments.HOOK.sPlatform );

	else

	{

		LOG_STRING( "Error, no supported platform specified (armv5/gcce/winscw).");

		bRet = false;

	}

	//BuildType.

	if ( !_stricmp( arguments.HOOK.sBuildType.c_str(), "urel" ) )

		SetBuildType( CATProject::UREL );

	else if ( !_stricmp( arguments.HOOK.sBuildType.c_str(), "udeb" ) )

		SetBuildType( CATProject::UDEB );

	else

	{

		LOG_STRING( "Error, no build type specified.");

		bRet = false;

	}

	//Internal data file.

	if ( arguments.HOOK.bDataFileName )

		SetS60FileName( arguments.HOOK.sDataFileName );

	//Build command.

	if ( arguments.HOOK.sBuildCmd.empty() && ( 

		GetMode() == CATProject::COMPILE ||

		GetMode() == CATProject::INSTRUMENT ||

		GetMode() == CATProject::INSTRUMENT_CONSOLE

		))

	{

		cout << AT_MSG << "Error, no build command specified." << endl;

		bRet = false;

	}

	SetBuildCommand( arguments.HOOK.sBuildCmd );

	//Variant.

	SetVariant( arguments.HOOK.sFeatureVariant );

	//Target programs.

	SetTargetModules( arguments.HOOK.vTargetPrograms );

	return bRet;

}

void CATProject::CleanModuleVectors()

{

	LOG_FUNC_ENTRY("CATProject::CleanModuleVectors");

	// delete modules from vector.

	for( size_t i = 0; i < m_vModules.size()  ; i++ )

		delete m_vModules[i];

	m_vModules.clear();

	// Delete modules from vector (unsupported).

	for( size_t i = 0; i < m_vUnsupportedModules.size()  ; i++ )

		delete m_vUnsupportedModules[i];

	m_vUnsupportedModules.clear();

	// Delete modules from static library vector.

	for( size_t i = 0; i < m_vStaticLibraries.size() ; i++ )

		delete m_vStaticLibraries[i];

	m_vStaticLibraries.clear();

}

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

// CATProject::Run

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

int CATProject::Run()

{

	LOG_FUNC_ENTRY("CATProject::Run");

	int iReturnCode = 0;

	switch( m_eMode )

	{

	case COMPILE:

		// Run compile

		iReturnCode = RunCompile();

		if ( iReturnCode == AT_RETURN_CODE::READ_MAKEFILE_ERROR

			|| iReturnCode == AT_RETURN_CODE::KERNEL_SIDE_MODULE_ERROR

			|| iReturnCode == AT_RETURN_CODE::INVALID_MMP_DEFINED )

		{

			DeleteTemporaryDirs();

			DirDelete( AT_TEMP_DIR, true );

		}

		else

		{

			DisplayCompileSummary();

			DisplayBuildSummary();

		}

		break;

	case CLEAN:

		iReturnCode = RunClean();

		break;

	case ANALYZE:

		iReturnCode = RunAnalyze();

		break;

	case INSTRUMENT:

		iReturnCode = RunInstrument();

		break;

	case INSTRUMENT_CONSOLE:

		iReturnCode = RunInstrumentConsole();

		if ( iReturnCode == AT_RETURN_CODE::READ_MAKEFILE_ERROR

			|| iReturnCode == AT_RETURN_CODE::KERNEL_SIDE_MODULE_ERROR )

		{

			DeleteTemporaryDirs();

			DirDelete( AT_TEMP_DIR, true );

		}

		else

		{

			DisplayBuildSummary();

		}

		break;

	case UNINSTRUMENT:

		iReturnCode = RunUninstrument();

		// Show summary

		DisplayCompileSummary();

		DisplayBuildSummary();

		break;

	case UNINSTRUMENT_CONSOLE:

		iReturnCode = RunUninstrumentConsole();

		// Show summary

		DisplayCompileSummary();

		DisplayBuildSummary();

		break;

	case UNINSTRUMENT_FAILED:

		iReturnCode = RunUninstrumentFailed();

		// Display message

		cout << AT_MSG << "Build aborted, because project contains compile error(s)."

			<< endl;

		break;

	default:

		cout << AT_MSG << "Error, mode not supported / implemented." << endl;

		break;

	}

	// Error messages

	switch( iReturnCode )

	{

		case AT_RETURN_CODE::MAKEFILE_ERROR:

			cout << AT_MSG << "Error, creating/reading makefiles." << endl;

			break;

		case AT_RETURN_CODE::COMPILE_ERROR:

			cout << AT_MSG << "Error, compiling project." << endl;

			break;

		case AT_RETURN_CODE::UNKNOWN:

			cout << AT_MSG << "Error, unknown." << endl;

			break;

		case AT_RETURN_CODE::WRONG_DATA_FILE_VERSION:

			cout << AT_MSG << "unable to analyze the data file.\n";

			cout << AT_MSG << "wrong data file version.\n";

			break;

		case AT_RETURN_CODE::INVALID_DATA_FILE:

			cout << AT_MSG << "Error, invalid datafile." << endl;

			break;

		case AT_RETURN_CODE::RELEASABLES_ERROR:

			cout << AT_MSG << "Error, copying releasable(s)." << endl;

			break;

		case AT_RETURN_CODE::RESTORE_MODULES_ERROR:

			cout << AT_MSG << "Error, restoring mmp file(s)." << endl;

			break;

		case AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR:

			cout << AT_MSG << "Error, creating temporary cpp file(s)." << endl;

			break;

		case AT_RETURN_CODE::CLEANING_TEMP_ERROR:

			cout << AT_MSG << "Error, cleaning temporary dir(s)." << endl;

			break;

		case AT_RETURN_CODE::READ_MAKEFILE_ERROR:

			cout << AT_MSG << "Error, reading makefile." << endl;

			break;

		case AT_RETURN_CODE::MODIFY_MODULES_ERROR:

			cout << AT_MSG << "Error, modifying mmp file(s)." << endl;

			break;

		case AT_RETURN_CODE::INVALID_MMP_DEFINED:

			break;

		case AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR:

			cout << AT_MSG << "Error, writing attributes." << endl;

			break;

		case AT_RETURN_CODE::READ_ATTRIBUTES_ERROR:

			cout << AT_MSG << "Error, reading project configuration. Instrument project again." << endl;

			break;

		case AT_RETURN_CODE::EMPTY_DATA_FILE:

			cout << AT_MSG << "Error, no data to be analyzed." << endl;

			break;

		case AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR:

			cout << AT_MSG << "Error, no modules found with supported target type." << endl;

			break;

		case AT_RETURN_CODE::KERNEL_SIDE_MODULE_ERROR:

			cout << AT_MSG << "Error, kernel side component found component. Build/instrument aborted." << endl;

			break;

	}	

	return iReturnCode;

}

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

// CATProject::RunRecoveryAndExit()

// Restore modules quick and exit. Used when user wants to kill/end process.

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

int CATProject::RunRecoveryAndExit()

{

	LOG_FUNC_ENTRY("CATProject::RunRecoveryAndExit");

	cout << AT_MSG << "Error, user requested exit." << endl;

	VerifyAndRecoverModules();

	DeleteTemporaryDirs();

	DirDelete( AT_TEMP_DIR, true );

	cout << AT_MSG << "Exit." << endl;

	return AT_RETURN_CODE::USER_ISSUED_EXIT;

}

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

// CATProject::IsUninstrumented()

// Reads projects configuration file if it exists. 

// Return false in case the data contains information that project is

// uninstrumented. Otherwise returns always true.

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

bool CATProject::IsUninstrumented()

{

	LOG_FUNC_ENTRY("CATProject::IsUninstrumented");

	string sCfgFile( AT_TEMP_DIR );

	sCfgFile.append( "\\" );

	sCfgFile.append( AT_PROJECT_ATTRIBUTES_FILE_NAME );

	if ( ! FileExists( sCfgFile.c_str() ) )

		return true;

	if( !ReadAttributes() )

	{

		LOG_STRING( "Error, reading project.cfg file." );

		return false;

	}

	return m_bUninstrumented;

}

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

// CATProject::RunCompile()

// Helper functions to run different modes.

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

int CATProject::RunCompile()

{

	LOG_FUNC_ENTRY("CATProject::RunCompile");

	// Store attributes

	if( ! MakeTempDirIfNotExist() )

		return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR;

	if ( ! WriteAttributes() )

		return AT_RETURN_CODE::WRITE_ATTRIBUTES_ERROR;

	// Create makefile

	if ( ! CreateMakeFile() )

		return AT_RETURN_CODE::MAKEFILE_ERROR;

	// Read makefile to get project attributes

	if ( ! ReadMakeFile() )

		return AT_RETURN_CODE::READ_MAKEFILE_ERROR;

	// Filter unsupported

	FilterModules();

	// Check that we have some "valid" modules to hook

	if ( m_vModules.size() == 0 &&(  m_vUnsupportedModules.size() > 0 || m_vStaticLibraries.size() > 0 ) )

		return AT_RETURN_CODE::NO_SUPPORTED_MODULES_ERROR;

	// Check is possible target module defined in project

	if ( ! IsTargetModuleInProject() )

		return AT_RETURN_CODE::INVALID_MMP_DEFINED;

	// Clean temporary dirs of modules

	if ( ! CleanTemporaryDirs() )

		return AT_RETURN_CODE::CLEANING_TEMP_ERROR;

	// Create temporary cpps for modulse

	if (! CreateTemporaryCpps() )

		return AT_RETURN_CODE::CREATING_TEMP_CPP_ERROR;

	// Hook modules

	if (! ModifyModules() )

		return AT_RETURN_CODE::MODIFY_MODULES_ERROR;

	// Compile all

	// Return code

	int iRetCode = AT_RETURN_CODE::OK;

	// Compile

	if ( ! Compile() )

		iRetCode = AT_RETURN_CODE::COMPILE_ERROR;

	// Listings

	if (! CreateListings() )

		iRetCode = AT_RETURN_CODE::COMPILE_ERROR;

	// Releasables

	if (! CopyReleasables() )

		iRetCode = AT_RETURN_CODE::RELEASABLES_ERROR;

	// Restore "unhook" modules

	if (! RestoreModules() )

		iRetCode = AT_RETURN_CODE::RESTORE_MODULES_ERROR;

	// Return error code OK

	return iRetCode;

}

int CATProject::RunClean()

{

	LOG_FUNC_ENTRY("CATProject::RunClean");

	int iRetCode = AT_RETURN_CODE::OK;

	bool bNothingFound = true;

	// Read attributes.

	if (  ReadAttributes() )

	{

		bNothingFound = false;

		if ( m_eBuildSystem == SBS_V1 )

			InitSbs1MakeFileWithPathToTemp();

		// Read makefile to get project attributes

		if( ReadMakeFile() )

		{

			// Filter unsupported

			FilterModules();

			// Restore modules to make sure no changes left

			if( VerifyAndRecoverModules() )

			{

				// Run reallyclean

				switch ( m_eBuildSystem )

				{

				case SBS_V1:

					RunReallyCleanSbs1();

					break;

				case SBS_V2:

					RunReallyCleanSbs2();

					break;

				default:

					break;

				}

				// Delete temporary dirs of modules

				if(! DeleteTemporaryDirs() )

				{

				}

			}

			else

			{

			}

		}

	}

	// Projects

	if ( ! DirDelete( AT_TEMP_DIR, true ) )

	{

	}

	else

		bNothingFound = false;

	if ( bNothingFound )

		cout << AT_MSG << "Nothing found to clean." << endl;

	else

		cout << AT_MSG << "Cleaning done." << endl;

	return iRetCode;

}

int CATProject::RunAnalyze()

{

	LOG_FUNC_ENTRY("CATProject::RunAnalyze");

	// Parse data file if it is trace.

	if ( !IsDataFile( m_sDataFile ) )

	{

		m_sDataFileTemp.clear();

		m_sDataFileTemp.append( m_sDataFile );

		m_sDataFileTemp.append( ".atool" );

		cout << AT_MSG << "Parsing trace file..." << endl;

		CATParseTraceFile Parser;

		if ( ! Parser.StartParse( m_sDataFile.c_str(), m_sDataFileTemp.c_str() ) )

		{

			return AT_RETURN_CODE::EMPTY_DATA_FILE;

		}

		m_sDataFile = m_sDataFileTemp;

	}

	// Init makefile member for this run mode.

	if ( m_eBuildSystem == SBS_V1 )

		InitSbs1MakeFileWithPathToTemp();

	// Read makefile to get project attributes

    if( ! ReadMakeFile() )

	{

		cout << AT_MSG << "Error, cannot find project build with AnalyzeTool." << endl;

	}

	else