/*

* Copyright (c) 2006 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 CNcdNodeManagerProxy class

*

*/

#include <e32err.h>

#include "ncdnodemanagerproxy.h"

#include "ncdnodeproxy.h"

#include "ncdnodefolderproxy.h"

#include "ncdbundlefolderproxy.h"

#include "ncdsearchnodefolderproxy.h"

#include "ncdnodeitemproxy.h"

#include "ncdsearchnodeitemproxy.h"

#include "catalogsclientserver.h"

#include "ncdnodefunctionids.h"

#include "ncdnodeclassids.h"

#include "ncdproviderdefines.h"

#include "ncdnodeidentifier.h"

#include "ncdrootnodeproxy.h"

#include "ncdpurchasedetails.h"

#include "catalogsdebug.h"

#include "ncdoperationmanagerproxy.h"

#include "ncdsearchrootnodeproxy.h"

#include "catalogsconstants.h"

#include "catalogsutils.h"

#include "ncdproviderproxy.h"

#include "ncdexpirednode.h"

#include "ncdnodesupplierproxy.h"

#include "ncdnodeidentifiereditor.h"

#include "ncdsearchnodebundleproxy.h"

#include "ncdfavoritemanagerproxy.h"

#include "ncdpanics.h"

CNcdNodeManagerProxy* CNcdNodeManagerProxy::NewL(

    MCatalogsClientServer& aSession, 

    TInt aHandle,

    CNcdOperationManagerProxy& aOperationManager,

    CNcdSubscriptionManagerProxy& aSubscriptionManager,

    CNcdProviderProxy& aProvider )

    {

    CNcdNodeManagerProxy* self = 

        CNcdNodeManagerProxy::NewLC( aSession, 

                                     aHandle,

                                     aOperationManager,

                                     aSubscriptionManager,

                                     aProvider );

    CleanupStack::Pop( self );

    return self;        

    }

CNcdNodeManagerProxy* CNcdNodeManagerProxy::NewLC(

    MCatalogsClientServer& aSession, 

    TInt aHandle,

    CNcdOperationManagerProxy& aOperationManager,

    CNcdSubscriptionManagerProxy& aSubscriptionManager,

    CNcdProviderProxy& aProvider )

    {

    CNcdNodeManagerProxy* self = 

        new( ELeave ) CNcdNodeManagerProxy( aSession,

                                            aHandle,

                                            aOperationManager,

                                            aSubscriptionManager,

                                            aProvider );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;        

    }

CNcdNodeManagerProxy::CNcdNodeManagerProxy(

    MCatalogsClientServer& aSession, 

    TInt aHandle,

    CNcdOperationManagerProxy& aOperationManager,

    CNcdSubscriptionManagerProxy& aSubscriptionManager,

    CNcdProviderProxy& aProvider )

: CNcdBaseProxy( aSession, aHandle ),

  iOperationManager( aOperationManager ),

  iSubscriptionManager( aSubscriptionManager ),

  iFavoriteManager( NULL ),

  iProvider( aProvider )

    {

    }

void CNcdNodeManagerProxy::ConstructL()

    {

    iOperationManager.SetNodeManager( this );

    }

CNcdNodeManagerProxy::~CNcdNodeManagerProxy()

    {

    DLTRACEIN((""));

    if( iSearchRootNode )

        {

        // release own reference to 

        iSearchRootNode->InternalRelease();

        }

    // Release all nodes without reference count. These nodes have not

    // been used after creation.

    for ( TInt i = iNodeCache.Count() - 1; i >= 0; i-- ) 

        {

        if ( iNodeCache[i]->TotalRefCount() == 0 )

            {

            // During delete, node is removed from the array automatically.

            // Notice that it is safe to call delete here instead of Release,

            // because we checked the total count above. Release implementation 

            // contains DASSERT that would assert if we called Release here.

            delete iNodeCache[i];

            }

        }

    // For debugging purposes check if some nodes have been left hanging.

    // All the nodes should be released before manager is deleted.

    DLINFO(("Cache count: %d", iNodeCache.Count()));

    #ifdef CATALOGS_BUILD_CONFIG_DEBUG

        DLINFO(("The following nodes have not been properly released:"));

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

            {

            DLINFO(( _L("MNcdNode: %x, namespace: %S, id: %S, refcount: %d"), 

                static_cast<MNcdNode*>( iNodeCache[i] ),

                &iNodeCache[i]->Namespace(), &iNodeCache[i]->Id(),

                iNodeCache[i]->TotalRefCount() ));

            }

        DLINFO(("release check end"));        

    #endif

    DASSERT( iNodeCache.Count() == 0 );           

    // Close the cache.

    iNodeCache.Close();

    // Notice that the root node is also included into the cache.

    // So, no need to delete it separately.

    DLTRACEOUT((""));

    }

