/*

* 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:   Contains CNcdRootNodeProxy class implementation

*

*/

#include "ncdrootnodeproxy.h"

#include "catalogsclientserver.h"

#include "ncdnodemanagerproxy.h"

#include "ncdoperationmanagerproxy.h"

#include "ncdnodeidentifier.h"

#include "catalogsdebug.h"

#include "ncdnodefunctionids.h"

#include "catalogsinterfaceidentifier.h"

#include "ncdloadnodeoperationproxy.h"

#include "ncdchildentity.h"

#include "ncderrors.h"

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

CNcdRootNodeProxy* CNcdRootNodeProxy::NewL( MCatalogsClientServer& aSession,

                                            TInt aHandle,

                                            CNcdNodeManagerProxy& aNodeManager,

                                            CNcdOperationManagerProxy& aOperationManager,

                                            CNcdFavoriteManagerProxy& aFavoriteManager )

    {

    CNcdRootNodeProxy* self = 

        CNcdRootNodeProxy::NewLC(

            aSession, aHandle, aNodeManager, aOperationManager, aFavoriteManager );

    CleanupStack::Pop( self );

    return self;

    }

CNcdRootNodeProxy* CNcdRootNodeProxy::NewLC( MCatalogsClientServer& aSession,

                                             TInt aHandle,

                                             CNcdNodeManagerProxy& aNodeManager,

                                             CNcdOperationManagerProxy& aOperationManager,

                                             CNcdFavoriteManagerProxy& aFavoriteManager )

    {

    CNcdRootNodeProxy* self = 

        new( ELeave ) CNcdRootNodeProxy(

            aSession, aHandle, aNodeManager, aOperationManager, aFavoriteManager );  

    // Using PushL because the object does not have any references yet

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CNcdRootNodeProxy::CNcdRootNodeProxy( MCatalogsClientServer& aSession,

                                      TInt aHandle,

                                      CNcdNodeManagerProxy& aNodeManager,

                                      CNcdOperationManagerProxy& aOperationManager,

                                      CNcdFavoriteManagerProxy& aFavoriteManager ) 

: CNcdParentOfTransparentNodeProxy(

    aSession, aHandle, aNodeManager, aOperationManager, aFavoriteManager )

    {

    }

void CNcdRootNodeProxy::ConstructL()

    {

    CNcdParentOfTransparentNodeProxy::ConstructL(); 

    }

CNcdRootNodeProxy::~CNcdRootNodeProxy()

    {

    }

TInt CNcdRootNodeProxy::ChildCount() const

    {

    return iChildren.Count();

    }

MNcdNode* CNcdRootNodeProxy::ChildL( TInt aIndex )

    {

    DLTRACEIN(( _L("This parent: %S, %S"), &Namespace(), &Id() ));

    if ( aIndex < 0 || aIndex >= iChildren.Count() )

        {

        // Nothing to be done 

        DLERROR(( "Index error. child count: %d Given index: %d", 

                  iChildren.Count(), aIndex ));

        DASSERT( EFalse );

        User::Leave( KErrArgument );

        }

    const CNcdNodeIdentifier* child = &iChildren[aIndex]->Identifier();

    MNcdNode* node( NULL );

    TRAPD( err, node = &NodeManager().NodeL( *child ) );

    if ( err == KErrNotFound ) 

        {

        return NULL;

        }        

    User::LeaveIfError( err );

    // Increase the reference counter by one

    node->AddRef();

    DLTRACEOUT((""));

    return node;

    }

MNcdNode::TState CNcdRootNodeProxy::State() const

    {

    DLTRACEIN((""));

    // Check if the link handle has been set, which means that also

    // link data has been internalized. Root node does not contain

    // metadata so it does not need to be checked.

    // The child count is also checked because in some situations when root loading

    // is cancelled the link handle may be set, but the children are not inserted to 

    // the root child list. So, the root should have children to be in initialized mode.

    if ( LinkHandleSet() && ChildCount() > 0 )

        {

        DLTRACE(("State was initialized"));

        // If state was initialized we have to check if the state

        // has acutally expired already 

        TTime now;

        now.HomeTime();

        DLTRACE(("now time: %d", now.Int64() ));

        DLTRACE(("expired time: %d", ExpiredTime().Int64() ));

        // We can just compare the times here. Server side

        // inserts the maximum value for the expired time if the

        // protocol has set never expire value for the validity delta.

        TBool isExpired = ( now > ExpiredTime() );

        TInt err = KErrNone;

        if ( !isExpired ) 

            {            

            TRAP( err, isExpired = IsTransparentChildExpiredL() );

            }

        if ( isExpired || err != KErrNone )

            {

            DLTRACEOUT(("Expired"));

            return MNcdNode::EStateExpired;

            }

        DLTRACEOUT(("Initialized"));

        return MNcdNode::EStateInitialized;

        }

     else

        {

        // Node has not been initialized.

        DLTRACEOUT(("Not intialized"));

        return MNcdNode::EStateNotInitialized;

        }

    }

MNcdLoadNodeOperation* CNcdRootNodeProxy::LoadL( MNcdLoadNodeOperationObserver& aObserver )

    {

    DLTRACEIN((""));

    CNcdLoadNodeOperationProxy* operation( NULL );

    operation =

        OperationManager().

            CreateLoadRootNodeOperationL( *this );

    operation->AddObserverL( this );

    operation->AddObserverL( &aObserver );

    DLTRACEOUT((""));

    return operation;

    }

MNcdLoadNodeOperation* CNcdRootNodeProxy::LoadChildrenL( TInt /*aIndex*/, 

                                                         TInt /*aSize*/,

                                                         TNcdChildLoadMode aMode,

                                                         MNcdLoadNodeOperationObserver& aObserver )

    {

    DLTRACEIN(("Root load mode: %d", aMode));

    // Root is a special case when children are loaded.

    // Because root operation always load its children same time normal LoadL is called

    // for the root, the children of the root are always up to date.

    // The only exception is, if the schemes are added to the root list separately.

    // Because of the possible schemes, this function is overloaded and the 

    // staring index is set to be zero and the size has to be the whole child array size which

    // includes the possible scheme.

    CNcdLoadNodeOperationProxy* operation = 

        OperationManager().CreateLoadNodeOperationL( *this, ETrue,

                                                     ServerChildCount(),

                                                     0,

                                                     1,

                                                     aMode );

    if( operation == NULL )

        {

        DLTRACEOUT(("NULL"));     

        return NULL;

        }

    operation->AddObserverL( this );

    operation->AddObserverL( &aObserver );

    DLTRACEOUT((""));        

    return operation;

    }

RCatalogsArray<MNcdOperation> CNcdRootNodeProxy::OperationsL() const

    {

    DLTRACEIN((""));

    RCatalogsArray<MNcdOperation> operations;

    CleanupClosePushL( operations );

    // Operations will be get differently for root node, because root

    // node does not have metadata.

    // Get the original array and insert its content to catalogs array.

    // Also, increase the reference counter for the items.

    const RPointerArray<MNcdOperation>& origArray = OperationManager().Operations();

    const MNcdNode* thisNode( this );

    MNcdOperation* oper( NULL );

    MNcdNode* node( NULL );

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

        {

        oper = origArray[ i ];

        // Notice that node ref count is increased. So, release it when done.

        node = oper->Node();

        CleanupReleasePushL( *node );

        if( node == thisNode )

            {

            operations.AppendL( oper );

            oper->AddRef();

            }

        CleanupStack::PopAndDestroy( node );

        }

    CleanupStack::Pop( &operations );

    DLTRACEOUT(( "" ));

    return operations;

    }

void CNcdRootNodeProxy::OperationComplete( MNcdLoadNodeOperation& /*aOperation*/,

                                           TInt aError )

    {

    DLTRACEIN((""));

    // Should all the error code checks be removed and always internalize root node?

    if( aError == KErrNone || aError == KNcdErrorSomeCatalogsFailedToLoad || 

        aError == KErrCancel )

        {

        // Because operation went ok. Update the node data.

        TRAP_IGNORE( InternalizeL() );

        }

    DLTRACEOUT((""));

    }