// 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();
	iHttpTimer = new(ELeave) CHttpTimer1(*this);
	iASW = new(ELeave) CActiveSchedulerWait();
	}

CPipeliningTestClient::~CPipeliningTestClient()
	{
	iTransArray.Reset();
	iTransArray.Close();
	iSession.Close();
	delete iHttpTimer;
	delete iASW;
	}

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:
			{
			iTestCase->ProcessHeadersL(aTransaction);
			} break;
		case THTTPEvent::EGotResponseBodyData:
			{
			// Done with that bit of body data
			aTransaction.Response().Body()->ReleaseData();
			} break;
		case THTTPEvent::EResponseComplete:
			{
			} break;
		case KErrHttpOptimiserFailsTrans:
			{
			_LIT(KTxtMessage, "Cancelling/Failing Transaction\n");
			iTestUtils.LogIt(KTxtMessage);
			aTransaction.Fail(THTTPFilterHandle::EProtocolHandler);
			} break;
		case THTTPEvent::ESucceeded:
			{
			++iCurrentTrans;
			aTransaction.Close();
			_LIT(KTxtSuccessful, "Client - Transaction %d, completed successfully.");
			iTestUtils.LogIt(KTxtSuccessful, tranID);
            if ((iTestCase->TestCaseName().Match(_L("Test Case 5")) == 0)||(iTestCase->TestCaseName().Match(_L("Test Case 6")) == 0)||(iTestCase->TestCaseName().Match(_L("Test Case 25")) == 0))
				{	
				TTimeIntervalMicroSeconds32 time(1000000);
				iHttpTimer->After(time);
				iASW->Start();	
				}
			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;
		case THTTPEvent::EReceiveTimeOut:
			{
			iTestUtils.Test().Printf(_L("Receive TimeOut\n"));
			_LIT(KTxtErrRecvTimeout, "Client - Receive Timeout.");
			iTestUtils.LogIt(KTxtErrRecvTimeout());
			}break;
		case THTTPEvent::ESendTimeOut:
			{
			iTestUtils.Test().Printf(_L("Send TimeOut\n"));
			_LIT(KTxtErrSendTimeout, "Client - Send Timeout.");
			iTestUtils.LogIt(KTxtErrSendTimeout());
			}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;
		_LIT(KTxtTitle, "Test Case Pipeline Fallback");
		THTTPHdrVal numberConnectionsVal;
		if (connInfo.Property(numberConnectionsString, numberConnectionsVal))
			{
			numberConnections = numberConnectionsVal.Int();
			connInfo.RemoveProperty(numberConnectionsString);
			
			if ((numberConnections > expectedConnections) && iTestCase->TestCaseName().Match(KTxtTitle) != 0)
				{

                _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);
		}
		
	if( iTestCase->TransportHandlerPriority() )
		{
		RHTTPConnectionInfo connInfo = iSession.ConnectionInfo();
		THTTPHdrVal enableTranspHndlrPriority(iSession.StringPool().StringF(HTTP::EEnableTranspHndlrPriority, RHTTPSession::GetTable()));
		connInfo.SetPropertyL(iSession.StringPool().StringF(HTTP::ETranspHndlrPriority, RHTTPSession::GetTable()), enableTranspHndlrPriority);
		}

	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();
			}
		}
	}
	
void CPipeliningTestClient::SetTestCase(MPipeliningTestCase* aTestCase)
	{
	iTestCase = aTestCase;
	}

void CPipeliningTestClient::TimeOut()
	{
	iASW->AsyncStop();		
	}

CHttpTimer1::CHttpTimer1(MTimerClient1& aClient)
:CActive(EPriorityStandard), iClient(aClient)
	{
	CActiveScheduler::Add(this);
	iTimer.CreateLocal();
	}

CHttpTimer1::~CHttpTimer1()
	{
	Cancel();
	iTimer.Close();	
	}
	
void CHttpTimer1::After(TTimeIntervalMicroSeconds32 anInterval)
	{
	iTimer.After(iStatus, anInterval);	
	SetActive();
	}

void CHttpTimer1::DoCancel()
	{
	
	}
	
void CHttpTimer1::RunL()
	{
	iClient.TimeOut();
	}