/*

* Copyright (c) 2006-2007 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:  ?Description

*

*/

#include <httpstringconstants.h>

#include <rhttpheaders.h>

#include <mmfcontrollerpluginresolver.h> //to get the supported MIME types

#ifdef _DEBUG

#include <bautils.h>

#include "irreportsettings.h"

#endif

#include "irdataprovider.h"

#include "irdebug.h"

#include "irhttpdataprovider.h"

#include "irhttppost.h"

#include "irhttprequestdata.h"

#include "irnetworkcontroller.h"

#include "irdatatransferobserver.h"

#include "irlogodownloadengine.h"

#include "irfavoritesdb.h"

#include "irsettings.h"

//Added for ALR/SNAP

const TInt KBufflengthMaxLength = 255;

const TInt KWapProfileMaxLength = 20;

const TInt KNokiaIrAppAcceptMaxLength = 25;

const TInt KSize = 1024;

const TInt KMaxSize = 2048;

const TInt KBufSize = 10;

const TUid KUidHelixController        = { 0x101F8514 }; // Helix Video controller UID

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

// CIRHttpDataProvider::CIRHttpDataProvider(MIRHttpDataProviderObserver&

// aObserver):iObserver(aObserver),iRunning(EFalse)

// Creates instance of CIRHttpDataProvider.

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

//

CIRHttpDataProvider::CIRHttpDataProvider( MIRHttpDataProviderObserver

    &aObserver ): iRunning( EFalse ), iObserver( aObserver )

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::CIRHttpDataProvider" );

    // Definition not required

    }

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

// CIRHttpDataProvider::~CIRHttpDataProvider()

// Destructs instance of CIRHttpDataProvider.

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

//

CIRHttpDataProvider::~CIRHttpDataProvider()

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::~CIRHttpDataProvider - Entering" );

    iHttpSession.Close();

    delete iLogMessage;

    if(iIRNetworkControllerHandle)

    	{

    	iIRNetworkControllerHandle->Close();

        }

    if(iLogoDownloadEngine)

    	{

	    delete iLogoDownloadEngine;

	    iLogoDownloadEngine = NULL;

    	}

    IRLOG_DEBUG( "CIRHttpDataProvider::~CIRHttpDataProvider - Exiting." );

    }

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

// CIRHttpDataProvider::NewL(MIRHttpDataProviderObserver& aObserver )

// Creates instance of CIRHttpDataProvider.

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

//

CIRHttpDataProvider *CIRHttpDataProvider::NewL( MIRHttpDataProviderObserver

	&aObserver )

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::NewL - Entering" );

    CIRHttpDataProvider *self = NewLC( aObserver );

    CleanupStack::Pop(self);

    IRLOG_DEBUG( "CIRHttpDataProvider::NewL - Exiting" );

    return self;

    }

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

// CIRHttpDataProvider::NewLC(MIRHttpDataProviderObserver& aObserver)

// Creates instance of CIRHttpDataProvider.

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

//

CIRHttpDataProvider *CIRHttpDataProvider::NewLC( MIRHttpDataProviderObserver

    &aObserver )

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::NewLC - Entering" );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    IRLOG_DEBUG( "CIRHttpDataProvider::NewLC - Exiting" );

    return self;

    }

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

// CIRHttpDataProvider::ConstructL()

// 2nd phase construction

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

//

void CIRHttpDataProvider::ConstructL()

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::ConstructL - Entering" );

    iFirstTime = ETrue;

    iIRNetworkControllerHandle = CIRNetworkController::OpenL();

    iLogMessage = CIRHttpPost::NewL(iHttpTransaction);

    iLogoDownloadEngine = CIRLogoDownloadEngine::NewL();

    IRLOG_DEBUG( "CIRHttpDataProvider::ConstructL - Exiting" );

    }

EXPORT_C CIRLogoDownloadEngine* CIRHttpDataProvider::GetLogoDownloadEngine()

