/*

* 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:  

*

*/

#include <badesca.h>

#include <s32mem.h>

#include <limits.h>

#include "ncdsearchoperationimpl.h"

#include "ncdoperationfunctionids.h"

#include "catalogsbasemessage.h"

#include "catalogshttpsession.h"

#include "catalogshttpoperation.h"

#include "catalogshttpconfig.h"

#include "catalogsdebug.h"

#include "catalogsbigdes.h"

#include "ncdrequestgenerator.h"

#include "catalogsaccesspointmanager.h"

#include "ncdrequestbase.h"

#include "ncdrequestbrowsesearch.h"

#include "ncdrequestconfiguration.h"

#include "ncd_pp_itemref.h"

#include "ncd_pp_folderref.h"

#include "ncd_pp_dataentity.h"

#include "ncd_pp_error.h"

// remove these

#include "ncd_pp_itemrefimpl.h"

#include "ncd_pp_folderrefimpl.h"

#include "ncd_pp_dataentityimpl.h"

#include "ncd_pp_datablock.h"

//

#include "ncdprotocolutils.h"

#include "ncdprotocol.h"

#include "ncdprotocolimpl.h"

#include "ncdparser.h"

#include "ncdnodemanager.h"

#include "ncdproviderdefines.h"

#include "ncdnodeidentifier.h"

#include "ncdnodeclassids.h"

#include "ncdnodefolder.h"

#include "ncdoperationobserver.h"

#include "catalogssession.h"

#include "ncdnodeimpl.h"

#include "ncdnodelink.h"

#include "ncdqueryimpl.h"

#include "catalogsutils.h"

#include "ncd_cp_query.h"

#include "ncdnodemetadata.h"

#include "ncdnodemetadataimpl.h"

#include "ncderrors.h"

#include "ncdoperationremovehandler.h"

#include "ncdstoragedescriptordataitem.h"

#include "ncdnodeiconimpl.h"

#include "ncdnodelink.h"

#include "catalogsconstants.h"

#include "ncdnodeclassids.h"

#include "ncdnodecontentinfoimpl.h"

#include "ncditempurpose.h"

#include "ncdutils.h"

#include "ncdsearchnodefolder.h"

#include "ncdnodeclassids.h"

#include "ncdnodefactory.h"

#include "ncdnodeidentifiereditor.h"

#include "ncdsearchnodefolder.h"

#include "ncdcapabilities.h"

#include "ncdsearchnodebundle.h"

#include "ncdchildentity.h"

//_LIT8(KRequestBody, "<?xml version=\"1.0\" encoding=\"UTF-8\"?> <preminetRequest xmlns=\"http://nokia.com/preminet/protocol/v/2/0\"  xmlns:cp=\"http://nokia.com/preminet/protocol/configuration/v/1/0\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\"  xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" version=\"2.0\" namespace=\"http://lynx.ionific.com:9086/ntp-cgw/catalogs\"> <configuration> <client> <cp:software version=\"3.2\" type=\"S60\"/> </client> </configuration> <search> <entity xsi:type=\"Folder\" id=\"cgw_normal\" timestamp=\"2007-12-17T09:30:47.0Z\"/> <entityFilter subscribableContent=\"false\"> <keywords all=\"true\" caseSensitive=\"false\"> <keyword exclude=\"false\">a</keyword> </keywords> <reviewScore>1</reviewScore> </entityFilter> <responseFilter structureDepth=\"2\" metadataDepth=\"2\" metadataPerLevel=\"5\" pageStart=\"2\" pageSize=\"2\"/> </search> </preminetRequest>");

// ======== MEMBER FUNCTIONS ========

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

// ?description_if_needed

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

//

