/*

* 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:   Implements CNcdSubscriptionManager class

*

*/

#include "ncdsubscriptionmanagerimpl.h"

#include <s32mem.h>

#include <bamdesca.h> // MDesCArray

#include "catalogssession.h"

#include "catalogsbasemessage.h"

#include "ncdnodefunctionids.h"

#include "ncdnodeclassids.h"

#include "catalogsconstants.h"

#include "ncd_pp_dataentity.h"

#include "ncd_pp_subscription.h"

#include "ncd_cp_query.h"

#include "catalogsutils.h"

#include "ncdstoragedataitem.h"

#include "ncdsubscriptionssourceidentifier.h"

#include "ncdserverpartofsubscription.h"

#include "ncdclientssubscriptions.h"

#include "ncdsubscriptiongroup.h"

#include "catalogscontext.h"

#include "ncddatabasestorage.h"

#include "ncdstorage.h"

#include "ncdproviderdefines.h"

#include "ncdstorageitem.h"

#include "ncdstoragemanagerimpl.h"

#include "ncdpurchaseoptionimpl.h"

#include "ncdnodeidentifier.h"

#include "ncdnodemanager.h"

#include "ncdrootnode.h"

#include "ncdsubscriptiongroup.h"

#include "ncdutils.h"

#include "ncdnodeiconimpl.h"

// This is for the contentsourcemap

#include "ncdloadrootnodeoperationimpl.h"

#include "ncdsubscriptionmanagerobserver.h"

#include "ncdsubscriptiondatacompleter.h"

#include "catalogsdebug.h"

CNcdSubscriptionManager::CNcdSubscriptionManager(

    CNcdStorageManager& aStorageManager,

    CNcdNodeManager& aNodeManager )

    : CCatalogsCommunicable(),

      iStorageManager( aStorageManager ),

      iNodeManager( aNodeManager )

    {

    DLTRACEIN((""));

    DLTRACEOUT((""));

    }

void CNcdSubscriptionManager::ConstructL()

    {

    }

CNcdSubscriptionManager* CNcdSubscriptionManager::NewL(

    CNcdStorageManager& aStorageManager,

    CNcdNodeManager& aNodeManager )

    {

    CNcdSubscriptionManager* self =

        CNcdSubscriptionManager::NewLC( aStorageManager, aNodeManager );

    CleanupStack::Pop( self );

    return self;        

    }

CNcdSubscriptionManager* CNcdSubscriptionManager::NewLC(

    CNcdStorageManager& aStorageManager,

    CNcdNodeManager& aNodeManager )

    {

    CNcdSubscriptionManager* self = 

        new( ELeave ) CNcdSubscriptionManager( aStorageManager, aNodeManager );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;        

    }

CNcdSubscriptionManager::~CNcdSubscriptionManager()

    {

    DLTRACEIN((""));

    iSubscriptionDataCompleters.ResetAndDestroy();

    // All subscriptions should be saved into database if they

    // are new or changed. So there is no need to save all of them

    // here.

    const TInt clientsCount( iClientSubscriptions.Count() );

    TInt indexer( 0 );

    while( indexer < clientsCount )

        {

        delete iClientSubscriptions[indexer];

        ++indexer;

        }

    iClientSubscriptions.Reset();

    // Complete the pending messages

    NotifyAllListeners( KErrServerTerminated );

    iPendingMessages.Close();

    DLTRACEOUT((""));

    }        

void CNcdSubscriptionManager::SetOperationManager(

    CNcdOperationManager* aManager )

    {

    iOperationManager = aManager;

    }

