/*

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

*

*/

#include "ncdnodemanager.h"

#include <e32err.h>

#include <s32mem.h>

#include <badesca.h>

#include "ncdnodedbmanager.h"

#include "ncdnodecachecleaner.h"

#include "ncdnodecachecleanermanager.h"

#include "ncdnodeidentifier.h"

#include "ncdnodeidentifiereditor.h"

#include "ncdnodeclassids.h"

#include "ncdnodeimpl.h"

#include "ncdnodeitem.h"

#include "ncdnodefolder.h"

#include "ncdbundlefolder.h"

#include "ncdnodetransparentfolder.h"

#include "ncdrootnode.h"

#include "ncdsearchnodefolder.h"

#include "ncdnodelink.h"

#include "ncdnodemetadataimpl.h"

#include "ncdnodeitemmetadata.h"

#include "ncdnodefoldermetadata.h"

#include "ncdsearchnodeitem.h"

#include "ncdsearchnodefolder.h"

#include "ncdsearchrootnode.h"

#include "ncdexpirednode.h"

#include "ncdchildentity.h"

#include "ncdpurchasehistorydbimpl.h"

#include "ncdnodepreviewimpl.h"

#include "ncdstoragedescriptordataitem.h"

#include "catalogsbasemessage.h"

#include "catalogssession.h"

#include "ncd_pp_folderref.h"

#include "ncd_pp_itemref.h"

#include "ncd_pp_dataentity.h"

#include "ncd_pp_download.h"

#include "ncdpreviewmanager.h"

#include "ncdstoragemanagerimpl.h"

#include "ncdconfigurationmanager.h"

#include "ncdnodefunctionids.h"

#include "ncdproviderdefines.h"

#include "ncdserverdetails.h"

#include "catalogscontext.h"

#include "catalogsutils.h"

#include "catalogsconstants.h"

#include "ncd_pp_expiredcacheddata.h"

#include "ncdproviderutils.h"

#include "ncdutils.h"

#include "ncdsearchnodebundle.h"

#include "ncdfavoritemanagerimpl.h"

#include "ncdnodeseeninfo.h"

#include "ncdnodeiconimpl.h"

#include "ncderrors.h"

#include "ncdsearchablenode.h"

#include "ncdnodeidentifierutils.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

// If the values from the provider are given in kilos and other classes

// require them in bytes, this value can be used for conversion.

const TInt KBytesToKilos( 1024 );

const TInt KNodeCacheGranularity = 256;

CNcdNodeManager::CNcdNodeManager( CNcdGeneralManager& aGeneralManager )

: CCatalogsCommunicable(),

  iPurchaseHistory( aGeneralManager.PurchaseHistory() ),  

  iNodeCache( KNodeCacheGranularity ),

  iNodeMetaDataCache( KNodeCacheGranularity ),

  iTempNodeCache( KNodeCacheGranularity ),

  iConfigurationManager( aGeneralManager.ConfigurationManager() ),

  iNodeOrder( CNcdNode::Compare ),

  iGeneralManager( aGeneralManager )

    {

    DLTRACEIN((""));    

    }

void CNcdNodeManager::ConstructL()

    {

    DLTRACEIN((""));

    iGeneralManager.SetNodeManager( *this );

    iDbManager = CNcdNodeDbManager::NewL( iGeneralManager.StorageManager() );

    // Make sure that db manager is created before factory is created.

    iNodeFactory = CNcdNodeFactory::NewL( *this );

    // Notice that this function uses the objects created above.

    // So, if the creation is moved somewhere else, make sure that

    // NodeDbManager and NodeFactory are also created.

    iNodeCacheCleanerManager = 

        CNcdNodeCacheCleanerManager::NewL( iGeneralManager, 

                                           NodeDbManager(),

                                           NcdProviderDefines::KDbDefaultMaxByteSize,

                                           NodeFactory() );

    iPreviewManager = CNcdPreviewManager::NewL( iGeneralManager, 

                                          NcdProviderDefines::KMaxClientPreviews );

    iPreviewManager->LoadDataL();

    iGeneralManager.SetNodeManager( *this );

    iSeenInfo = CNcdNodeSeenInfo::NewL( iGeneralManager );

    iSearchableNode = new ( ELeave ) CNcdSearchableNode( *this );

    DLTRACEOUT((""));

    }

