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

//

#include <f32file.h>

#include <hal.h>

#include "TestMgr.h"

#include "DummyAgtRef.h"

#include "serial.h"

//

//indexes in TCommands array

//

CTestMgr::CTestMgr(CTestExecuteLogger& aLogger, CPPPANVL* aTestHarness)

	: CActive(CActive::EPriorityStandard), iLogger(aLogger), iTestHarness(aTestHarness), KCmdIDIndex(0),

	KIniIdIndex(1)

{

}

//

CTestMgr* 

CTestMgr::NewL(CTestExecuteLogger& aLogger, CPPPANVL* aTestHarness)

{

	CTestMgr* self = NewLC(aLogger, aTestHarness);

	CleanupStack::Pop();    // self

	return self;

}

//      

CTestMgr* 

CTestMgr::NewLC(CTestExecuteLogger& aLogger, CPPPANVL* aTestHarness)

{

	CTestMgr * self = new (ELeave) CTestMgr(aLogger, aTestHarness);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

void 

CTestMgr::ConstructL()

{

	ConfigureSerialL();

	//

	CActiveScheduler::Add(this);

	// Construct the send / recv AOs

	ipSerialRx = CSerialListener::NewL(&iCommPort, this);

	ipSerialTx = CSerialSender::NewL(&iCommPort, this);

	//

	ipDummyAgtRef=CDummyNifAgentRef::NewL(_L("aa"),*this, iLogger);

	//initial state

	iCurrentState=EIdle;

	// create a console to give the interactive user some progress feedback

	console = Console::NewL(_L("te_ppp progress"),TSize(KConsFullScreen,KConsFullScreen));

}

CTestMgr::~CTestMgr()

{

	delete console ;

	delete ipSerialRx;

	delete ipSerialTx;

	delete ipDummyAgtRef;

}

void 

CTestMgr::ConfigureSerialL()

{

	TInt err=iCommServer.Connect();

	MGR_TEST_CHECKL(err, KErrNone, _L("Failed comm server connect\n"));

	// ;

	// load CSY module - RS232

	TBuf<16> csyName;

	csyName.Copy(_L("ECUART"));     // RS232

	err=iCommServer.LoadCommModule(csyName);

	MGR_TEST_CHECKL(err,KErrNone,_L("Failed load comm module\n"));

	// Open comm port - available comm port depends on test platform

	TInt iMashineId=0;

	HAL::Get(HAL::EMachineUid,iMashineId);

	switch (iMashineId)

		{

		case HALData::EMachineUid_Assabet :

		case HALData::EMachineUid_Lubbock :

			err = iCommPort.Open(iCommServer, iData.KCtrlCommPortName4asbt, ECommShared) ;

			aPortNo = iData.KCtrlCommPortName4asbt [6] - '0' ;

			break ;

		// H2 target only possible for EKA2 kernel (see defs in HALData)

		case HALData::EMachineUid_OmapH2 :

			err = iCommPort.Open(iCommServer, iData.KCtrlCommPortName4H2, ECommShared) ;

			aPortNo = iData.KCtrlCommPortName4H2 [6] - '0' ;

			break ;

		default : // Emulator etc - generally port 1

			err = iCommPort.Open(iCommServer, iData.KCtrlCommPortName, ECommShared);

			if (err == KErrNone)

				{

				aPortNo = iData.KCtrlCommPortName [6] - '0' ;

				}

			else

				{					

				// though some machines use port 2 via USB

				err = iCommPort.Open(iCommServer, iData.KCtrlCommPortName4asbt, ECommShared);

				aPortNo = iData.KCtrlCommPortName4asbt [6] - '0' ;

				}

		}

	LOG_ERR_PRINTF2(_L("comm port open returned %d"),err);

	MGR_TEST_CHECKL(err,KErrNone,_L("Failed open commport \n"));

	// configure the physical port setttings

	TCommConfig portSettings;

	iCommPort.Config (portSettings);

	portSettings().iRate = EBps38400;

	portSettings().iParity = EParityNone;

	portSettings().iDataBits = EData8;

	portSettings().iStopBits = EStop1;

	// configure the logical port settings

	//      portSettings().iFifo = EFifoEnable;

	//      portSettings().iHandshake = (KConfigObeyXoff | KConfigSendXoff);        // for xon/xoff handshaking

	// terminate end-of-command with a $

	portSettings().iTerminator[0] = static_cast<TText8>(iData.KTerminator);

	portSettings().iTerminatorCount = iData.KTerminatorCount;

	err=iCommPort.SetConfig(portSettings);

	MGR_TEST_CHECKL(err,KErrNone,_L("Failed comm port SetConfig \n"));

}

void CTestMgr::DoCancel()

{

}

void CTestMgr::StartEngineL()

{

	// Start serial port listener

	LOG_INFO_PRINTF1(_L("Starting serial port listener\n"));

	console->Printf (_L("ready to receive on port %d\nPlase start ANVL on Linux Machine\n\n"), aPortNo) ;

	ipSerialRx->Recv();

}

void CTestMgr::Notify(TEvent aEvent)

{

	iEvent = aEvent;        

	SetActive();

	TRequestStatus* theStatus=&iStatus;//for the next line to compile

	User::RequestComplete(theStatus, KErrNone);

}

//

//State machine

//

void CTestMgr::RunL()

{

	switch(iCurrentState)

	{

	case EIdle:

		HandleEvents_Idle();

		break;

	case ETestStarted:

		HandleEvents_TestStarted();

		break;

	case ETestClosed:

		HandleEvents_TestClosed();

		break;

	default:

		__ASSERT_ALWAYS(ETrue,User::Panic(_L("Wrong state"),KErrGeneral));

		break;

	}

}

void 

CTestMgr::HandleEvents_Idle()

{

	switch (iEvent)

	{

	case EReadComplete:

		{

			//parse buffer and extract commands

			TBuffer buffer;

			buffer.Copy( *(ipSerialRx->GetData()) );

			//translate 8->16 if needed (for logging purposes)

			TBuf<KMaxMsgLen> bufferU ;

			bufferU.Copy(buffer);

			LOG_ERR_PRINTF2(_L("State: Idle -> Serial link read: (%S) \n") ,&bufferU);

			TCommands cmd;

			int result=ParseForCommands(buffer,cmd);

			if (result > 0)

			{

				//issue start event if needed

				if (0==iData.KStartCmd.CompareF(cmd[KCmdIDIndex]))

				{

					//echo the command (ack)

					//We need to do it as early as possible for

					//ANVL to have time to prepare for the negotiation

					ipSerialTx->Send(buffer);

					User::After(250000);

					LOG_INFO_PRINTF1(_L(""));

					LOG_INFO_PRINTF1(_L("##################################################"));

					LOG_INFO_PRINTF1(_L(""));

					//as the reader may buffer info -> kill it

					ipDummyAgtRef->DestroyIniReader();

					TRAPD(errCode,UpdateIniFileL(cmd));

					//even if we failed -> try to use ppp.ini

					if (!ipDummyAgtRef->CreateIniReader())

					{

						console->Printf (_L("*** ERROR failed to open ppp.ini file ***\n")) ;

					}

					else

					{

						console->Printf (_L("OPENed .ini file\n")) ;

					}

					//translate 8->16 if needed (for logging purposes)

					TBuf<KMaxMsgLen> indexU;

					indexU.Copy(cmd[KIniIdIndex]);

					if (errCode != KErrNone)

						LOG_ERR_PRINTF3(_L("State: Idle -> PPP configuration (id : %S) change failed (error : %d)"),&indexU,errCode);

					else

						LOG_ERR_PRINTF2(_L("State: Idle -> PPP configuration (id : %S) changed"),&indexU);

					LOG_INFO_PRINTF1(_L("State: Idle -> Serial link read acknowlegment sent"));

					//change the state

					Notify(EStartTest);

				}

			}

			else

				LOG_INFO_PRINTF1(_L("State: Idle -> Unrecognized command on serial link") );

		}

		break;

	case EStartTest:

		//issue request to the dummy agt ref

		LOG_INFO_PRINTF1(_L("State: Idle ->Starting PPP") );

		iCurrentState=ETestStarted;

		//imitate an agent's upcalls

		ipDummyAgtRef->ServiceStarted();

		if (EStopTest != iEvent)//ServiceStarted might have problems...

			ipDummyAgtRef->ConnectComplete(KErrNone);

		break;

	case EWriteComplete:

		LOG_INFO_PRINTF1(_L("State:Idle -> control link write finished"));

		break;

	default:

		LOG_ERR_PRINTF2(_L("State: Idle -> Unexpected event (%d) ") ,STATIC_CAST(TInt,iEvent));

	};

}

void

CTestMgr::HandleEvents_TestStarted()

{

	switch (iEvent)

	{

	case EReadComplete:

		//parse the buffer and extract instructions

		{

			TBuffer buffer;

			buffer.Copy( *(ipSerialRx->GetData()) );

			//translate 8->16 if needed (for logging purposes)

			TBuf<KMaxMsgLen> bufferU ;

			bufferU.Copy(buffer);

			LOG_ERR_PRINTF2(_L("State: TestStarted ->Serial link read: (%S) ") ,&bufferU);

			TCommands cmd;

			int result=ParseForCommands(buffer,cmd);

			if (result > 0)

			{

				//issue stop event if needed

				if (0==iData.KStopCmd.CompareF(cmd[KCmdIDIndex]))

					Notify(EStopTest);

				else if (0==iData.KStartTermCmd.CompareF(cmd[KCmdIDIndex]))

				{

					//initiate PPP termination from our side

					Notify(EStartTerminate);

				}

				else

					LOG_INFO_PRINTF1(_L("State: TestStarted -> Unexpected command "));

			}

			else

				LOG_INFO_PRINTF1(_L("State: TestStarted -> Unrecognized command on the serial link "));

		}

		break;

	case EStopTest:         // It's stopped by the ANVL

		//send stop to the dummy agt

		LOG_INFO_PRINTF1(_L("State: TestStarted ->Stop test "));

		iCurrentState=EIdle;

		ipDummyAgtRef->ServiceClosed();

		break;

	case EStartTerminate:           

		//

		LOG_INFO_PRINTF1(_L("State: TestStarted ->Send terminate Req"));

		//make PPP send Terminate Req

		ipDummyAgtRef->Stop();

		break;

	case ETestFinished://PPP considers negotiations finished 

		LOG_INFO_PRINTF1(_L("State: TestStarted -> Test finished"));

		iCurrentState=ETestClosed;

		break;

	case EWriteComplete:

		LOG_INFO_PRINTF1(_L("State:TestStarted -> control link write finished"));

		break;

	case EStartTest:

		//

		LOG_ERR_PRINTF2(_L("State: TestStarted -> Stop is missed and new start is received (%d) "),STATIC_CAST(TInt,iEvent));

		ipDummyAgtRef->ServiceClosed();

		//issue request to the dummy agt ref

		LOG_INFO_PRINTF1(_L("State: Idle ->Starting PPP") );

		//imitate an agent's upcalls

		ipDummyAgtRef->ServiceStarted();

		if (EStopTest != iEvent)//ServiceStarted might have problems...

			ipDummyAgtRef->ConnectComplete(KErrNone);

		break;

	default:

		LOG_ERR_PRINTF2(_L("State: TestStarted -> Unexpected event (%d) "),STATIC_CAST(TInt,iEvent));

	};

}

//ETestClosed state isn't used at the current state of the harness.

//So it's made transitional

void

CTestMgr::HandleEvents_TestClosed()

{

	switch (iEvent)

	{

	case EReadComplete:

		//parse the buffer and extract instructions

		{

			TBuffer buffer;

			buffer.Copy( *(ipSerialRx->GetData()) );

			//translate 8->16 if needed (for logging purposes)

			TBuf<KMaxMsgLen> bufferU ;

			bufferU.Copy(buffer);

			LOG_ERR_PRINTF2(_L("State: TestClosed ->Serial link read: (%S) ") ,&bufferU);

			TCommands cmd;

			int result=ParseForCommands(buffer,cmd);

			if (result > 0)

			{

				//issue stop event if needed

				if (0==iData.KStopCmd.CompareF(cmd[KCmdIDIndex]))

				{

					iCurrentState=EIdle;

					ipDummyAgtRef->ServiceClosed();

				}

				else 

					LOG_INFO_PRINTF1(_L("State: TestClosed -> Unexpected command "));

			}

			else

				LOG_INFO_PRINTF1(_L("State: TestClosed -> Unrecognized command on the serial link "));

		}

		break;

	default:

		LOG_ERR_PRINTF2(_L("State: TestClosed -> Unexpected event (%d) "),STATIC_CAST(TInt,iEvent));

	};

}

//The command from the ANVL are supposed to be of the next format

// startID            - where ID is one byte and designates the configuration tobe used

// stop 

//all others commands're considered to be wrong

TInt//return the number of elements put into aCommands  

CTestMgr::ParseForCommands(const TBuffer& aRawData,TCommands& aCommands )

{

	TInt index=aRawData.FindF(iData.KStartCmd);

	if (index >= 0)

	{

		TInt minimumLenght=iData.KMaxCfgIdLength+index+iData.KStartCmd.Length();

		if (aRawData.Length() >= minimumLenght)

		{

			//the cmd

			aCommands[KCmdIDIndex].Set(aRawData.Mid(index,iData.KStartCmd.Length()));

			//the cfg id

			TInt terminatorIndex=aRawData.FindF(iData.KTerminatorStr);

			if (terminatorIndex > 0)

			{

				aCommands[KIniIdIndex].Set(aRawData.Mid(index+iData.KStartCmd.Length(),terminatorIndex-index-iData.KStartCmd.Length()));

			}

			else

			{

				aCommands[KIniIdIndex].Set(_L8("no_index!!!"));

			}

			// display a progress message

			TInt val ;

			TLex8 lex (aCommands[KIniIdIndex]);

			lex.Val (val) ;

			console->Printf (_L("Start Command: %d\n"), val) ;

			return 2;

		}

		LOG_INFO_PRINTF1(_L("Wrong format of the start command"));

	}

	else

	{

		index=aRawData.FindF(iData.KStopCmd);

		if (index >=0)

		{

			console->Printf (_L("Stop Command\n")) ;

			aCommands[KCmdIDIndex].Set(aRawData.Mid(index,iData.KStopCmd.Length()));

			return 1;

		}

		else 

		{

			index=aRawData.FindF(iData.KStartTermCmd);

			if (index >= 0)

			{

				aCommands[KCmdIDIndex].Set(aRawData.Mid(index,iData.KStartTermCmd.Length()));

				return 1;

			}

		}

	}

	return 0;

}

//the  test ini file has format

//[[testid1]]

//........  <----content to be copied into ppp.ini

//[[testid2]]

//....

void CTestMgr::UpdateIniFileL(const TCommands& aCommands)

{

	TAutoClose<RFs> fs;

	RFs& fileServer=fs.iObj;

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

	//open the test configuration file

	TFindFile fileLookup(fileServer);

	TInt error = fileLookup.FindByPath(iData.KTestConfigFileName,&iData.KTestConfigFilePaths) ;

	if (error != KErrNone)

	{

		LOG_ERR_PRINTF1(_L("Failed to find te_ppp.cfg configuration file"));

	}

	// show user some progress info

	TPtrC fn = fileLookup.File() ;

	console->Printf (_L("TE_PPP.CFG configuration file is %S\n"), &fn) ;

	TAutoClose<RFile> f;

	RFile& cfgFile=f.iObj;

	TInt fileSize=0;

	User::LeaveIfError(cfgFile.Open(fileServer,fileLookup.File(),EFileShareAny));

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

	//read its content & look for the config ID

	TUint8* pFileContent__=new TUint8[fileSize+1];

	if (!pFileContent__)

		User::Leave(KErrNoMemory);

	CleanupStack::PushL(pFileContent__);

	TPtr8 fileContent(pFileContent__,fileSize+1,fileSize+1);

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

	TBuf8<10> sectionHeader;

	sectionHeader.Append(_L8("[["));

	sectionHeader.Append(aCommands[KIniIdIndex]);

	sectionHeader.Append(_L8("]]"));

	//cut out the specific section: from "[[0xnn]]" to next "[[" or the end of file 

	TInt startPosition = fileContent.Find(sectionHeader);

	if (startPosition>= 0)

	{

		fileContent.Delete(0,startPosition+sectionHeader.Length());

		TInt endPosition=fileContent.Find(_L8("[["));

		if (endPosition >0 )

			fileContent.Delete(endPosition,fileContent.Length()-endPosition);

		TAutoClose<RFile> fileIni;

		RFile& iniFile=fileIni.iObj;

		//create new ppp.ini

		User::LeaveIfError(iniFile.Replace(fileServer,iData.KPppIniFullPath,EFileShareAny));

		User::LeaveIfError(iniFile.Write(fileContent));

		//              LOG_INFO_PRINTF1(_L("<<<<<<<<ppp.ini content>>>>>>>>>>>>"));

		//              LOG_ERR_PRINTF2(_L("%S"),&fileContent);

		//              LOG_INFO_PRINTF1(_L(">>>>>>>>-----------------<<<<<<<<<<<<"));

	}

	CleanupStack::Pop();//pFileContent__

}