/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#define __INCLUDE_CAPABILITY_NAMES__

#include <e32test.h>

#include <f32file.h>

#include <test/testexecutelogger.h>

#include "tuiscriptadaptors.h"

#include <tconvbase64.h>

#include "languagetable.h"

#include "swispubsubdefs.h"

#include <swi/launcher.h>

#include <e32capability.h>

#include <utf.h>

using namespace Swi;

using namespace Swi::Test;

using namespace Xml;

_LIT8(KParserDataType, "text/xml");

_LIT8(KTrueValue,      "true");

_LIT8(KFalseValue,     "false");

_LIT8(KIndexType,      "item");

_LIT8(KReturnType,     "return");

_LIT8(KDialogName,     "dialog");

_LIT8(KUpdateProgressReturn, "updateprogressreturn");

_LIT8(KUpdateProgressFinalReturn, "updateprogressfinalreturn");

enum TDialogs

		{

		KDisplayInstall1      = 1, 

		KDisplayLanguage1,

		KDisplayDrive1,

		KDisplayUpgrade1,	

		KDisplayOptions1,

		KDisplaySecurityWarning1,

		KDisplayOcspResult1,

		KDisplayCannotOverwriteFile1,

		KDisplayUninstall1,

		KDisplayText1,

		KDisplayError1,

		KDisplayDependencyBreak1,

		KDisplayApplicationsInUse1,

		KDisplayQuestion1,

		KDisplayMissingDependency1,

		KInstallEvenDialogSetProgressBar,

		KInstallEvenDialogUpdateProgressBar,

		KInstallEvenDialogCompletedInstall,

		KInstallEvenDialogOcspCheckEnd,

		KInstallEvenDialogCompletedUnInstall,

		KInstallEvenDevCert,

		KCancelInstallRemoving,

		KCancelInstallShuttingDown,

		KCancelInstallCopyingFiles,

		KCancelInstallOcspCheckStart

		};

/* Functions Literals */

_LIT8(KDisplayInstall,               "DisplayInstall");

_LIT8(KDisplayGrantCapabilities,     "DisplayGrantCapabilities");

_LIT8(KDisplayLanguage,              "DisplayLanguage");

_LIT8(KDisplayDrive,                 "DisplayDrive");

_LIT8(KDisplayUpgrade,               "DisplayUpgrade");

_LIT8(KDisplayOptions,               "DisplayOptions");

_LIT8(KHandleInstallEvent,           "HandleInstallEvent");

_LIT8(KHandleCancellableInstallEvent,"HandleCancellableInstallEvent");

_LIT8(KDisplaySecurityWarning,       "DisplaySecurityWarning");

_LIT8(KDisplayOcspResult,            "DisplayOcspResult");

_LIT8(KDisplayCannotOverwriteFile,   "DisplayCannotOverwriteFile");

_LIT8(KDisplayUninstall,             "DisplayUninstall");

_LIT8(KDisplayText,                  "DisplayText");

_LIT8(KDisplayError,                 "DisplayError");

_LIT8(KDisplayDependencyBreak,       "DisplayDependencyBreak");

_LIT8(KDisplayApplicationsInUse,     "DisplayApplicationsInUse");

_LIT8(KDisplayQuestion,              "DisplayQuestion");

_LIT8(KDisplayMissingDependency,     "DisplayMissingDependency");

_LIT8(KDisplaySIDMismatch,           "DisplaySIDMismatch"); 

#define	KGenericBufferSize		      100

// Init defaults which will be overridden by script data (or not)

TXmlFileData::TXmlFileData()

	: InstallResult(ETrue)

	, CapabilitiesResult(ETrue)

	, LanguagesResult(0)

	, DriveResult('c'-'a') // Default to installing to C:

	, UpgradeResult(ETrue)

	, OptionsResult(ETrue)

	, WarningResult(ETrue)

	, OcspResult(ETrue)

	, UninstallResult(ETrue)

	, TextResult(ETrue)

	, DependencyResult(EFalse)

	, ApplicationsInUseResult(ETrue)

	, QuestionResult(EFalse)

	, MissingDependencyResult(EFalse)

	, DevCertsResult(ETrue)

	, UpdateProgressBarResult(ETrue)

	, ProgressBarFinalValueResult(ETrue)

	{

	}

