// Copyright (c) 2002-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:
// $Header$
// GT0149 Applications Protocol Integration Test Harness
// blank application
// created by: mark j davey
// mjd systems solutions ltd
// mark@mjdss.com
// This is the 'main' code entry point for the Test Harness Application.
// As other projects adopt policy, then separate DLL's will be created for
// each group which can be specified (or colocated) for inclusion.
// This way the harness is sanitized from the project knowledge domain
// 
//

#include <e32base.h>
#include <e32cons.h>
#include <uri8.h>
#include <bacline.h>

//----------------------------------------------------------------------------
//  application specific includes

#include "GT0149.h"
#include "ECommandIDs.h"
#include "ErrorCodes.h"
#include "TEngine.h"
#include "CCmdFamily.h"
#include "CCmdBase.h"
#include "CCmdStandard.h"
#include "CCmdMisc.h"
#include "CCmdLog.h"
#include "CLogFile.h"
#include "HttpSessionCmds.h"
#include "HttpTransactionCmds.h"

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

#if defined (HTTP_INTEGRATION)

// for StartC32()
#if !defined __C32COMM_H__
	#include <c32comm.h>
#endif

#if !defined __IN_SOCK_H__
	#include <in_sock.h>
#endif

#if defined (__WINS__)
	#define PDD_NAME		_L("ECDRV")
#else
	#define PDD_NAME		_L("EUART1")
	#define PDD2_NAME		_L("EUART2")
	#define PDD3_NAME		_L("EUART3")
	#define PDD4_NAME		_L("EUART4")
#endif

#define LDD_NAME		_L("ECOMM")

//----------------------------------------------------------------------------
//	Integration Domain specific includes

#include "CHTTPFamily.h"

#endif

//----------------------------------------------------------------------------
//  create this (Console) ONLY if we're NOT being driven from the command line

LOCAL_D CConsoleBase *Console;

//----------------------------------------------------------------------------
//	Global Defines for 

GLDEF_D TBool exitConsoleAtExit = ETrue;
GLDEF_D TBool consoleRequired = EFalse;
GLDEF_D TBool debugRequired = EFalse;
GLDEF_D TInt sysError = KErrNone;
TPtrC ScriptFilename;
TBuf<256> Arguments;
TInt nArgs;

//----------------------------------------------------------------------------
//  method defs

LOCAL_C TInt ExecuteManagerL(void);
LOCAL_C TInt CreateFrameworkCommandsL(CCmdFamily *);
LOCAL_C void TestHarnessMainL(void);
LOCAL_C void pressAnyKey(void);
LOCAL_C void reportError(void);
LOCAL_C void processCommandLine(void);

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

#if defined (HTTP_INTEGRATION)

//	specialist commands here...
//	ideally this is a method from a dynamically loaded DLL...

LOCAL_C void InitCommsL();
LOCAL_C TInt CreateHTTPIntegrationCommands(CCmdFamily *);


#endif

//----------------------------------------------------------------------------
//	Register the fundamental 'framework' commands