CNcdNodeManager::~CNcdNodeManager()

    {

    DLTRACEIN((""));

    // Ensure that all cached objects are closed

    FullCacheCleanup();

    if ( iSearchableNode ) 

        {

        iSearchableNode->Close();        

        }

    // Delete member variables in reverse order when comparing

    // to the creation order.

    delete iPreviewManager;

    // Delete node cache cleaner.

    delete iNodeCacheCleanerManager;   

    // Delete node factory.

    delete iNodeFactory;

    // Delete the db manager.

    delete iDbManager;

    // Delete the seen info.

    delete iSeenInfo;

    iClientDatabaseLocks.Close();

    DLTRACEOUT((""));

    }

CNcdNodeManager* CNcdNodeManager::NewL( CNcdGeneralManager& aGeneralManager )

    {

    CNcdNodeManager* self =

        new( ELeave ) CNcdNodeManager( aGeneralManager );

    CleanupClosePushL( *self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// General getter functions

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

CNcdPurchaseHistoryDb& CNcdNodeManager::PurchaseHistory() const

    {

    return iPurchaseHistory;

    }

CNcdPreviewManager& CNcdNodeManager::PreviewManager()  const

    {

    return *iPreviewManager;

    }

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

// Functions to get node objects from caches or from db. 

// And, functions to create node objects.

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

CNcdNode& CNcdNodeManager::NodeL( const CNcdNodeIdentifier& aIdentifier )

    {

    DLTRACEIN((""));

    CNcdNode* node = NodePtrL( aIdentifier );

    if ( node == NULL )

        {

        User::Leave( KErrNotFound );

        }

    DLTRACEOUT((""));

    return *node;

    }

CNcdNode& CNcdNodeManager::NodeL( const CNcdNodeIdentifier& aParentNodeIdentifier,

                                  const CNcdNodeIdentifier& aNodeMetaDataIdentifier )

    {

    DLTRACEIN((""));

    CNcdNodeIdentifier* identifier =

        NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentNodeIdentifier, 

                                                         aNodeMetaDataIdentifier );

    CNcdNode& node = NodeL( *identifier );

    CleanupStack::PopAndDestroy( identifier );

    DLTRACEOUT((""));

    return node;

    }

CNcdNode* CNcdNodeManager::NodePtrL( const CNcdNodeIdentifier& aIdentifier )

    {

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

                &aIdentifier.NodeNameSpace(),

                &aIdentifier.NodeId(),

                aIdentifier.ClientUid().iUid ));

    CNcdNode* node( FindNodeFromCacheL( aIdentifier ) );

    if ( node != NULL )

        {

        DLTRACEOUT(("Found node"));

        return node;

        }

    DLINFO(("Start loading the node from storage"));

    // Check if the node can be found from the db because it was not found

    // from the cache.

    // This function leaves with KErrNotFound if the data was not found from

    // the database. If this is the case then the data should be loaded from

    // internet. But it is not job of this function. Let it leave.

    TRAPD( trapError, node = &DbNodeL( aIdentifier ) );

    if ( trapError == KErrNotFound )

        {

        // Node was not found from db. So, return NULL value.

        DLTRACEOUT(("Node was not found anywhere. Return NULL."));

        return NULL;

        }

    // Leave if some other error occurred.

    User::LeaveIfError( trapError );

    DLTRACEOUT(("Node found from db"));

    return node;

    }

CNcdNode* CNcdNodeManager::NodePtrL( const CNcdNodeIdentifier& aParentNodeIdentifier,

                                     const CNcdNodeIdentifier& aNodeMetaDataIdentifier )

    {

    DLTRACEIN((""));

    CNcdNodeIdentifier* identifier =

        NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentNodeIdentifier, 

                                                         aNodeMetaDataIdentifier );

    CNcdNode* node = NodePtrL( *identifier );

    CleanupStack::PopAndDestroy( identifier );

    DLTRACEOUT((""));

    return node;

    }