RPointerArray<CNcdSubscriptionsSourceIdentifier>

    CNcdSubscriptionManager::SubscriptionsSourcesL( TUid aClientUid ) const

    {    

    DLTRACEIN((""));

    // First read possibly existing subscriptions sources from the

    // subscriptions database

    TInt clientIndex( -1 );

    RPointerArray<CNcdSubscriptionsSourceIdentifier> sources;    

    TRAP_IGNORE( clientIndex = IsInCacheL( aClientUid ) );

    if ( clientIndex > -1 )

        {

        TRAP_IGNORE( sources = SubscriptionsSourcesL( clientIndex ) );

        }

    DLINFO(( "Getting subscriptions sources from the root node." ));

    // Get content sources from root node.

    CNcdRootNode& rootNode = 

        iNodeManager.CreateRootL( aClientUid );

    CNcdContentSourceMap& csMap = rootNode.ContentSourceMap();

    DLTRACE(("Content sources: %d", csMap.ContentSourceCount() ));

    TIdentityRelation<CNcdSubscriptionsSourceIdentifier> match( 

            &CNcdSubscriptionsSourceIdentifier::CompareIdentifiers );

    for ( TInt i = 0; i < csMap.ContentSourceCount(); i++ ) 

        {

        CNcdContentSource& contentSource = csMap.ContentSource( i );

        // When we get the source identifier from the root node, we don't know

        // if it supports subscriptions so that has to be checked when sending

        // requests -> aRequireCapabilityCheck (last param) is set ETrue

        CNcdSubscriptionsSourceIdentifier* sourceId =

            CNcdSubscriptionsSourceIdentifier::NewLC(

                contentSource.Uri(), contentSource.NameSpace(), ETrue );

        // Do not add the source identifier if the same exists already.

        if ( sources.Find( sourceId, match ) == KErrNotFound )

            {

            sources.AppendL( sourceId );

            DLINFO(( "Subscriptions source appended into the array." ));

            CleanupStack::Pop( sourceId );

            }

        else

            {

            DLINFO(( "Subscriptions source already found from the array." ));

            CleanupStack::PopAndDestroy( sourceId );

            }

        DLINFO(( _L( "Source namespace: %S."), &contentSource.NameSpace() ));

        }

    // Handle bundle content sources. This actually helps only after the

    // user has browsed inside a bundle because we won't know the capabilities

    // of the bundle's servers before that

    TInt bundleCount = csMap.BundleFolderCount();

    DLINFO(("Bundle folders: %d", bundleCount ));

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

        {

        const CNcdNodeIdentifier& bundleId = csMap.BundleFolder( i );

        TInt folderIndex = csMap.FindFolder( bundleId );

        CNcdFolderContent& folderContent = csMap.FolderContent( folderIndex );

        DLTRACE(("Bundle has %d content sources", 

            folderContent.ContentSourceCount() ));

        for ( TInt index = 0; index < folderContent.ContentSourceCount(); ++index ) 

            {            

            CNcdContentSource& contentSource = folderContent.ContentSource( index );

            // When we get the source identifier from the root node, we don't know

            // if it supports subscriptions so that has to be checked when sending

            // requests -> aRequireCapabilityCheck (last param) is set ETrue

            CNcdSubscriptionsSourceIdentifier* sourceId =

                CNcdSubscriptionsSourceIdentifier::NewLC(

                    contentSource.Uri(), contentSource.NameSpace(), ETrue );

            // Do not add the source identifier if the same exists already.

            if ( sources.Find( sourceId, match ) == KErrNotFound )

                {

                sources.AppendL( sourceId );

                CleanupStack::Pop( sourceId );

                }

            else

                {

                CleanupStack::PopAndDestroy( sourceId );

                }

            DLINFO(( _L( "Source namespace: %S."), &contentSource.NameSpace() ));

            }

        }

    return sources;    

    }

void CNcdSubscriptionManager::InternalizeSubscriptionsFromServerL(

    TUid aClientUid,

    const TDesC& aUri,

    RPointerArray<MNcdPreminetProtocolSubscription>& aServersSubscriptions,

    MCatalogsContext* aContext,

    MNcdSubscriptionManagerObserver* aObserver )

    {

    DLTRACEIN((""));

    // Should do leave handling

    // First we create objects resembling subscriptions

    // and mark them as recently created.

    // This also writes subscriptions to database.

    InternalizeAndMarkSubscriptionsL( aClientUid,

                                      aUri,

                                      aServersSubscriptions );

    // Get the subscriptions related to given server

    // Here we should get also the recently created ones

    RPointerArray<CNcdSubscriptionGroup> serversGroups =

        ServersGroupsL( aClientUid, aUri );

    // In the end we remove subscriptions that were

    // not received in the aServersSubscriptions array and reset

    // the flags of subscriptions that were received. (Subscriptions that

    // were not received from the server in the aServersSubscriptions array

    // and are marked as received from the server (earlier) are removed

    // from the database, from the cache and from the serversGroups

    // array.)

    TRAP_IGNORE( RemoveUnmarkedSubscriptionsL( aClientUid, serversGroups ) );

    // Check that server's current subscriptions have all needed data and

    // if not get them from the corresponding nodes. Do also the needed

    // callback of observer and notifying of subscription manager's listeners

    // Also database write is done after completion. The earlier write

    // was done to ensure that some entry is found from the db if this

    // operation does not end before shutdown or some possible error situation

    // occurs.

    TRAP_IGNORE( CompleteSubscriptionsDataL( aClientUid,

                                             serversGroups,

                                             aContext,

                                             aObserver ) );

    // As the subscriptions are stored in member variable,

    // they should not be deleted. Just close for the array.

    serversGroups.Close();    

    }    