LOCAL_C TInt CreateFrameworkCommandsL(CCmdFamily *aList)
{
aList->RegisterL(CCmdRemark::NewL(THA_KCmdRemark, THA_TxtCmdRemark)); 
aList->RegisterL(CCmdRemark::NewL(THA_KCmdComment, THA_TxtCmdComment)); 

aList->RegisterL(CCmdExit::NewL(THA_KCmdExit, THA_TxtCmdExit )); 
aList->RegisterL(CCmdExit::NewL(THA_KCmdExit, THA_TxtCmdQuit )); 
aList->RegisterL(CCmdExit::NewL(THA_KCmdExit, THA_TxtCmdStop )); 

aList->RegisterL(CCmdEchoMode::NewL( THA_KCmdEchoMode, THA_TxtCmdEchoMode));

aList->RegisterL(CCmdPause::NewL(THA_KCmdPause, THA_TxtCmdPause));

aList->RegisterL(CCmdHold::NewL(THA_KCmdHold, THA_TxtCmdHold));
aList->RegisterL(CCmdLogPath::NewL(THA_KCmdLogPath, THA_TxtCmdLogPath));
aList->RegisterL(CCmdLogFile::NewL(THA_KCmdLogFile, THA_TxtCmdLogFile));
aList->RegisterL(CCmdEndLog::NewL(THA_KCmdEndLog, THA_TxtCmdEndLog));

aList->RegisterL(CCmdSetPrompt::NewL(THA_KCmdSetPrompt, THA_TxtCmdSetPrompt));
aList->RegisterL(CCmdSetPath::NewL(THA_KCmdSetPath, THA_TxtCmdSetPath));

aList->RegisterL(CCmdCall::NewL(THA_KCmdCall, THA_TxtCmdCall, THA_TxtCmdCallHelp));

aList->RegisterL(CCmdReturn::NewL(THA_KCmdReturn, THA_TxtCmdReturn));
aList->RegisterL(CCmdCheckMode::NewL(THA_KCmdCheckMode, THA_TxtCmdCheckMode));
aList->RegisterL(CCmdPrint::NewL(THA_KCmdPrint, THA_TxtCmdPrint, THA_TxtCmdPrintHelp));

aList->RegisterL(CCmdDefine::NewL(THA_KCmdDefine, THA_TxtCmdDefine, THA_TxtCmdDefineHelp));
aList->RegisterL(CCmdListAll::NewL(THA_KCmdListAll, THA_TxtCmdListAll, THA_TxtCmdListAllHelp)); 

//	new command: IF, ELSE, ENDIF
aList->RegisterL(CCmdIf::NewL(THA_KCmdIf, THA_TxtCmdIf, THA_TxtCmdIfHelp)); 
aList->RegisterL(CCmdElse::NewL(THA_KCmdElse, THA_TxtCmdElse, THA_TxtCmdElseHelp)); 
aList->RegisterL(CCmdEndIf::NewL(THA_KCmdEndIf, THA_TxtCmdEndIf, THA_TxtCmdEndIfHelp)); 

// Register CASE and SELECT COMMANDS (TVi)
aList->RegisterL(CCmdCase::NewL(ECase, KTxtCase));
aList->RegisterL(CCmdEndCase::NewL(EEndCase, KTxtEndCase));
aList->RegisterL(CCmdSelect::NewL(ECmdSelect, KTxtCmdSelect));

return KErrNone;
}

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

#if defined (HTTP_INTEGRATION)

//----------------------------------------------------------------------------
//	provide any framework infrastructure configuration

LOCAL_C void InitCommsL()
{
TInt ret = User::LoadPhysicalDevice(PDD_NAME);
User::LeaveIfError(ret == KErrAlreadyExists ? KErrNone : ret);

#ifndef __WINS__
ret = User::LoadPhysicalDevice(PDD2_NAME);
ret = User::LoadPhysicalDevice(PDD3_NAME);
ret = User::LoadPhysicalDevice(PDD4_NAME);
#endif

ret = User::LoadLogicalDevice(LDD_NAME);
User::LeaveIfError(ret == KErrAlreadyExists?KErrNone:ret);
ret = StartC32();
User::LeaveIfError(ret == KErrAlreadyExists?KErrNone:ret);
}

//----------------------------------------------------------------------------
//	Register the fundamental 'framework' commands