CNcdNodeProxy& CNcdNodeManagerProxy::NodeL( const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((_L("Node ID: %S, %S, %d"), 

                &aNodeIdentifier.NodeId(),

                &aNodeIdentifier.NodeNameSpace(),

                aNodeIdentifier.ClientUid()));

    // Check if the node proxy already exists in the cache.

    // Every node has its own namespace and dataid.

    // If it does, do not create it.

    DLTRACE(("Node cache count: %d", iNodeCache.Count() ));

    CNcdNodeProxy* node( NodeExists( aNodeIdentifier ) );

    if ( node != NULL )

        {

        // Node was found. So, return it.

        DLTRACEOUT(("Node found"));

        return *node;

        }

    else if ( aNodeIdentifier.NodeNameSpace() 

                == NcdProviderDefines::KRootNodeNameSpace )

        {

        DLTRACE(("RootNode"));

        // Because the node was not found from the cache,

        // create a new node.

        return RootNodeL();

        }

    else

        {

        DLTRACE(("Create a new node"));

        // Because the node was not found from the cache,

        // create a new node.

        return CreateNodeL( aNodeIdentifier );        

        }

    }

CNcdRootNodeProxy& CNcdNodeManagerProxy::RootNodeL()

    {

    DLTRACEIN((""));

    if( iRootNode == NULL )

        {

        DLTRACE(("Root did not exist. Create it."));

        // Root does not exist. So, create it.

        // First get the handle to the node of the server side.

        // The handle is gotten from the server side nodemanager.

        TInt rootHandle( 0 );

        User::LeaveIfError(

                ClientServerSession().

                    SendSync( NcdNodeFunctionIds::ENcdRootNodeHandle,

                              KNullDesC,

                              rootHandle,

                              Handle() ) );

        DLTRACE(("Root handle: %d", rootHandle ));

        // Now we have handle. So, create the actual root proxy. 

        // Notice that if the proxy object leaves during the construction

        // the destructor automatically releases the handle from the server side.               

        iRootNode = 

            CNcdRootNodeProxy::NewL( ClientServerSession(), 

                                     rootHandle,

                                     *this,

                                     iOperationManager,

                                     *iFavoriteManager );

        // Because root node is created now, it is not in the cache yet.

        // Put it into the cache. So, users can find the root then also

        // by using the NodeL function.

        iNodeCache.AppendL( iRootNode );

        }

    DLTRACEOUT((""));

    return *iRootNode;

    }

CNcdSearchRootNodeProxy& CNcdNodeManagerProxy::SearchRootNodeL()

    {

    DLTRACEIN((""));

    if( iSearchRootNode == NULL )

        {

        DLTRACE(("Search root did not exist. Create it."));

        // Search root does not exist. So, create it.

        // First get the handle to the node of the server side.

        // The handle is gotten from the server side nodemanager.

        TInt searchRootHandle( 0 );

        User::LeaveIfError(

                ClientServerSession().

                    SendSync( NcdNodeFunctionIds::ENcdSearchRootNodeHandle,

                              KNullDesC,

                              searchRootHandle,

                              Handle() ) );

        DLTRACE(("Search root handle: %d", searchRootHandle ));

        // Now we have handle. So, create the actual search root proxy. 

        // Notice that if the proxy object leaves during the construction

        // the destructor automatically releases the handle from the server side.               

        iSearchRootNode = 

            CNcdSearchRootNodeProxy::NewL( ClientServerSession(), 

                                     searchRootHandle,

                                     *this,

                                     iOperationManager,

                                     *iFavoriteManager );

        // call addref to keep search root alive for search ops (search root 

        // is set as observer for them)

        iSearchRootNode->InternalAddRef();

        // Because search root node is created now, it is not in the cache yet.

        // Put it into the cache. So, users can find the search root then also

        // by using the NodeL function.

        iNodeCache.AppendL( iSearchRootNode );

        }

    DLTRACEOUT((""));

    return *iSearchRootNode;

    }

