/*

* Copyright (c) 2006-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:   Implements CNcdServerReportManager class

*

*/

#include <e32err.h>

#include <e32base.h>

#include <s32mem.h>

#include "ncdserverreportmanagerimpl.h"

#include "ncdreportmanager.h"

#include "ncdnodeidentifier.h"

#include "ncdnodeimpl.h"

#include "ncdnodemetadataimpl.h"

#include "ncdproviderimpl.h"

#include "ncdpurchasehistorydbimpl.h"

#include "ncdpurchasehistoryutils.h"

#include "ncdutils.h"

#include "ncdnodefunctionids.h"

#include "catalogssession.h"

#include "catalogsbasemessage.h"

#include "catalogscontext.h"

#include "catalogsaccesspointmanager.h"

#include "catalogshttpsession.h"

#include "catalogsdebug.h"

CNcdServerReportManager* CNcdServerReportManager::NewL( CNcdProvider& aProvider )

    {

    CNcdServerReportManager* self = 

        CNcdServerReportManager::NewLC( aProvider );

    CleanupStack::Pop( self );

    return self;        

    }

CNcdServerReportManager* CNcdServerReportManager::NewLC( CNcdProvider& aProvider )

    {

    CNcdServerReportManager* self = 

        new( ELeave ) CNcdServerReportManager( aProvider);

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;        

    }

CNcdServerReportManager::CNcdServerReportManager( CNcdProvider& aProvider )

: CCatalogsCommunicable(),

  iProvider( aProvider )

    {

    }

void CNcdServerReportManager::ConstructL()

    {

    DLTRACEIN((""));

    }

CNcdServerReportManager::~CNcdServerReportManager()

    {

    DLTRACEIN((""));

    }