LOCAL_C TInt CreateHTTPIntegrationCommands(CCmdFamily *aList)
{
aList->RegisterL(CCmdConnect::NewL(THA_KHTTP_Connect, THA_TxtCmdConnect, THA_TxtCmdConnectHelp)); 
aList->RegisterL(CCmdDisconnect::NewL(THA_KHTTP_Disconnect, THA_TxtCmdDisconnect, THA_TxtCmdDisconnectHelp)); 
aList->RegisterL(CCmdTransaction::NewL(THA_KHTTP_Transaction, THA_TxtCmdTransaction, THA_TxtCmdTransactionHelp)); 
aList->RegisterL(CCmdEndTransaction::NewL(THA_KHTTP_EndTransaction, THA_TxtCmdEndTrans, THA_TxtCmdEndTransHelp)); 
aList->RegisterL(CCmdShowTransaction::NewL(THA_KHTTP_ShowTransaction, THA_TxtCmdShowTrans, THA_TxtCmdShowTransHelp)); 

return KErrNone;
}

#endif

//----------------------------------------------------------------------------
//	This is where it's at
//	
//	Create the scheduler, the Command Tree, Look for PlugIn Language DLL's etc
//	Offer Console *or* script processing

LOCAL_C TInt ExecuteManagerL(void)
{
TInt StackObjects = 0;

//	Create scheduler etc
CActiveScheduler *Scheduler = new (ELeave) CActiveScheduler;
CleanupStack::PushL(Scheduler);
++StackObjects;

//	no problems, so install it
CActiveScheduler::Install(Scheduler);

if (Console)
	Console->Printf(KTHAWelcomeMessage);

//	create the Test Engine and get it cracking...
CTEngine *Engine = CTEngine::NewLC(Console);
++StackObjects;

//	create command list and register

CCmdFamily *Commands = CCmdFamily::NewLC();
++StackObjects;

if (Engine)
	{

	//	we have a basic 'set' of framework commands that are applicable whatever the project
	//	area. as a result these are 'static'
	CreateFrameworkCommandsL(Commands);

	//	now determine if there are any app specific commands to add to 'Commands'
	//	since this is the 'dynamic' part of the system. All the project commands are
	//	to be supplied in a separate '.dll' which we load and append the commands.
	//	e.g.	we have a set of WAP framework commands
	//	CreateWAPFrameworkCommandsL(Commands);

#if defined (HTTP_INTEGRATION)

	InitCommsL();

	//	ideally do search and load of "dll's"
	CreateHTTPIntegrationCommands(Commands);

#endif

	//	now register the command list to the Test Harness Engine
	Engine->SetCmdFamily(Commands);

	//	Set our own prompt for the console
	if (Console)
		(void) Engine->SetPrompt(THA_CommandPrompt);

	if (nArgs > 1)
		sysError = Engine->Run(ScriptFilename, Arguments);
	else
		{
		sysError = KErrNone;
		Engine->Run();
		}
	}
else
	sysError = KErrUnabletoCreateTestEngine;

//	and start it!
if (sysError != KErrNone)
	//	reset the scheduler to run 'as interactive'
	Engine->Run();

//	kick off the scheduler...
CActiveScheduler::Start();

//  finish Console

	CleanupStack::PopAndDestroy(StackObjects); 

//	unnecessary (since global!)
return sysError;
}
 
//----------------------------------------------------------------------------
//  must have some command lines. 
//  <scriptname[.ths]> must be first parameter
//  -c = Console required once script executed
//  -d = debug mode on (log to Console as well)
//  read the command line
//  If we've got a script provided, then do not create a Console object
//  unless we have a -d (for debug) mode command

