/*

* Copyright (c) 2007-2008 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 "ncdnodeseenfolderimpl.h"

#include "catalogsdebug.h"

#include "ncdnodefunctionids.h"

#include "catalogsbasemessage.h"

#include "ncdnodemanager.h"

#include "ncdnodefolder.h"

#include "ncdnodeseenimpl.h"

#include "catalogsutils.h"

#include "ncdnodeidentifier.h"

CNcdNodeSeenFolder* CNcdNodeSeenFolder::NewL( CNcdNodeFolder& aParent ) 

    {

    DLTRACEIN((""));

    CNcdNodeSeenFolder* self = NewLC( aParent );

    CleanupStack::Pop( self );

    return self;

    }

CNcdNodeSeenFolder* CNcdNodeSeenFolder::NewLC( CNcdNodeFolder& aParent ) 

    {

    DLTRACEIN((""));

    CNcdNodeSeenFolder* self = new( ELeave ) CNcdNodeSeenFolder( aParent );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;

    }

CNcdNodeSeenFolder::CNcdNodeSeenFolder( CNcdNodeFolder& aParent ) :

    iOwnerNode( aParent ) 

    {

    }

void CNcdNodeSeenFolder::ConstructL() 

    {

    }

CNcdNodeSeenFolder::~CNcdNodeSeenFolder() 

    {

    DLTRACEIN((""));

    }

void CNcdNodeSeenFolder::ReceiveMessage(

    MCatalogsBaseMessage* aMessage,

    TInt aFunctionNumber )

    {

    DLTRACEIN((""));

    DASSERT( aMessage );

    TInt trapError( KErrNone );

    switch( aFunctionNumber )

        {

        case NcdNodeFunctionIds::ENcdNodeSeenFolderSetContentsSeen:

            TRAP( trapError, SetContentsSeenRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdNodeSeenFolderNewCount:

            TRAP( trapError, NewCountRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdNodeSeenFolderNewNodes:

            TRAP( trapError, NewNodesRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdRelease:

            ReleaseRequest( *aMessage );

            break;

        default:

            DLERROR(("Unidentified function request"));

            DASSERT( EFalse );

            break;

        }

    if ( trapError != KErrNone )

        {

        // Because something went wrong the complete has not been

        // yet called for the message.

        // So, inform the client about the error.

        aMessage->CompleteAndRelease( trapError );

        }

    }

void CNcdNodeSeenFolder::CounterPartLost( const MCatalogsSession& /*aSession*/ )

    {

    DLTRACEIN((""));

    }    

void CNcdNodeSeenFolder::SetContentsSeenRequestL(

    MCatalogsBaseMessage& aMessage ) const

    {

    DLTRACEIN((""));

    SetContentsSeenL();        

    aMessage.CompleteAndRelease( KErrNone );

    }

void CNcdNodeSeenFolder::NewCountRequestL(

    MCatalogsBaseMessage& aMessage ) const

    {

    DLTRACEIN((""));

    // Read the level number.

    RCatalogsMessageReader reader;

    reader.OpenLC( aMessage );

    TInt level = reader().ReadInt32L();

    DASSERT( level > 0 );

    CleanupStack::PopAndDestroy( &reader );

    TInt count = NewChildCountL( level - 1 );

    aMessage.CompleteAndReleaseL( count, KErrNone );

    }

void CNcdNodeSeenFolder::NewNodesRequestL(

    MCatalogsBaseMessage& aMessage ) const

    {

    DLTRACEIN((""));

    // Read the level number

    RCatalogsMessageReader reader;

    reader.OpenLC( aMessage );

    TInt level = reader().ReadInt32L();

    DASSERT( level > 0 );

    CleanupStack::PopAndDestroy( &reader );

    RPointerArray<CNcdNodeIdentifier> newNodes;

    CleanupResetAndDestroyPushL( newNodes );

    NewChildrenL( level - 1, newNodes );

    TInt newCount = newNodes.Count();

    DLINFO(("found %d new nodes", newCount ));

    // Write the node identifier to output buffer.

    RCatalogsBufferWriter writer;

    writer.OpenLC();

    writer().WriteInt32L( newCount );

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

        {

        newNodes[ i ]->ExternalizeL( writer() );

        }

    aMessage.CompleteAndReleaseL( writer.PtrL(), KErrNone );

    CleanupStack::PopAndDestroy( &writer );

    CleanupStack::PopAndDestroy( &newNodes );

    }

void CNcdNodeSeenFolder::ReleaseRequest( MCatalogsBaseMessage& aMessage ) const

    {

    DLTRACEIN((""));

    // Decrease the reference count for this object.

    // When the reference count reaches zero, this object will be destroyed

    // and removed from the session.

    MCatalogsSession& requestSession( aMessage.Session() );

    TInt handle( aMessage.Handle() );

    aMessage.CompleteAndRelease( KErrNone );

    requestSession.RemoveObject( handle );

    DLTRACEOUT((""));

    }    

