/*

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

*

*/

#ifndef C_NCDLOADROOTNODEOPERATIONIMPL_H

#define C_NCDLOADROOTNODEOPERATIONIMPL_H

#include <e32base.h>

#include "ncdbaseoperation.h"

#include "ncdoperationobserver.h"

#include "ncdparserobserver.h"

#include "catalogshttpobserver.h"

#include "catalogshttptypes.h"

#include "catalogshttpsession.h"

#include "catalogsutils.h"

#include "ncdnodeidentifier.h"

#include "ncdconfigurationobserver.h"

#include "ncdproviderdefines.h"

class CDesC16Array;

class CDesC16ArrayFlat;

class CDesC8ArrayFlat;

class MNcdParser;

class CNcdNodeManager;

class MNcdProtocol;

class CNcdNodeIdentifier;

class CNcdLoadNodeOperationImpl;

class CCatalogsContext;

class MCatalogsAccessPointManager;

class MNcdConfigurationManager;

class MNcdOperationRemoveHandler;

class CNcdContentSourceMap;

class CNcdChildEntityMap;

// ======== CONSTANTS ========

class CNcdContentSource : public CBase

    {

public:

    static CNcdContentSource* NewLC( const CNcdNodeIdentifier& aParentIdentifier )

        {

        CNcdContentSource* self =

        new( ELeave ) CNcdContentSource;

        CleanupStack::PushL( self );

        self->ConstructL( aParentIdentifier );

        return self;

        }

    static CNcdContentSource* NewL( RReadStream& aStream ) 

        {

        CNcdContentSource* self = new ( ELeave ) CNcdContentSource;        

        CleanupStack::PushL( self );

        self->ConstructL( aStream );

        CleanupStack::Pop( self );

        return self;

        }

    ~CNcdContentSource()

        {

        delete iParentIdentifier;

        delete iNameSpace;

        delete iProvider;

        delete iUri;

        delete iNodeId;

        }

    const TDesC& NameSpace() const

        {

        return *iNameSpace;

        }

    void SetNameSpaceL( const TDesC& aNameSpace )

        {

        AssignDesL( iNameSpace, aNameSpace );

        }

    const TDesC& Provider() const

        {

        return *iProvider;

        }

    void SetProviderL( const TDesC& aProvider )

        {

        AssignDesL( iProvider, aProvider );

        }

    const TDesC& Uri() const

        {

        return *iUri;

        }

    void SetUriL( const TDesC& aUri )

        {

        AssignDesL( iUri, aUri );

        }

    /**

     * Getter for node id.

     *     

     * @return const TDesC

     */

    const TDesC& NodeId() const

        {

        return *iNodeId;

        }

    void SetNodeIdL( const TDesC& aNodeId )

        {

        AssignDesL( iNodeId, aNodeId );

        }

    void SetBroken( TBool aBroken ) 

        {

        DLTRACEIN(("broken: %d", aBroken));

        iBroken = aBroken;

        }

    TBool IsBroken() const 

        {

        DLTRACEIN(("broken: %d", iBroken));

        return iBroken;

        }

    void SetAlwaysVisible( TBool aValue ) 

        {

        iAlwaysVisible = aValue;

        }

    TBool AlwaysVisible() const 

        {

        return iAlwaysVisible;

        }

    void SetTransparent( TBool aValue )

        {

        iTransparent = aValue;

        }

    TBool IsTransparent() const

        {

        return iTransparent;

        }

    CNcdNodeIdentifier& ParentIdentifier() const 

        {

        return *iParentIdentifier;

        }

    CNcdContentSource* CopyL() const

        {

        CNcdContentSource* copy = CNcdContentSource::NewLC( *iParentIdentifier );

        copy->SetNameSpaceL( *iNameSpace );

        copy->SetProviderL( *iProvider );

        copy->SetUriL( *iUri );

        copy->SetNodeIdL( *iNodeId );

        copy->SetBroken( iBroken );

        copy->SetAlwaysVisible( iAlwaysVisible );

        copy->SetTransparent( iTransparent );

        CleanupStack::Pop( copy );

        return copy;

        }

    TBool Equals( const CNcdContentSource& aContentSource ) const 

        {

        if ( aContentSource.NameSpace() == NameSpace() &&

             aContentSource.Provider() == Provider() &&

             aContentSource.Uri() == Uri() &&

             aContentSource.NodeId() == NodeId() ) 

            {

            return ETrue;

            }

        else 

            {

            return EFalse;

            }

        }

    void ExternalizeL( RWriteStream& aStream ) 

        {

        iParentIdentifier->ExternalizeL( aStream );

        ExternalizeDesL( NameSpace(), aStream );

        ExternalizeDesL( Provider(), aStream );

        ExternalizeDesL( Uri(), aStream );

        ExternalizeDesL( NodeId(), aStream );

        aStream.WriteInt8L( iBroken );

        aStream.WriteInt8L( iAlwaysVisible );

        aStream.WriteInt8L( iTransparent );

        }

private:

    CNcdContentSource()

    : iBroken( EFalse ),

      iAlwaysVisible( EFalse ),

      iTransparent( EFalse )

        {

        }

    void ConstructL( const CNcdNodeIdentifier& aParentIdentifier )

        {

        iParentIdentifier = CNcdNodeIdentifier::NewL( aParentIdentifier );

        iNameSpace = KNullDesC().AllocL();

        iProvider = KNullDesC().AllocL();

        iUri = KNullDesC().AllocL();

        iNodeId = KNullDesC().AllocL();

        }

    void ConstructL( RReadStream& aStream ) 

        {

        iParentIdentifier = CNcdNodeIdentifier::NewL( aStream );

        InternalizeDesL( iNameSpace, aStream );

        InternalizeDesL( iProvider, aStream );

        InternalizeDesL( iUri, aStream );

        InternalizeDesL( iNodeId, aStream );

        iBroken = aStream.ReadInt8L();

        iAlwaysVisible = aStream.ReadInt8L();

        iTransparent = aStream.ReadInt8L();

        }

private:

    CNcdNodeIdentifier* iParentIdentifier;

    HBufC* iNameSpace;

    HBufC* iProvider;

    HBufC* iUri;

    HBufC* iNodeId;

    TBool iBroken;

    TBool iAlwaysVisible;

    TBool iTransparent;

    };

