// 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:

// Runs the actual multiple test step

//

// LBS includes. 

#include <lbs/lbsnetprotocolbase.h>

#include <lbs/lbsassistancedatabuilderset.h>

// LBS test includes.

#include "ctlbshybridmultipletest.h"

#include <lbs/test/tlbsutils.h>

#include "argutils.h"

#include <lbs/test/activeyield.h>

/**

Static Constructor

*/

CT_LbsHybridMultipleTest* CT_LbsHybridMultipleTest::New(CT_LbsHybridMultipleServer& aParent)

	{

	// Note that we do not use ELeave.

	// This means that having insufficient memory will return NULL;

	CT_LbsHybridMultipleTest* testStep = new CT_LbsHybridMultipleTest(aParent);

	if (testStep)

		{

		TInt err = KErrNone;

		TRAP(err, testStep->ConstructL());

		if (err)

			{

			delete testStep;

			testStep = NULL;

			}

		}

	return testStep;

	}

/**

 * Constructor

 */

CT_LbsHybridMultipleTest::CT_LbsHybridMultipleTest(CT_LbsHybridMultipleServer& aParent) : CT_LbsHybridMultipleStep(aParent),

iCheckForNewSequencesToStart(ETrue)

	{

	SetTestStepName(KLbsHybridMultipleTest);

	}

void CT_LbsHybridMultipleTest::ConstructL()

	{

	// Create the base class objects.

	CT_LbsHybridMultipleStep::ConstructL();

	iController = CLbsPrivacyController::NewL(*this);

	iCheckNewSequenceIdle = CIdle::NewL(CActive::EPriorityStandard);

	}

/**

 * Destructor

 */

CT_LbsHybridMultipleTest::~CT_LbsHybridMultipleTest()

	{

	if(iCheckNewSequenceIdle)

		{

		iCheckNewSequenceIdle->Cancel();

		delete iCheckNewSequenceIdle;

		}

	delete iController;

	}

/** Actual test step, which starts the test on the first sequence

 */

TVerdict CT_LbsHybridMultipleTest::doTestStepL()

	{

	INFO_PRINTF1(_L(""));

	INFO_PRINTF1(_L("---------------------------------- Starting Test ----------------------------------"));

	//Start off the master sequence; sequence 0

	iActiveSequences = 1;

	iSequences[0]->SignalCallbackIdleStart();

	//This will cause the sequence to start its session; sending and receiving messages to LBS.  The other

	// sequences should start as this sequence progresses.

	//Wait for the test to complete.  When all the sequences have finished, the active scheduler will

	// be stopped (from StopTest()) causing this test to complete.

	CActiveScheduler::Start();

	return TestStepResult();

	}

/** Stops the active scheduler causing the test to finish

 * 

 * @param aError If less than KErrNone, it will set the test step result to fail

 */

void CT_LbsHybridMultipleTest::StopTest(TInt aError)

	{

	//Check to see if we are ending the test in error

	if(aError < 0)

		{		

		//Fail the test step

		SetTestStepResult(EFail);

		}

	CActiveScheduler::Stop();

	}

/** Finds out which sequence relates to the session ID and checks that the received message was expected

 * 

 * @param aSessionId Session ID that was past into the message

 * @param aMessageType ID of the message that was received by the PM

 * 

 * @return The ID of the sequence that this message relates to, or KErrNotFound

 */

TInt CT_LbsHybridMultipleTest::WasMessageExpectedSessionId(TInt aSessionId, TNetProtocolResponseType aMessageType)

	{	

	//Loop through all the sequences

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

		{

		//Get the session id and the current sequence action

		TLbsNetSessionId sessionId = iSequences[i]->GetSessionId();

		TInt currentAction = iSequences[i]->GetCurrentAction();

		//Check the session ID of any sequence that is currently active with the session id past in

		if((sessionId.SessionNum() == aSessionId) && (currentAction != KErrArgument))

			{

			//Found the sequence with the requested session id, now check if the message type was expected

			if(currentAction == aMessageType)

				{

				//Message type was found, return sequence number

				return i;

				}

			else

				{

				//Message not expected by this sequence

				INFO_PRINTF3(_L("Error - Received unexpected message %d for session Id: %d"), aMessageType, aSessionId);

				INFO_PRINTF3(_L(" -> On Sequence: %d, at position: %d"), i , iSequences[i]->GetCurrentPosition());

				return KErrNotFound;

				}

			}

		}

	//Error, session ID not found in any sequence

	INFO_PRINTF3(_L("Error - Received unexpected session Id (%d) for message: %d"), aSessionId, aMessageType);

	return KErrNotFound;

	}