{

IRLOG_DEBUG( "CIRHttpDataProvider::GetLogoDownloadEngine" );

	return iLogoDownloadEngine;

}

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

// CIRHttpDataProvider::CancelTransactionL()

// Cancel the issued Http transaction

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

//

void CIRHttpDataProvider::CancelTransaction()

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::CancelTransaction  - Entering" );

    // Make sure that logfile is closed

    CloseLogFile ();

    if ( !iRunning )

        {

        return ;

        }

    // Close() also cancels transaction (Cancel() can also be used but

    // resources allocated by transaction must be still freed with Close())

    iHttpTransaction.Close();

    // Not running anymore

    iRunning = EFalse;

    IRLOG_DEBUG( "CIRHttpDataProvider::CancelTransaction - Exiting." );

    }

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

// CIRHttpDataProvider::CloseLogFile  ( CIRHttpRequestData& aRequestInfo )

// Used to Close the log file LogUsage.gz externally from other sources (bug-fixing)

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

//

void CIRHttpDataProvider::CloseLogFile ()

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::CloseLogFile  - Entering" );

	if (iLogMessage) iLogMessage->CloseLogFile ();

	IRLOG_DEBUG( "CIRHttpDataProvider::CloseLogFile  - Exiting" );

    }

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

// CIRHttpDataProvider::IssueHttpRequestL( CIRHttpRequestData& aRequestInfo )

// Used to issue the request.

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

//

TInt CIRHttpDataProvider::IssueHttpRequestL( CIRHttpRequestData &aRequestInfo )

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::IssueHttpRequestL - Entering" );

    IRRDEBUG2("CIRHTTPDATAPROVIDER::IRHTTPISSUEREQUESTL",KNullDesC);

    iNotModified = EFalse;

    if ( !( iIRNetworkControllerHandle->GetNetworkStatus() ) )

        {

        // Error Network connection inactive

        return KErrCouldNotConnect;

        }

    if ( iFirstTime )

        {

        InitializeHttpDataProviderL();

        iIRNetworkControllerHandle->InitializeHttpSessionL( iHttpSession,

        			 MIRDataTransferTracker::EIRTransferCategoryIsds);

        iFirstTime = EFalse;

        }

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

    TUriParser8 uri;

    uri.Parse( aRequestInfo.iUri );

    // Get request method string

    RStringF method;

    switch ( aRequestInfo.iMethod )

        {

        case EIRHttpGET:

                {

                method = iHttpSession.StringPool().StringF( HTTP::EGET,

					RHTTPSession::GetTable() );

                }

            break;

        case EIRHttpPOST:

                {

                method = iHttpSession.StringPool().StringF( HTTP::EPOST,

					RHTTPSession::GetTable() );

                }

            break;

        default:

            {

            }

            break;

        }

    CleanupClosePushL( method );

    IRLOG_DEBUG( "CIRHttpDataProvider::IssueHttpRequestL - Opening transaction" );

    // Open transaction with previous method and parsed uri. This class will

    // receive transaction events in MHFRunL and MHFRunError.

    iHttpTransaction = iHttpSession.OpenTransactionL( uri,  *this, method );

#ifdef _DEBUG

    RFs iFs;

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

    TTime timeStamp;

    //timeStamp.UniversalTime();

    timeStamp.HomeTime();

    TDateTime dateTime =  timeStamp.DateTime();

    _LIT(KFormatTime,"-%d-%d-%d %d.%d.%d.xml.gz\n");

    TBuf<32>    sendTime;

    sendTime.Format(KFormatTime,dateTime.Year(),TInt(dateTime.Month()+1),dateTime.Day()+1,

                                dateTime.Hour(),dateTime.Minute(),dateTime.Second());

    _LIT( KDstFilePath, "c:\\data\\IR_Log\\");

    TFileName dstFileName(KDstFilePath);

    dstFileName.Append(KGZipLogFileName);

    dstFileName.Append(sendTime);

    iFs.MkDirAll(dstFileName);

    if ( aRequestInfo.iMethod == EIRHttpPOST )

        {

        CIRSettings * settings = CIRSettings::OpenL();

        if(NULL != settings)

            {

            TFileName filePath = settings->PrivatePath();

            filePath.Append( KGZipLogFileName );                   

            BaflUtils::CopyFile(iFs, filePath, dstFileName);

            settings->Close();

        }

    }