class CNcdNodeMap : public CBase 

    {

public:

    CNcdNodeMap( CNcdContentSource* aContentSource )

    : iContentSource( aContentSource )

        {

        }

    static CNcdNodeMap* NewL( RReadStream& aStream ) 

        {

        CNcdNodeMap* self = new ( ELeave ) CNcdNodeMap;

        CleanupStack::PushL( self );

        self->ConstructL( aStream );

        CleanupStack::Pop( self );

        return self;

        }

    virtual ~CNcdNodeMap() 

        {

        delete iContentSource;

        iNodes.ResetAndDestroy();

        }

    TBool ContainsNode( const CNcdNodeIdentifier& aNodeIdentifier ) 

        {

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

            {

            if ( iNodes[i]->Equals( aNodeIdentifier ) ) 

                {

                return ETrue;

                }

            }

        return EFalse;

        }

    void ExternalizeL( RWriteStream& aStream ) 

        {

        iContentSource->ExternalizeL( aStream );

        aStream.WriteInt32L( iNodes.Count() );

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

            {

            iNodes[i]->ExternalizeL( aStream );

            }

        }

private:

    CNcdNodeMap() 

        {

        }

    void ConstructL( RReadStream& aStream ) 

        {

        DLTRACEIN((""));

        iContentSource = CNcdContentSource::NewL( aStream );

        TInt32 nodeCount = aStream.ReadInt32L();

        for ( TInt i = 0; i < nodeCount; i++ ) 

            {

            CNcdNodeIdentifier* nodeId = CNcdNodeIdentifier::NewLC( aStream );

            iNodes.AppendL( nodeId );

            CleanupStack::Pop( nodeId );

            }

        }

public:

    CNcdContentSource* iContentSource;

    RPointerArray<CNcdNodeIdentifier> iNodes;

    };

class CNcdFolderContent : public CBase

    {

public:

    static CNcdFolderContent* NewL(

        CNcdNodeIdentifier* aFolderIdentifier, TInt aPositionInGrid ) 

        {

        CNcdFolderContent* self =

            new ( ELeave ) CNcdFolderContent( aFolderIdentifier, aPositionInGrid );

        return self;

        }

    static CNcdFolderContent* NewLC( RReadStream& aStream ) 

        {

        CNcdFolderContent* self = new ( ELeave ) CNcdFolderContent;

        CleanupStack::PushL( self );

        self->InternalizeL( aStream );

        return self;

        }

    ~CNcdFolderContent() 

        {

        delete iFolderIdentifier;

        iContentSources.ResetAndDestroy();

        }

    TInt Find( const CNcdContentSource& aContentSource ) const 

        {

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

            {

            if ( iContentSources[i]->Equals( aContentSource ) ) 

                {

                return i;

                }

            }

        return KErrNotFound;

        }

    const CNcdNodeIdentifier& FolderIdentifier() const 

        {

        DASSERT( iFolderIdentifier );

        return *iFolderIdentifier;

        }

    TInt PositionInGrid() const 

        {

        return iPositionInGrid;

        }

    CNcdContentSource& ContentSource( TInt aIndex ) const 

        {

        DASSERT( aIndex >= 0 && aIndex < iContentSources.Count() );

        return *iContentSources[aIndex];

        }

    TInt ContentSourceCount() const 

        {

        return iContentSources.Count();

        }

    void AppendContentSourceL( CNcdContentSource* aContentSource ) 

        {

        iContentSources.AppendL( aContentSource );

        }

    void ClearContentSources() 

        {

        iContentSources.ResetAndDestroy();

        }

    void ExternalizeL( RWriteStream& aStream ) 

        {

        DLTRACEIN((""));

        aStream.WriteInt32L( iPositionInGrid );

        iFolderIdentifier->ExternalizeL( aStream );

        aStream.WriteInt32L( iContentSources.Count() );

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

            {

            iContentSources[i]->ExternalizeL( aStream );

            }

        }

protected:

    CNcdFolderContent( CNcdNodeIdentifier* aFolderIdentifier, TInt aPositionInGrid ) :

        iPositionInGrid( aPositionInGrid ), iFolderIdentifier( aFolderIdentifier ) 

        {

        }

    CNcdFolderContent() 

        {

        }

    void InternalizeL( RReadStream& aStream ) 

        {

        DLTRACEIN((""));

        iPositionInGrid = aStream.ReadInt32L();

        delete iFolderIdentifier;

        iFolderIdentifier = NULL;

        iFolderIdentifier = CNcdNodeIdentifier::NewL( aStream );

        iContentSources.ResetAndDestroy();

        TInt contentSourceCount = aStream.ReadInt32L();

        for ( TInt i = 0; i < contentSourceCount; i++ ) 

            {

            CNcdContentSource* contentSource = CNcdContentSource::NewL( aStream );

            CleanupStack::PushL( contentSource );

            iContentSources.AppendL( contentSource );

            CleanupStack::Pop( contentSource );

            }

        }

private:

    TInt iPositionInGrid;

    CNcdNodeIdentifier* iFolderIdentifier;

    RPointerArray<CNcdContentSource> iContentSources;    

    };