/** Finds out whether any of the sequences (using aPmId) expected the following message

 * 

 * @param aPmId ID of the PM that the message was received on (on sequences related to this id are checked)

 * @param aMessageType ID of the message that was received by the PM

 * 

 * @return The ID of the sequence that this message relates to, or KErrNotFound

 */

TInt CT_LbsHybridMultipleTest::WasMessageExpectedPmId(TInt aPmId, TNetProtocolResponseType aMessageType)

	{

	//Loop through all sequences

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

		{

		//Check to see whether any sequences the are using PM ID, aPmId, are expecting this message

		if((iSequences[i]->GetPmId() == aPmId) && (iSequences[i]->GetCurrentAction() == aMessageType))

			{

			//Return the sequenceId

			return i;

			}

		}

	//Error, message was not found in any of the sequences

	INFO_PRINTF2(_L("Was not expecting message %d in any sequence"), aMessageType);

	return KErrNotFound;

	}

/* Called when one of the stub PM's receives a message from the NG

 * 

 * @param aPmId The ID of the PM that received this message

 * @param aMessageType The ID of the message type received from the PM

 */

void CT_LbsHybridMultipleTest::OnHandleNGMessage(TUint aPmId, TInt aMessageType)

	{

	//Get the correct proxy

	CLbsTestNgMessageHandler* proxy = LookupProtocolModuleProxy(aPmId);

	if (!proxy)

	    {

        INFO_PRINTF2(_L("ERROR: No NG proxy setup for PM%d"), aPmId);

	    User::Leave(KErrNotFound);

	    }

	TInt cleanupCnt;

	TInt sequenceId = KErrNotFound;

	//For each of the different message types, find out whether the message type was expected by the

	// sequence (if a session Id is sent with the message) or by any sequence (if the session Id is not

	// present).  Then confirm the message parameters are expected and then move the correct sequence

	// onto the next message.

	switch(aMessageType)

		{	

		// >> AdviceSystemStatus() [2009]

		case ENetMsgGetCurrentCapabilitiesResponse:

			{

			sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgGetCurrentCapabilitiesResponse);

			INFO_PRINTF2(_L("-> AdviceSystemStatus() [2009] Sq: %d"), sequenceId);

			if(sequenceId != KErrNotFound)

				{

				CLbsNetworkProtocolBase::TLbsSystemStatus status;

				cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);

				TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone);

				CleanupStack::PopAndDestroy(cleanupCnt);

				}

			break;

			}

		// >> RespondPrivacyRequest() [2000]

		case ENetMsgRespondPrivacyRequest:

			{						

			TLbsNetSessionId* getSessionId = NULL;

			CLbsNetworkProtocolBase::TLbsPrivacyResponse getPrivacy;

			cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRespondPrivacyRequest, &getSessionId, &getPrivacy);

			sequenceId = WasMessageExpectedSessionId(getSessionId->SessionNum(), ENetMsgRespondPrivacyRequest);

			INFO_PRINTF3(_L("-> RespondPrivacyRequest(%d) [2000] Sq: %d"), getPrivacy, sequenceId);

			if(sequenceId != KErrNotFound)

				{

				iSequences[sequenceId]->CheckRespondPrivacyRequest(getPrivacy);

				}

			CleanupStack::PopAndDestroy(cleanupCnt);//getSessionId

			break;

			}

		// >> RequestAssistanceData() [2004]

		case ENetMsgRequestAssistanceData:

			{

			sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestAssistanceData);

			//Request Assistance Data is a special case.  Depending upon the timing of when the messages

			// will be sent/received, it is not possible to predict in advance whether this message will

			// always arrive in some of the later sequences.  As such, a RequestAssistanceData message can

			// arrive and even if it is not expected by any of the sequences, it will not fail the test.

			if(sequenceId != KErrNotFound)

				{

				INFO_PRINTF2(_L("-> RequestAssistanceData() [2004] Sq: %d"), sequenceId);

				TLbsAsistanceDataGroup dataGroup;

				cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestAssistanceData, &dataGroup);

				CleanupStack::PopAndDestroy(cleanupCnt);

				}

			else

				{

				//Message was not expected by any sequence.  Manually set the Net Proxy off listening

				// again, so the sequence can receive the message it expected.

				INFO_PRINTF2(_L("-> RequestAssistanceData() [2004] Sq: unknown, PM: %d"), aPmId);

				//Break out of the function now

				return;

				}

			break;

			}

		// >> ResponsdLocationRequest() [2001]

		case ENetMsgRespondLocationRequest:

			{

			TLbsNetSessionId* getSessionId = NULL;

			getSessionId = NULL;

			TInt getReason = KErrNone;

			TPositionSatelliteInfo* getPositionInfo = NULL;

			cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRespondLocationRequest, &getSessionId, &getReason, &getPositionInfo);

			sequenceId = WasMessageExpectedSessionId(getSessionId->SessionNum(), ENetMsgRespondLocationRequest);

			INFO_PRINTF3(_L("-> RespondLocationRequest(%d) [2001] Sq: %d"), getReason, sequenceId);

			CleanupStack::PopAndDestroy(cleanupCnt);

			break;

			}

		// >> RequestSelfLocation() [2005]

		case ENetMsgRequestSelfLocation:

			{

			TLbsNetSessionId* sessionId = NULL;

			TLbsNetPosRequestOptionsAssistance*	opts = NULL;

			cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts);

			sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestSelfLocation);

			INFO_PRINTF2(_L("-> RequestSelfLocation() [2005] Sq: %d"), sequenceId);

			if(sequenceId != KErrNotFound)

				{

				iSequences[sequenceId]->CheckSelfLocationRequest(sessionId);

				}

			CleanupStack::PopAndDestroy(cleanupCnt);

			break;

			}

		// >> CancelSelfLocation() [2006]

		case ENetMsgCancelSelfLocation:

			{

			TLbsNetSessionId* sessionId = NULL;

			TInt reason = 0;

			cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgCancelSelfLocation, &sessionId, &reason);

			sequenceId = WasMessageExpectedSessionId(sessionId->SessionNum(), ENetMsgRequestSelfLocation);

			INFO_PRINTF2(_L("-> CancelSelfLocation() [2006] Sq: %d"), sequenceId);

			CleanupStack::PopAndDestroy(cleanupCnt);

			break;

			}

		// >> RequestTransmitLocation() [2002]

		case ENetMsgRequestTransmitLocation:

			{

			HBufC16* getThirdParty = NULL;

			TLbsNetSessionId* getSessionId = NULL;

			TInt getPriority(0);

			TInt cleanupCnt;

			cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestTransmitLocation, &getSessionId, &getThirdParty, &getPriority);

			sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestTransmitLocation);

			INFO_PRINTF2(_L("-> RequestTransmitLocation() [2002] Sq: %d"), sequenceId);

			if(sequenceId != KErrNotFound)

				{

				iSequences[sequenceId]->CheckRequestTransmitLocation(getSessionId, getPriority, *getThirdParty);

				}

			CleanupStack::PopAndDestroy(cleanupCnt);

			break;

			}

		// >> CancelTransmitLocation() [2003]

		case ENetMsgCancelTransmitLocation:

			{

			TLbsNetSessionId* sessionId = NULL;

			TInt reason = 0;

			cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgCancelTransmitLocation, &sessionId, &reason);

			sequenceId = WasMessageExpectedSessionId(sessionId->SessionNum(), ENetMsgCancelTransmitLocation);

			INFO_PRINTF2(_L("-> CancelTransmitLocation() [2003] Sq: %d"), sequenceId);

			CleanupStack::PopAndDestroy(cleanupCnt);

			break;

			}

		// >> RequestNetworkLocation() [2007]

		case ENetMsgRequestNetworkLocation:

			{

            TLbsNetSessionId* sessionId = NULL;

            TLbsNetPosRequestOptionsAssistance* opts = NULL;

            cleanupCnt = proxy->ProtocolProxy()->GetArgsLC(ENetMsgRequestNetworkLocation, &sessionId, &opts);

            sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgRequestNetworkLocation);

			INFO_PRINTF2(_L("-> RequestNetworkLocation() [2007] Sq: %d"), sequenceId);

            if(sequenceId != KErrNotFound)

                {

                iSequences[sequenceId]->CheckNetworkLocationRequest(sessionId);

                }

			break;

			}

		// >> CancelNetworkLocation [2008]

		case ENetMsgCancelNetworkLocation:

			{

			sequenceId = WasMessageExpectedPmId(aPmId, ENetMsgCancelNetworkLocation);

			INFO_PRINTF2(_L("-> CancelNetworkLocation() [2008] Sq: %d"), sequenceId);

			//NOTE: Currently no handling implemented for this message type

			break;

			}

		// Timeout occurred waiting for a NG Message

		case -1000:

			{

			INFO_PRINTF2(_L("Error - Timeout occurred waiting for NG message on PM: %d"), aPmId);

			break;

			}

		//Error occurred, not a recognised message.  Fail the test.

		default:

			{

			INFO_PRINTF3(_L("Error - Received invalid NG message: %d on PM: %d"), aMessageType, aPmId);

			return StopTest(KErrArgument);

			}

		}

	//If the message was expected, continue the test

	if(sequenceId != KErrNotFound)

		{

		iSequences[sequenceId]->SignalCallbackIdleStart();

		}

	else

		{

		// when an unexpected message arrives merley ignore and wait for next one!

		}

	}