TInt CNcdNodeSeenFolder::NewChildCountL(

    TInt aRecursionLevel ) const 

    {

    DLTRACEIN((""));

    DASSERT( aRecursionLevel >= 0 );

    CNcdNodeManager& nodeManager = iOwnerNode.NodeManager();

    TInt newCount( 0 );

    for ( TInt i = 0; i < iOwnerNode.ChildCount(); i++ ) 

        {

        const CNcdNodeIdentifier& childIdentifier =

            iOwnerNode.ChildL( i );

        CNcdNode* child = nodeManager.NodePtrL( childIdentifier );

        if ( child ) 

            {

            // Increase the count if the node is not seen, but skip transparent nodes since

            // they are not visible in proxy side anyway.

            if ( !child->NodeSeen().IsSeenL() &&

                 child->ClassId() != NcdNodeClassIds::ENcdTransparentFolderNodeClassId ) 

                {

                newCount++;

                }

            else if ( child->ClassId() == NcdNodeClassIds::ENcdTransparentFolderNodeClassId

                      && aRecursionLevel == 0 ) 

                {

                // Transparent child, add the children of the folder to child count.

                CNcdNodeFolder* transparent = static_cast<CNcdNodeFolder*>( child );

                newCount += transparent->NodeSeenFolder().NewChildCountL( aRecursionLevel );

                }

            if ( aRecursionLevel > 0 ) 

                {

                // If recursion level is greater than 0 and the

                // the node is a folder, add the child count of

                // the folder too.

                if ( CNcdNodeFactory::NodeTypeL( *child ) == CNcdNodeFactory::ENcdNodeFolder )

                    {

                    CNcdNodeFolder* folder = static_cast<CNcdNodeFolder*>( child );

                    // If the folder is transparent folder, the recursion level must not

                    // be decreased.

                    TInt nextRecursionLevel( aRecursionLevel - 1 );

                    if ( folder->ClassId() == NcdNodeClassIds::ENcdTransparentFolderNodeClassId ) 

                        {

                        nextRecursionLevel++;

                        }

                    newCount += folder->NodeSeenFolder().NewChildCountL(

                        nextRecursionLevel );

                    }

                }

            }

        }

    return newCount;

    }

void CNcdNodeSeenFolder::NewChildrenL(

    TInt aRecursionLevel, RPointerArray<CNcdNodeIdentifier>& aNodes ) const

    {

    DLTRACEIN(("level %d", aRecursionLevel));

    DASSERT( aRecursionLevel >= 0 );

    CNcdNodeManager& nodeManager = iOwnerNode.NodeManager();

    TInt childCount = iOwnerNode.ChildCount();

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

        {

        const CNcdNodeIdentifier& childId = iOwnerNode.ChildL( i );

        CNcdNode* child = nodeManager.NodePtrL( childId );

        if ( !child ) 

            {

            continue;

            }

        // If the child is transparent folder, don't add it to the array.

        if ( child->ClassId() != NcdNodeClassIds::ENcdTransparentFolderNodeClassId && !child->NodeSeen().IsSeenL() ) 

            {

            // Create copy of the identifier and add it to the array.

            CNcdNodeIdentifier* copy = CNcdNodeIdentifier::NewLC( childId );

            aNodes.AppendL( copy );

            CleanupStack::Pop( copy );

            }

        else if ( child->ClassId() == NcdNodeClassIds::ENcdTransparentFolderNodeClassId

                  && aRecursionLevel == 0 ) 

            {

            // Transparent child, and this is the last recursion level. The children of the

            // transparent folder must be added to the array.

            CNcdNodeFolder* transparent = static_cast<CNcdNodeFolder*>( child );

            transparent->NodeSeenFolder().NewChildrenL( aRecursionLevel, aNodes );

            }            

        if ( aRecursionLevel > 0 ) 

            {

            // If the node is a folder, go further in recursion.

            CNcdNodeFactory::TNcdNodeType nodeType = CNcdNodeFactory::NodeTypeL( *child );

            if ( nodeType == CNcdNodeFactory::ENcdNodeFolder || 

                 nodeType == CNcdNodeFactory::ENcdNodeRoot )

                {

                CNcdNodeFolder* folder = static_cast<CNcdNodeFolder*>( child );

                // If the folder is transparent folder, the recursion level must not

                // be decreased.

                TInt nextRecursionLevel( aRecursionLevel - 1 );

                if ( folder->ClassId() == NcdNodeClassIds::ENcdTransparentFolderNodeClassId ) 

                    {

                    nextRecursionLevel++;

                    }

                folder->NodeSeenFolder().NewChildrenL( nextRecursionLevel, aNodes );

                }

            }

        }

    }

void CNcdNodeSeenFolder::SetContentsSeenL() const

    {

    DLTRACEIN((""));

    CNcdNodeManager& nodeManager = iOwnerNode.NodeManager();

    // Set the children of the folder as seen.

    for ( TInt i = 0; i < iOwnerNode.ChildCount(); i++ ) 

        {

        const CNcdNodeIdentifier& childIdentifier =

            iOwnerNode.ChildL( i );

        CNcdNode* child = nodeManager.NodePtrL( childIdentifier );

        if ( child ) 

            {

            // If the child is transparent folder, set its contents as seen since in

            // UI they are immediate children of this folder.

            if ( child->ClassId() == NcdNodeClassIds::ENcdTransparentFolderNodeClassId ) 

                {

                CNcdNodeFolder* transparent = static_cast<CNcdNodeFolder*>( child );

                transparent->NodeSeenFolder().SetContentsSeenL();

                }

            else 

                {

                child->NodeSeen().SetSeenL();

                }

            }

        }

    }