CNcdSearchOperation* CNcdSearchOperation::NewL(    

    const CNcdNodeIdentifier& aNodeIdentifier,

    const CNcdNodeIdentifier& aParentIdentifier,

    const CNcdSearchFilter& aSearchFilter,

    TNcdResponseFilterParams aFilterParams,    

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MNcdOperationQueue* aOperationQueue,

    MCatalogsSession& aSession,

    TBool aLoadChildren,

    TNcdChildLoadMode aMode,

    TInt aRecursionLevels,

    TBool aIsSubOperation )

    {

    CNcdSearchOperation* self = CNcdSearchOperation::NewLC(

        aNodeIdentifier,

        aParentIdentifier,

        aSearchFilter,

        aFilterParams,        

        aGeneralManager,        

        aHttpSession,        

        aRemoveHandler,

        aOperationQueue,        

        aSession,

        aLoadChildren,

        aMode,

        aRecursionLevels,

        aIsSubOperation );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdSearchOperation* CNcdSearchOperation::NewLC(

    const CNcdNodeIdentifier& aNodeIdentifier,

    const CNcdNodeIdentifier& aParentIdentifier,

    const CNcdSearchFilter& aSearchFilter,

    TNcdResponseFilterParams aFilterParams,

    CNcdGeneralManager& aGeneralManager,    

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MNcdOperationQueue* aOperationQueue,

    MCatalogsSession& aSession,

    TBool aLoadChildren,

    TNcdChildLoadMode aMode,

    TInt aRecursionLevels,

    TBool aIsSubOperation )

    {

    CNcdSearchOperation* self =

        new( ELeave ) CNcdSearchOperation( aFilterParams, aMode,

            aLoadChildren, aGeneralManager, aHttpSession,

            aRemoveHandler, aOperationQueue, aSession, aRecursionLevels,

            aIsSubOperation );

    CleanupClosePushL( *self );

    self->ConstructL( aNodeIdentifier, aParentIdentifier, aSearchFilter );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdSearchOperation::~CNcdSearchOperation()

    {    

    DLTRACEIN((""));

    delete iSearchFilter;

    iRemoteFoldersChildOfTransparent.ResetAndDestroy();

    }

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

// ?implementation_description

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

//

void CNcdSearchOperation::FolderRefL(

    MNcdPreminetProtocolFolderRef* aData )

    {

    DLTRACEIN(("%X",aData));

    if ( aData == NULL )

        {

        return;

        }

    TRAPD( err, DoFolderRefL( aData ) );

    if( err != KErrNone )

        {

        Cancel();

        iError = err;

        iLoadNodeState = EFailed;

        }

    RunOperation();

    }

void CNcdSearchOperation::DoFolderRefL( MNcdPreminetProtocolFolderRef* aData )    

    {

    DLTRACEIN((""));        

    // Normal PushL causes USER 42

    CleanupDeletePushL( aData );

    DLTRACE(( _L("folder id=%S, ns=%S"), 

        &aData->Id(), &aData->Namespace() ));

    DLTRACE(( _L("Parent id=%S, ns=%S"), 

        &aData->ParentId(), &aData->ParentNamespace() ));

#ifdef CATALOGS_BUILD_CONFIG_DEBUG    

    if ( iParentIdentifier ) 

        {

        DLNODEID( (*iParentIdentifier) );

        }

#endif

    TBool nodeAdded = EFalse;

    // This will contain pointer to the iNodeIdentifier or to the iParentIdentifier

    // So, we will know in the end which one is the parent of the current data item.

    // Do not delete this in the end because this just points to the member

    // variables.

    CNcdNodeIdentifier* tmpSearchParentIdentifier( iParentIdentifier );

    CNcdNodeIdentifier* metaIdentifier =

                    NcdNodeIdentifierEditor::CreateMetaDataIdentifierLC( *iNodeIdentifier );

    switch ( iLoadMode )

        {

        case EContentSource:

            {

            DLTRACE(("Should never come here, ERROR"));

            DASSERT(0);

            User::Leave( KErrGeneral );

            break;

            }

        case ESingleNode:

            {

            DASSERT( iNodeIdentifier );

            DLINFO(( _L("iNodeIdentifier: ns= %S, id= %S, aData: ns= %S, id= %S"),

                &iNodeIdentifier->NodeNameSpace(), &iNodeIdentifier->NodeId(),

                &aData->Namespace(), &aData->Id() ));

            // Because aData contains metadata ids, we have to get

            // the metadata id from the iNodeIdentifier

            if ( aData->Id() == metaIdentifier->NodeId() && 

                aData->Namespace() == metaIdentifier->NodeNameSpace() )

                {

                DLTRACE(("ESingleNode"));

                // Because the data id is same as the meta id, we know

                // that this can not be the root search. Root search namespace

                // and id are defined locally here in the client, not in the 

                // web server.

                CNcdNodeManager::TNcdRefHandleMode mode;

                if( CNcdNodeFactory::NodePurposeL(

                    iNodeManager->NodeL( *iNodeIdentifier ) ) ==

                        CNcdNodeFactory::ENcdSearchNode )

                    {

                    mode = CNcdNodeManager::EUpdate;

                    }

                else

                    {

                    mode =  CNcdNodeManager::EInsert;

                    }

                iNodeManager->RefHandlerL( *iParentIdentifier,

                    *aData,

                    iClientUid,

                    mode,

                    0,

                    iParentType,

                    CNcdNodeFactory::ENcdSearchNode,

                    CNcdNodeFactory::ENcdSearchNode );

                nodeAdded = ETrue;

                }

            else if( aData->ParentId() == metaIdentifier->NodeId() &&

                aData->ParentNamespace() == metaIdentifier->NodeNameSpace() )

                {

                DLINFO(("ESingleNode, adding children"));

                // A child of the node that we are loading is received

                CNcdNode& node = 

                    iNodeManager->RefHandlerL( *iNodeIdentifier,

                                                *aData,

                                                iClientUid,

                                                CNcdNodeManager::EInsert, // use insertion because child count is not known yet

                                                iNodeIndex++,

                                                CNcdNodeFactory::ENcdNodeFolder,

                                                CNcdNodeFactory::ENcdSearchNode,

                                                CNcdNodeFactory::ENcdSearchNode );

                // Before saving the node information make sure that the node remote info is

                // set correctly. Because nodeAdded will be set true below the node will be 

                // saved in the end of this function.

                if ( aData->RemoteUri() != KNullDesC )

                    {

                    DLINFO((_L("Remote search node: %S"), &node.Identifier().NodeId()));

                    node.NodeLinkL().SetRemoteFlag( ETrue );

                    if ( iNodeManager->SearchFolderL( *iNodeIdentifier ).IsTransparent() )

                        {

                        DLINFO(("Parent is transparent folder, add child to remote folder array"));

                        iRemoteFoldersChildOfTransparent.AppendL( CNcdNodeIdentifier::NewLC( node.Identifier() ) );

                        CleanupStack::Pop(); // the nodeidentifier

                        }

                    else if ( iRecursionLeft ) 

                        {

                        // Sub operations should not go any further in recursion

                        DLINFO(("Recursion left"));

                        iRemoteFolders.AppendL( CNcdNodeIdentifier::NewLC( node.Identifier() ) );

                        CleanupStack::Pop(); // the nodeidentifier

                        }

                    }

                else

                    {

                    DLINFO((_L("Normal search node: %S"), &node.Identifier().NodeId()));

                    node.NodeLinkL().SetRemoteFlag( EFalse );

                    }

                // The parent is not the node identified by the iParentIdentifier

                tmpSearchParentIdentifier = iNodeIdentifier;

                nodeAdded = ETrue;

                }

            break;

            }

        case EChildren:

            {

            DLTRACE(("EChildren"));

            DASSERT( iNodeIdentifier );

            // Get the parent node. So, we can use its link to get the metadataidentifier.

            // The parent always has the link information set here.    

            CNcdNode& currentNode = iNodeManager->NodeL( *iNodeIdentifier );

            DLNODEID( currentNode.NodeLinkL().MetaDataIdentifier() );

            if ( aData->Id() == currentNode.NodeLinkL().MetaDataIdentifier().NodeId() && 

                aData->Namespace() == currentNode.NodeLinkL().MetaDataIdentifier().NodeNameSpace() )

                {

                DLINFO(("EChildren Add parent"));

                // Get the actual parent for this operation. This is required to check

                // if the parent is root or some other kind of folder.

                CNcdNode& addParent = iNodeManager->NodeL( *iParentIdentifier );                    

                // add parent

                iNodeManager->RefHandlerL( *iParentIdentifier,

                    *aData,

                    iClientUid,

                    CNcdNodeManager::EUpdate,

                    0, // Should give no index in this case

                    CNcdNodeFactory::NodeTypeL( addParent ),

                    CNcdNodeFactory::ENcdSearchNode,

                    CNcdNodeFactory::ENcdSearchNode );

                nodeAdded = ETrue;

                // Structure loaded for parent -> send update notification

                // for parent node so that it gets internalized.

                CNcdNodeIdentifier* loadedNodeId = 

                    CNcdNodeIdentifier::NewLC( currentNode.Identifier() );

                iLoadedNodes.AppendL( loadedNodeId );

                CleanupStack::Pop( loadedNodeId );

                }

            else if ( aData->ParentId() == metaIdentifier->NodeId() ||

                aData->ParentNamespace() == metaIdentifier->NodeNameSpace() )

                {

                DLINFO(("EChildren"));

                // add child

                // We are loading the children of the current node that is

                // identified by the iNodeIdentifier.

                CNcdNode& node = 

                    iNodeManager->RefHandlerL( *iNodeIdentifier,

                                                *aData,

                                                iClientUid,

                                                CNcdNodeManager::EReplace,

                                                iNodeIndex++,

                                                CNcdNodeFactory::ENcdNodeFolder,

                                                CNcdNodeFactory::ENcdSearchNode,

                                                CNcdNodeFactory::ENcdSearchNode );

                // Before saving the node information make sure that the node remote info is

                // set correctly. Because nodeAdded will be set true below the node will be 

                // saved in the end of this function.

                if ( aData->RemoteUri() != KNullDesC )

                    {

                    DLINFO((_L("Remote search node: %S"), &node.Identifier().NodeId()));

                    node.NodeLinkL().SetRemoteFlag( ETrue );

                    CNcdNodeIdentifier* identifier = CNcdNodeIdentifier::NewLC( node.Identifier() );

                    iRemoteFolders.AppendL( identifier );

                    CleanupStack::Pop( identifier );

                    }

                else

                    {

                    DLINFO((_L("Normal search node: %S"), &node.Identifier().NodeId()));

                    node.NodeLinkL().SetRemoteFlag( EFalse );

                    }

                // The parent is not the node identified by the iParentIdentifier

                tmpSearchParentIdentifier = iNodeIdentifier;

                nodeAdded = ETrue;

                }

            break;

            }

        }

    CleanupStack::PopAndDestroy( metaIdentifier );

    // add search filter to folder, this is needed so that consecutive

    // search ops (started while paging results) can get the filter

    if ( nodeAdded )

        {

        CNcdNodeIdentifier* searchMetaIdentifier = 

            CNcdNodeIdentifier::NewLC( aData->Namespace(),

                                       aData->Id(), 

                                       aData->ServerUri(),

                                       iClientUid );

        CNcdSearchNodeFolder& searchFolder = iNodeManager->SearchFolderL(

            *tmpSearchParentIdentifier,

            *searchMetaIdentifier );

        searchFolder.SetSearchFilterL( *iSearchFilter );

        if( iLoadMode == ESingleNode && CNcdNodeFactory::NodePurposeL(

            iNodeManager->NodeL( *iNodeIdentifier ) ) !=

                CNcdNodeFactory::ENcdSearchNode )

            {

            // search op started for a normal node, add origin identifier

            searchFolder.SetOriginIdentifierL( *iNodeIdentifier );

            }

        iNodeManager->DbSaveNodeL( searchFolder );

        CleanupStack::PopAndDestroy( searchMetaIdentifier );

        }

    // Delete data because ownership has been transferred.

    CleanupStack::PopAndDestroy( aData );

    DLTRACEOUT((""));

    }

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

// ?implementation_description

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

//    

void CNcdSearchOperation::FolderDataL(

    MNcdPreminetProtocolDataEntity* aData )

    {

    DLTRACEIN((""));

    if ( aData != NULL )

        {

        TInt err( KErrNone );

        TRAP( err,

        // Normal PushL causes USER 42

        CleanupDeletePushL( aData );

        // This node will contain the metadata that is updated by calling

        // the handler function.

        // Notice that after this the metadata has also been created.

        // So, metadata can be directly used.

        CNcdNodeIdentifier* parentIdentifier( NULL );

        TBool addMetaData = ETrue;

        if( iLoadMode == EChildren || iLoadMode == ESingleNode )

            {

            DLINFO(("EChildren"));

            DASSERT( iNodeIdentifier );

            CNcdNodeIdentifier* metaIdentifier = 

                NcdNodeIdentifierEditor::CreateMetaDataIdentifierL( *iNodeIdentifier );

            if ( aData->Id() != metaIdentifier->NodeId() || 

                 aData->Namespace() != metaIdentifier->NodeNameSpace() )

                {

                // aData must be child of iNodeIdentifier

                parentIdentifier = CNcdNodeIdentifier::NewLC( *iNodeIdentifier );

                }

            delete metaIdentifier;

            metaIdentifier = NULL;

            }

        if( addMetaData )

            {

            // set iParentIdentifier as parent if not set otherwise, this would be the case of a

            // normal top-level node from a content source

            if ( ! parentIdentifier ) 

                {

                parentIdentifier = CNcdNodeIdentifier::NewLC( *iParentIdentifier );

                }

            CNcdNode& node = 

                iNodeManager->DataHandlerL( *parentIdentifier, *aData, iClientUid );

            CleanupStack::PopAndDestroy( parentIdentifier );

            // Notice that the loaded nodes should contain the actual node identifier

            // instead of metadata identifier, because the identifiers are returned to

            // the proxy side after operation completes.

            CNcdNodeIdentifier* loadedNodeId = 

                CNcdNodeIdentifier::NewLC( node.Identifier() );

            iLoadedNodes.AppendL( loadedNodeId );

            CleanupStack::Pop( loadedNodeId );

            DLINFO(("node loaded, id: %S", &node.Identifier().NodeId() ));

            // If the data contains icon id and datablock id, they are stored until

            // the datablock arrives later (in DataBlocksL method).

            const MNcdPreminetProtocolIcon* icon = aData->Icon();

            if ( icon != NULL ) 

                {

                const TDesC& iconId = icon->Id();

                const TDesC& dataBlockId = icon->DataBlock();

                if ( iconId != KNullDesC && dataBlockId != KNullDesC ) 

                    {

                    // Icon id may be mapped to the metadata id here

                    MapIconIdForDataBlockL( iconId, dataBlockId, 

                                            node.NodeMetaDataL().Identifier() );

                    // Notice that here we need to get the node by using the

                    // parent identifier and metadata id, because the metadata

                    // identifier itself is not enough to identify the node.

                    node.NodeMetaDataL().IconL().SetIconDataReady( EFalse );

                    }

                }

            }

        else if ( parentIdentifier )

            {

            CleanupStack::PopAndDestroy( parentIdentifier );

            }

        // Delete data because ownership has been transferred.

        CleanupStack::PopAndDestroy( aData );

        ); //TRAPD

        if( err != KErrNone )

            {

            iError = err;

            iLoadNodeState = EFailed;

            }

        }

    RunOperation();

    DLTRACEOUT((""));

    }

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