/** Checks to see whether any of the other sequences should be started.

 */

void CT_LbsHybridMultipleTest::CheckForNewSequenceToStart()

	{

	TBool check = EFalse;

	//Check for other sequences to start

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

		{

		//Check to see whether this sequence has been started

		TInt currentPosition = iSequences[i]->GetCurrentPosition();

		if(iSequences[i]->GetCurrentPosition() >= 0)

			{

			//Sequence is started, move onto next sequence

			continue;

			}

		//There are still sequences that need to be started, keep checking for new sequences

		check = ETrue;

		//Check to see whether this sequence needs to be started

		if(iSequences[0]->GetCurrentPosition() >= iSequences[i]->GetStartPosition())

			{

			iActiveSequences++;

			iSequences[i]->SignalCallbackIdleStart();

			//Break, don't check any other sequences.  This sequence has to be given a chance

			//  to start before trying to start any other sequences.

			break;

			}

		}

	// Set the check bool for future checks.  If check is not set to ETrue above then no sequences

	//  are still waiting to be started, so there is no point in checking anymore.

	iCheckForNewSequencesToStart = check;

	}

TInt CT_LbsHybridMultipleTest::HandlerCompleteCallback(TAny* aAny)

    {

    reinterpret_cast<CT_LbsHybridMultipleTest*>(aAny)->HandlerCompleteNotify();

    return KErrNone;

    }

