/*
* Copyright (c) 2008 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:  WMDRM DLA Default Metering
*
*/


#include <chttpformencoder.h>
#include <httpstringconstants.h>
#include <httperr.h>
#include <http/rhttpheaders.h>
#include <http/thttphdrfielditer.h>
#include <stringpool.h>
#include <escapeutils.h>
#include <wmdrmdlatypes.h>
#include <wmdrmdlauinotifier.h>
#include "wmdrmdladefaultmetering.h"
#include "wmdrmdladefaulthttpplugin.h"
#include "wmdrmdladefaulthttpmanager.h"

#define _LOGGING_FILE L"wmdrmdladefaulthttpplugin.txt"
#include "logfn.h"

// CONSTANTS
_LIT8( KDefaultIdentifier, "camese" );

_LIT8( KAcceptHeader8, "*/*" );
_LIT8( KAcceptLanguageHeader8, "en-us" );
_LIT8( KPostContentTypeHeader8, "application/x-www-form-urlencoded" );

_LIT8( KDataTypeMeteringResponse, "application/vnd.ms-wmdrm.meter-resp" );
_LIT8( KGetMeterChallengeParam8, "meterchallenge" );

// ======== LOCAL FUNCTIONS ========

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::ConstructL
// ---------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::ConstructL()
    {
    LOGFN( "CWmDrmDlaDefaultMetering::ConstructL" );
    iHttpManager = CWmDrmDlaDefaultHttpManager::NewL( *this );
    iHttpManager->SetKeepAlive( ETrue );
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::CWmDrmDlaDefaultMetering
// ---------------------------------------------------------------------------
//
CWmDrmDlaDefaultMetering::CWmDrmDlaDefaultMetering( 
    CWmDrmDlaDefaultHttpPlugin* aPlugin ) 
    : iState( CWmDrmDlaDefaultMetering::ENotActive ), iPlugin( aPlugin )
    {
    LOGFN( "CWmDrmDlaDefaultMetering::CWmDrmDlaDefaultMetering" );
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::NewL
// ---------------------------------------------------------------------------
//
CWmDrmDlaDefaultMetering* CWmDrmDlaDefaultMetering::NewL(
    CWmDrmDlaDefaultHttpPlugin* aPlugin )
    {
    LOGFN( "CWmDrmDlaDefaultMetering::NewL" );
    CWmDrmDlaDefaultMetering* self 
        = new( ELeave ) CWmDrmDlaDefaultMetering( aPlugin );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::~CWmDrmDlaDefaultMetering
// ---------------------------------------------------------------------------
//
CWmDrmDlaDefaultMetering::~CWmDrmDlaDefaultMetering()
    {
    LOGFN( "CWmDrmDlaDefaultMetering::~CWmDrmDlaDefaultMetering" );
    delete iHttpManager;
    delete iFormEncoder;
    delete iMeteringResponse;
    delete iMeteringServerUrl;
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::SupportedMeteringCertificateL
// ---------------------------------------------------------------------------
//
TBool CWmDrmDlaDefaultMetering::SupportedMeteringCertificateL( 
    const TDesC8& aCertificate,
    CWmDrmDlaUiNotifier*& aUiNotifier )
    {
    LOGFN( "CWmDrmDlaDefaultMetering::SupportedMeteringCertificateL" );
    
    TBool supported( iPlugin->Supported( aCertificate, KDefaultIdentifier ) );
    if ( supported )
        {
        iPlugin->InitializeUiNotifierL();
        aUiNotifier = iPlugin->UiNotifier();
        }
    LOG2( "supported: %d", supported );     
    return supported;
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::ProcessMeteringChallenge
// ---------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::ProcessMeteringChallenge( 
    const TDesC8& aMeteringChallenge, 
    const TDesC& aUrl, 
    TRequestStatus& aStatus )
    {
    TInt err( KErrNone );
    
    LOGFNR( "CWmDrmDlaDefaultMetering::ProcessMeteringChallenge", err );
    
    iPlugin->UiNotifier()->SetProgress( EProcessingMeteringChallenge );
    aStatus = KRequestPending;
    iClientStatus = &aStatus;
    
    delete iMeteringServerUrl;
    iMeteringServerUrl = NULL;
    iMeteringServerUrl = aUrl.Alloc();
    if ( !iMeteringServerUrl )
        {
        CompleteClientRequest( KErrNoMemory );
        return;
        }
    
    TRAP( err, ProcessMeteringChallengeL( aMeteringChallenge ) );
    if ( err )
        {
        CompleteClientRequest( err );
        return;
        }
    iState = CWmDrmDlaDefaultMetering::ESendingMeteringChallenge;
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::GetMeteringResponse
// ---------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::GetMeteringResponse( 
    HBufC8*& aResponse, 
    TRequestStatus& aStatus )
    {
    TInt err( KErrNone );
    
    LOGFNR( "CWmDrmDlaDefaultMetering::GetMeteringResponse", err );
        
    aStatus = KRequestPending;
    iClientStatus = &aStatus;
    
    if ( iMeteringResponse )
        {
        aResponse = iMeteringResponse->Alloc();
        if ( !aResponse )
            {
            err = KErrNoMemory;
            }
        }
    else
        {
        aResponse = NULL;
        }
    CompleteClientRequest( err );
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::MeteringFinished
// ---------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::MeteringFinished()
    {
    LOGFN( "CWmDrmDlaDefaultMetering::MeteringFinished" );
    iPlugin->UiNotifier()->SetProgress( EIdle );
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::CancelMetering
// ---------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::CancelMetering()
    {
    LOGFN( "CWmDrmDlaDefaultMetering::CancelMetering" );
    iHttpManager->Stop();
    CompleteClientRequest( KErrCancel );
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultHttpPlugin::SetIapId
// ---------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::SetIapId( TInt aIapId )
    {
    LOGFN( "CWmDrmDlaDefaultMetering::SetIapId" );
    LOG2( "aIapId: %d", aIapId );
    iHttpManager->SetIapId( aIapId );
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::OnGetUsernamePasswordL
// From MHttpManagerObserver
// This function is called when using HTTPS authentication. Authentication is 
// not currently used in the Camese project
// ----------------------------------------------------------------------------
//
TBool CWmDrmDlaDefaultMetering::OnGetUsernamePasswordL(
    HBufC8*& /*aUsername*/,
    HBufC8*& /*aPassword*/)
    {
    LOGFN( "CWmDrmDlaDefaultMetering::OnGetUsernamePasswordL" );
    return EFalse;
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::OnResponseHeadersL
// From MHttpManagerObserver
// ----------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::OnResponseHeadersL(
    const RHTTPResponse& /*aResponse*/,
    const RHTTPHeaders& aHeaders,
    const RStringPool& aStringPool,
    TInt aHttpStatus )
    {
    LOGFN( "CWmDrmDlaDefaultMetering::OnResponseHeadersL" );
    LOG2( "iState: %d", iState );
    LOG2( "aHttpStatus: %d", aHttpStatus );
    if ( aHttpStatus == HTTPStatus::EOk )
        {
        RStringF contentTypeNameStr 
            = aStringPool.StringF( HTTP::EContentType, 
                                   RHTTPSession::GetTable() );

        // read the first part of content-type field
        THTTPHdrVal contentTypeVal;
        if( !aHeaders.GetField( contentTypeNameStr, 0, contentTypeVal ) )
            {
            //Metering
            if ( iState == 
                        CWmDrmDlaDefaultMetering::ESendingMeteringChallenge &&
                 contentTypeVal.StrF().DesC().MatchF( 
                         KDataTypeMeteringResponse ) != KErrNotFound )
                {
                iHttpStatus = HTTPStatus::EOk;
                }
            else
                {
                iHttpStatus = KErrHttpDecodeContentType;
                }
            }
        else
            {
            iHttpStatus = KErrHttpDecodeContentType;
            }
        contentTypeNameStr.Close();
        }
    else
        {
        iHttpStatus = aHttpStatus;
        }
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::OnResponseBodyDataL
// From MHttpManagerObserver
// ----------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::OnResponseBodyDataL( const TPtrC8 aDataChunk )
    {
    LOGFN( "CWmDrmDlaDefaultMetering::OnResponseBodyDataL" );
    LOG2( "iState: %d", iState );
    LOG2( "iHttpStatus: %d", iHttpStatus );
    if ( iHttpStatus == HTTPStatus::EOk && 
         iState == CWmDrmDlaDefaultMetering::ESendingMeteringChallenge )
        {
        if ( !iMeteringResponse )
            {
            iMeteringResponse = HBufC8::NewL( aDataChunk.Length() );
            }
        else
            {
            iMeteringResponse 
                = iMeteringResponse->ReAllocL( iMeteringResponse->Length() + 
                                               aDataChunk.Length() );
            }
        iMeteringResponse->Des().Append( aDataChunk );
        }
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::OnTransactionComplete
// From MHttpManagerObserver
// ----------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::OnTransactionComplete( TInt aSystemError )
    {
    LOGFN( "CWmDrmDlaDefaultMetering::OnTransactionComplete" );
    LOG2( "iState: %d", iState );
    LOG2( "aSystemError: %d", aSystemError );
    LOG2( "iHttpStatus: %d", iHttpStatus );
    if ( iHttpStatus == HTTPStatus::EOk && !aSystemError )
        {
        CompleteClientRequest( aSystemError );
        }
    else if ( iHttpStatus != HTTPStatus::EOk )
        {
        CompleteClientRequest( KErrCommsBreak );
        }
    else
        {
        CompleteClientRequest( aSystemError );
        }
    iState = CWmDrmDlaDefaultMetering::ENotActive;
    }

// ----------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::CompleteClientRequest
// ----------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::CompleteClientRequest( TInt aError )
    {
    LOGFN( "CWmDrmDlaDefaultMetering::CompleteClientRequest" );
    LOG2( "aError: %d", aError );
    if ( iClientStatus )
        {
        User::RequestComplete( iClientStatus, aError );
        iClientStatus = NULL;
        }
    }

// ---------------------------------------------------------------------------
// CWmDrmDlaDefaultMetering::ProcessMeteringChallengeL
// ---------------------------------------------------------------------------
//
void CWmDrmDlaDefaultMetering::ProcessMeteringChallengeL( 
    const TDesC8& aMeteringChallenge )
    {
    LOGFN( "CWmDrmDlaDefaultMetering::ProcessMeteringChallengeL" );
    // Make an 8-bit URI of the challenge URL.
    HBufC8* meteringServerUrl8( 
            EscapeUtils::ConvertFromUnicodeToUtf8L( *iMeteringServerUrl ) );
    CleanupStack::PushL( meteringServerUrl8 );
    TUriParser8 uri;
    User::LeaveIfError( uri.Parse( *meteringServerUrl8 ) );
    
    // POST the DrmHeader status to the server
    // Set headers
    RArray< CWmDrmDlaDefaultHttpManager::THeader > headers;
    CleanupClosePushL( headers );

    headers.AppendL( CWmDrmDlaDefaultHttpManager::THeader( HTTP::EAccept,
                                                           KAcceptHeader8 ) );
    headers.AppendL( 
            CWmDrmDlaDefaultHttpManager::THeader( HTTP::EAcceptLanguage, 
                                                  KAcceptLanguageHeader8 ) );
    headers.AppendL( 
            CWmDrmDlaDefaultHttpManager::THeader( HTTP::EContentType, 
                                                  KPostContentTypeHeader8 ) );
    
    // Set POST contents
    delete iFormEncoder;
    iFormEncoder = NULL;
    iFormEncoder = CHTTPFormEncoder::NewL();
    iFormEncoder->AddFieldL( KGetMeterChallengeParam8, aMeteringChallenge );

    iHttpManager->Post( *meteringServerUrl8, headers, iFormEncoder );

    CleanupStack::PopAndDestroy( 2, meteringServerUrl8 ); //headers, 
                                                          //meteringServerUrl8
    }