/*

* Copyright (c) 2007-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:   CNcdReportManager implementation

*

*/

#include "ncdreportmanager.h"

#include "ncdoperationobserver.h"

// Supported reports

#include "ncdreportdownload.h"

#include "ncdreportomadownload.h"

#include "ncdreportinstall.h"

#include "ncdproviderdefines.h"

#include "ncdproviderutils.h"

#include "ncdpanics.h"

#include "ncdnodeidentifier.h"

#include "ncdconfigurationmanager.h"

#include "ncdserverdetails.h"

#include "ncdgeneralmanager.h"

// Protocol

#include "ncdprotocol.h"

#include "ncdrequestgenerator.h"

#include "ncdrequestinstallation.h"

#include "ncdcapabilities.h"

#include "ncdprotocol.h"

// Storage

#include "ncdstorage.h"

#include "ncddatabasestorage.h"

#include "ncdstoragemanager.h"

#include "ncdstorageitem.h"

#include "ncdstoragedataitem.h"

#include "catalogscontext.h"

#include "catalogsutils.h"

// HTTP

#include "catalogshttpincludes.h"

#include "catalogshttptransaction.h"

#include "catalogshttpsessionmanagerimpl.h"

#include "catalogsnetworkmanager.h"

#include "catalogshttpconnectionmanager.h"

#include "catalogsdebug.h"

void CNcdReportManager::ReportIdToDescriptor( 

    const TNcdReportId& aId, TDes& aTarget )

    {                

    aTarget.Num( aId );

    }

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

// NewL

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