class CNcdContentSourceMap : public CBase

    {

public:

    static CNcdContentSourceMap* NewL()

        {

        CNcdContentSourceMap* self =

            new( ELeave ) CNcdContentSourceMap;

        CleanupStack::PushL( self );

        self->ConstructL();

        CleanupStack::Pop( self );

        return self;

        }

    static CNcdContentSourceMap* NewL( RReadStream& aStream ) 

        {

        CNcdContentSourceMap* self = new ( ELeave ) CNcdContentSourceMap;

        CleanupStack::PushL( self );

        self->ConstructL( aStream );

        CleanupStack::Pop( self );

        return self;

        }

    ~CNcdContentSourceMap()

        {

        iNodeMaps.ResetAndDestroy();

        iFolderContents.ResetAndDestroy();

        }

    TInt GetInsertIndexL(

        const CNcdContentSource& aContentSource,

        const CNcdNodeIdentifier& aParentIdentifier )

        {

        DLTRACEIN((""));

        TInt folderIndex = FindFolder( aParentIdentifier );

        User::LeaveIfError( folderIndex );        

        CNcdFolderContent& folderContent = FolderContent( folderIndex );

        TInt csIndex = folderContent.Find( aContentSource );

        User::LeaveIfError( csIndex );

        TInt insertIndex = 0;

        for ( TInt i = 0; i <= csIndex; i++ ) 

            {

            CNcdContentSource& contentSource = folderContent.ContentSource( i );            

            insertIndex += NodeCount( contentSource );

            }

        if ( aParentIdentifier.NodeNameSpace() == 

                NcdProviderDefines::KRootNodeNameSpace ) 

            {

            // There may be bundles before this content source, so the index

            // must be increased possibly.

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

                {

                if ( iFolderContents[i]->FolderIdentifier().NodeNameSpace() != 

                     NcdProviderDefines::KRootNodeNameSpace && 

                     iFolderContents[i]->PositionInGrid() <= csIndex ) 

                    {

                    insertIndex++;

                    }

                }

            return insertIndex;             

            }

         else 

            {

            return insertIndex;

            }

        }        

    void AppendContentSourceL(

        CNcdContentSource* aContentSource,

        TInt aPositionInGrid = 0 ) 

        {

        DLTRACEIN((""));

        CNcdNodeMap* map = new ( ELeave ) CNcdNodeMap( aContentSource->CopyL() );

        CleanupStack::PushL( map );                

        iNodeMaps.AppendL( map );        

        CleanupStack::Pop( map );

        TInt folderIndex = FindFolder( aContentSource->ParentIdentifier() );

        if ( folderIndex != KErrNotFound ) 

            {

            CNcdFolderContent& folderContent = FolderContent( folderIndex );

            folderContent.AppendContentSourceL( aContentSource );

            }

        else 

            {

            CNcdNodeIdentifier* parentCopy = 

                CNcdNodeIdentifier::NewLC( aContentSource->ParentIdentifier() );

            CNcdFolderContent* folderContent = CNcdFolderContent::NewL(

                parentCopy, aPositionInGrid );

            CleanupStack::Pop( parentCopy );

            CleanupStack::PushL( folderContent );

            iFolderContents.AppendL( folderContent );

            CleanupStack::Pop( folderContent );

            folderContent->AppendContentSourceL( aContentSource );

            }