#endif

    if ( aRequestInfo.iMethod == EIRHttpPOST )

        {

        IRLOG_DEBUG( "CIRHttpDataProvider::IssueHttpRequestL - POST method" );

        // Close the LogFile

        iLogMessage->CloseLogFile ();

        iLogMessage->SetTransaction( iHttpTransaction );

        TInt FileSize(KErrNone);

        TRAPD(err, iLogMessage->GetFileToPostL(&FileSize));

        if( err )

	        {

	        // failed to open the file to be posted hence cancel the request

	        CleanupStack::PopAndDestroy(&method);

	        iHttpTransaction.Close();

	        return KErrCouldNotConnect;

	        }

        TBuf8<KBufflengthMaxLength> bufflength;

        _LIT8(KFormat,"%d");

        bufflength.Format(KFormat,FileSize);

        aRequestInfo.iContentType.Copy(KPostContentType);

        RHTTPRequest LogRequest;

        LogRequest = iHttpTransaction.Request();

        LogRequest.SetBody((MHTTPDataSupplier&) *iLogMessage);

        RHTTPHeaders header = iHttpTransaction.Request().GetHeaderCollection();

        SetHeaderL(header,HTTP::EContentType,aRequestInfo.iContentType );

        SetHeaderL(header,HTTP::EContentLength,bufflength);

        }

     // Setup the headers for the HTTP request

    BuildHeadersL(aRequestInfo);

    // Submit the transaction. After this the framework will give transaction

    // events via MHFRunL and MHFRunError.

    iHttpTransaction.SubmitL();

#ifdef _DEBUG  

    if ( aRequestInfo.iMethod == EIRHttpPOST )

        {

        _LIT( KSentPrefix, "X__");

        TFileName sentLogFileName(KDstFilePath);

        sentLogFileName.Append(KSentPrefix);

        sentLogFileName.Append(KGZipLogFileName);

        sentLogFileName.Append(sendTime);

        BaflUtils::RenameFile(iFs, dstFileName, sentLogFileName);      

        }

    iFs.Close();

#endif    

    CleanupStack::PopAndDestroy( &method );

    iRunning = ETrue;

    IRLOG_INFO( "CIRHttpDataProvider::IssueHttpRequestL - Submitted HTTP request" );

    return KErrNone;

    }

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

// CIRHttpDataProvider::SetHttpContentType(TDesC& aContentType,TDesC& aCharSet)

// Set the Http content type

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

//

void CIRHttpDataProvider::SetHttpContentType( const TDesC &aContentType,

    const TDesC &aCharSet )

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::SetHttpContentType - Entering" );

    iContentType.Copy( aContentType );

    iCharSet.Copy( aCharSet );

    IRLOG_DEBUG( "CIRHttpDataProvider::SetHttpContentType - Exiting." );

    }

