// Copyright (c) 2007-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:
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code 
*/

#include <e32base.h>
#include <e32debug.h>
#include <f32file.h>
#include <e32const.h>
#include <bautils.h>
#include <bacline.h>
#include <apacmdln.h>
#include <utf.h>
#include <test/testexecutestepbase.h>
#include <cinidata.h>
#include <sysmonclisess.h>

#include "tamastarter_constants.h"

_LIT(KAmaStarterTestAppPanic, "AmaStarterTestApp");


//Function to create the new file if it does not exists.
void CreateResultFileL(const TDesC& aFileName)
	{
	RFs fs;
	User::LeaveIfError(fs.Connect());	
	CleanupClosePushL(fs);
	
	if (!BaflUtils::FileExists(fs, aFileName))
		{
		// Create the folder if it does not exist
		TInt ret = fs.MkDirAll(KTestAppResultsPath);
		if (ret != KErrAlreadyExists)
			{
			User::LeaveIfError(ret);
			}
		
		RFile	resultFile;
		ret = resultFile.Create(fs, aFileName, EFileShareExclusive); //CIniData isn't thread safe
		resultFile.Close();
		User::LeaveIfError(ret);
		}
	
	CleanupStack::PopAndDestroy(&fs);
	}



// Set the counter value to '0' in case it does not exists.
void InitCounterL(CIniData& aIniData, const TDesC& aSection, const TDesC& aKey)
	{
	TInt value = 0;
	TBool readResult = aIniData.FindVar(aSection, aKey, value);
	if (!readResult)
		{
		TBuf<2> descVal;
		descVal.Num(value);
		User::LeaveIfError(aIniData.AddValue(aSection, aKey, descVal));		
		aIniData.WriteToFileL();
		}
	}

// Get the counter value from the data (log) file.
TInt GetCounter(CIniData& aIniData, const TDesC& aSection, const TDesC& aKey)
	{
	TInt value = 0;
	aIniData.FindVar(aSection, aKey, value);
	return value;
	}


// IncrementCounter increment the counter value by '1'
void IncrementCounterL(CIniData& aIniData, const TDesC& aSection, const TDesC& aKey)
	{
	TInt value = 1 + GetCounter(aIniData, aSection, aKey);
	TBuf<2> descVal;
	descVal.Num(value);
	User::LeaveIfError(aIniData.SetValue(aSection, aKey, descVal));
	aIniData.WriteToFileL();
	}