CNcdNodeProxy& CNcdNodeManagerProxy::CreateSchemeNodeL(

    const CNcdNodeIdentifier& aMetadataIdentifier,

    TNcdSchemeNodeType aType,

    TBool aRemoveOnDisconnect,

    TBool aForceCreate )

    {

    DLTRACEIN((""));

    CNcdNodeProxy* node( NULL );

    // Check the favorites for the given metadata and return the node which has

    // the metadata if one exists.

    node = iFavoriteManager->FavoriteNodeByMetaDataL( aMetadataIdentifier );

    if ( node )

        {

        return *node;

        }

    // Node was not found from favorites.

    if ( aForceCreate )

        {

        // Creation is forced, create node of correct type.

        switch ( aType )

            {

            case ENcdSchemeItem:

                node = &CreateTemporaryNodeItemL( aMetadataIdentifier, EFalse );

                break;

            case ENcdSchemeFolder:

                node = &CreateTemporaryNodeFolderL( aMetadataIdentifier, EFalse );

                break;

            case ENcdSchemeBundleFolder:

                node = &CreateTemporaryBundleFolderL( aMetadataIdentifier, EFalse );

                break;

            default:

                NCD_ASSERT_ALWAYS( EFalse, ENcdPanicInvalidArgument );

                break;

            }

        }

    else 

        {

        // Creation not forced, create temporary node item if metadata exists already.

        // This leaves with KErrNotFound if metadata does not exist, thus the

        // node cannot be created.

        node = &CreateTemporaryNodeIfMetadataExistsL( aMetadataIdentifier );

        }

    DASSERT( node );

    // Scheme nodes must be added to favourites.

    node->AddToFavoritesL( aRemoveOnDisconnect );

    DLTRACEOUT((""));

    return *node;

    }

CNcdNodeProxy& CNcdNodeManagerProxy::CreateTemporaryNodeL( 

    const MNcdPurchaseDetails& aDetails )

    {

    DLTRACEIN((""));

    CNcdNodeProxy* node( NULL );

    CNcdNodeIdentifier* identifier( 

        CNcdNodeIdentifier::NewLC( aDetails.Namespace(), 

                                   aDetails.EntityId(), 

                                   aDetails.ServerUri(),

                                   aDetails.ClientUid() ) );

    if ( aDetails.ItemType() == MNcdPurchaseDetails::EItem )

        {

        DLINFO(("Item from purchase history"));

        node = &CreateTemporaryNodeItemL( *identifier, ETrue );

        }

    else if ( aDetails.ItemType() == MNcdPurchaseDetails::EFolder )

        {

        DLINFO(("Folder from purchase history"));

        node = &CreateTemporaryNodeFolderL( *identifier, ETrue );

        }

    else

        {

        DLINFO(("Unknown from purchase history"));

        node = &CreateTemporaryOrSupplierNodeL( *identifier );

        }

    CleanupStack::PopAndDestroy( identifier );

    DLTRACEOUT((""));

    return *node;

    }