CNcdNodeFolder& CNcdNodeManager::FolderL( const CNcdNodeIdentifier& aIdentifier )

    {

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

                &aIdentifier.NodeNameSpace(),

                &aIdentifier.NodeId(),

                aIdentifier.ClientUid().iUid ));

    CNcdNode& node( NodeL( aIdentifier ) );

    CNcdNodeFactory::TNcdNodeType nodeType( NodeFactory().NodeTypeL( node ) );

    if ( nodeType != CNcdNodeFactory::ENcdNodeFolder &&

        nodeType != CNcdNodeFactory::ENcdNodeSearchBundle

         && nodeType != CNcdNodeFactory::ENcdNodeRoot )

        {

        // The node was not of the right type

        DLERROR(("Wrong type of node: %d. Should be folder: %d or %d or %d",

                 nodeType, 

                 CNcdNodeFactory::ENcdNodeFolder,

                 CNcdNodeFactory::ENcdNodeSearchBundle,

                 CNcdNodeFactory::ENcdNodeRoot));

        // For debug purposes

        DASSERT( EFalse );

        User::Leave( KErrArgument );

        }

    DLTRACEOUT((""));

    return static_cast<CNcdNodeFolder&>( node );

    }

CNcdRootNode& CNcdNodeManager::RootNodeL( const TUid& aClientUid )

    {

    DLTRACEIN((""));

    // All the search roots have the same namespace, but their ids are

    // the client UIDs.

    CNcdNodeIdentifier* identifier = 

        NcdNodeIdentifierEditor::CreateRootIdentifierForClientLC( aClientUid );

    CNcdNode& node( NodeL( *identifier ) );

    CleanupStack::PopAndDestroy( identifier );

    // Check the type to make sure that the casting is ok in the end.

    CNcdNodeFactory::TNcdNodeType nodeType( NodeFactory().NodeTypeL( node ) );

    if ( nodeType != CNcdNodeFactory::ENcdNodeRoot )

        {

        // The node was not right

        DLERROR(("Wrong node type. Should be root"));

        // For debug purposes

        DASSERT( EFalse );

        User::Leave( KErrArgument );

        }

    DLTRACEOUT((""));

    return static_cast<CNcdRootNode&>( node );            

    }

CNcdSearchNodeFolder& CNcdNodeManager::SearchFolderL( const CNcdNodeIdentifier& aParentNodeIdentifier,

                                                      const CNcdNodeIdentifier& aNodeMetaDataIdentifier )

    {

    DLTRACEIN((""));

    CNcdNode& node( NodeL( aParentNodeIdentifier, aNodeMetaDataIdentifier ) );

    // Check the type and purpose to make sure that the casting is ok in the end.

    CNcdNodeFactory::TNcdNodeType nodeType( NodeFactory().NodeTypeL( node ) );

    CNcdNodeFactory::TNcdNodePurpose nodePurpose( NodeFactory().NodePurposeL( node ) );

    if ( nodeType != CNcdNodeFactory::ENcdNodeFolder

         && nodeType != CNcdNodeFactory::ENcdNodeRoot

         || nodePurpose != CNcdNodeFactory::ENcdSearchNode )

        {

        // The node was not right

        DLERROR(("Wrong node class."));

        DASSERT( EFalse );

        // The node was not of the right type

        User::Leave( KErrArgument );

        }

    DLTRACEOUT((""));

    return static_cast<CNcdSearchNodeFolder&>( node );

    }

CNcdSearchNodeFolder& CNcdNodeManager::SearchFolderL( const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((""));

    CNcdNode& node( NodeL( aNodeIdentifier ));

    // Check the type and purpose to make sure that the casting is ok in the end.

    CNcdNodeFactory::TNcdNodeType nodeType( NodeFactory().NodeTypeL( node ) );

    CNcdNodeFactory::TNcdNodePurpose nodePurpose( NodeFactory().NodePurposeL( node ) );

    if ( nodeType != CNcdNodeFactory::ENcdNodeFolder

         && nodeType != CNcdNodeFactory::ENcdNodeRoot

         && nodeType != CNcdNodeFactory::ENcdNodeSearchBundle

         || nodePurpose != CNcdNodeFactory::ENcdSearchNode )

        {

        // The node was not right

        DLERROR(("Wrong node class."));

        DASSERT( EFalse );

        // The node was not of the right type

        User::Leave( KErrArgument );

        }

    DLTRACEOUT((""));

    return static_cast<CNcdSearchNodeFolder&>( node );

    }

