/*

* Copyright (c) 2005-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:  

* Script Engine executable entry point.

* Log initialisation.

* Command line read.

* Trigger entry into the top level state machine.

*

*/

/**

 @file testexecute.cpp

*/

#include <test/testexecuteclient.h>

#include "scriptengine.h"

#include <test/testexecutelogger.h>

#include "testwatcher.h"

#include "version.h"

#include "tefutils.h"

#include <f32file.h>

#include <test/wrapperutilsplugin.h>

const TInt KBuffSize= 500;

GLDEF_D TInt CScriptControl::commentedCommandsCount;

GLDEF_D TInt CScriptControl::iRunScriptFailCount;

/**

 * Code for reading commandline set when testexecute is invoked

 * @param aCommandLine - Function fills descriptor with space separated command line args

 */

LOCAL_C void ReadCommandLineL(TDes& aCommandLine)

	{

	// Far simpler for EKA2

	if(User::CommandLineLength() > aCommandLine.MaxLength())

		User::Leave(KErrTooBig);

	User::CommandLine(aCommandLine);

	}

/**

 * Function to parse command line and set optional flags with ON/OFF status acordingly

 * @param aCommandLine - Command line descriptor with ' ' separated arguments/tokens

 * @param aSeparateLogFiles - Function sets to ETrue if -slf is detected in command line

 * @param aJustInTime - Function sets to ETrue if -d is detected in command line

 * @param aGraphicalWindowServer - Function sets to ETrue if -gws is detected in command line

 * @param HelpRequest - Function sets to ETrue if -help is detected in command line

 * @param aVersionRequest - Function sets to ETrue if -v is detected in command line

 * @param aParseTestExecuteIni - Object of the parser class for checking options set through testexecute.ini

 * @param aParserState - TInt value representing whether the parser object instance is active or not

 */

LOCAL_C void ParseCommandLine(const TDesC& aCommandLine,TBool& aSeparateLogFiles,TBool& aJustInTime,

TBool& aGraphicalWindowServer,TBool& aIncludeSelectiveCases,TBool& aExcludeSelectiveCases, TBool& aPipe, TBool& aHelpRequest, TBool& aVersionRequest, 

CTestExecuteIniData& aParseTestExecuteIni, TInt& aParserState)

	{

	// Set up a lex for looping through the command line arguments

	TLex flagLex(aCommandLine);

	// Initialise all flags to false

	aJustInTime = EFalse;

	aSeparateLogFiles = EFalse;

	aGraphicalWindowServer = EFalse;

	aHelpRequest = EFalse;

	aVersionRequest = EFalse;

	_LIT(KTestExecuteCommandLineHelp, "-help");

	_LIT(KTestExecuteCommandLineVersion, "-v");

	while(!flagLex.Eos())

		{

		TPtrC token(flagLex.NextToken());

		TInt result = 0;

		// Get the value for JustInTimeDebug from the TestExecute.ini parser 

		if (aParserState == KErrNone)

			{

			// Get the value from testexecute.ini for optional flag 'JustInTimeDebug'

			aParseTestExecuteIni.GetKeyValueFromIni(KTEFJustInTimeDebug, result);

			}

		const TInt KOne = 1;

		if(token == KTestExecuteCommandLineFlagDebugMode || result == KOne)

			{

			// if the command line contains the token '-d' or the testexecute.ini flag options for JustinTime is set to 'ON'

			aJustInTime = ETrue;

			}

		else if(token == KTestExecuteCommandLineFlagSeparateLogFileMode)

			{

			// if the command line contains the token '-slf'

			aSeparateLogFiles = ETrue;

			}

		else if(token == KTestExecuteCommandLineFlagIncludeSelectiveCases)

			{

			// if the command line contains the token '-tci'

			aIncludeSelectiveCases= ETrue;

			}

		else if(token == KTestExecuteCommandLineFlagExcludeSelectiveCases)

			{

			// if the command line contains the token '-tcx'

			aExcludeSelectiveCases= ETrue;

			}

		else if(token == KTestExecuteCommandLineFlagPipe)

			{

			aPipe = ETrue ; 

			}

		else if(token == KTestExecuteCommandLineHelp)

			{

			// if the command line contains the token '-help'

			aHelpRequest = ETrue;

			}

		else if(token == KTestExecuteCommandLineVersion)

			{

			// if the command line contains the token '-v'

			aVersionRequest = ETrue;

			}

		}

	}

