/*

* 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 CNcdNodeProxy class implementation

*

*/

#include "ncdnodeproxy.h"

#include "ncdrootnodeproxy.h"

#include "ncdnodecontainer.h"

#include "ncdnodefolderproxy.h"

#include "ncdnodemetadataproxy.h"

#include "ncdnodeuserdataproxy.h"

#include "ncdoperationmanagerproxy.h"

#include "ncdloadnodeoperationproxy.h"

#include "catalogsclientserver.h"

#include "ncdnodeidentifier.h"

#include "ncdnodefunctionids.h"

#include "ncdnodeclassids.h"

#include "catalogsinterfaceidentifier.h"

#include "catalogsdebug.h"

#include "catalogsutils.h"

#include "ncdnodemanagerproxy.h"

#include "ncdfavoritemanagerproxy.h"

#include "ncdquery.h"

#include "ncdnodedisclaimerproxy.h"

#include "ncdnodefavorite.h"

#include "ncdnodeidentifiereditor.h"

#include "ncdnodeseenproxy.h"

CNcdNodeProxy::CNcdNodeProxy( MCatalogsClientServer& aSession,

                              TInt aHandle, 

                              CNcdNodeManagerProxy& aNodeManager,

                              CNcdOperationManagerProxy& aOperationManager,

                              CNcdFavoriteManagerProxy& aFavoriteManager ) 

: CNcdInterfaceBaseProxy( aSession, aHandle, NULL ),

  iNodeManager( aNodeManager ),

  iOperationManager( aOperationManager ),

  iFavoriteManager( aFavoriteManager )

    {

    }

void CNcdNodeProxy::ConstructL( )

    {

    DLTRACEIN(("this-ptr as MNcdNode: %X", static_cast<MNcdNode*>( this )));

    // Register the interfaces of this object

    MNcdNode* node( this );

    AddInterfaceL( 

        CCatalogsInterfaceIdentifier::NewL( node, this, MNcdNode::KInterfaceUid ) );

    // Make sure that at least some values are inserted to the link descriptors.

    // So, the references returned from functions of this class will contain at

    // least something.

    iTimestamp = KNullDesC().AllocL();

    iCatalogSourceName = KNullDesC().AllocL(); 

    iExpiredTime = 0;

    // Get the data from the server side.

    // It may be possible that actually not much is received

    // because the node may be in uninitialized state.

    // But at least the namespace and id information should be gotten.

    TRAPD( trapError, InternalizeL() );    

    // This node can not exist if the identifier data is not set.

    // So, if node identifier is not set this should leave and

    // prevent the creation of the node.

    if ( iNodeIdentifier == NULL )

        {

        User::LeaveIfError( trapError );

        }

    // Also make sure that parent identifier is set at least to empty value

    if ( iParentIdentifier == NULL )

        {

        // If we have to set the parent identifier here, it means that

        // the node link was not set yet. 

        // If node link was set, then the parent id was also set to correct value. 

        // And, then this value should not be set here.

        iParentIdentifier = CNcdNodeIdentifier::NewL();        

        }

    if ( iRealParentIdentifier == NULL ) 

        {

        iRealParentIdentifier = CNcdNodeIdentifier::NewL();

        }

    DLTRACEOUT((""));

    }