CNcdSearchNodeItem& CNcdNodeManager::SearchNodeItemL( const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN((""));

    CNcdNode& node( NodeL( aNodeIdentifier ));

    if ( node.ClassId() != NcdNodeClassIds::ENcdSearchItemNodeClassId )

        {

        // The node was not right

        DLERROR(("Wrong node class."));

        DASSERT( EFalse );

        // The node was not of the right type

        User::Leave( KErrArgument );

        }

    DLTRACEOUT((""));

    return static_cast<CNcdSearchNodeItem&>( node );

    }

CNcdNode& CNcdNodeManager::CreateNodeL( CNcdNodeFactory::TNcdNodeType aNodeType,

                                        CNcdNodeFactory::TNcdNodePurpose aNodePurpose,

                                        const CNcdNodeIdentifier& aNodeIdentifier )

    {

    DLTRACEIN(("Nodetype: %d, nodepurpose: %d", aNodeType, aNodePurpose));

    DLINFO((_L("Identifier ns: %S, id: %S"), 

            &aNodeIdentifier.NodeNameSpace(),

            &aNodeIdentifier.NodeId()));

    // The node identifier can not be empty

    DASSERT( !aNodeIdentifier.ContainsEmptyFields() );

    // Get the class id of the node that has the given purpose.

    // The data type parameter informs if an item or a folder should be created.

    // Set the class id to be some item as a default.

    NcdNodeClassIds::TNcdNodeClassId classId =

            NodeFactory().NodeClassIdL( aNodeType, aNodePurpose );

    DLINFO(("classid of node: %d", classId));

    CNcdNode* node( NodePtrL( aNodeIdentifier ) );

    if ( node == NULL )

        {

        DLINFO(("Create node"));

        // Create the node according to the class id

        node = NodeFactory().CreateNodeLC( aNodeIdentifier,

                                           classId );

        DASSERT( node );

        // and insert node to the cache.

        AppendNodeToCacheL( node );

        // cache takes ownership of the node

        CleanupStack::Pop( node );

        // NodePtr inserts the metadata if node was found there.

        // There is no reason to insert the metadata here, because the

        // node has been just created, and it does not contains the

        // link data where the metadata id info is inserted.

        }

    else if ( NodeFactory().NodeTypeL( *node ) != aNodeType

              || NodeFactory().NodePurposeL( *node  ) != aNodePurpose )

        {

        // Node was already in the list. But, the node is not

        // of the expected type or purpose.

        // Notice, that if the requested node purpose was scheme node and the

        // node that already exists is of the different purpose, then we use the

        // original node. So, schemes do not require this checking.

        DLINFO(("classid of real node: %d", node->ClassId() ));

        DLERROR(("Wrong node type or purpose."));

        DLERROR(("Type: %d, should be: %d",

                 NodeFactory().NodeTypeL( *node ), 

                 aNodeType));

        DLERROR(("Purpose: %d, should be: %d",

                 NodeFactory().NodePurposeL( *node ), 

                 aNodePurpose));

        DASSERT( EFalse );

        User::Leave( KErrArgument );

        }

    DLTRACEOUT((""));

    return *node;     

    }

CNcdNode& CNcdNodeManager::CreateNodeL( CNcdNodeFactory::TNcdNodeType aNodeType,

                                        CNcdNodeFactory::TNcdNodePurpose aNodePurpose,

                                        const CNcdNodeIdentifier& aParentNodeIdentifier,

                                        const CNcdNodeIdentifier& aMetaDataIdentifier )

    {

    DLTRACEIN((""));

    // Check the metadata identifier because it has to contain values. These values

    // are used when the node is created. The parent node may contain empty values.

    // because the root does not have parent.

    if ( aMetaDataIdentifier.ContainsEmptyFields() )

        {

        DLERROR(("Cannot create node with empty identifier meta values"));

        // For debug purposes

        DASSERT( EFalse );

        User::Leave( KErrArgument );

        }

    // Try to find the node before creating it.

    // Use the correct form of identifier by asking it from the factory

    CNcdNodeIdentifier* identifier =

        NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentNodeIdentifier, 

                                                         aMetaDataIdentifier );

    CNcdNode& node( CreateNodeL( aNodeType, aNodePurpose, *identifier ) );

    CleanupStack::PopAndDestroy( identifier );

    DLTRACEOUT((""));

    return node; 

    }