/*

* 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 CNcdNodeMetaData class

*

*/

#include "ncdnodemetadataimpl.h"

#include "ncdnodeidentifier.h"

#include "ncdnodedisclaimer.h"

#include "ncdnodeiconimpl.h"

#include "ncdnodescreenshotimpl.h"

#include "ncdnodeskinimpl.h"

#include "ncdnodeupgradeimpl.h"

#include "ncdnodedependencyimpl.h"

#include "ncdnodeuricontentimpl.h"

#include "ncdnodecontentinfoimpl.h"

#include "ncdnodepreviewimpl.h"

#include "ncdpurchaseoptionimpl.h"

#include "ncdpurchasedetails.h"

#include "ncdpurchasehistorydbimpl.h"

#include "ncdnodedownloadimpl.h"

#include "ncdnodeinstallimpl.h"

#include "ncdnodeuserdataimpl.h"

#include "catalogssession.h"

#include "catalogsbasemessage.h"

#include "ncdnodefunctionids.h"

#include "catalogsconstants.h"

#include "ncd_pp_dataentity.h"

#include "ncd_pp_dataentitycontent.h"

#include "ncd_cp_query.h"

#include "ncd_pp_download.h"

#include "ncd_pp_purchaseoption.h"

#include "ncdprotocoltypes.h"

#include "catalogsutils.h"

#include "ncdutils.h"

#include "ncdkeyvaluepair.h"

#include "ncdpanics.h"

#include "ncdserversubscribablecontent.h"

#include "ncdpurchasehistoryutils.h"

#include "ncderrors.h"

#include "catalogsdebug.h"

CNcdNodeMetaData::CNcdNodeMetaData(

    NcdNodeClassIds::TNcdNodeClassId aClassId,

    CNcdNodeManager& aNodeManager )

: CCatalogsCommunicable(),

  iClassId( aClassId ),

  iNodeManager( aNodeManager )  

    {

    DLTRACEIN(("Meta class id: %d", aClassId));

    }

void CNcdNodeMetaData::ConstructL( const CNcdNodeIdentifier& aIdentifier )

    {

    DLTRACEIN((""));

    // These two values has to be set. So, this metadata can be identified.

    iIdentifier = CNcdNodeIdentifier::NewL( aIdentifier );

    // The user data is part of the metadata. So, the ui may set its own info

    // for the node by using this object.

    iUserData = CNcdNodeUserData::NewL( *iIdentifier, iNodeManager );   

    iTimeStamp = KNullDesC().AllocL();

    iName = KNullDesC().AllocL();

    iDescription = KNullDesC().AllocL();

    iLayoutType = KNullDesC().AllocL();

    // This internalization is not related to purchase history so it's done

    // separately

    TRAP_IGNORE( InternalizeInstallFromContentInfoL() );

    TRAPD( phError,

        {

        // Get purchase details

        CNcdPurchaseDetails* details = PurchaseDetailsLC();

        InternalizeContentInfoL( *details );

        // Try to internalize URI content from purchase history

        InternalizeUriContentL( *details );                    

        InternalizeDependencyL( *details );

        // Try to internalize node download from purchase history.

        InternalizeDownloadL( *details );

        // Try to internalize node install from purchase history

        InternalizeInstallL( *details );

        // Try to internalize node icon from purchase history

        // (does not read icon data to memory)

        InternalizeIconL( *details );

        CleanupStack::PopAndDestroy( details );

        });

    if( phError != KErrNone && 

	phError != KErrNotFound &&

	phError != KNcdErrorNoPurchaseInformation )

        {

        DLERROR(( "phError: %d", phError ));

        User::Leave( phError );

        }

    DLTRACEOUT((""));

    }