void CIRHttpDataProvider::InitializeHttpDataProviderL()

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::InitializeHttpDataProviderL - Entering" );

    iHttpSession.Close();

    TRAPD( LeaveValue, iHttpSession.OpenL() );

    if ( LeaveValue != KErrNone )

        {

        // Most common error; no access point configured, and session creation

        // leaves with KErrNotFound.

        // Load a string from the resource file and add the error code to string

        User::Leave( LeaveValue );

        }

    // Set the HTTP connection properties

    RStringPool strP = iHttpSession.StringPool();

    RHTTPConnectionInfo connInfo = iHttpSession.ConnectionInfo();

    // RSocketServ Handle

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

		RHTTPSession::GetTable() ),

		THTTPHdrVal( iIRNetworkControllerHandle->GetIRSocketServer().Handle() ) );

    // RConnection Handle

    TInt connPtr = REINTERPRET_CAST( TInt,

		&( iIRNetworkControllerHandle->GetIRConnection() ) );

    connInfo.SetPropertyL( strP.StringF( HTTP::EHttpSocketConnection,

		RHTTPSession::GetTable() ), THTTPHdrVal( connPtr ) );

    // HTTP Version ( Specify that i am using HTTP/1.1

	connInfo.SetPropertyL( strP.StringF( HTTP::EVersion,

		RHTTPSession::GetTable() ),

		THTTPHdrVal( strP.StringF( HTTP::EHttp11, RHTTPSession::GetTable() ) ) );

	RStringF temp = strP.OpenFStringL( KAccept );

    CleanupClosePushL( temp );

    connInfo.SetPropertyL( strP.StringF( HTTP::EAccept,

		RHTTPSession::GetTable() ), THTTPHdrVal( temp ) );

	CleanupStack::PopAndDestroy( &temp );

    iContentType.Copy( KDefaultContentType );

    iCharSet.Copy( KDefaultCharSet );

    IRLOG_DEBUG( "CIRHttpDataProvider::InitializeHttpDataProviderL - Exiting." );

    }

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

// CIRHttpDataProvider::MHFRunL()

// Inherited from MHTTPTransactionCallback

// Called by framework to pass transaction events.

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

//

void CIRHttpDataProvider::MHFRunL( RHTTPTransaction aTransaction,

    const THTTPEvent &aEvent )

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::MHFRunL - Entering." );

    switch ( aEvent.iStatus )

        {

        case THTTPEvent::EGotResponseHeaders:

            {

            IRLOG_INFO( "CIRHttpDataProvider::MHFRunL - THTTPEvent::EGotResponseHeaders" );

            IRRDEBUG2("CIRHTTPDATAPROVIDER::MHFRUNL--HEADERS",KNullDesC);

            // HTTP response headers have been received. Use

            // aTransaction.Response() to get the response. However, it's not

            // necessary to do anything with the response when this event occurs.

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

            RHTTPResponse resp = aTransaction.Response();

            iStatusCode = resp.StatusCode();

            // Get status text (e.g. "OK")

            iStatusText.Copy(

				( const unsigned short int* )resp.StatusText().DesC().Ptr(),

				iStatusText.MaxLength() );

            // Extract header field names and value

	            	ExtractResponseHeadersL( aTransaction );

	        // Validate the status code

            ValidateStatusCode( iStatusCode );

            }

        break;

        case THTTPEvent::EGotResponseBodyData:

            {

            // Part  of response's body data received. Use

            // aTransaction.Response().Body()->GetNextDataPart() to get the actual

            // body data.

            // Get the body data supplier

            IRLOG_INFO( "CIRHttpDataProvider::MHFRunL - THTTPEvent::EGotResponseBodyData" );

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

            TPtrC8 dataChunk;

            body->GetNextDataPart( dataChunk );

            iObserver.HttpBodyReceived( dataChunk );

            // To release the body data.

            body->ReleaseData();

            }

        break;

        case THTTPEvent::ESucceeded:

            {

            IRRDEBUG2("CIRHTTPDATAPROVIDER::MHFRUNL--SUCCEEDED",KNullDesC);

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

            aTransaction.Close();

            iRunning = EFalse;

            iObserver.HttpEventComplete();

            IRLOG_INFO( "CIRHttpDataProvider::MHFRunL - THTTPEvent::ESucceeded" );

            }

        break;

        case THTTPEvent::EFailed:

            {

            IRRDEBUG2("CIRHTTPDATAPROVIDER::MHFRUNL--FAILED",KNullDesC);

            // Transaction completed with failure.

            aTransaction.Close();

            iRunning = EFalse;

            iObserver.HttpTransactionError( iStatusCode );

            IRLOG_ERROR2( "CIRHttpDataProvider::MHFRunL - THTTPEvent::EFailed (status=%d)", iStatusCode );

            }

        break;

       case THTTPEvent::ENotifyNewRequestBodyPart:

            {

            iLogMessage->ReleaseData();

            }

            break;

        case KServiceUnavailable:

	        {

			IRRDEBUG2("MHFRunl:KServiceUnavailable",KNullDesC);

			aTransaction.Close();

            iRunning = EFalse;

			iObserver.HttpTransactionError(KServiceUnavailable);

	        }

	        break;

		case KDndTimedOut:      

				{

                IRRDEBUG2("MHFRunL :KDndTimedOut ",KNullDesC);

      			// Just close the transaction on errors

                aTransaction.Close();

                iRunning = EFalse;

				iObserver.HttpTransactionError(KDndTimedOut);	

				}   

				break;      

        default:

            // There are more events in THTTPEvent,

            // Which is needed can be implemented incase required

            // by the HTTP Data Provider

                {

                IRRDEBUG2("CIRHTTPDATAPROVIDER::MHFRUNL--DEFAULT",KNullDesC);

                if ( aEvent.iStatus < 0 )

                    {

                    IRRDEBUG2("CIRHTTPDATAPROVIDER::MHFRUNL %d",aEvent.iStatus);

                    // Just close the transaction on errors

                    aTransaction.Close();

                    iRunning = EFalse;

                    iObserver.HttpTransactionError( iStatusCode );

                    }

                // Other events are not errors

				// (e.g. permanent and temporary redirections)

				// ignore such errors

                }

            break;

        }

    IRLOG_DEBUG( "CIRHttpDataProvider::MHFRunL - Exiting." );

    }

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