LOCAL_C void processCommandLine(void)
{
TInt iIgnore;
CCommandLineArguments *cmdArgs = CCommandLineArguments::NewLC();

nArgs = cmdArgs->Count();
iIgnore = nArgs;
if (nArgs == 1)  //  arg(0) is '.exe' name (arg==1)
	// no args (apart from Exename) means assume Interactive (Console) session required
  consoleRequired = ETrue;

else
	{
	//  get the Command File name - why?
	TPtrC ExeFilename;
	ExeFilename.Set(cmdArgs->Arg(0));

	//  construct call arguments
	for (TInt i = 1; i < nArgs; ++i)
		{
		//  look for command/control flags
		TInt Pos = cmdArgs->Arg(i).Find(KControlFlagSeparator);
		if (Pos != KErrNotFound)
			{
			//	valid argument (i.e. has a - in front) but is it supported?
			//	require a Console? (Console created and displayed once script 
			if (cmdArgs->Arg(i).Find(KControlFlagRequiredScript) != KErrNotFound)
				{
				//	remove the -s from the filename and do not add this to the 
				//	argument list				
				//ScriptFilename.Set(cmdArgs->Arg(i).Mid(2));
				ScriptFilename.Set(cmdArgs->Arg(i).Mid(KControlFlagRequiredScript().Length()));
				sysError = KSysCmdParameter;
				}

			//	require a Console? (Console created and displayed once script 
			else if (cmdArgs->Arg(i).Find(KControlFlagRequireConsole) != KErrNotFound)
				{
				consoleRequired = ETrue;
				sysError = KSysCmdParameter;
				--iIgnore;
				}

			else if (cmdArgs->Arg(i).Find(KControlFlagDebugViaConsole) != KErrNotFound)
				{
				debugRequired = ETrue;
				consoleRequired = ETrue;
				sysError = KSysCmdParameter;
				--iIgnore;
				}

			else
				sysError = KErrCommandFlagNotDefined;
			}

		//	get the args - use spaces to separate and 'fill out'
		Arguments.Append(_L(" "));          //  put a space in between them!
		if (sysError == KAppendParameter)
			Arguments.Append(cmdArgs->Arg(i));  //  copy in the argument

		}
	}

//	update the num args to those we're really interested in
nArgs = iIgnore;

//	clear the error
sysError = KErrNone;

//	no longer need them (args) so delete them!
CleanupStack::PopAndDestroy();
}

//----------------------------------------------------------------------------
//  Application Start Point
//  Integration Test Harness
//
//  The application can be passed a parameter <scriptname> which is autoexecuted

LOCAL_C void TestHarnessMainL(void)
{
TInt StackObjects = 0;

//	see what's cooking on the command line...
processCommandLine();

//	create the Console if required and title it
Console = Console::NewL(_L("GT0149 Integration Test Harness"), TSize(KConsFullScreen, KConsFullScreen));
CleanupStack::PushL(Console);
++StackObjects;

//	execute the bit we want

if (sysError == KErrNone)
	TRAP(sysError, ExecuteManagerL());

//	report any errors
if (sysError != KErrNone)
	{
	reportError();
	if (nArgs != 1)  //  arg(0) is '.exe' name (arg==1)
		pressAnyKey();
	}

//  inform user we're closing...
if (Console)
	{
	Console->Printf(_L("\r\n[press any key]"));
		
	//  get the keypress
	Console->Getch();
	}

//  finish Console
if (StackObjects > 0)
	CleanupStack::PopAndDestroy(StackObjects); //  2=Console & cmdArgs
}

//----------------------------------------------------------------------------
//	simple log error message

LOCAL_C void reportError()
{
if (Console)
  {
	Console->Printf(_L("\r\nThe following error code was returned: %d"), sysError);
	Console->Printf(_L("\r\nPlease report this to the appropriate project team"));
	}
}

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

LOCAL_C void pressAnyKey()
{
if (Console)
	{
	Console->Printf(_L("\r\n[Press any key]"));
	Console->Getch();
	Console->Printf(_L("\n"));
	}
}

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

GLDEF_C TInt E32Main()
// Main program - run the Test Harness within a TRAP harness, reporting any errors that
// occur via the panic mechanism. Test for memory leaks using heap marking.
{
__UHEAP_MARK;
CTrapCleanup* tc = CTrapCleanup::New();

TRAPD(err, TestHarnessMainL());
if (err!=KErrNone)
	User::Panic(_L("\r\nIntegration Test Harness failed with error code: %i"), err);

  delete tc;

__UHEAP_MARKEND;
return KErrNone;
}

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