void CNcdServerReportManager::ReceiveMessage( MCatalogsBaseMessage* aMessage,

                                              TInt aFunctionNumber )

    {

    DLTRACEIN(("handle: %d, function: %d", 

               aMessage->Handle(), 

               aFunctionNumber));

    DASSERT( aMessage );

    // Now, we can be sure that rest of the time iMessage exists.

    // This member variable is set for the CounterPartLost function.

    iMessage = aMessage;

    TInt trapError( KErrNone );

    switch( aFunctionNumber )

        {

        case NcdNodeFunctionIds::ENcdServerReportManagerSetReportingMethod:

            TRAP( trapError, SetReportingMethodRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdServerReportManagerReportingMethod:

            TRAP( trapError, ReportingMethodRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdServerReportManagerSetReportingStyle:

            TRAP( trapError, SetReportingStyleRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdServerReportManagerReportingStyle:

            TRAP( trapError, ReportingStyleRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdServerReportManagerNodeSetAsInstalled:

            TRAP( trapError, NodeSetAsInstalledRequestL( *aMessage ) );

            break;        

        case NcdNodeFunctionIds::ENcdRelease:

            ReleaseRequest( *aMessage );

            break;

        default:

            DLERROR(("Unidentified function request"));

            DASSERT( EFalse );

            break;

        }

    if ( trapError != KErrNone )

        {

        // Because something went wrong the complete has not been

        // yet called for the message.

        // So, inform the client about the error.

        DLTRACEIN(("Complete with error message"));

        aMessage->CompleteAndRelease( trapError );

        }

    // Because the message should not be used after this, set it NULL.

    // So, CounterPartLost function will know that no messages are

    // waiting the response at the moment.

    iMessage = NULL;

    DLTRACEOUT((""));

    }

void CNcdServerReportManager::CounterPartLost( const MCatalogsSession& aSession )

    {

    // This function may be called whenever -- when the message is waiting

    // response or when the message does not exist.

    // iMessage may be NULL here, because in the end of the

    // ReceiveMessage it is set to NULL. The life time of the message

    // ends shortly after CompleteAndRelease is called.

    if ( iMessage != NULL )

        {

        iMessage->CounterPartLost( aSession );

        }    

    }

CNcdProvider& CNcdServerReportManager::Provider()

    {

    return iProvider;

    }

CNcdReportManager& CNcdServerReportManager::ReportManagerL( MCatalogsBaseMessage& aMessage )

    {

    // Get current context

    MCatalogsContext& context( aMessage.Session().Context() );

    // All the clients have their own report manager.

    TNcdProviderContext providerContext;

    Provider().GetProviderContextL( context, providerContext );

    CNcdReportManager& reportManager( *providerContext.iReportManager );

    return reportManager;

    }

void CNcdServerReportManager::SetReportingMethodRequestL( MCatalogsBaseMessage& aMessage )

    {

    HBufC8* input = HBufC8::NewLC( aMessage.InputLength() );

    TPtr8 inputPtr = input->Des();

    aMessage.ReadInput( inputPtr );

    RDesReadStream inputStream( *input );

    CleanupClosePushL( inputStream );

    MNcdServerReportManager::TReportingMethod method(

        static_cast<MNcdServerReportManager::TReportingMethod>( inputStream.ReadInt32L() ) );

    CleanupStack::PopAndDestroy( &inputStream );

    CleanupStack::PopAndDestroy( input );

    ReportManagerL( aMessage ).SetReportingMethod( method );

    // If this leaves, ReceiveMessge will complete the message.

    aMessage.CompleteAndRelease( KErrNone );

    }

void CNcdServerReportManager::ReportingMethodRequestL( MCatalogsBaseMessage& aMessage )

    {

    TInt method( 

        ReportManagerL( aMessage ).ReportingMethod() );

    aMessage.CompleteAndReleaseL( method, KErrNone );    

    }

void CNcdServerReportManager::SetReportingStyleRequestL( MCatalogsBaseMessage& aMessage )

    {

    HBufC8* input = HBufC8::NewLC( aMessage.InputLength() );

    TPtr8 inputPtr = input->Des();

    aMessage.ReadInput( inputPtr );

    RDesReadStream inputStream( *input );

    CleanupClosePushL( inputStream );

    MNcdServerReportManager::TReportingStyle style(

        static_cast<MNcdServerReportManager::TReportingStyle>( inputStream.ReadInt32L() ) );

    CleanupStack::PopAndDestroy( &inputStream );

    CleanupStack::PopAndDestroy( input );

    ReportManagerL( aMessage ).SetReportingStyle( style );

    // If this leaves, ReceiveMessge will complete the message.

    aMessage.CompleteAndRelease( KErrNone );

    }

void CNcdServerReportManager::ReportingStyleRequestL( MCatalogsBaseMessage& aMessage )

    {

    TInt style( 

        ReportManagerL( aMessage ).ReportingStyle() );

    aMessage.CompleteAndReleaseL( style, KErrNone );    

    }

void CNcdServerReportManager::NodeSetAsInstalledRequestL( MCatalogsBaseMessage& aMessage )

    {

    HBufC8* input = HBufC8::NewLC( aMessage.InputLength() );

    TPtr8 inputPtr = input->Des();

    aMessage.ReadInput( inputPtr );

    RDesReadStream inputStream( *input );

    CleanupClosePushL( inputStream );

    TInt errorCode( inputStream.ReadInt32L() );

    CNcdNodeIdentifier* identifier( CNcdNodeIdentifier::NewLC( inputStream ) );

    CNcdReportManager& reportManager( ReportManagerL( aMessage ) );

    CNcdNode& node( Provider().NodeManager().NodeL( *identifier ) ); 

    CNcdNodeMetaData& metaData( node.NodeMetaDataL() );

    TNcdReportStatusInfo info( ENcdReportCreate, errorCode );

    // Use the node identifier to identify the content in install report.

    // Node id uniquely identifies the node that contains contents

    // that will be installed. One node may contains multiple contents but

    // they are all thought as one bundle, in one operation. Also, notice that 

    // multiple nodes can contain same metadata and same content.

    TNcdReportId reportId = 

        reportManager.RegisterInstallL( 

            identifier->NodeId(),

            metaData.Identifier(),

            info,

            metaData.Identifier().ServerUri(),

            metaData.Identifier().NodeNameSpace() );

    // Set access point for report.

    UpdateInstallReportAccessPointL( aMessage.Session().Context().FamilyId(),

                                     reportId,

                                     node,

                                     metaData,

                                     reportManager,

                                     HttpSessionL( aMessage.Session().Context() ) );    

    // Set the final success information directly into the report instead of

    // reporting other install statuses here.

    TNcdReportStatus status( ENcdReportSuccess );

    if ( errorCode == KErrNone )

        {

        status = ENcdReportSuccess;

        }

    else if ( errorCode == KErrCancel )

        {

        status = ENcdReportCancel;

        }

    else 

        {

        status = ENcdReportFail;

        }

    // Create the status info object with the given info.

    info.iStatus = status;

    info.iErrorCode = errorCode;

    reportManager.ReportInstallStatusL(

            reportId,

            info );

    CleanupStack::PopAndDestroy( identifier );

    CleanupStack::PopAndDestroy( &inputStream );

    CleanupStack::PopAndDestroy( input );

    aMessage.CompleteAndRelease( KErrNone );    

    }

void CNcdServerReportManager::ReleaseRequest( MCatalogsBaseMessage& aMessage ) const

    {

    DLTRACEIN((""));

    // Decrease the reference count for this object.

    // When the reference count reaches zero, this object will be destroyed

    // and removed from the session.

    MCatalogsSession& requestSession( aMessage.Session() );

    TInt handle( aMessage.Handle() );

    aMessage.CompleteAndRelease( KErrNone );

    requestSession.RemoveObject( handle );

    DLTRACEOUT((""));

    }

void CNcdServerReportManager::UpdateInstallReportAccessPointL( const TUid& aClientUid,

                                                               TInt aReportId,

                                                               CNcdNode& aNode,

                                                               CNcdNodeMetaData& aMetaData,

                                                               CNcdReportManager& aReportManager,

                                                               MCatalogsHttpSession& aHttpSession )

    {

    DLTRACEIN((""));

    CNcdPurchaseHistoryDb& db = Provider().NodeManager().PurchaseHistory();    

    CNcdPurchaseDetails* purchase = 

        NcdPurchaseHistoryUtils::PurchaseDetailsLC(

            db,

            aClientUid,

            aMetaData.Identifier(),

            EFalse );

    // Create origin identifier

    CNcdNodeIdentifier* originIdentifier = 

        CNcdNodeIdentifier::NewL(

            aNode.Identifier().NodeNameSpace(), 

            purchase->OriginNodeId(), 

            aNode.Identifier().ClientUid() );

    CleanupStack::PopAndDestroy( purchase );

    CleanupStack::PushL( originIdentifier );

    // Get report ap    

    TUint32 apId( 0 );

    TInt error = 

        Provider().AccessPointManager().AccessPointIdL(

            *originIdentifier, 

            MCatalogsAccessPointManager::EBrowse, 

            aClientUid, 

            apId );

    TCatalogsConnectionMethod reportAp;

    if ( error == KErrNone ) 

        {

        DLTRACE(( "Setting access point %d for reports", apId ))   

        reportAp = 

            TCatalogsConnectionMethod( 

                apId, 

                ECatalogsConnectionMethodTypeAccessPoint );

        }

    if ( reportAp.iId == 0 ) 

        {

        reportAp = aHttpSession.ConnectionManager().DefaultConnectionMethod();

        }

    CleanupStack::PopAndDestroy( originIdentifier );

    aReportManager.SetInstallReportAccessPoint( 

        aReportId,

        reportAp );

    }

MCatalogsHttpSession& CNcdServerReportManager::HttpSessionL( MCatalogsContext& aContext )

    {

    TNcdProviderContext providerContext;

    Provider().GetProviderContextL( aContext, providerContext );

    return *providerContext.iHttpSession;

    }