LOCAL_C void DistinguishElement(const TPtrC& aElement, RArray<TRange>& aSelectiveCaseRange)

{

	TInt colonOccurance = aElement.FindC(KTEFColon);

	//we are expecting only a range or a test case ID over here...

	if( colonOccurance!=KErrNotFound )

		{

		//then this is a range of testcases, split it at the colon

		TRange newRange(aElement.Left(colonOccurance),aElement.Mid(colonOccurance+1));

		aSelectiveCaseRange.Append(newRange);

		}

	else

		{

		TRange newRange(aElement,aElement);

		aSelectiveCaseRange.Append(newRange);	

		}

}

/**

 * Read the Cfg File data into a heap buffer

 * And populate the arrays of selective test case IDs and 

 * Ranges to be used by the state machine

 * NOTE: we do not support nested cfgs...

 */

LOCAL_C void CreateCfgDataFromFileL(TPtrC& aCfgFilePath,RArray<TRange>& aSelectiveCaseRange, TDesC*& aSelTestCfgFileData)

	{

	RFs fS;

	User::LeaveIfError(fS.Connect());

	CleanupClosePushL(fS);

	RFile cfgFile;

	User::LeaveIfError(cfgFile.Open(fS,aCfgFilePath,EFileRead | EFileShareAny));

	CleanupClosePushL(cfgFile);

	TInt fileSize;

	User::LeaveIfError(cfgFile.Size(fileSize));

	// Create a 16bit heap buffer

	HBufC* cfgData = HBufC::NewL(fileSize);

	CleanupStack::PushL(cfgData);

	HBufC8* narrowData = HBufC8::NewL(fileSize);

	CleanupStack::PushL(narrowData);

	TPtr8 narrowPtr=narrowData->Des();

	// Read the file into an 8bit heap buffer

	User::LeaveIfError(cfgFile.Read(narrowPtr));

	TPtr widePtr(cfgData->Des());

	// Copy it to the 16bit buffer

	widePtr.Copy(narrowData->Des());

	CleanupStack::PopAndDestroy(narrowData);

	CleanupStack::Pop(cfgData);

	CleanupStack::Pop(2);

	cfgFile.Close();

	fS.Close();

	// Set up the instance token parser

	TLex cfgLex = cfgData->Des();

	aSelTestCfgFileData = cfgData; // to preserve the pointer of cfgdata and transfer the ownership to aSelTestCfgFileData 

	cfgData = NULL; // relinquish the ownership

	while(!cfgLex.Eos())

		{

		DistinguishElement(cfgLex.NextToken(),aSelectiveCaseRange) ; 

		}

	}

LOCAL_C void ParseCommandLineForSelectiveTestingOptions(const TDesC& aCommandLine,CTestExecuteIniData& aParseTestExecuteIni,RArray<TRange>& aSelectiveCaseRange,  TDesC*& aSelTestCfgFileData)

	{

	TLex flagLex(aCommandLine);

	//first of all navigate the command line arguments to the selective test cases flag...

	while(!flagLex.Eos())

	{

		TPtrC token(flagLex.NextToken());

		if( (token.CompareF(KTestExecuteCommandLineFlagIncludeSelectiveCases) == 0) || (token.CompareF(KTestExecuteCommandLineFlagExcludeSelectiveCases) == 0) )

			{

			break;

			}

	}

	TPtrC argument(flagLex.NextToken()) ; 

	while(argument.Length() > 0 )	

		{

		TInt commaOccurance = argument.FindC(KTEFComma) ;

		TPtrC element ; 

		if(commaOccurance == -1)	

			{

			//handle the case where no comma is found, 

			//assume only one item in the list

			element.Set(argument) ; 

			//reset argument to break the while

			argument.Set(KNull);

			}

		else

			{

			element.Set(argument.Left(commaOccurance));

			//take the remaining in the argument

			TInt len = argument.Length()-commaOccurance-1 ; 

			argument.Set(argument.Right(len)) ; 	

			}

		TInt cfgExtensionOccurance = element.FindC(KTEFCfgExtension) ; 

		if (cfgExtensionOccurance!=KErrNotFound) //madatory extension to be given

			{

			TPtrC cfgFilePath(element);

			//its probably the cfg file path.

			TBuf<KBuffSize> tempScriptPath(cfgFilePath);

			// Check whether cfg name is provided along with folder path in the command line

			// If not, take the path from testexecute.ini & name from the command line

			if(cfgFilePath.FindC(KTEFColon)==KErrNotFound)

				{

				TBuf<KMaxTestExecuteNameLength> tempBuffer;

				aParseTestExecuteIni.GetKeyValueFromIni(KTEFDefaultScriptPath, tempBuffer);

				cfgFilePath.Set(tempBuffer);

				// Construct the full file path from the values extracted from command line and ini file

				TBuf<KBuffSize> storeScriptPathTemp(cfgFilePath);

				storeScriptPathTemp.Append(tempScriptPath);

				cfgFilePath.Set(storeScriptPathTemp);

				tempScriptPath.Copy(cfgFilePath);

				}

				// and parse this cfg File to populate our structures

				TRAP_IGNORE(CreateCfgDataFromFileL(cfgFilePath,aSelectiveCaseRange, aSelTestCfgFileData));

				//actually do nothing with the error...

			}

		else

			{

			DistinguishElement(element,aSelectiveCaseRange  );

			}

		}

	}

