// Copyright (c) 2003-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 "CPipeliningTestClient.h"

#include "httptestutils.h"

#include "MPipeliningTestCase.h"

#include "MPipeliningTestObserver.h"

CPipeliningTestClient* CPipeliningTestClient::NewL(CHTTPTestUtils& aTestUtils, MPipeliningTestObserver& aObserver)

	{

	CPipeliningTestClient* self = new (ELeave) CPipeliningTestClient(aTestUtils, aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CPipeliningTestClient::CPipeliningTestClient(CHTTPTestUtils& aTestUtils, MPipeliningTestObserver& aObserver)

: iTestUtils(aTestUtils), iObserver(aObserver)

	{

	}

void CPipeliningTestClient::ConstructL()

	{

	iSession.OpenL();

	}

CPipeliningTestClient::~CPipeliningTestClient()

	{

	iTransArray.Reset();

	iTransArray.Close();

	iSession.Close();

	iNetworkConnection.Close();

	iSocketServ.Close();

	}

RHTTPSession& CPipeliningTestClient::GetSession()

	{

	return iSession;

	}

// From MHTTPTransactionCallback

void CPipeliningTestClient::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)

	{

	TInt expectedError = iTestCase->ExpectedError(aTransaction);		

	TInt tranID = aTransaction.Id();

	switch (aEvent.iStatus)

		{

		case THTTPEvent::EGotResponseHeaders:

			{

			} break;

		case THTTPEvent::EGotResponseBodyData:

			{

			// Done with that bit of body data

			aTransaction.Response().Body()->ReleaseData();

			} break;

		case THTTPEvent::EResponseComplete:

			{

			TRAPD(err1, iTestCase->ProcessHeadersL(aTransaction));

			if ( err1 != KErrNone )

				{

				_LIT(KProcessHeadersError, "Client - Transaction %d Failed, Error = %d");

				iTestUtils.LogIt(KProcessHeadersError, tranID, err1);

				EndTestL(err1);

				}

			} break;

		case THTTPEvent::ESucceeded:

			{

			++iCurrentTrans;

			aTransaction.Close();

			_LIT(KTxtSuccessful, "Client - Transaction %d, completed successfully.");

			iTestUtils.LogIt(KTxtSuccessful, tranID);

			if( expectedError != KErrNone )

				{

				_LIT(KTxtErrorExpected, "Client - Expected error code %d");

				iTestUtils.LogIt(KTxtErrorExpected, expectedError);

				EndTestL(KErrNotFound);

				}

			if( iTestCase->TotalTransactionCount() == iCurrentTrans )

				{	

				EndTestL(KErrNone);

				}

			} break;

		case THTTPEvent::EFailed:

			{

			++iCurrentTrans;

			aTransaction.Close();

			if( expectedError == iLastError )

				{

				_LIT(KTxtExpectedError, "Client - Transaction %d Failed, Expected: %d, Actual: %d");

				iTestUtils.LogIt(KTxtExpectedError(), tranID, expectedError, iLastError);

				if( iTestCase->TotalTransactionCount() == iCurrentTrans )

					{

					EndTestL(KErrNone);

					}

				}

			else

				{

				_LIT(KTxtErrorUnexpected, "Client - Error code mismatch.");

				iTestUtils.LogIt(KTxtErrorUnexpected());

				EndTestL(KErrNotFound);

				}

			} break;

		case THTTPEvent::ERedirectedPermanently:

			{

			} break;

		case THTTPEvent::ERedirectedTemporarily:

			{

			} break;

		case THTTPEvent::ERedirectRequiresConfirmation:

 			{

 			aTransaction.SubmitL();

 			} break;

		default:

			{

			if (aEvent.iStatus < 0)

				{

				iLastError = aEvent.iStatus;

				_LIT(KTxtClientError, "Client - Transaction %d, received error code %d");

				iTestUtils.LogIt(KTxtClientError, tranID, iLastError);

				}

			} break;

		}

	}

void CPipeliningTestClient::EndTestL(TInt aErrorCode)

	{

	#if defined (_DEBUG)

	_LIT(KTxtClientError, "Error - Code %d");	

	iTestUtils.LogIt(KTxtClientError, aErrorCode);      	

	if (aErrorCode == KErrNone)

		{

		TInt expectedConnections = iTestCase->RealExpectedConnectionCount();

		RStringPool stringPool = iSession.StringPool();

		_LIT8(KNumberConnectionManagers, "__NumConnectionManagers");

		RStringF numberConnectionsString = stringPool.OpenFStringL(KNumberConnectionManagers);

		CleanupClosePushL(numberConnectionsString);

		RHTTPConnectionInfo connInfo = iSession.ConnectionInfo();

		TInt numberConnections =0;

		THTTPHdrVal numberConnectionsVal;

		if (connInfo.Property(numberConnectionsString, numberConnectionsVal))

			{

			numberConnections = numberConnectionsVal.Int();

			connInfo.RemoveProperty(numberConnectionsString);

			if (numberConnections > expectedConnections)

				{

                _LIT(KTxtClientError, "Client - Connections %d, Expected: %d");

                iTestUtils.LogIt(KTxtClientError, numberConnections, expectedConnections);				

				aErrorCode = KErrNotFound;

				}

			}

		CleanupStack::PopAndDestroy(&numberConnectionsString);

		}

	#endif

	iObserver.EndTest(aErrorCode);

	}	

TInt CPipeliningTestClient::MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& /*aEvent*/)

	{

	_LIT(KTxtRunError, "Client - MHFRunError - Transaction %d with error code %d.");

	iTestUtils.LogIt(KTxtRunError(), aTransaction.Id(), aError);

	return KErrNone;

	}

