#include <commdb.h>

#include <commdbconnpref.h>

#include "loadgen_httpreceiver.h"

// CONSTANTS

_LIT8( KHttpScheme, "http" );

_LIT8( KSchemeAddon, "://" );

// This client accepts all content types.

_LIT8(KAccept, "*/*");

CHTTPReceiver* CHTTPReceiver::NewL( MHTTPRecvObserver& aObserver )

	{

	CHTTPReceiver* self = CHTTPReceiver::NewLC( aObserver );

	CleanupStack::Pop( self );

	return self;

	}

CHTTPReceiver* CHTTPReceiver::NewLC( MHTTPRecvObserver& aObserver )

	{

	CHTTPReceiver* self = new (ELeave)CHTTPReceiver( aObserver );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

CHTTPReceiver::CHTTPReceiver( MHTTPRecvObserver& aObserver ) :

	iObserver(aObserver), iRunning(EFalse), iConnectionSetupDone(EFalse)

	{

	}

void CHTTPReceiver::ConstructL()

	{

#ifdef _DEBUG

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

#endif

	}

CHTTPReceiver::~CHTTPReceiver()

	{

	TRACE( "Entry: CHTTPReceiver::~CHTTPReceiver" );

	CancelTransaction();

	TRAP_IGNORE( iSession.DisconnectL() );

	iSession.Close();

	iConnection.Stop();

	iConnection.Close();

	iSocketServ.Close();

	TRACE( "Entry: CHTTPReceiver::~CHTTPReceiver - delete iUrl" );

	delete iUrl;

#ifdef _DEBUG

	iFs.Close();

#endif

	TRACE( "Exit: CHTTPReceiver::~CHTTPReceiver" );

	}

void CHTTPReceiver::CancelTransaction()

	{

	if ( !iRunning)

		return;

	TRACE( "Entry: CHTTPReceiver::CancelTransaction" );

	if ( iRunning)

		{

		iTransaction.Close();

		iRunning = EFalse;

		}

	TRACE( "Exit: CHTTPReceiver::CancelTransaction" );

	}

// ----------------------------------------------------------------------------

// CHTTPReceiver::SendHTTPGetL()

//

// Start a new HTTP GET transaction.

// ----------------------------------------------------------------------------

void CHTTPReceiver::SendHTTPGetL( const TDesC8& aURL )

	{

	TRACE( "Entry: CHTTPReceiver::SendHTTPGetL" );

	iResponseStatus = KErrGeneral;

#ifdef _DEBUG

    iResponseFile.Replace( iFs, _L("C:\\Data\\loadgen.htm"), EFileWrite );

#endif

	SetupConnectionL();	

	// Parse string to URI (as defined in RFC2396)

	TUriParser8 uri;

	CheckForHTTPSchemeL(uri, aURL);

	RStringF method = iSession.StringPool().StringF(HTTP::EGET, RHTTPSession::GetTable());

	CleanupClosePushL( method );

	iTransaction = iSession.OpenTransactionL(uri, *this, method);

	// Set headers for request: accepted content type

	RHTTPHeaders hdr = iTransaction.Request().GetHeaderCollection();

	SetHeaderL(hdr, HTTP::EAccept, KAccept);

	iTransaction.SubmitL();

	iRunning = ETrue;

	CleanupStack::PopAndDestroy();

	TRACE( "Exit: CHTTPReceiver::SendHTTPGetL" );

	return;

	}

void CHTTPReceiver::CheckForHTTPSchemeL(TUriParser8& aUri, const TDesC8& aURL)

	{

	if( iUrl )

	    {

	    delete iUrl;

	    iUrl = NULL;

	    }

	iUrl = aURL.AllocL();

	aUri.Parse( *iUrl );

	TPtrC8 scheme( aUri.Extract (EUriScheme) );

	// unsupported or no scheme in url.

	// Insert 'http://' to the beginning of it.

	if ( scheme != KHttpScheme )

		{

		HBufC8* tempBuf = HBufC8::NewL( KHttpScheme().Length() + KSchemeAddon().Length() + aURL.Length() );

		CleanupStack::PushL( tempBuf );

		tempBuf->Des().Append( KHttpScheme );

		tempBuf->Des().Append( KSchemeAddon );

		tempBuf->Des().Append( aURL );

		if( iUrl )

		    {

            delete iUrl;

            iUrl = NULL;

		    }

		iUrl = tempBuf;

		aUri.Parse( *iUrl );

		CleanupStack::PopAndDestroy( tempBuf );

		}

	}

// Used to set header value to HTTP request

void CHTTPReceiver::SetHeaderL (RHTTPHeaders aHeaders, TInt aHdrField, const TDesC8& aHdrValue)

	{

	RStringF valStr = iSession.StringPool().OpenFStringL (aHdrValue);

	CleanupClosePushL (valStr);

	THTTPHdrVal val(valStr);

	aHeaders.SetFieldL (iSession.StringPool().StringF (aHdrField, RHTTPSession::GetTable ()), val);

	CleanupStack::PopAndDestroy (); // valStr

	}

// Inherited from MHTTPTransactionCallback

// Called by framework to pass transaction events.

// ----------------------------------------------------------------------------

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

	{

	TRACE( "Entry: CHTTPReceiver::MHFRunL" );

	TRACE2( "Entry: CHTTPReceiver::MHFRunL <%d>", aEvent.iStatus );

	// state check

	if ( !iRunning )

		{

		TRACE( "Exit1: CHTTPReceiver::MHFRunL: recv in wrong state" );

		return;

		}

	switch ( aEvent.iStatus )

		{

	case THTTPEvent::EGotResponseHeaders:

		{

		TRACE( "Entry: CHTTPReceiver::MHFRunL EGotResponseHeaders" );

		// Get HTTP status code from header (e.g. 200)

		RHTTPResponse resp = aTransaction.Response();

		iResponseStatus = resp.StatusCode();

		}

		break;

	case THTTPEvent::EGotResponseBodyData:

		{

		// Get the body data supplier

		TRACE( "Entry: CHTTPReceiver::MHFRunL EGotResponseBodyData" );

		MHTTPDataSupplier* body = aTransaction.Response().Body ();

		TPtrC8 dataChunk;

		body->GetNextDataPart ( dataChunk );

#ifdef _DEBUG

		if ( dataChunk.Length() )

		    {

			iResponseFile.Write( dataChunk );

		    }

#endif

		body->ReleaseData ();

		}

		break;

	case THTTPEvent::EResponseComplete:

		{

		// Indicates that header & body of response is completely received.

		// Notify Observer

		TRACE( "Entry: CHTTPReceiver::MHFRunL EResponseComplete" );

		}

		break;

	case THTTPEvent::ESucceeded:

		{

		// Transaction can be closed now. It's not needed anymore.

		TRACE( "Entry: CHTTPReceiver::MHFRunL ESucceeded" );

		Finalize();

		}

		break;

	case THTTPEvent::EFailed:

		{

		TRACE( "Entry: CHTTPReceiver::MHFRunL EFailed" );

		iResponseStatus = KErrGeneral;

		Finalize();

		}

		break;

	default:

		TRACE( "Entry: CHTTPReceiver::MHFRunL EDefault" );

		break;

		}

	}

// Called by framework when *leave* occurs in handling of transaction event.

// These errors must be handled, or otherwise HTTP-CORE 6 panic is thrown.

// ----------------------------------------------------------------------------

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

	{

	TRACE( "Entry: CHTTPReceiver::MHFRunError" );

	iResponseStatus = aError;

	Finalize();

	TRACE( "Exit: CHTTPReceiver::MHFRunError" );

	return KErrNone;

	}

void CHTTPReceiver::SetupConnectionL ()

	{

	TRACE( "Entry: CHTTPReceiver::StartConnectionL" );

	// check if conncetion is already open

	if ( iRunning )

		{

		return;

		}

	if ( iConnectionSetupDone )

	    {

		return;

	    }

	iConnectionSetupDone = ETrue;

	// open HTTP session

	iSession.OpenL();

	// open socket server

	TInt result = iSocketServ.Connect();

	if ( result == KErrNone)

		{

		// open connection

		result = iConnection.Open(iSocketServ);

		if ( result == KErrNone)

			{

			// set overrides

			TCommDbConnPref pref;

			pref.SetDialogPreference (ECommDbDialogPrefPrompt);

			//pref.SetDirection (ECommDbConnectionDirectionOutgoing);

			//pref.SetIapId (accessPoint);

			// start with overrides

			result = iConnection.Start(pref);

			if ( result == KErrNone)

				{

				// get connection info from iSession

				RHTTPConnectionInfo connInfo = iSession.ConnectionInfo ();

				RStringPool pool = iSession.StringPool ();

				// set socket server

				connInfo.SetPropertyL (pool.StringF (HTTP::EHttpSocketServ,

						RHTTPSession::GetTable () ),

						THTTPHdrVal( iSocketServ.Handle () ) );

				// attach to connection

				TInt connectionPtr= REINTERPRET_CAST( TInt,

						&iConnection );

				connInfo.SetPropertyL (pool.StringF (

						HTTP::EHttpSocketConnection,

						RHTTPSession::GetTable () ),

						THTTPHdrVal (connectionPtr) );

#if defined(__WINSCW__) || defined(__WINS__) // if Emulator

				_LIT8(KProxyAddr, "192.168.0.252:4040");

				TBufC8<30> proxyAddr(KProxyAddr);

				RStringF prxAddr = iSession.StringPool().OpenFStringL (proxyAddr);

				CleanupClosePushL (prxAddr);

				THTTPHdrVal prxUsage(iSession.StringPool().StringF (HTTP::EUseProxy,

						RHTTPSession::GetTable ()));

				iSession.ConnectionInfo().SetPropertyL (iSession.StringPool().StringF (HTTP::EProxyUsage,

						RHTTPSession::GetTable ()), prxUsage);

				iSession.ConnectionInfo().SetPropertyL (iSession.StringPool().StringF (HTTP::EProxyAddress,

						RHTTPSession::GetTable ()), prxAddr);

				CleanupStack::PopAndDestroy (); // prxAddr	

#endif 

				}

			else

				{

				TRACE2( "CHTTPReceiver:: connection start: <%d>", result );

				}

			}

		else

			{

			TRACE2( "CHTTPReceiver:: connection open: <%d>", result );

			}

		}

	else

		{

		TRACE2( "CHTTPReceiver:: connection to socket server: <%d>", result );		

		}

	User::LeaveIfError( result );

	TRACE( "Exit: CHTTPReceiver::StartConnectionL" );

	}

// ----------------------------------------------------------------------------

// CHTTPReceiver::Finalize

// 

// ----------------------------------------------------------------------------

//

void CHTTPReceiver::Finalize()

    {

    TRACE( "Exit: CHTTPReceiver::Finalize" );

#ifdef _DEBUG

    iResponseFile.Close();

#endif

    iTransaction.Close();

    iRunning = EFalse;

    iObserver.HTTPFileReceived( iResponseStatus );

    TRACE( "Exit: CHTTPReceiver::Finalize" );

    }