CNcdNodeMetaData::~CNcdNodeMetaData()

    {

    DLTRACEIN((""));

    delete iIdentifier;

    iIdentifier = NULL;

    delete iTimeStamp;

    iTimeStamp = NULL;

    delete iName;

    iName = NULL;

    delete iDescription;

    iDescription = NULL;

    delete iLayoutType;

    iLayoutType = NULL;

    // Notice that CCatalogsCommunicable classes cannot be destroyed by

    // calling delete! Instead call Close to them

    if ( iUserData )

        {

        DLINFO(("Closing node user data"));

        iUserData->Close();       

        iUserData = NULL; 

        }

    if ( iDisclaimer != NULL )

        {

        iDisclaimer->Close();

        iDisclaimer = NULL;

        }

    if ( iIcon != NULL )

        {

        iIcon->Close();

        iIcon = NULL;        

        }

    if ( iScreenshot != NULL )

        {

        iScreenshot->Close();

        iScreenshot = NULL;

        }

    if ( iSkin != NULL )

        {

        iSkin->Close();

        iSkin = NULL;        

        }

    if( iUriContent != NULL )

        {

        iUriContent->Close();

        iUriContent = NULL;

        }

    if( iContentInfo != NULL )

        {

        iContentInfo->Close();

        iContentInfo = NULL;

        }

    if( iPreview != NULL )

        {

        iPreview->Close();

        iPreview = NULL;

        }

    if ( iUpgrade != NULL )

        {

        iUpgrade->Close();

        iUpgrade = NULL;

        }

    if ( iDependency != NULL )

        {

        iDependency->Close();

        iDependency = NULL;

        }

    if ( iDownload )

        {

        DLINFO(("Closing node download"));

        iDownload->Close();

        iDownload = NULL;

        }

    if ( iInstall )

        {

        DLINFO(("Closing node install"));

        iInstall->Close();

        iInstall = NULL;

        }

    if ( iMoreInfo != NULL )

        {

        iMoreInfo->Close();

        iMoreInfo = NULL;

        }

    iDetails.ResetAndDestroy();

    delete iSubscribableContent;

    iSubscribableContent = NULL;

    ResetAndCloseArray( iPurchaseOptions );

    DLTRACEOUT((""));

    }        

CNcdNodeManager& CNcdNodeMetaData::NodeManager() const

    {

    return iNodeManager;

    }

const CNcdNodeIdentifier& CNcdNodeMetaData::Identifier() const

    {

    return *iIdentifier;

    }

NcdNodeClassIds::TNcdNodeClassId CNcdNodeMetaData::ClassId() const

    {

    return iClassId;

    }    

const TDesC& CNcdNodeMetaData::TimeStamp() const

    {

    DASSERT( iTimeStamp );

    return *iTimeStamp;

    }

const TDesC& CNcdNodeMetaData::NodeName() const

    {

    DASSERT( iName );

    return *iName;

    }

void CNcdNodeMetaData::SetNodeNameL( const TDesC& aName )

    {

    HBufC* newName = aName.AllocL();

    delete iName;

    iName = newName;

    }

const TDesC& CNcdNodeMetaData::Description() const

    {

    DASSERT( iDescription );

    return *iDescription;    

    }

void CNcdNodeMetaData::SetDescriptionL(

    const TDesC& aDescription ) 

    {

    HBufC* newDescription = aDescription.AllocL();

    delete iDescription;

    iDescription = newDescription;

    }

const TDesC& CNcdNodeMetaData::LayoutType() const 

    {

    DASSERT( iLayoutType );

    return *iLayoutType;

    }

const CNcdNodeDisclaimer& CNcdNodeMetaData::DisclaimerL() const

    {

    if ( iDisclaimer == NULL )

        {

        User::Leave( KErrNotFound );

        }

    return *iDisclaimer;

    }

void CNcdNodeMetaData::SetDisclaimer( CNcdNodeDisclaimer* aDisclaimer )

    {

    if ( iDisclaimer != NULL )

        {

        iDisclaimer->Close();        

        }

    iDisclaimer = aDisclaimer;

    }

const CNcdNodeDisclaimer& CNcdNodeMetaData::MoreInfoL() const

    {

    if ( iMoreInfo == NULL )

        {

        User::Leave( KErrNotFound );

        }

    return *iMoreInfo;

    }

CNcdNodeIcon& CNcdNodeMetaData::IconL() const

    {

    if ( iIcon == NULL )

        {

        User::Leave( KErrNotFound );

        }

    return *iIcon;

    }

void CNcdNodeMetaData::SetIcon( CNcdNodeIcon* aIcon ) 

    {

    if ( iIcon ) 

        {

        iIcon->Close();

        }

    iIcon = aIcon;

    }

const CNcdNodeScreenshot& CNcdNodeMetaData::ScreenshotL() const

    {

    if ( iScreenshot == NULL )

        {

        User::Leave( KErrNotFound );

        }

    return *iScreenshot;

    }

const CNcdNodeSkin& CNcdNodeMetaData::SkinL() const

    {

    DASSERT( iSkin );

    return *iSkin;

    }

CNcdNodePreview& CNcdNodeMetaData::PreviewL() const

    {

    if ( iPreview == NULL )

        {

        User::Leave( KErrNotFound );

        }

    return *iPreview;

    }