void CNcdSubscriptionManager::InternalizeSubscriptionL( 

    TUid aClientUid,

    const TDesC& aUri,

    MNcdPreminetProtocolSubscription& aSubscription,

    MCatalogsContext* aContext,

    MNcdSubscriptionManagerObserver* aObserver )

    {

    DLTRACEIN((""));

    // Get or create subscription group

    CNcdSubscriptionGroup& groupForSubscription = ClientsSubscriptionGroupL(

        aClientUid,

        aSubscription.EntityId(),

        aSubscription.Namespace(),

        aUri );

    groupForSubscription.InternalizeSubscriptionL( aSubscription );

    DLTRACE(( "Subscription internalized." ));

    // Database should always have updated info so at this point we have

    // to write updates there.

    // Because there is a database for each client the writing has

    // to be done here where we know which group was updated.

    SaveGroupIntoDatabaseL( aClientUid,

                            groupForSubscription );

    DLTRACE(( "Subscription group saved into database." ));

    // Check that current subscription (and its group) has all needed

    // data and if not, get them from the corresponding nodes. Do also

    // the needed callback of observer and notifying of subscription

    // manager's listeners. Also database write is done after completion.

    // The earlier write was done to ensure that some entry is found

    // from the db if this operation does not end before shutdown or

    // some possible error situation occurs.

    RPointerArray<CNcdSubscriptionGroup> groups;

    groups.AppendL( &groupForSubscription );

    TRAP_IGNORE( CompleteSubscriptionsDataL( aClientUid,

                                             groups,

                                             aContext,

                                             aObserver ) );

    // As the subscriptions are stored in member variable,

    // they should not be deleted. Just close for the array.

    groups.Close();

    DLTRACEOUT((""));

    }

void CNcdSubscriptionManager::RemoveSubscriptionL(

    const CNcdNodeIdentifier& aData,

    const TDesC& aPurchaseOptionId)

    {

    CNcdSubscriptionGroup& group = FindGroupL( aData.ClientUid(),

                                               aData.NodeId(),

                                               aData.NodeNameSpace() );

    group.RemoveSubscriptionL( aPurchaseOptionId );

    if ( group.SubscriptionCount() == 0 )

        {

        TInt index = IsInCacheL( aData.ClientUid() );

        CNcdClientsSubscriptions* clientsSubscriptions =

        iClientSubscriptions[index];

        clientsSubscriptions->RemoveGroup( &group );

        RemoveGroupFromDatabaseL( aData.ClientUid(),

                                  group );

        }    

    else

        {

        SaveGroupIntoDatabaseL( aData.ClientUid(), group );

        }

    // As the clientsSubscriptions only exists in the cache,

    // it is not checked that if groups still exist after this

    // group removal and whether the clientsSubscriptions

    // should be removed.    

    // Notify the listeners.

    NotifyListeners( aData.ClientUid() );

    }

CNcdSubscription& CNcdSubscriptionManager::SubscriptionL(

    const TDesC& aNodeId,

    const TDesC& aNodeNameSpace,

    const TDesC& aPurchaseOptionId,

    const TUid& aClientUid ) 

    {

    DLTRACEIN((""));

    TInt index = IsInCacheL( aClientUid );

    CNcdClientsSubscriptions* subscriptions = iClientSubscriptions[index];

    RPointerArray<CNcdSubscriptionGroup>& groups = subscriptions->Groups();

    TInt groupIndex = FindGroupL( groups, aNodeId, aNodeNameSpace );

    CNcdSubscriptionGroup* group = groups[groupIndex];

    return group->SubscriptionIfExistsL( aPurchaseOptionId );

    }