CUIScriptAdaptor::CUIScriptAdaptor(const TFileName& aXmlFileName,

								   CTestExecuteLogger& aLogger,

								   RArray<TTableOfInstallSizes>* aExpectedValue)

	: 

	iXmlFileName(aXmlFileName),

	iLogger(aLogger),

	iExpectedValue(aExpectedValue),

	iDelayDialogNumber(-1)

	{

	}

CUIScriptAdaptor* CUIScriptAdaptor::NewLC(const TFileName& aXmlFileName,

										  CTestExecuteLogger& aLogger,

										  RArray<TTableOfInstallSizes>* aExpectedValue)

	{

	CUIScriptAdaptor* self = new(ELeave) CUIScriptAdaptor(aXmlFileName, aLogger, aExpectedValue);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CUIScriptAdaptor* CUIScriptAdaptor::NewL(const TFileName& aXmlFileName, 

										 CTestExecuteLogger& aLogger,

										 RArray<TTableOfInstallSizes>* aExpectedValue)

	{

	CUIScriptAdaptor* self = NewLC(aXmlFileName, aLogger, aExpectedValue);

	CleanupStack::Pop(self);

	return self;

	}

CUIScriptAdaptor::CUIScriptAdaptor(const TFileName& aXmlFileName,

								   CTestExecuteLogger& aLogger,

								   TPtrC aExpectedText,

								   TPtrC aTextIsHash,

								   TInt aExpectedDailog,

								   TInt aKerrCode)

	: 

	iXmlFileName(aXmlFileName),

	iLogger(aLogger),

	iExpectedDisplayText(aExpectedText),

	iExpectedHash(aTextIsHash),

	iExpectedDialog(aExpectedDailog),

	iKerrCode(aKerrCode),

	iDelayDialogNumber(-1),

	iDisplayedTextActual(NULL)

	{

	}

CUIScriptAdaptor* CUIScriptAdaptor::NewLC(const TFileName& aXmlFileName,

										  CTestExecuteLogger& aLogger,

										  TPtrC aExpectedText,

										  TPtrC aTextIsHash,

										  TInt aExpectedDailog,

										  TInt aKerrCode

										  )

	{

	CUIScriptAdaptor* self = new(ELeave) CUIScriptAdaptor(aXmlFileName, aLogger, aExpectedText, aTextIsHash, aExpectedDailog, aKerrCode);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CUIScriptAdaptor* CUIScriptAdaptor::NewL(const TFileName& aXmlFileName, 

										 CTestExecuteLogger& aLogger,

	   								     TPtrC aExpectedText,

	   								     TPtrC aTextIsHash,

	   								     TInt aExpectedDailog,

										 TInt aKerrCode

	   								     )

	{

	CUIScriptAdaptor* self = NewLC(aXmlFileName, aLogger, aExpectedText,aTextIsHash, aExpectedDailog, aKerrCode);

	CleanupStack::Pop(self);

	return self;

	}	

void CUIScriptAdaptor::ConstructL()

	{

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

	ScriptParseL();

	}

CUIScriptAdaptor::~CUIScriptAdaptor()

	{

	iResult.OptionSelection.Close();

	iFs.Close();

    iObservedOcspOutcomes.ResetAndDestroy();

    delete iFileOwner;

   	delete iDisplayedTextActual;

	}

/**

 * The function is called to parse the XML file.

 */

void CUIScriptAdaptor::ScriptParseL()

	{

	CRebuildingContentHandler* contentHandler = 

		CRebuildingContentHandler::NewLC(iLogger);

	// Open parser session

	CParser* parser = CParser::NewLC(KParserDataType, *contentHandler);

	// Starts parser session and active scheduler.

	INFO_PRINTF1(_L("Parsing XML..."));

	ParseL(*parser, iFs, iXmlFileName);

	iResult = contentHandler->GetOptions();

	CleanupStack::PopAndDestroy(2, contentHandler); // parser, contentHandler

	}

/**

 * Extracts the nPos command line argument.

 */

HBufC* GetArgumentL(TInt nPos)

	{

	HBufC *argv = HBufC::NewLC(User::CommandLineLength());

	TPtr cmd(argv->Des());

	User::CommandLine(cmd);

	TLex arguments(cmd);

	// finds nth parameter

	while(nPos && !arguments.Eos())

		{

		TPtrC token = arguments.NextToken();

		if(token.Length() > 0)

			{

			nPos--;

			}

		}

	HBufC* result = NULL;

	if(!arguments.Eos())

		{

		TPtrC testfile(arguments.NextToken());

		if(testfile.Length() > 0)

			{

			result = testfile.AllocL();

			}

		};

	// no parameter found, but must return something so..

	if(!result)

		{

		result = HBufC::NewL(0);

		}

	CleanupStack::PopAndDestroy(argv);

	return result;

	}

CRebuildingContentHandler* CRebuildingContentHandler::NewLC(

	CTestExecuteLogger& aLogger)

	{

	CRebuildingContentHandler* self = new(ELeave) CRebuildingContentHandler(

		aLogger);

	CleanupStack::PushL(self);

	return self;

	}

CRebuildingContentHandler* CRebuildingContentHandler::NewL(

	CTestExecuteLogger& aLogger)

	{

	CRebuildingContentHandler* self = new(ELeave) CRebuildingContentHandler(

		aLogger);

	return self;

	}

CRebuildingContentHandler::CRebuildingContentHandler(

	CTestExecuteLogger& aLogger)

	: 

	iError(KErrNone), 

	iLogger(aLogger),

	iLevel1(EScript)

	{

	}

CRebuildingContentHandler::~CRebuildingContentHandler()

	{

	}

void CRebuildingContentHandler::OnStartDocumentL(const RDocumentParameters& 

											/*aDocParam*/, TInt aErrorCode)

	{

	User::LeaveIfError(aErrorCode);

	}

void CRebuildingContentHandler::OnEndDocumentL(TInt aErrorCode)

	{

	User::LeaveIfError(aErrorCode);

	}

void CRebuildingContentHandler::OnStartElementL(const RTagInfo& aElement, 

						const RAttributeArray& aAttributes, TInt aErrorCode)

	{

	User::LeaveIfError(aErrorCode);

	TInt nAttributes = aAttributes.Count();

	for(TInt i=0; i<nAttributes; i++)

		{

		const RAttribute& attribute = aAttributes[i];

		const TDesC8& value8 = attribute.Value().DesC();

		const TDesC8& tagname8 = aElement.LocalName().DesC();

		switch(iLevel1)

			{

			case EScript:

				if(value8.Compare(KDisplaySIDMismatch)==KErrNone)

					{

					 iLevel1 = EDisplaySIDMismatch;

					  break;

					}

				else if (value8.Compare(KDisplayInstall) == KErrNone )

					{

					iLevel1 = EDisplayInstall;

					break;

					}

				else if (value8.Compare(KDisplayGrantCapabilities) == KErrNone)

					{

					iLevel1 = EDisplayGrantCapabilities;

					break;

					}

				else if (value8.Compare(KDisplayLanguage) == KErrNone )

					{

					iLevel1 = EDisplayLanguage;

					break;

					}

				else if (value8.Compare(KDisplayDrive) == KErrNone )

					{

					iLevel1 = EDisplayDrive;

					break;

					}

				else if (value8.Compare(KDisplayUpgrade) == KErrNone )

					{

					iLevel1 = EDisplayUpgrade;

					break;

					}

				else if (value8.Compare(KDisplayOptions) == KErrNone )

					{

					iLevel1 = EDisplayOptions;

					break;

					}

				else if (value8.Compare(KHandleInstallEvent) == KErrNone )

					{

					iLevel1 = EHandleInstallEvent;

					break;

					}

				else if (value8.Compare(KHandleCancellableInstallEvent) == KErrNone )

					{

					iLevel1 = EHandleCancellableInstallEvent;

					break;

					}

				else if (value8.Compare(KDisplaySecurityWarning) == KErrNone )

					{

					iLevel1 = EDisplaySecurityWarning;

					break;

					}

				else if (value8.Compare(KDisplayOcspResult) == KErrNone )

					{

					iLevel1 = EDisplayOcspResult;

					break;

					}

				else if (value8.Compare(KDisplayCannotOverwriteFile) == KErrNone )

					{

					iLevel1 = EDisplayCannotOverwriteFile;

					break;

					}

				else if (value8.Compare(KDisplayUninstall) == KErrNone )

					{

					iLevel1 = EDisplayUninstall;

					break;

					}

				else if (value8.Compare(KDisplayText) == KErrNone )

					{

					iLevel1 = EDisplayText;

					break;

					}

				else if (value8.Compare(KDisplayError) == KErrNone )

					{

					iLevel1 = EDisplayError;

					break;

					}

				else if (value8.Compare(KDisplayDependencyBreak) == KErrNone )

					{

					iLevel1 = EDisplayDependencyBreak;

					break;

					}

				else if (value8.Compare(KDisplayApplicationsInUse) == KErrNone )

					{

					iLevel1 = EDisplayApplicationsInUse;

					break;

					}

				else if (value8.Compare(KDisplayQuestion) == KErrNone )

					{

					iLevel1 = EDisplayQuestion;

					break;

					}

				else if (value8.Compare(KDisplayMissingDependency) == KErrNone )

					{

					iLevel1 = EDisplayMissingDependency;

					break;

					}

			case EDisplayInstall:

			case EDisplayGrantCapabilities:

			case EDisplayLanguage:

			case EDisplayDrive:

			case EDisplayUpgrade:

			case EHandleCancellableInstallEvent:

			case EDisplaySecurityWarning:

			case EDisplayOcspResult:

			case EDisplayCannotOverwriteFile:

			case EDisplayUninstall:

			case EDisplayText:

			case EDisplayError:

			case EDisplayDependencyBreak:

			case EDisplayApplicationsInUse:

			case EDisplayQuestion:

			case EDisplayMissingDependency:

			case EDisplaySIDMismatch:

				if ( tagname8.Compare(KReturnType) == KErrNone )

					{

					iLevel2 = EReturn;

					}

				break;

			case EDisplayOptions:

				if ( tagname8.Compare(KIndexType) == KErrNone )

					{

					iLevel3 = EItemIndex;

					}

				else if ( tagname8.Compare(KReturnType) == KErrNone )

						{

						iLevel2 = EReturn;

						}

				break;

			case EHandleInstallEvent:

				if ( tagname8.Compare(KUpdateProgressReturn) == KErrNone )

					{

					iLevel2 = EUpdateProgress;

					}

				else if (tagname8.Compare(KUpdateProgressFinalReturn) == KErrNone )

					{

					iLevel2 = EUpdateProgressFinal;

					}

				else if ( tagname8.Compare(KReturnType) == KErrNone )

					{

					iLevel2 = EReturn;

					}

				break;

			default:

				break;

			}

		}

	}

void CRebuildingContentHandler::OnEndElementL(const RTagInfo& aElement, 

												TInt aErrorCode)

	{

	User::LeaveIfError(aErrorCode);

	const TDesC8& localPart8 = aElement.LocalName().DesC();

	if ( localPart8.Compare(KDialogName) == KErrNone )

		{

		iLevel1 = EScript;

		iLevel2 = KErrNone;

		iLevel3 = KErrNone;

		}

	}

void CRebuildingContentHandler::OnContentL(const TDesC8& aData8, 

												TInt aErrorCode)

	{

	User::LeaveIfError(aErrorCode);

	switch(iLevel1)

		{

		case EDisplayInstall:

			if ( iLevel2 == EReturn )	

				{

				if ( aData8.Compare(KTrueValue) == KErrNone )

					{

					INFO_PRINTF1(_L("DisplayInstallL will return ETrue"));

					iResult.InstallResult = ETrue;

					}

				else if ( aData8.Compare(KFalseValue) == KErrNone )

					{

					INFO_PRINTF1(_L("DisplayInstallL will return EFalse"));

					iResult.InstallResult = EFalse;

					}

				}

			break;

		case EDisplayGrantCapabilities:

			if ( iLevel2 == EReturn )	

				{

				if ( aData8.Compare(KTrueValue) == KErrNone )

					{

					INFO_PRINTF1(_L("DisplayGrantCapabilitiesL will return ETrue"));

					iResult.CapabilitiesResult = ETrue;

					}

				else if ( aData8.Compare(KFalseValue) == KErrNone )

					{

					INFO_PRINTF1(_L("DisplayGrantCapabilitiesL will return EFalse"));

					iResult.CapabilitiesResult = EFalse;

					}

				}

			break;

		case EDisplayLanguage:

			if ( iLevel2 == EReturn )	

				{

				TName	tagdata;