//StartTestL processes the command line, and appropriately updates the various counters
//(Sucessful, failure, panic etc) depending on the arguments provided during the launch.
//The EXE name is used as section name where all the counters will be added/updated.
//This way each EXE launched will update its own result in the section in the result
//file. The result file name is expected to be provided as an command line argument for the
//result of the launch of this test EXE to be logged.
void StartTestL(void)
	{
	//Get the executable filename
	RProcess testApp;
	TParse parse;
	parse.Set(testApp.FullName(), NULL, NULL);
	
	TTime starttime;
	starttime.UniversalTime();
	TFileName fileForLog(parse.Name());
	RDebug::Print( _L("*** %S::StartTestL - entry at time %d:%d.%d"), &fileForLog, starttime.DateTime().Minute(), starttime.DateTime().Second(), starttime.DateTime().MicroSecond());

	HBufC* commandLineDes = NULL;	
	//EXE is launched as new process
	if ( User::CommandLineLength() > 0 )
		{
		commandLineDes = HBufC::New(User::CommandLineLength());
		TPtr cmd = commandLineDes->Des();
		User::CommandLine(cmd);
		}
	//EXE is launched as APP
	else
		{
		CApaCommandLine*	apaCmdLine = NULL;
		CApaCommandLine::GetCommandLineFromProcessEnvironment(apaCmdLine);
		CleanupStack::PushL(apaCmdLine);		
		commandLineDes = CnvUtfConverter::ConvertToUnicodeFromUtf8L(apaCmdLine->TailEnd());
		CleanupStack::PopAndDestroy(apaCmdLine);
		}
	
	CleanupStack::PushL(commandLineDes);
	TLex cmdLine = commandLineDes->Des();
	
	TInt	timeout = 0;
	TInt	retriedCount = 0;
	
	TInt	err = KErrNone;
	TBool	toLeave = EFalse;
	
	TInt	panic = 0;
	TBool	toPanic = EFalse;
	
	TInt	rend = KErrNone;
	TBool	toRend = EFalse;
	
	TInt	cancelMonLaunch = 0;
	TBool	cancelMon = EFalse;
	
	TBuf<KMaxFileName>	fileName(KTestAppResultsPath);
	TPtrC ptr;

	for(ptr.Set(cmdLine.NextToken()) ; ptr.Length() ; ptr.Set(cmdLine.NextToken()))
		{
		//Result file name
		if ( !ptr.CompareF(KLog) )
			{
			fileName.Append(cmdLine.NextToken());
			fileName.Append(KTestLogFileExtension);
			CreateResultFileL(fileName);
			}
		//Rendezvous with
		else if ( !ptr.CompareF(KRendezvous) )
			{
			TLex	lex(cmdLine.NextToken());
			lex.Val(rend);
			toRend = ETrue;
			}
		//Timeout
		else if ( !ptr.CompareF(KTimeout) )
			{
			TLex	lex(cmdLine.NextToken());
			lex.Val(timeout);
			}
		//Retry count
		else if ( !ptr.CompareF(KRetry) )
			{
			TLex	lex(cmdLine.NextToken());
			lex.Val(retriedCount);
			}
		//Leave Error value
		else if ( !ptr.CompareF(KLeaveErrorValue) )
			{
			TLex	lex(cmdLine.NextToken());
			lex.Val(err);
			toLeave = ETrue;
			}
		//Panic
		else if ( !ptr.CompareF(KPanicValue) )
			{
			TLex	lex(cmdLine.NextToken());
			lex.Val(panic);
			toPanic = ETrue;
			}
		//Cancel monitoring after N launches/restarts
		else if ( !ptr.CompareF(KCancelMonitoring) )
			{
			TLex	lex(cmdLine.NextToken());
			lex.Val(cancelMonLaunch);
			cancelMon = ETrue;
			}	
		}
		
	CIniData* appResults = CIniData::NewL(fileName);
	CleanupStack::PushL(appResults);

	// Set all the counters to 0
	//  NOTE: This is done if the counter does not exist (otherwise, it keeps the old value)
	InitCounterL(*appResults, parse.Name(), KLaunchCntr);
	InitCounterL(*appResults, parse.Name(), KRetryCntr);
	InitCounterL(*appResults, parse.Name(), KSuccessCntr);
	InitCounterL(*appResults, parse.Name(), KPanicCntr);
	InitCounterL(*appResults, parse.Name(), KLeaveCntr);
	InitCounterL(*appResults, parse.Name(), KFailedCntr);

	// Update the Launch counter	
	IncrementCounterL(*appResults, parse.Name(), KLaunchCntr);

	// Update the Retry counter	
	if (retriedCount > 0)
		{
		TInt retryCntr = GetCounter(*appResults, parse.Name(), KRetryCntr);	

		//Check if app is to be timedout in case retry counter is set > 0
		if (retryCntr < retriedCount && timeout > 0)
			{
			IncrementCounterL(*appResults, parse.Name(), KRetryCntr);
			User::After(TTimeIntervalMicroSeconds32(timeout*1000));
			}
		}		

	// Update the Success counter (or Panic, or Leave)
	if (toPanic == EFalse && toLeave == EFalse && rend == KErrNone)
		{
		IncrementCounterL(*appResults, parse.Name(), KSuccessCntr);
		}
	else
		{
		if (toPanic)
			{
			IncrementCounterL(*appResults, parse.Name(), KPanicCntr);
			User::SetJustInTime(EFalse);
			User::Panic(KAmaStarterTestAppPanic,panic);			
			}
		if (toLeave)
			{
			IncrementCounterL(*appResults, parse.Name(), KLeaveCntr);
			User::Leave(err);
			}
		}

	// Update the Failed counter	
	if (toRend)
		{
		if (rend != KErrNone)
			{
			IncrementCounterL(*appResults, parse.Name(), KFailedCntr);
			}
		RProcess::Rendezvous(rend);
		}
	
	CleanupStack::PopAndDestroy(2); //cmdLine, iAppResults
	
	//Check if this app/process was asked to cancel its monitoring, after it has been
	//restarted/launched 'N' (cancelMonLaunch) times
	if (cancelMon)
		{
		TInt launchCntr = GetCounter(*appResults, parse.Name(), KLaunchCntr);
		if (launchCntr >= cancelMonLaunch)
			{
			//Wait for 25 secs to let process execution time get passed throttle time
			User::After(TTimeIntervalMicroSeconds32(25000000));
			RSysMonSession	sysMonSession;
			sysMonSession.CancelMonitorSelfL();
			}
		}
	
	TTime endtime;
	endtime.UniversalTime();
	RDebug::Print( _L("*** %S::StartTestL - exit at time %d:%d.%d"), &fileForLog, endtime.DateTime().Minute(), endtime.DateTime().Second(), endtime.DateTime().MicroSecond());
	}

TInt E32Main()
	{	
	__UHEAP_MARK;

	CTrapCleanup* theTrapCleanup = CTrapCleanup::New();

	TRAPD(err, StartTestL());
	if (err)
		{
		User::Panic(KAmaStarterTestAppPanic,err);
		}
    delete theTrapCleanup;

	__UHEAP_MARKEND;
	
	return KErrNone;
	}