CNcdNodeProxy::~CNcdNodeProxy()

    {

    DLTRACEIN(("this-ptr: %x", this));

    // Because this object is deleted. Remove the interfaces from the

    // interface list.

    RemoveInterface( MNcdNode::KInterfaceUid );

    RemoveInterface( MNcdNodeChildOfTransparent::KInterfaceUid );

    RemoveInterface( MNcdNodeFavorite::KInterfaceUid );

    // Inform node manager that this node is under deletion.    

    iNodeManager.NodeDeleted( this );

    delete iNodeIdentifier;

    iNodeIdentifier = NULL;

    // Delete link data

    delete iCatalogSourceName;

    iCatalogSourceName = NULL;

    delete iParentIdentifier;

    iParentIdentifier = NULL;

    delete iRealParentIdentifier;

    iRealParentIdentifier = NULL;

    delete iTimestamp;

    iTimestamp = NULL;

    // Delete the objects that are owned by this class and provide functionality

    // through the api.

    // Notice that the api-objects are Released (not deleted) from the UI side.

    // The node owns the data and the reference counter of the node keeps

    // track of the api objects it owns. When the reference counter of the node

    // reaches zero, it means that nobody is using the node or the classes owned

    // by the node. If somebody is using the object owned by the node, the reference

    // counter can not be zero until everything is released.

    // Thus, the node may delete the data here.

    delete iMetadata;

    iMetadata = NULL;

    delete iNodeSeen;

    iNodeSeen = NULL;

    DLTRACEOUT(("this-ptr: %x", this));

    }

CNcdNodeIdentifier& CNcdNodeProxy::NodeIdentifier() const

    {

    return *iNodeIdentifier;    

    }

CNcdNodeManagerProxy& CNcdNodeProxy::NodeManager() const

    {

    return iNodeManager;

    }

CNcdOperationManagerProxy& CNcdNodeProxy::OperationManager() const

    {

    return iOperationManager;    

    }

CNcdNodeMetadataProxy* CNcdNodeProxy::Metadata() const

    {

    //DASSERT( iMetadata );

    return iMetadata;

    }

void CNcdNodeProxy::InternalizeL()

    {

    DLTRACEIN(("this-ptr: %x", this));

    DPROFILING_BEGIN( x );

    HBufC8* data( NULL );

    // Because we do not know the exact size of the data id, use

    // the alloc method, which creates the buffer of the right size

    // and sets the pointer to point to the created buffer.

    User::LeaveIfError(

            ClientServerSession().

                SendSyncAlloc( NcdNodeFunctionIds::ENcdInternalize,

                               KNullDesC8,

                               data,

                               Handle(),

                               0 ) );

    if ( data == NULL )

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PushL( data );

    DLINFO(( "Ncd node internalize data length: %d", data->Length() ));

    // Read the data from the stream and insert it to the memeber variables

    RDesReadStream stream( *data );

    CleanupClosePushL( stream );

    // Let this leave. If the node can not internalize itself, then

    // something is really badly wrong. In this case this node should

    // even be created. So, if this is called from ContstructL it should

    // most likely to leave also.

    InternalizeNodeDataL( stream );

    // Closes the stream

    CleanupStack::PopAndDestroy( &stream ); 

    CleanupStack::PopAndDestroy( data );

    // The node data was internalized.

    // Next, internalize the link data if it exists.    

    DLINFO(("Internalize node proxy link"));

    InternalizeLinkL();    

    // TRAP the functions after this. So, all the existing new interfaces

    // may be added to the interface list.

    // Also, metadata may be ready for initialization.

    DLINFO(("Internalize node proxy metadata"));

    TRAP_IGNORE( InternalizeMetadataL() );

    // Internalize node seen proxy.

    DLINFO(("Internalize node seen"));

    InternalizeNodeSeenL();

    // Install the MNcdNodeFavorite interface if the same metadata is favorite already.

    if ( iFavoriteManager.IsFavoriteL( *iNodeIdentifier ) ) 

        {

        MNcdNodeFavorite* node( this );

        AddInterfaceL( 

            CCatalogsInterfaceIdentifier::NewL( node, this, MNcdNodeFavorite::KInterfaceUid ) );

        }

    DPROFILING_END( x );

    DLTRACEOUT((""));

    }