// CIRHttpDataProvider::MHFRunError()

// Inherited from MHTTPTransactionCallback

// Called by framework to pass transaction errors

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

//

TInt CIRHttpDataProvider::MHFRunError( TInt /* aError*/,

    RHTTPTransaction /*aTransaction*/, const THTTPEvent & /*aEvent*/ )

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::MHFRunError - Entering" );

    IRRDEBUG2("CIRHTTPDATAPROVIDER::MHFRUNERROR",KNullDesC);

    // Handle error and return KErrNone.

    IRLOG_DEBUG( "CIRHttpDataProvider::MHFRunError - Exiting." );

    return KErrNone;

    }

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

// CIRHttpDataProvider::ExtractResponseHeadersL( RHTTPTransaction aTransaction )

// Used to Extract the response headers.

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

//

void CIRHttpDataProvider::ExtractResponseHeadersL(const RHTTPTransaction&

	aTransaction )

    {

    IRLOG_DEBUG( "CIRHttpDataProvider::ExtractResponseHeadersL - Entering" );

    RHTTPResponse response = aTransaction.Response();

    RHTTPHeaders respHeader = response.GetHeaderCollection();

    THTTPHdrFieldIter iterator = respHeader.Fields();

    RStringPool httpStringPool = aTransaction.Session().StringPool();

    iterator.First();

    HBufC8 *headerField = HBufC8::NewLC( KMaxHeaderNameLength +

		KMaxHeaderValueLength );

    HBufC8 *fieldValBuf = HBufC8::NewLC( KMaxHeaderValueLength );

    while ( iterator.AtEnd() == EFalse )

        {

        RStringTokenF fieldName = iterator();

        RStringF fieldNameStr = httpStringPool.StringF( fieldName );

        THTTPHdrVal fieldVal;

        if ( respHeader.GetField( fieldNameStr, 0, fieldVal ) == KErrNone )

            {

            const TDesC8 &fieldNameDesC = fieldNameStr.DesC();

            headerField->Des().Copy( fieldNameDesC.Left(