/** Handler Complete

 */

void CT_LbsHybridMultipleTest::HandlerCompleteNotify()

    {

    CheckForNewSequenceToStart();

    }

/** Uses the TestExecute logger to allow the CTestSessionSequence class to log messages to

 *    the TestExecute log file.

 * 

 * @param aMessage Contains the message that should be logged

 */

void CT_LbsHybridMultipleTest::LogTestStatement(const TDesC& aMessage)

	{

	INFO_PRINTF2(_L("%S"), &aMessage);

	}

/** Signals the the sequence has finished.  Check to see if the test should now end

 */

void CT_LbsHybridMultipleTest::SequenceFinished()

	{

	//This sequence is finished

	iActiveSequences--;

	//Check to see whether any other sequences are active

	if(iActiveSequences > 0)

		{

		return;

		}

	else

		{

		//No active sequences, end the test

		return StopTest(0);

		}

	}

/** Signal from the Test Sequence that the test should check for more sequences to start

 */

void CT_LbsHybridMultipleTest::SignalCheckForNewSequences()

	{

	if(iCheckForNewSequencesToStart)

		{

		iCheckNewSequenceIdle->Start(TCallBack(HandlerCompleteCallback, this));

		}

	}

/* >> ProcessNetworkLocationRequest()

*/

void CT_LbsHybridMultipleTest::ProcessNetworkLocationRequest(TUint aRequestId, const TLbsExternalRequestInfo& /*aRequestInfo*/, const TNotificationType& /*aNotificationType*/)

	{

	//Loop through the sequences identifying which sequence this privacy request belongs to

	TInt i;

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

		{

		if(iSequences[i]->GetSessionId().SessionNum() == aRequestId)

			{

			INFO_PRINTF2(_L("--> ProcessNetworkLocationRequest() [3000] Sq: %d"), i);

			if(iSequences[i]->GetCurrentAction() == EProcessNetworkLocationRequest)

				{

				iSequences[i]->SignalCallbackIdleStart();

				}

			break;

			}

		}