void CNcdNodeProxy::AddToFavoritesL( TBool aRemoveOnDisconnect ) 

    {

    DLTRACEIN(("aRemoveOnDisconnect: %d", aRemoveOnDisconnect));

    if ( !iFavoriteManager.IsFavoriteL( *iNodeIdentifier ) ) 

        {

        iFavoriteManager.AddToFavoritesL( *iNodeIdentifier, aRemoveOnDisconnect );        

        }

    // Register the MNcdNodeFavorite interface.

    MNcdNodeFavorite* node( this );

    AddInterfaceL( 

        CCatalogsInterfaceIdentifier::NewL( node, this, MNcdNodeFavorite::KInterfaceUid ) );        

    }

// MNcdNode functions

MNcdNode::TState CNcdNodeProxy::State() const

    {

    DLTRACEIN((_L("Node namespace=%S, id=%S"), &Namespace(), &Id() ));

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

    // link data has been internalized. Also, check if the metadata 

    // exists, which means that metadata has also been internalized.

    if ( LinkHandleSet() 

         && iMetadata != NULL )

        {

        DLINFO(("State was initialized"));

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

        // has acutally expired already 

        TTime now;

        now.HomeTime();

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

        DLINFO(("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.

        if ( now > ExpiredTime() )

            {

            DLTRACEOUT(("Expired"));

            return MNcdNode::EStateExpired;

            }

        DLTRACEOUT(("Initialized"));

        return MNcdNode::EStateInitialized;

        }

     else

        {

        // Node has not been initialized.

        DLTRACEOUT(("Not initialized"));

        return MNcdNode::EStateNotInitialized;

        }

    }

const TDesC& CNcdNodeProxy::Id() const

    {

    DLTRACEIN((""));

    return iNodeIdentifier->NodeId(); 

    }

const TDesC& CNcdNodeProxy::Namespace() const

    {

    DLTRACEIN((""));

    return iNodeIdentifier->NodeNameSpace();

    }

const TDesC& CNcdNodeProxy::CatalogSourceName() const

    {

    DLTRACEIN((""));

    return *iCatalogSourceName;

    }    

MNcdNodeContainer* CNcdNodeProxy::ParentL() const

    {

    DLTRACEIN((""));

    if( iParentIdentifier == NULL

        || iParentIdentifier->ContainsEmptyFields() )

        {

        DLTRACEOUT(("Parent identifier was not set. Return NULL"));

        return NULL;

        }

    else

        {

        DLINFO(("Parent identifier was set. Get the parent"));

        // This always gives reference to the node

        // We use pointer instead of reference afterwards.

        // NodeL leaves if the node was not found.

        MNcdNode* parent = &iNodeManager.NodeL( *iParentIdentifier );

        DLINFO(("Parent was gotten"));

        // This should always give something because parent is always container.

        // Notice, that the query interface increases the reference count automatically.

        MNcdNodeContainer* container = parent->QueryInterfaceL<MNcdNodeContainer>();

        DLTRACEOUT(( _L("Return parent container interface: %X"), container ));

        return container;

        }

    }

MNcdLoadNodeOperation* CNcdNodeProxy::LoadL( MNcdLoadNodeOperationObserver& aObserver )

    {

    DLTRACEIN((""));

    CNcdLoadNodeOperationProxy* operation( NULL );

    operation =

        iOperationManager.CreateLoadNodeOperationL( *this );

    operation->AddObserverL( this );

    operation->AddObserverL( &aObserver );

    DLTRACEOUT((""));

    return operation;

    }

RCatalogsArray<MNcdOperation> CNcdNodeProxy::OperationsL() const

    {

    DLTRACEIN(("this: %x, iMetadata: %x", this, iMetadata ));

    RCatalogsArray<MNcdOperation> operations;

    CleanupClosePushL( operations );

    if ( iMetadata ) 

        {

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

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

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

        MNcdOperation* oper( NULL );

        MNcdNode* node( NULL );

        CNcdNodeMetadataProxy* metadata( NULL );

        DLTRACE(("Getting metaidentifier"));

        const CNcdNodeIdentifier& metadataId( iMetadata->Identifier() );

        DLTRACE(("Origarray.count: %d", origArray.Count() ));

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

            {            

            oper = origArray[ i ];

            DLTRACE(("oper: %x", oper));

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

            node = oper->Node();

            if ( node ) 

                {

                CleanupReleasePushL( *node );

                // Compare metadatas

                metadata = static_cast<CNcdNodeProxy*>( node )->Metadata();

                DLTRACE(("Metadata: %x", metadata));

                if ( metadata && metadata->Identifier().Equals( metadataId ) )

                    {

                    DLTRACE(("Appending to ops array"));

                    operations.AppendL( oper );

                    oper->AddRef();

                    }

                CleanupStack::PopAndDestroy( node );

                }

            }

        }

    CleanupStack::Pop( &operations );

    DLTRACEOUT(( "" ));

    return operations;

    }

void CNcdNodeProxy::AddToFavoritesL() 

    {

    AddToFavoritesL( EFalse );

    }

// MNcdLoadNodeOperationObserver

void CNcdNodeProxy::NodesUpdated( MNcdLoadNodeOperation& /*aOperation*/,

                                  RCatalogsArray< MNcdNode >& aNodes )

    {

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

        {

        // Should the node provide its own function instead of API interface

        // that can be called when node/nodes should be updated. Operations know

        // the node proxy object so they could use the function directly instead

        // of using more restricted API interfaces. Then, no casting would be required

        // here...        

        CNcdNodeProxy* node = static_cast<CNcdNodeProxy*>(aNodes[i]);

        TRAP_IGNORE( node->InternalizeL() );

        /*// make sure that this node is a child of this node

        TIdentityRelation<CNcdNodeIdentifier> relation(CNcdNodeIdentifier::Equals);        

        if ( iChildren.Find( node->NodeIdentifier(), relation ) == KErrNotFound )

            {

            }*/

        }    

    // This function of the observer interface does not need to do anythin here.

    }

void CNcdNodeProxy::QueryReceived( MNcdLoadNodeOperation& /*aOperation*/,

                                   MNcdQuery* aQuery )

    {

    // This function of the observer interface does not need to do anythin here.

    aQuery->Release();

    }

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

                                       TInt /*aError*/ )

    {

    DLTRACEIN((""));

    DLINFO(("Nothing done."));

    DLTRACEOUT((""));

    }

// MNcdNodeChildOfTransparent    

MNcdNode* CNcdNodeProxy::TransparentParentL() const 

    {

    DLTRACEIN((""));

    DASSERT( iRealParentIdentifier );

    DASSERT( !iRealParentIdentifier->ContainsEmptyFields() );

    MNcdNode* parent( NULL );

    TRAPD( err, parent = &NodeManager().NodeL( *iRealParentIdentifier ) );    

    if ( err == KErrNotFound ) 

        {

        return NULL;

        }

    User::LeaveIfError( err );

    parent->AddRef();

    return parent;

    }

// MNcdNodeFavorite

void CNcdNodeProxy::RemoveFromFavoritesL() 

    {

    DLTRACEIN((""));

    iFavoriteManager.RemoveFromFavoritesL( *iNodeIdentifier );

    RemoveInterface( MNcdNodeFavorite::KInterfaceUid );

    }

void CNcdNodeProxy::SetDisclaimerL( MNcdNode* aDisclaimerOwner ) 

    {

    DLTRACEIN((""));

    iFavoriteManager.SetNodeDisclaimerL( *iNodeIdentifier, aDisclaimerOwner );

    }

MNcdQuery* CNcdNodeProxy::DisclaimerL() const 

    {

    DLTRACEIN((""));

    MNcdQuery* disclaimer = iFavoriteManager.NodeDisclaimerL( *iNodeIdentifier );

    if ( disclaimer ) 

        {

        disclaimer->AddRef();

        }

    return disclaimer;

    }

// Other functions