void CNcdSubscriptionManager::ClearSubscriptionDbL( const MCatalogsContext& aContext ) 

    {

    DLTRACEIN((""));

    iStorageManager.RemoveStorageL(

        aContext.FamilyId().Name(), NcdProviderDefines::KSubscriptionNamespace );

    // Remove from RAM cache too.

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

        {

        if ( iClientSubscriptions[i]->ClientId() == aContext.FamilyId() ) 

            {

            delete iClientSubscriptions[i];

            iClientSubscriptions.Remove( i );

            break;

            }

        }    

    }

void CNcdSubscriptionManager::NotifyListeners( TUid aClientUid ) 

    {

    DLTRACEIN((""));

    for ( TInt i = iPendingMessages.Count() - 1; i >= 0; i-- ) 

        {

        if ( iPendingMessages[i]->Session().Context().FamilyId() == 

             aClientUid ) 

            {            

            iPendingMessages[i]->CompleteAndRelease( KErrNone );

            iPendingMessages.Remove( i );                        

            }

        }

    }

void CNcdSubscriptionManager::SubscriptionCompleted(

        CNcdSubscriptionDataCompleter* aFinishedCompleter )

    {

    const TInt KCompleterAmount( iSubscriptionDataCompleters.Count() );

    TInt completerIndexer( 0 );

    CNcdSubscriptionDataCompleter* tempCompleter( NULL );

    while ( completerIndexer < KCompleterAmount )

        {

        tempCompleter = iSubscriptionDataCompleters[ completerIndexer ];

        if ( tempCompleter == aFinishedCompleter )

            {

            iSubscriptionDataCompleters.Remove( completerIndexer );

            delete aFinishedCompleter;

            return;

            }        

        ++completerIndexer;

        }

    }

void CNcdSubscriptionManager::SaveGroupIntoDatabaseL(

    TUid aClientUid,

    CNcdSubscriptionGroup& aGroup )

    {

    DLTRACEIN((""));

    // Databases are created for each client. (for each uid)

    // As a namespace we use a constant namespace (KSubscriptionNameSpace)

    // so we know in the future where from to load all data.

    HBufC* dataId = GenerateGroupDataIdL( aGroup );

    CleanupStack::PushL( dataId );

    DLTRACE(( _L("DataId for subscription group database item: %S"),

              dataId ));

    SaveDataIntoDatabaseL( aClientUid,

                           NcdProviderDefines::KSubscriptionNamespace,

                           *dataId,

                           aGroup,

                           NcdNodeClassIds::ENcdSubscriptionsData );

    CleanupStack::PopAndDestroy( dataId );

    DLTRACEOUT((""));

    }

void CNcdSubscriptionManager::ReceiveMessage( 

    MCatalogsBaseMessage* aMessage,

    TInt aFunctionNumber )

    {

    DLTRACEIN((""));    

    DASSERT( aMessage );

    // Now, we can be sure that rest of the time iMessage exists.

    // This member variable is set for the CounterPartLost function.

    iMessage = aMessage;

    TInt trapError( KErrNone );

    // Check which function is called by the proxy side object.

    // Function number are located in ncdnodefunctinoids.h file.

    switch( aFunctionNumber )

        {

        case NcdNodeFunctionIds::ENcdSubscriptionGroupIdentifiers:

            // Subscription group identifiers requested from proxy side.

            TRAP( trapError, SubscriptionGroupIdentifiersRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdInternalize:

            // Internalize the proxy side according to the data

            // of this object.

            TRAP( trapError, InternalizeRequestL( *aMessage ) );

            break;

        case NcdNodeFunctionIds::ENcdRelease:

            // The proxy does not want to use this object anymore.

            // So, release the handle from the session.

            ReleaseRequest( *aMessage );

            break;

        case NcdNodeFunctionIds::ENcdListenerEnrollment:

            // The proxy wants to enroll as listener.

            TRAP( trapError, ListenerEnrolledL( *aMessage ) );

            break;

        default:

            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 if the

        // message is still available.

        aMessage->CompleteAndRelease( trapError );

        }

    // Because the message should not be used after this, set it NULL.

    // So, CounterPartLost function will know that no messages are

    // waiting the response at the moment.

    iMessage = NULL;