CNcdNodeProxy& CNcdNodeManagerProxy::CreateTemporaryNodeFolderL( 

    const CNcdNodeIdentifier& aMetadataIdentifier, TBool aCreateMetaData )

    {

    DLTRACEIN((_L("Metadata ID: %S, %S, %S, %d"), 

                &aMetadataIdentifier.NodeId(),

                &aMetadataIdentifier.NodeNameSpace(),

                &aMetadataIdentifier.ServerUri(),

                aMetadataIdentifier.ClientUid()));        

    // Check if the node proxy already exists in the cache.

    // Every node has its own namespace and dataid.

    // If it does exist, do not create it.

    // At first, try to find the node from cache by creating the node identifier

    // from the metadata identifier.

    CNcdNodeIdentifier* tempNodeIdentifier =

        NcdNodeIdentifierEditor::CreateTemporaryNodeIdentifierLC( aMetadataIdentifier );

    CNcdNodeProxy* node( NodeExists( *tempNodeIdentifier ) );

    if ( node ) 

        {

        // Node was found. So, return it.

        CleanupStack::PopAndDestroy( tempNodeIdentifier );

        DLTRACEOUT(("Node found in cache"));

        return *node;

        }

    // Notice that the actual node identifier is given here, instead of the

    // metadata identifier.

    HBufC8* nodeIdentifierData( tempNodeIdentifier->NodeIdentifierDataL() );

    CleanupStack::PopAndDestroy( tempNodeIdentifier );

    CleanupStack::PushL( nodeIdentifierData );

    DLINFO(("Get node handle"));

    // First get the handle to the node of the server side.

    // The handle is gotten from the server side nodemanager.

    // NOTE: The identifier may contain NULL UID here, but it will

    // be replaced by the family id in the server side. And then

    // the node proxy will contain the right UID when the created node is

    // internalized during its creation.

    TInt function = aCreateMetaData ? 

        NcdNodeFunctionIds::ENcdTemporaryNodeFolderWithMetaDataHandle : 

        NcdNodeFunctionIds::ENcdTemporaryNodeFolderHandle;

    TInt nodeHandle( 0 );

    User::LeaveIfError(

            ClientServerSession().

                SendSync( function,

                          *nodeIdentifierData,

                          nodeHandle,

                          Handle() ) );

    DLTRACE(("Node handle: %d", nodeHandle ));

    CleanupStack::PopAndDestroy( nodeIdentifierData );

    // No need to check the class id here, because we requested an item

    // node above.

    node = 

        CNcdNodeFolderProxy::NewLC( ClientServerSession(),

                                    nodeHandle,

                                    *this,

                                    iOperationManager,

                                    *iFavoriteManager );

    // Because we creted a new node, it should be added to the cache.

    iNodeCache.AppendL( node );

    CleanupStack::Pop( node );

    DLTRACEOUT((""));

    return *node;

    }

CNcdNodeProxy& CNcdNodeManagerProxy::CreateTemporaryBundleFolderL(

    const CNcdNodeIdentifier& aMetadataIdentifier, TBool aCreateMetaData )

    {

    DLTRACEIN((_L("Metadata ID: %S, %S, %S, %d"), 

                &aMetadataIdentifier.NodeId(),

                &aMetadataIdentifier.NodeNameSpace(),

                &aMetadataIdentifier.ServerUri(),

                aMetadataIdentifier.ClientUid()));        

    // Check if the node proxy already exists in the cache.

    // Every node has its own namespace and dataid.

    // If it does exist, do not create it.

    // At first, try to find the node from cache by creating the node identifier

    // from the metadata identifier.

    CNcdNodeIdentifier* tempNodeIdentifier =

        NcdNodeIdentifierEditor::CreateTemporaryNodeIdentifierLC( aMetadataIdentifier );

    CNcdNodeProxy* node( NodeExists( *tempNodeIdentifier ) );

    if ( node ) 

        {

        // Node was found. So, return it.

        CleanupStack::PopAndDestroy( tempNodeIdentifier );

        DLTRACEOUT(("Node found in cache"));

        return *node;

        }

    // Notice that the actual node identifier is given here, instead of the

    // metadata identifier.

    HBufC8* nodeIdentifierData( tempNodeIdentifier->NodeIdentifierDataL() );

    CleanupStack::PopAndDestroy( tempNodeIdentifier );

    CleanupStack::PushL( nodeIdentifierData );

    DLINFO(("Get node handle"));

    // First get the handle to the node of the server side.

    // The handle is gotten from the server side nodemanager.

    // NOTE: The identifier may contain NULL UID here, but it will

    // be replaced by the family id in the server side. And then

    // the node proxy will contain the right UID when the created node is

    // internalized during its creation.

    TInt function = aCreateMetaData ?

        NcdNodeFunctionIds::ENcdTemporaryBundleFolderWithMetaDataHandle :

        NcdNodeFunctionIds::ENcdTemporaryBundleFolderHandle;

    TInt nodeHandle( 0 );

    User::LeaveIfError(

            ClientServerSession().

                SendSync( function,

                          *nodeIdentifierData,

                          nodeHandle,

                          Handle() ) );

    DLTRACE(("Node handle: %d", nodeHandle ));

    CleanupStack::PopAndDestroy( nodeIdentifierData );

    // No need to check the class id here, because we requested a bundle folder

    // node above.

    node = 

        CNcdBundleFolderProxy::NewLC( ClientServerSession(),

                                      nodeHandle,

                                      *this,

                                      iOperationManager,

                                      *iFavoriteManager );