const CNcdNodeUpgrade& CNcdNodeMetaData::UpgradeL() const

    {

    if ( iUpgrade == NULL )

        {

        User::Leave( KErrNotFound );

        }

    return *iUpgrade;

    }

const CNcdNodeDependency& CNcdNodeMetaData::DependencyL() const

    {

    if ( iDependency == NULL )

        {

        User::Leave( KErrNotFound );

        }

    return *iDependency;

    }

const CNcdNodeContentInfo& CNcdNodeMetaData::ContentInfoL() const

    {

    if ( iContentInfo == NULL )

        {

        User::Leave( KErrNotFound );      

        }

    return *iContentInfo;

    }

const CNcdServerSubscribableContent*

    CNcdNodeMetaData::SubscribableContent() const

    {

    return iSubscribableContent;

    }

const RPointerArray<CNcdPurchaseOptionImpl>& CNcdNodeMetaData::PurchaseOptions() const

    {

    return iPurchaseOptions;    

    }

CNcdPurchaseOptionImpl& CNcdNodeMetaData::PurchaseOptionByIdL(

    const TDesC& aPurchaseOptionId ) const 

    {

    DLTRACEIN((""));

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

        {

        if ( iPurchaseOptions[i]->Id() == aPurchaseOptionId ) 

            {

            return *iPurchaseOptions[i];

            }

        }

    User::Leave( KErrNotFound );

    CNcdPurchaseOptionImpl* foo( NULL );

    return *foo;

    }  

TBool CNcdNodeMetaData::AlwaysVisible() const 

    {

    return iAlwaysVisible;

    }

void CNcdNodeMetaData::SetAlwaysVisible( TBool aValue ) 

    {

    iAlwaysVisible = aValue;

    }

void CNcdNodeMetaData::InternalizeL( MNcdPreminetProtocolDataEntity& aData )

    {

    DLTRACEIN((""));

    // First create the new values

    HBufC* tmpTimeStamp = aData.Timestamp().AllocLC();

    HBufC* tmpName = aData.Name().AllocLC();

    HBufC* tmpDescription = aData.Description().AllocLC();

    HBufC* tmpLayoutType = aData.LayoutType().AllocLC();

    DLTRACE(( _L("MetaData timestamp: %S"), tmpTimeStamp ));

    DLTRACE(( _L("MetaData name: %S"), tmpName ));

    DLTRACE(( _L("MetaData description: %S"), tmpDescription ));

    delete iLayoutType;

    iLayoutType = tmpLayoutType;

    CleanupStack::Pop( tmpLayoutType );

    delete iDescription;

    iDescription = tmpDescription;

    CleanupStack::Pop( tmpDescription );

    delete iName;

    iName = tmpName;

    CleanupStack::Pop( tmpName );    

    delete iTimeStamp;

    iTimeStamp = tmpTimeStamp;

    CleanupStack::Pop( tmpTimeStamp );

    if ( aData.Disclaimer() )

        {

        // New disclaimer info should be set

        if ( iDisclaimer == NULL )

            {

            // Create disclaimer because it did not exist before.

            iDisclaimer = CNcdNodeDisclaimer::NewL();

            }

        // Update disclaimer info.

        iDisclaimer->InternalizeL( *aData.Disclaimer() );        

        }

    else if ( iDisclaimer )

        {

        // Because new data does not contain disclaimer.

        // Close old one and set the value NULL.

        // Notice that CCatalogsCommunicalbe classes should be Closed

        // instead of deleting.

        // Because this object may still be left hanging for proxy object if it is used by UI,

        // set the object obsolete. So, UI will know this if it is trying to internalize 

        // the hanging object.

        iDisclaimer->SetAsObsolete( ETrue );

        iDisclaimer->Close();

        iDisclaimer = NULL;                    

        }

    if ( aData.Icon() )

        {

        // New icon info should be set.

        if ( iIcon == NULL )

            {

            iIcon = CNcdNodeIcon::NewL( iNodeManager, *this );            

            }

        iIcon->InternalizeL( aData );

        }

    else if ( iIcon != NULL )

        {

        // Notice that icons should not be deleted because

        // all the CCatalogsCommunicable classes should be Closed instead.

        // Because this object may still be left hanging for proxy object if it is used by UI,

        // set the object obsolete. So, UI will know this if it is trying to internalize 

        // the hanging object.

        iIcon->SetAsObsolete( ETrue );

        iIcon->Close();

        iIcon = NULL;            

        }

    if ( aData.ScreenshotCount() > 0 )

        {