// 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 ctlbshybridmultiplestep.cpp

// This is the class implementation for the Lbs Hybrid Multiple Test Step Base

// 

//

#include "ctlbshybridmultiplestep.h"

CT_LbsHybridMultipleStep::~CT_LbsHybridMultipleStep()

	{

	iSequences.ResetAndDestroy();

	iSequences.Close();

	iProxy.ResetAndDestroy();

	iProxy.Close();

	iExpectedModuleGpsOptions.ResetAndDestroy();

	iExpectedModuleGpsOptions.Close();	

	}

CT_LbsHybridMultipleStep::CT_LbsHybridMultipleStep(CT_LbsHybridMultipleServer& aParent) :iParent(aParent), iExpectedModuleGpsOptionsIndex(0), 

											iAgpsModuleEventListener(NULL)

	{

	}

void CT_LbsHybridMultipleStep::ConstructL()

	{	

	}

/**

 * @return - TVerdict

 * Implementation of CTestStep base class virtual

 * It is used for doing all initialisation common to derived classes in here.

 * Make it being able to leave if there are any errors here as there's no point in

 * trying to run a test step if anything fails.

 * The leave will be picked up by the framework.

 */

TVerdict CT_LbsHybridMultipleStep::doTestStepPreambleL()

	{

	// Process some common pre setting to test steps then set SetTestStepResult to EFail or Epass.

	INFO_PRINTF1(_L("doTestStepPreabmleL()"));

	SetTestStepResult(EPass);

	// Get the expected module GPS options

	T_LbsUtils utils;

	TPtrC configFileName;

	_LIT(KUpdateOptionsFile, "agps_module_update_file");

	GetStringFromConfig(ConfigSection(), KUpdateOptionsFile, configFileName);

	utils.GetExpected_ModuleModes(configFileName, ConfigSection(), iExpectedModuleGpsOptions);

	if(iExpectedModuleGpsOptions.Count() > 0)

		{ // Start listening for the GPS module options only if expecting any options

		iAgpsModuleEventListener = CT_AgpsModuleEventListener::NewL(*this);

		}

	//Read in the sequences from the testdata ini file

	TInt numberOfSequences = 0;

	GetIntFromConfig(ConfigSection(), _L("NumberOfSequences"), numberOfSequences);

	if(numberOfSequences <= 0)

		{

		INFO_PRINTF1(_L("ERROR - Trying to run the test with no sequences!"));

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	//Loop through the sequences carrying out the required configuration

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

		{

		ReadTestDataConfig(i);

		}

	return TestStepResult();

	}

/**

 * @return - TVerdict

 * Implementation of CTestStep base class virtual

 * It is used for doing all after test treatment common to derived classes in here.

 * Make it being able to leave

 * The leave will be picked up by the framework.

 */

TVerdict CT_LbsHybridMultipleStep::doTestStepPostambleL()

	{

	// Process some common post setting to test steps then set SetTestStepResult to EFail or Epass.

	INFO_PRINTF1(_L("doTestStepPostabmleL()"));

	//Loop through all the sequences to print out their final status

	INFO_PRINTF1(_L("---------------------------------- Sequence Status ----------------------------------"));

	INFO_PRINTF1(_L("Still waiting for the following messages on the following sequences:"));

	for(TInt i=0; i<iSequences.Count(); ++i)

		{

		iSequences[i]->PrintRemainingActions();

		}

	TEST(iExpectedModuleGpsOptionsIndex == iExpectedModuleGpsOptions.Count());

	iExpectedModuleGpsOptions.ResetAndDestroy();

	iExpectedModuleGpsOptionsIndex = 0;

	delete iAgpsModuleEventListener;

	iAgpsModuleEventListener = NULL;

	//SetTestStepResult(EPass);  // or EFail

	return TestStepResult();

	}

/** Reads in the details of a sequence from the test data ini file

 */

void CT_LbsHybridMultipleStep::ReadTestDataConfig(TInt aCurrentNum)

	{

	CTestSessionSequence* newSequence;

	//Get the name of the file being used

	TPtrC fileName;

	GetStringFromConfig(_L("FileName"), _L("sequence_data_file"), fileName);

	//Find out what Protocol Module this sequence is going to be run on

	TBuf<4> pmName;

	TInt pmNum = 0;

	pmName.Format(_L("PM%d"), aCurrentNum);

	GetIntFromConfig(ConfigSection(), pmName, pmNum);

	//Create the required protocol module Net Proxy and get the position of this PM in the array

	TInt position;

	position = CreateProtocolModuleProxy(pmNum);

	//Find out what type the sequence is

	TBuf<6> typeName;

	TPtrC sequenceType;

	typeName.Format(_L("Type%d"), aCurrentNum);

	GetStringFromConfig(ConfigSection(), typeName, sequenceType);

	//Create the specific test sequence type

	if(sequenceType.Find(_L("MOLR")) != KErrNotFound)	//MOLR

		{

		newSequence = CTestMolrSessionSequence::NewL(*iProxy[position], *this, aCurrentNum, fileName, ConfigSection());

		}

	else if(sequenceType.Find(_L("X3P")) != KErrNotFound)	//X3P

		{

		newSequence = CTestX3PSessionSequence::NewL(*iProxy[position], *this, aCurrentNum, fileName, ConfigSection());

		}

	else if((sequenceType.Find(_L("MTLR")) != KErrNotFound) || (sequenceType.Find(_L("NIMTLR")) != KErrNotFound))	//MTLR

		{

		newSequence = CTestMtlrSessionSequence::NewL(*iProxy[position], *this, aCurrentNum, fileName, ConfigSection());

		}

	else	//Unknown type, will get generic handling

		{

		newSequence = CTestSessionSequence::NewL(*iProxy[position], *this, aCurrentNum, fileName, ConfigSection());

		}

	//Add the new sequence to the array

	TRAPD(err, iSequences.AppendL(newSequence));

	if(err != KErrNone)

		{

		SetTestStepResult(EFail);

		}

	}

/** Creates the Protocol Module Proxy for the PM id past into the function. If the 

 *   protocol module proxy is already created, do nothing, just return the position

 *   of the proxy in the iProxy array

 */

CLbsTestNgMessageHandler* CT_LbsHybridMultipleStep::LookupProtocolModuleProxy(TInt aPmId)

    {

    for(TInt i=0; i<iProxy.Count(); ++i)

        {

        if(iProxy[i]->GetPmId() == aPmId)

            {

            return iProxy[i];

            }

        }

    // Didn't find a proxy, so return null

    return 0;

    }

/** Creates the Protocol Module Proxy for the PM id past into the function. If the 

 *   protocol module proxy is already created, do nothing, just return the position

 *   of the proxy in the iProxy array

 */

TInt CT_LbsHybridMultipleStep::CreateProtocolModuleProxy(TInt aPmId)

	{

	TInt position = KErrNotFound;

	//Check to see whether this PM has already been created for another sequence

	for(TInt i=0; i<iProxy.Count(); ++i)

		{

		if(iProxy[i]->GetPmId() == aPmId)

			{

			position = i;

			break;

			}

		}

	if(position == KErrNotFound)

		{

		//Create the new Protocol Proxy for this new Protocol Module

		CLbsTestNgMessageHandler* pmProxy = CLbsTestNgMessageHandler::NewL(*this, aPmId);		

		iProxy.AppendL(pmProxy);

		position = iProxy.Count() - 1;

		}

	return position;

	}

void CT_LbsHybridMultipleStep::OnSetGpsOptions(const TLbsGpsOptions& aGpsOptions)

/**

 * Compares the GPS options received by the AGPS module to the ones expected by the test

 */

	{

	INFO_PRINTF1(_L("CT_LbsHybridMTLRStep::OnSetGpsOptions()"));

	if(iExpectedModuleGpsOptionsIndex >= iExpectedModuleGpsOptions.Count())

		{

		INFO_PRINTF3(_L("CT_LbsHybridX3PStep::OnSetGpsOptions - FAILED because got unexpected number of mode changes. Got %d expected %d"), iExpectedModuleGpsOptionsIndex -1, iExpectedModuleGpsOptions.Count());

		TEST(EFalse);

		return;

		}

	TLbsGpsOptions* expectedOptions = iExpectedModuleGpsOptions[iExpectedModuleGpsOptionsIndex];

	++iExpectedModuleGpsOptionsIndex;

	if(aGpsOptions.GpsMode() != expectedOptions->GpsMode())

		{

		INFO_PRINTF3(_L("CT_LbsHybridX3PStep::OnSetGpsOptions - FAILED because got unexpected mode. Got 0x%x expected 0x%x()"), aGpsOptions.GpsMode(), expectedOptions->GpsMode());

		TEST(EFalse);

		return;

		}

	if(aGpsOptions.ClassType() != expectedOptions->ClassType())

		{

		TEST(EFalse);

		return;

		}

	if(aGpsOptions.ClassType() & ELbsGpsOptionsArrayClass)

		{

		const TLbsGpsOptionsArray& optionsArr = reinterpret_cast<const TLbsGpsOptionsArray&>(aGpsOptions);

		const TLbsGpsOptionsArray& expectedOptionsArr = reinterpret_cast<const TLbsGpsOptionsArray&>(*expectedOptions);

		if(optionsArr.NumOptionItems() != expectedOptionsArr.NumOptionItems())

			{

			TEST(EFalse);

			return;

			}

		for(TInt index = 0; index < optionsArr.NumOptionItems(); ++index)

			{

			TLbsGpsOptionsItem item;

			TLbsGpsOptionsItem expectedItem;

			optionsArr.GetOptionItem(index, item);

			expectedOptionsArr.GetOptionItem(index, expectedItem);

			if(item.PosUpdateType() != expectedItem.PosUpdateType())

				{

				TEST(EFalse);

				return;

				}

			}

		}

	}