/**

 * Subroutine performing pre-processing tasks for testexecute execution

 * Also, responsible for triggering the state machine through instance of ScriptMaster

 * @param aScheduler - Instance of ActiveScheduler created through MainL()

 * @param aSysDrive - Default system drive letter to be used for all script parsing

 */

LOCAL_C void ProcessMainL(CActiveScheduler* aScheduler, const TDriveName aSysDrive)

	{

	TDriveName defaultSysDrive(aSysDrive);

	TDriveName testSysDrive(KTEFLegacySysDrive);

	TInt waitForLoggingTime = 0;

	TBuf<KMaxTestExecuteNameLength> htmlLogPath;

	// Create a object of the Parser for TestExecute.ini

	CTestExecuteIniData* parseTestExecuteIni = NULL;

	TRAPD(err, parseTestExecuteIni = CTestExecuteIniData::NewL(defaultSysDrive));

	if (err == KErrNone)

		{

		CleanupStack::PushL(parseTestExecuteIni);

		// Extract all the key values within the object

		parseTestExecuteIni->ExtractValuesFromIni();

		}

	// Read and parse the command line for the flags

	// -d -slf -help and -v

	TBuf<KMaxTestExecuteCommandLength> commandLine;

	TDesC* selTestCfgFileData = NULL; //the pointer to the data of in the .tcs file

	ReadCommandLineL(commandLine);

	// Make lower case because we parse it for flags and search for ".script"

	commandLine.LowerCase();

	TBool separateLogFiles(EFalse); // -slf

	TBool justInTime(EFalse); // -d

	TBool graphicalWindowServer(EFalse); // -gws

	TBool helpRequest(EFalse); // -help

	TBool versionRequest(EFalse); // -v

	TBool includeSelectiveCases(EFalse); // -tci

	TBool excludeSelectiveCases(EFalse); // -tcx

	TBool pipe(EFalse) ; 

	// Set up the bools from the command line

	ParseCommandLine(commandLine,separateLogFiles,justInTime,graphicalWindowServer,includeSelectiveCases, excludeSelectiveCases,pipe, helpRequest,versionRequest,*parseTestExecuteIni,err);

	// If -d then set Just In Time debugging. Panicks break into debug on emulator

	(justInTime) ? (User::SetJustInTime(ETrue)) : (User::SetJustInTime(EFalse)); 

	// Hooks for creating the Graphical Window server

	#ifdef GWS

	#endif

	// Create a console

	_LIT(KMessage,"TestExecute Script Engine");

	CConsoleBase* console = Console::NewL(KMessage,TSize(KConsFullScreen,KConsFullScreen));

	CleanupStack::PushL(console);

	console->SetCursorHeight(0);

	RConsoleLogger consoleLogger(*console);

	CScriptControl::iRunScriptFailCount=0;

	// A lex for getting the first command line argument, ie the script file path

	TLex lex(commandLine);

	TPtrC scriptFilePath(lex.NextToken());

	TInt ret = KErrNotFound;

	if (scriptFilePath.CompareF(KNull) != 0)

		{

		_LIT(KTEFSwitchPrefix, "-");

		if(scriptFilePath.Mid(0,1).CompareF(KTEFSwitchPrefix) == 0)

			{

			// If the first command line argument is not the script file path but a optional switches

			// Then set the script file path for the execution to be 'blank'

			scriptFilePath.Set(KNull);

			}

		else

			{

			TBuf<KBuffSize> tempScriptPath(scriptFilePath);

			// Check whether script name is provided along with folder path in the command line

			// If not, take the path from testexecute.ini & name from the command line

			ret=scriptFilePath.FindC(KTEFColon);

			if(ret==KErrNotFound)

				{

				if (parseTestExecuteIni != NULL)

					{

					TBuf<KMaxTestExecuteNameLength> tempBuffer;

					parseTestExecuteIni->GetKeyValueFromIni(KTEFDefaultScriptPath, tempBuffer);

 					// If the relative script file path does not refer to the root,

 					// we will look for DefaultScriptDir entry in testexecute.ini

 					// If available prepend it to the relative path

 					// else if the relative path refers to root,

 					// then set the default system drive, i.e. c:

 					// else leaving it as it is (considering invalid path)

 					if (scriptFilePath.Left(1).CompareF(KTEFSlash) != 0 &&

 					 tempBuffer.Length() > 0)

 						scriptFilePath.Set(tempBuffer);

 					else if (scriptFilePath.Left(1).CompareF(KTEFSlash) == 0)

 						scriptFilePath.Set(defaultSysDrive);

 					else

 						scriptFilePath.Set(KNull);

					}

				else

					{

					// If the file path is not provided in command line as well as in testexecute.ini

					// then set the  script file path to be 'blank'

					scriptFilePath.Set(KNull);

					}

				// Construct the full file path from the values extracted from command line and ini file

				TBuf<KBuffSize> storeScriptPathTemp(scriptFilePath);

				storeScriptPathTemp.Append(tempScriptPath);

				scriptFilePath.Set(storeScriptPathTemp);

				tempScriptPath.Copy(scriptFilePath);

				}

			//If scriptFilePath is not appended by .script Append .script 

			if(scriptFilePath.Find(KTEFScriptExtension)==KErrNotFound)

				{

				tempScriptPath.Append(KTEFScriptExtension);

				}

			scriptFilePath.Set(tempScriptPath);

			}

		}

	TPtrC pipeName ; 

	if(pipe)

		{

		TLex flagLex(commandLine);

		//first of all navigate the command line arguments to the selective test cases flag...

		while(!flagLex.Eos())

		{

			TPtrC token(flagLex.NextToken());

			if( (token.CompareF(KTestExecuteCommandLineFlagPipe) == 0) )

				{

				break;

				}

		}

		pipeName.Set(flagLex.NextToken()) ; 	

		}

	TSelectiveTestingOptions* selTestingOptions =NULL;

	if (includeSelectiveCases && excludeSelectiveCases)

		{

			//mutually exclusive options have been encountered

			includeSelectiveCases =EFalse;

			excludeSelectiveCases =EFalse;					

			console->Printf(KTEFInvalidCommandSetMessage);

			console->Printf(KTEFEnterKeyMessage);

			console->Getch();

		}

	else

		{

		if(includeSelectiveCases || excludeSelectiveCases)

			{

			RArray<TRange> selectiveCaseRange;

			ParseCommandLineForSelectiveTestingOptions(commandLine,*parseTestExecuteIni,selectiveCaseRange, selTestCfgFileData);

			//you need to sort these two arrays first, and also if they are both empty ignore the entire option altogether.

			if(  selectiveCaseRange.Count() > 0 )

				{

				CleanupStack::PushL(selTestCfgFileData);

				TLinearOrder<TRange> orderingrng(TRange::CompareTRangeStartOrder) ; 

				selectiveCaseRange.Sort(orderingrng );

				ESelectiveTesting selectiveTestingType(iExclusive);

				if(includeSelectiveCases)

					{

					selectiveTestingType = iInclusive ; 

					}

				selTestingOptions = new(ELeave) TSelectiveTestingOptions(selectiveCaseRange, selectiveTestingType);

				}

			else

				{

				//if no arguments to this option have been found, ignore it...

				includeSelectiveCases =EFalse;

				excludeSelectiveCases =EFalse;

				delete selTestCfgFileData;

				}

			}

		}

	if (scriptFilePath.CompareF(KNull)==0)

		{

		if (!separateLogFiles && !justInTime)

			{

			// Print the product version details through console window

			console->Printf(KTEFVersionMessage);

			console->Printf(KTEFProductVersion);

			if (!(versionRequest && !helpRequest))

				{

				// Print the help & usage informations through console window along with product version

				console->Printf(KTEFConsoleHelpMessage1);

				console->Printf(KTEFConsoleHelpMessage2);

				console->Printf(KTEFConsoleHelpMessage3);

				console->Printf(KTEFConsoleHelpMessage4);

				console->Printf(KTEFConsoleHelpMessage5);

				}

			}

		else

			{

			// Display a error message on the console window for invalid set of arguments

			console->Printf(KTEFInvalidCommandSetMessage);

			}

		// Exit on a key press from user

		console->Printf(KTEFEnterKeyMessage);

		console->Getch();

		}

	else

		{

		// Create a Interface class object for generating HTML & XML logs

		CTestExecuteLogger *tefLogger = new(ELeave) CTestExecuteLogger();

		CleanupStack::PushL(tefLogger);

		TInt logMode;

		TInt logLevel;

		TInt remotePanicDetection;

		TBuf<KMaxTestExecuteNameLength> iniSysDrive;

		if (parseTestExecuteIni != NULL)

			{

			// Parse ini for retrieving logging options set through ini

			parseTestExecuteIni->GetKeyValueFromIni(KTEFLogMode, logMode);

			parseTestExecuteIni->GetKeyValueFromIni(KTEFLogSeverityKey, logLevel);

			parseTestExecuteIni->GetKeyValueFromIni(KTEFRemotePanicDetection, remotePanicDetection);

			parseTestExecuteIni->GetKeyValueFromIni(KTEFDefaultSysDrive, iniSysDrive);

			parseTestExecuteIni->GetKeyValueFromIni(KTEFWaitForLoggingTime, waitForLoggingTime);

			parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, htmlLogPath);

			}

		else

			{

			// Set default values for logging options if parser is not functioning

			logMode = TLoggerOptions(ELogHTMLOnly);

			logLevel = RFileFlogger::TLogSeverity(ESevrAll);

			remotePanicDetection = 0;

			iniSysDrive.Copy(KTEFIniSysDrive);

			waitForLoggingTime = 5;

			htmlLogPath.Copy(KTestExecuteLogPath);

			htmlLogPath.Replace(0, 2, defaultSysDrive);

			}

		tefLogger->SetLoggerOptions(logMode);

		if(pipe)

			{

			tefLogger->SetPipeName(pipeName) ; 

			}

		// Initialise the logging passing in the script file path & log level to the interface

		tefLogger->InitialiseLoggingL(scriptFilePath, separateLogFiles, logLevel);

		// Check to see if defaultsysdrive key is set in testexecute.ini

		// if set to SYSDRIVE, assign the default system drive obtained from the plugin

		// else, if a true value is set in testexecute.ini, use it as system drive for all test artifacts

		if (iniSysDrive.Length() == 2 && iniSysDrive.Right(1).Compare(KTEFColon) == 0)

			testSysDrive.Copy(iniSysDrive);

		else if (iniSysDrive.CompareF(KTEFIniSysDrive) == 0)

			testSysDrive.Copy(defaultSysDrive);

		// Pass the first command line argument to the script master

		// which is always the command script

		CScriptMaster* scriptMaster = new (ELeave) CScriptMaster(scriptFilePath,*tefLogger, consoleLogger, defaultSysDrive, testSysDrive, selTestingOptions);

		// To kick the state machine of the script master off -

		// Call the kick method which jumps us into the RunL() of the CScriptMaster class

		// CScriptMaster is the top AO in the hierarchy.

		scriptMaster->Kick();

		// Construct and Install a test watcher object for capturing remote panics during test execution

		CTestWatcher* testWatcher = NULL;

		if (remotePanicDetection != 0)

			{

			testWatcher = CTestWatcher::NewL();

			testWatcher->StartL();

			}

		// Enter the Active Scheduler