CNcdReportManager* CNcdReportManager::NewL(

    const MCatalogsContext& aContext,   

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    TBool aClientCrashed )

    {

    CNcdReportManager* self = new(ELeave) CNcdReportManager(

        aContext,

        aGeneralManager,

        aHttpSession,

        aClientCrashed );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

CNcdReportManager::~CNcdReportManager()

    {

    DLTRACEIN((""));

    CancelReportSending();

    Cancel();

    iReports.ResetAndDestroy();

    if ( iNetworkManager )

        {        

        iNetworkManager->RemoveObserver( *this );

        }

    }

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

//

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

//

void CNcdReportManager::SetReportingMethod( const MNcdServerReportManager::TReportingMethod& aMethod )

    {

    DLTRACEIN((""));

    // Here we create a copy of the member variable for later comparison. Notice, that

    // we crete a copy instead of a reference because if reference was used then the value of the

    // variable would change when iReporting is changed.

    MNcdServerReportManager::TReportingMethod tmpMethod( iReportingMethod ); 

    iReportingMethod = aMethod;

    if ( tmpMethod != iReportingMethod

         && iReportingMethod == MNcdServerReportManager::EReportingBackground

         && iManagerState == ENcdReportManagerIdle

         && iTransactions.Count() == 0 )

        {

        // If reporting method was changed to background method,

        // then try one loop to send the reports now, instead of waiting for the next report setting.

        // Also, transactions are checked to be sure that no pending transactions exist and

        // to check if all HTTP operations are completed yet.

        // Probably there is not anything to send, but just in case.

        // This setting will also start the RunL loop for the sending.

        TRAP_IGNORE( SetManagerStateL( ENcdReportManagerPreparing ) );

        }

    }

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

//

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

//

const MNcdServerReportManager::TReportingMethod& CNcdReportManager::ReportingMethod() const

    {

    DLTRACEIN((""));

    return iReportingMethod;

    }

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

//

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

//

void CNcdReportManager::SetReportingStyle( const MNcdServerReportManager::TReportingStyle& aStyle )

    {

    DLTRACEIN((""));

    iReportingStyle = aStyle;

    }

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

//

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

//

const MNcdServerReportManager::TReportingStyle& CNcdReportManager::ReportingStyle() const

    {

    DLTRACEIN((""));

    return iReportingStyle;

    }

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

//

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

//

void CNcdReportManager::StartSendReportsL( MNcdOperationObserver& aObserver )

    {

    DLTRACEIN((""));

    if ( iObserver != NULL )

        {

        // Operation is already going on and observer is set.

        User::Leave( KErrInUse );

        }

    else if ( iReportingMethod != MNcdServerReportManager::EReportingManaged )

        {

        // This function should be called only for managed reports.

        User::Leave( KErrArgument );

        }

    else if ( iManagerState != ENcdReportManagerIdle

              || iTransactions.Count() > 0 )

        {

        // This case may occur if the reporting method has just been changed and

        // there was still an automated operation pending when sending was asked

        // by the manager.

        // Because observer was not set, then set it here.

        // Observers are set only when reporting is managed.

        // For automated reporting observers are not used.

        // Also, transactions are checked to be sure that no pending transactions exist and

        // to check if all HTTP operations are completed yet.

        // Notice, that ownership is not transferred here.

        iObserver = &aObserver;

        return;

        }

    else

        {

        // We are having a managed report and operation is in idle state.

        // So, start the action.

        SetManagerStateL( ENcdReportManagerPreparing );

        // Notice, that ownership is not transferred here.

        iObserver = &aObserver;

        }

    }

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

//

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

TNcdReportId CNcdReportManager::RegisterDownloadL(

    const TDesC& aUri,

    const CNcdNodeIdentifier& aMetadataId,

	const TNcdReportStatusInfo& aStatus, 

	const TDesC& aReportUri,

	const TDesC& aReportNamespace )

    {

    DLTRACEIN(( _L("aUri: %S, aStatus: %d"), &aUri, aStatus.iStatus ));

    // Check if the download has already been registered

    CNcdReport* report = FindReport( 

        aUri, 

        aMetadataId, 

        aReportUri,

        ENcdReportDownload, 

        iReports );

    // Use old report only if it can still be updated with a new

    // status before sending. We don't want to overwrite any pending 

    // cancellation/failure/success reports

    if ( report && !report->StatusIsFinal() ) 

        {

        DLTRACEOUT(("Download has already been registered"));

        report->Attributes().SetAttributeL( 

            ENcdReportAttributeIsUsed, ETrue );

        return report->ReportId();

        }

    report = NULL;

    TBool serverSupports = ServerSupportsReports( 

        ENcdReportDownload,

        aReportUri, 

        aReportNamespace );

    if ( serverSupports ) 

        {        

        DLTRACE(("Server supports download reports"));

        report = CNcdReportDownload::NewLC( 

            *this,

            aUri, 

            aMetadataId,

            aStatus,

            aReportUri,

            aReportNamespace );

        iReports.InsertInOrderAllowRepeatsL( 

            report, 

            TLinearOrder<CNcdReport>( CNcdReport::Compare ) );

        CleanupStack::Pop( report );

        report->SetReportId( GenerateReportId() );

        report->Attributes().SetAttributeL( 

            ENcdReportAttributeIsUsed, ETrue );

        DLTRACEOUT(("Report added"));        

        return report->ReportId();

        }

    return KNcdReportNotSupported;

    }

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

//

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

TNcdReportId CNcdReportManager::RegisterOmaDownloadL(

    const TDesC& aUri,

    const CNcdNodeIdentifier& aMetadataId,

	const TNcdReportStatusInfo& aStatus, 	

	const TDesC& aReportUri )

    {

    DLTRACEIN(( _L("aUri: %S, aStatus: %d"), &aUri, aStatus.iStatus ));       

    // Check if the download has already been registered

    CNcdReport* report = FindReport( 

        aUri, 

        aMetadataId, 

        aReportUri,

        ENcdReportOmaDownload,

        iReports );

    // Use old report only if it can still be updated with a new

    // status before sending    

    if ( report && !report->StatusIsFinal() ) 

        {

        DLTRACEOUT(("Download has already been registered"));

        report->Attributes().SetAttributeL( 

            ENcdReportAttributeIsUsed, ETrue );

        return report->ReportId();

        }

    report = NULL;

    DLTRACE(("Server supports download reports"));

    report = CNcdReportOmaDownload::NewLC( 

        *this,

        aUri, 

        aMetadataId,

        aStatus,

        aReportUri );

    iReports.InsertInOrderAllowRepeatsL( 

        report, 

        TLinearOrder<CNcdReport>( CNcdReport::Compare ) );

    CleanupStack::Pop( report );    

    report->SetReportId( GenerateReportId() );

    report->Attributes().SetAttributeL( 

        ENcdReportAttributeIsUsed, ETrue );

    DLTRACEOUT(("Report added"));

    return report->ReportId();

    }

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

//

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

TInt CNcdReportManager::SetDownloadReportAccessPoint( 

    const TNcdReportId& aReportId,    

    const TCatalogsConnectionMethod& aAccessPoint )

    {

    DLTRACEIN(("aAccessPoint: %d", aAccessPoint.iId ));

    CNcdReport* report = FindReport( 

        aReportId,

        iReports );

    if ( !report ) 

        {

        DLERROR(("Download has not been been registered"));

        return KErrNotFound;

        }

    report->SetAccessPoint( aAccessPoint );

    DLTRACEOUT(("Access point set successfully"));

    return KErrNone;

    }

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

//

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

void CNcdReportManager::ReportDownloadStatusL( 

    const TNcdReportId& aReportId,

    const TNcdReportStatusInfo& aStatus,

    TBool aSendable )

    {

    DLTRACEIN(("aStatus: %d", aStatus.iStatus ));

    CNcdReport* report = FindReport( 

        aReportId,

        iReports );

    if ( !report ) 

        {

        DLERROR(("Report not found"));

        return;

        }    

    SetReportStatusL( *report, aStatus, aSendable );

    }

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

//

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

TNcdReportId CNcdReportManager::RegisterInstallL(

    const TDesC& aContentIdentifier,

    const CNcdNodeIdentifier& aMetadataId,

	const TNcdReportStatusInfo& aStatus, 

	const TDesC& aReportUri,

	const TDesC& aReportNamespace )

    {

    DLTRACEIN(( _L("aReportUri: %S, aStatus: %d"), &aReportUri, aStatus.iStatus ));

    // Check if the install has already been registered.

    CNcdReport* report = FindReport( 

        aContentIdentifier,

        aMetadataId, 

        aReportUri,

        ENcdReportInstall,

        iReports );

    if ( report && !report->StatusIsFinal() ) 

        {

        DLTRACEOUT(("Install has already been registered"));

        report->Attributes().SetAttributeL( 

            ENcdReportAttributeIsUsed, ETrue );

        return report->ReportId();

        }        

    TBool serverSupports = ServerSupportsReports( 

        ENcdReportInstall,

        aReportUri, 

        aReportNamespace );

    if ( serverSupports ) 

        {        

        DLTRACE(("Server supports install reports"));

        report = CNcdReportInstall::NewLC( 

            *this,

            aContentIdentifier,

            aMetadataId,

            aStatus,

            aReportUri,

            aReportNamespace );

        iReports.InsertInOrderAllowRepeatsL( 

            report, 

            TLinearOrder<CNcdReport>( CNcdReport::Compare ) );

        CleanupStack::Pop( report );

        report->SetReportId( GenerateReportId() );

        report->Attributes().SetAttributeL( 

            ENcdReportAttributeIsUsed, ETrue );

        DLTRACEOUT(("Report added"));        

        return report->ReportId();

        }

    return KNcdReportNotSupported;

    }

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

//

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

TInt CNcdReportManager::SetInstallReportAccessPoint( 

    const TNcdReportId& aReportId,    

    const TCatalogsConnectionMethod& aAccessPoint )

    {

    DLTRACEIN(("aAccessPoint: %d", aAccessPoint.iId ));

    // Same implementation with download and install.

    TInt error( SetDownloadReportAccessPoint( aReportId, aAccessPoint ) );

    DLTRACEOUT(("Access point set successfully"));

    return error;

    }

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

//

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

void CNcdReportManager::ReportInstallStatusL( 

    const TNcdReportId& aReportId,

    const TNcdReportStatusInfo& aStatus )

    {

    DLTRACEIN(("aStatus: %d", aStatus.iStatus));

    // Same implementation with download and install    

    TBool sendable( EFalse );

    if ( aStatus.iStatus == ENcdReportSuccess

         || aStatus.iStatus == ENcdReportCancel

         || aStatus.iStatus == ENcdReportFail )

        {

        sendable = ETrue;

        }

    ReportDownloadStatusL( aReportId, aStatus, sendable );

    }

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

// 

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

void CNcdReportManager::SetReportsAsUsedL( 

    const CNcdNodeIdentifier& aMetadataId )

    {

    DLTRACEIN((""));

    for ( TInt i = 0; i < iReports.Count(); ++i )

        {

        if ( iReports[i]->MetadataId().Equals( aMetadataId ) ) 

            {

            DLINFO(("Setting report as used"));       

            iReports[i]->Attributes().SetAttributeL( 

                ENcdReportAttributeIsUsed, ETrue );

            // No break since there may be other reports with

            // the same metadata id

            } 

        }

    }

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

//

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

void CNcdReportManager::RemoveUnusedReportsL()

    {

    DLTRACEIN((""));

    for ( TInt i = 0; i < iReports.Count(); ++i )

        {

        if ( !iReports[i]->Attributes().AttributeInt32(

                ENcdReportAttributeIsUsed ) )

            {            

            TNcdReportStatusInfo info( ENcdReportCancel, KErrCancel );

            SetReportStatusL( *iReports[i], info, ETrue );

            }

        }

    }

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

//

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