/*

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

*

*/

#include <httpstringconstants.h>

#include <rhttpheaders.h>

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

#ifdef ENABLE_USAGE_REPORT_TEST

#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

const TInt KLogbufferLenth = KLogBufferSize/2 - 1;

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

// 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" );

    // remove E32USER-CBase-66

#ifdef _DEBUG

    TRAP_IGNORE( iHttpSession.Close() );

#else

    iHttpSession.Close();

#endif

    delete iLogMessage;

    if ( iIRNetworkControllerHandle )

        {

        iIRNetworkControllerHandle->Close();

        }

    if(iLogoDownloadEngine)

    	{

	    delete iLogoDownloadEngine;

	    iLogoDownloadEngine = NULL;

    	}

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

    }

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

// CIRHttpDataProvider::NewL()

// 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()

// 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()

// 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()

// Used to issue the request.

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

//

TInt CIRHttpDataProvider::IssueHttpRequestL( CIRHttpRequestData &aRequestInfo )

    {

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

    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 ENABLE_USAGE_REPORT_TEST

    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 ENABLE_USAGE_REPORT_TEST  

    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()

// 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." );

    }

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

// CIRHttpDataProvider::InitializeHttpDataProviderL()

// Initialize the data provider component

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

//

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 - EGotResponseHeaders" );

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

            {

            IRLOG_INFO( "CIRHTTPDATAPROVIDER::MHFRUNL - ESucceeded" );

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

            aTransaction.Close();

            iRunning = EFalse;

            iObserver.HttpEventComplete();

            }

            break;

        case THTTPEvent::EFailed:

            {

            IRLOG_INFO( "CIRHttpDataProvider::MHFRunL - EFailed" );

            IRLOG_INFO2( "CIRHttpDataProvider::MHFRunL aEvent.iStatus= %d", aEvent.iStatus );

            IRLOG_INFO2( "CIRHttpDataProvider::MHFRunL iStatusCode= %d", iStatusCode );

            // Transaction completed with failure.

            aTransaction.Close();

            iRunning = EFalse;

            iObserver.HttpTransactionError( iStatusCode );

            }

            break;

       case THTTPEvent::ENotifyNewRequestBodyPart:

            {

            iLogMessage->ReleaseData();

            }

            break;

        case KServiceUnavailable:

            {

            IRLOG_INFO( "CIRHttpDataProvider::MHFRunL - KServiceUnavailable" );

            aTransaction.Close();

            iRunning = EFalse;

            iObserver.HttpTransactionError( KServiceUnavailable );

            }

            break;

        case KDndTimedOut:

            {

            IRLOG_INFO( "CIRHttpDataProvider::MHFRunL - KDndTimedOut" );

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

            {

            IRLOG_INFO( "CIRHttpDataProvider::MHFRunL - default" );

            if ( aEvent.iStatus < 0 )

                {

                IRRDEBUG2( "CIRHttpDataProvider::MHFRunL aEvent.iStatus= %d", aEvent.iStatus );

                // Just close the transaction on errors

                aTransaction.Close();

                iRunning = EFalse;

                iObserver.HttpTransactionError( aEvent.iStatus );

                }

            // 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" );

    // Handle error and return KErrNone.

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

    return KErrNone;

    }

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

// CIRHttpDataProvider::ExtractResponseHeadersL()

// 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 );