void CPipeliningTestClient::AddTransactionL(RHTTPTransaction aTransaction)

	{

	User::LeaveIfError(iTransArray.Append(aTransaction));

	}

void CPipeliningTestClient::StartClientL()

	{

	__ASSERT_DEBUG(iTestCase != NULL, User::Invariant());

	if( iTestCase->EnableBatching() )

		{

		// @todo we need to add the session property for enabling batching

		RHTTPConnectionInfo connInfo = GetSession().ConnectionInfo();

		THTTPHdrVal batchingSupport(iSession.StringPool().StringF(HTTP::EEnableBatching,RHTTPSession::GetTable()));

		connInfo.SetPropertyL(iSession.StringPool().StringF(HTTP::EHttpBatching,RHTTPSession::GetTable()), batchingSupport);

		}

	TBool batchTrans = iTestCase->BatchTransactions();	

	// Create transactions

	for( TInt ii=0; ii < iTestCase->TotalTransactionCount(); ++ii )

		{

		RHTTPTransaction trans = iTestCase->GetTransactionL(ii, GetSession(), *this);

		CleanupClosePushL(trans);

		AddTransactionL(trans);

		if(!batchTrans)

			{

			trans.SubmitL();

			}

		CleanupStack::Pop(&trans);

		}

	if(batchTrans)

		{

		for( TInt jj=0; jj < iTransArray.Count(); ++jj )

			{

			iTransArray[jj].SubmitL();

			}

		}

	}

TInt CPipeliningTestClient::LastError()

{

	return iLastError;

}

void CPipeliningTestClient::SetTestCase(MPipeliningTestCase* aTestCase)

	{

	iTestCase = aTestCase;

	}

void CPipeliningTestClient::StartAndSetNetworkToHttp()

    {

    if(iSocketServ.Handle() != KNullHandle)

        {

        iNetworkConnection.Close();

        iSocketServ.Close();

        }

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

    User::LeaveIfError(iNetworkConnection.Open(iSocketServ));

    User::LeaveIfError(iNetworkConnection.Start());

    // Set the RSocketServ & RConnection

    RStringPool strPool = iSession.StringPool();

    RHTTPConnectionInfo connInfo1 = iSession.ConnectionInfo();

    connInfo1.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketServ, 

                             RHTTPSession::GetTable() ), 

                             THTTPHdrVal (iSocketServ.Handle()) );

    TInt connPtr = REINTERPRET_CAST(TInt, &iNetworkConnection);                

    connInfo1.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketConnection, 

                             RHTTPSession::GetTable() ), 

                             THTTPHdrVal(connPtr));    

    }