/*

* 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 CNcdSubscription class

*

*/

#include "ncdsubscriptionimpl.h"

#include "ncdpurchaseoptionimpl.h"

#include "ncdserversubscription.h"

#include "ncdserverpartofsubscription.h"

#include "ncdserverupgrade.h"

#include "ncd_pp_subscriptiondetails.h"

#include "catalogssession.h"

#include "catalogsbasemessage.h"

#include "ncdnodefunctionids.h"

#include "ncdnodeclassids.h"

#include "catalogsconstants.h"

#include "ncd_pp_dataentity.h"

#include "ncd_cp_query.h"

#include "ncd_pp_subscription.h"

#include "catalogsutils.h"

#include "ncdserversubscribablecontent.h"

#include "ncdsubscriptiongroup.h"

#include "ncdprotocolutils.h"

#include "catalogsdebug.h"

CNcdSubscription::CNcdSubscription( CNcdSubscriptionGroup& aParentGroup )

    : CCatalogsCommunicable(),

      iParentGroup( aParentGroup )

    {

    }

void CNcdSubscription::ConstructL()

    {

    }

CNcdSubscription* CNcdSubscription::NewL(

    CNcdSubscriptionGroup& aParentGroup )

    {

    CNcdSubscription* self =   

        CNcdSubscription::NewLC( aParentGroup );

    CleanupStack::Pop( self );

    return self;        

    }

CNcdSubscription* CNcdSubscription::NewLC(

    CNcdSubscriptionGroup& aParentGroup )

    {

    CNcdSubscription* self = 

        new( ELeave ) CNcdSubscription( aParentGroup );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;        

    }

CNcdSubscription::~CNcdSubscription()

    {

    DLTRACEIN((""));

    ResetMemberVariables();

    DLTRACEOUT((""));

    }        

const TDesC& CNcdSubscription::SubscriptionName() const

    {

    DLTRACEIN((""));

    if ( iName == NULL )

        {

        DLTRACEOUT((""));

        return KNullDesC;

        }

    else

        {

        DLTRACEOUT((""));

        return *iName;

        }      

    }

void CNcdSubscription::SetSubscriptionNameL( const TDesC& aNewName )

    {

    delete iName;

    iName = NULL;

    iName = aNewName.AllocL();

    }

const TDesC& CNcdSubscription::PurchaseOptionId() const

    {

    DLTRACEIN((""));

    if ( iPurchaseOptionId == NULL )

        {

        DLTRACEOUT((""));

        return KNullDesC;

        }

    else

        {

        DLTRACEOUT((""));

        return *iPurchaseOptionId;

        }    

    }

CNcdSubscriptionGroup& CNcdSubscription::ParentGroup() const 

    {

    DLTRACEIN((""));

    return iParentGroup;

    }

MNcdSubscription::TType CNcdSubscription::SubscriptionType() const 

    {

    DLTRACEIN((""));

    return iSubscriptionType;

    }

void CNcdSubscription::InternalizeL( const CNcdPurchaseOptionImpl& aData )

    {

    DLTRACEIN(("Subscriptionimpl internalizing from purchase option."));

    // Current time saved in the beginning for later use.

    // Done as soon as possible so it won't be too long

    // after message is received from the server and delta

    // values are hopefully still valid.

    TTime now;

    now.HomeTime();

    ResetMemberVariables();

    iName = aData.PurchaseOptionName().AllocL();

    DLTRACE(( _L("Name: %S."), iName ));

    // Cannot get expired on info from the purchaseoption and

    // if this subscription is just bought as it should be, it

    // has not expired.

    // Expired on is left into its initial value.

    // The same thing is with iCancelled. It is assumed that as the

    // subscription is just bought, it is not unsubscribed yet.

    // Get subscription type from the subscribable content

    const CNcdServerSubscribableContent* subscribableContent =

        aData.ParentSubscribableContent();

    // Protocol makes it possible that although we have a node that has

    // a purchaseoption that can be used to buy a subscription the node

    // does not need to have a subscribable content field.    

    if ( subscribableContent != NULL )

        {

        iSubscriptionType = subscribableContent->SubscriptionType();

        DLINFO(( "Subscriptionimpl internalizing, type: %d",

                 iSubscriptionType ));        

        }

    else

        {

        // We use the default type of subscription

        DLINFO(( "Subscribable content not found, have to use default type: %d",

                 iSubscriptionType ));

        }

    // Next we set total values if they are set in the subscription

    const CNcdServerSubscription* subscriptionInfo =

        aData.SubscriptionInfo();

    if ( subscriptionInfo == NULL )

        {

        User::Leave( KErrArgument );

        }

    iTotalValidityDelta = subscriptionInfo->ValidityDelta();

    DLINFO(( "Total validitydelta: %d.", iTotalValidityDelta ));

    if ( iTotalValidityDelta >= 0 )

        {

        iValidityTimeSet = ETrue;

        }

    DLINFO(( "ValidityTimeSet: %d.", iValidityTimeSet ));

    iTotalCredits = subscriptionInfo->AmountOfCredits();

    DLINFO(( "Total credits: %f.", iTotalCredits ));

    // Simple >0 is decided to be enough because no complicated operations

    // are done with TReal numbers

    if ( iTotalCredits >= 0 )

        {

        iCreditLimitSet = ETrue;

        }

    iTotalDownloads = subscriptionInfo->NumberOfDownloads();

    DLINFO(( "Total downloads: %d.", iTotalDownloads ));

    if ( iTotalDownloads >= 0 )

        {

        iDownloadLimitSet = ETrue;

        }

    // Because this function should be used just after purchase

    // of the subscription, we set maximum values to the

    // "left" variables

    // validityDelta is in minutes so we use TTimeIntervalMinutes

    // to reprsent the interval

    TTimeIntervalMinutes validityInterval( iTotalValidityDelta );

    iValidUntil = now + validityInterval;

    iCreditsLeft = iTotalCredits;

    iDownloadsLeft = iTotalDownloads;

    iPurchaseOptionId = aData.Id().AllocL();

    DLTRACEOUT((""));

    }

void CNcdSubscription::InternalizeL(

    MNcdPreminetProtocolSubscription& aData )

    {

    DLTRACEIN(("Subscriptionimpl internalizing from protocol."));

    // Current time saved in the beginning for later use.

    // Done as soon as possible so it won't be too long

    // after message is received from the server and delta

    // values are hopefully still valid.

    TTime now;

    now.HomeTime();

    // ResetMemberVariables function is not called here

    // because it deletes all member variables and

    // we cannot recreate all of them from the given protocol object.

    // Instead ResetProtocolMemberVariables is called

    ResetProtocolMemberVariables();

    // Nothing is done to existing name and icon

    // info because hopefully they are received some other way

    // (from purchase option)

    iExpiredOn = aData.ExpiredOn().AllocL();

    iCancelled = aData.Cancelled();

    TNcdSubscriptionType tmpType = aData.Type();

    DASSERT( tmpType != ENotSubscribable );

    switch( tmpType )

        {

        case EPeriodic:

            iSubscriptionType = MNcdSubscription::EPeriodic;

            break;

        case EAutomaticContinous:

            iSubscriptionType = MNcdSubscription::EAutomaticContinous;

            break;

        default:

            DASSERT( false ); // Should not end up here

            break;

        }

    // If we have a expired subscription TotalUsageRights is

    // assumed to return usagerights of the expired subscription

    const MNcdPreminetProtocolSubscriptionDetails* totalRights =

        aData.TotalUsageRights();

    DASSERT( totalRights != NULL );

    if ( totalRights != NULL )

        {

        // We assume here that if any of the original limits or

        // validity negative then that particular limit or validity

        // is not in use.

        iTotalValidityDelta = totalRights->ValidityDelta();

        if ( iTotalValidityDelta >= 0 )

            {

            iValidityTimeSet = ETrue;

            }

        iTotalCredits = totalRights->AmountOfCredits();

        // Also here >0 is deemed to be enough because no complicated

        // operations are done on the TReal numbers

        if ( iTotalCredits >= 0 )

            {

            iCreditLimitSet = ETrue;

            }

        iTotalDownloads = totalRights->NumberOfDownloads();

        if ( iTotalDownloads >= 0 )

            {

            iDownloadLimitSet = ETrue;

            }

        }

    const MNcdPreminetProtocolSubscriptionDetails* remainingRights =

        aData.RemainingUsageRights();

    TInt validityDelta( -1 );

    if ( remainingRights != NULL )

        {

        validityDelta = remainingRights->ValidityDelta();

        // validityDelta is in minutes so we use TTimeIntervalMinutes

        // to reprsent the interval

        TTimeIntervalMinutes validityInterval( validityDelta );        

        iValidUntil = now + validityInterval;

        iCreditsLeft = remainingRights->AmountOfCredits();

        iDownloadsLeft = remainingRights->NumberOfDownloads();

        }

    // expiredOn is set to iValidUntil so that client can receive

    // some kind of validuntil (from proxyside interface)

    // even if the subscription has already expired.

    // This way iValidUntil is not necessiraly the original validUntil.

    // For example in situation where other constraint has run out first

    // (for example credits), iValidUntil would be this expiration

    // point. Anyway it is close enough.

    // NOTICE: iValidUntil of expired subscription cannot be greater

    //         than "now" because server does not return

    //         remaining usagerights of expired subscriptions

    if ( iValidityTimeSet && validityDelta == -1 && iExpiredOn != NULL &&

         *iExpiredOn != KNullDesC )

        {

        iValidUntil = NcdProtocolUtils::DesToTimeL( *iExpiredOn ); 

        }

    iPurchaseOptionId = aData.PurchaseOptionId().AllocL();

    DLTRACEOUT((""));

    }

void CNcdSubscription::SetRecentlyUpdated( TBool aNewState )

    {

    DLTRACEIN((""));

    iRecentlyUpdated = aNewState;

    DLTRACEOUT((""));

    }

TBool CNcdSubscription::RecentlyUpdated() const

    {

    DLTRACEIN((""));

    DLTRACEOUT((""));

    return iRecentlyUpdated;

    }

// Internalization from and externalization to the database

void CNcdSubscription::ExternalizeL( RWriteStream& aStream )

    {

    DLTRACEIN((""));

    ExternalizeOwnDataL( aStream );

    DLTRACEOUT((""));

    }

void CNcdSubscription::InternalizeL( RReadStream& aStream )

    {

    DLTRACEIN((""));

    ResetMemberVariables();

    InternalizeDesL( iName, aStream );

    InternalizeDesL( iExpiredOn, aStream );

    iCancelled = aStream.ReadInt32L();

    iSubscriptionType = 

        static_cast<MNcdSubscription::TType>(aStream.ReadInt32L());

    iValidityTimeSet = aStream.ReadInt32L();

    TInt64 intValidUntil( 0 );

    aStream >> intValidUntil;

    iValidUntil = intValidUntil;

    iTotalValidityDelta = aStream.ReadInt32L();

    iCreditLimitSet = aStream.ReadInt32L();

    iCreditsLeft = aStream.ReadReal32L();

    iTotalCredits = aStream.ReadReal32L();

    iDownloadLimitSet = aStream.ReadInt32L();

    iDownloadsLeft = aStream.ReadInt32L();

    iTotalDownloads = aStream.ReadInt32L();

    InternalizeDesL( iPurchaseOptionId, aStream );

    DLTRACE(( _L(" Internalized subscription, purchaseoptionid: %S"),

              iPurchaseOptionId ));

    DLTRACEOUT((""));

    }

void CNcdSubscription::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::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;

        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;        

    DLTRACEOUT((""));

    }

void CNcdSubscription::CounterPartLost( const MCatalogsSession& aSession )

    {

    // This function may be called whenever -- when the message is waiting

    // response or when the message does not exist.

    // iMessage may be NULL here, because in the end of the

    // ReceiveMessage it is set to NULL. The life time of the message

    // ends shortly after CompleteAndRelease is called.

    if ( iMessage != NULL )

        {

        iMessage->CounterPartLost( aSession );

        }

    }

void CNcdSubscription::InternalizeRequestL( MCatalogsBaseMessage& aMessage )

    {

    DLTRACEIN((""));

    CBufBase* buf = CBufFlat::NewL( KBufExpandSize );

    CleanupStack::PushL( buf );

    RBufWriteStream stream( *buf );

    CleanupClosePushL( stream );

    // Include all the necessary node data to the stream

    ExternalizeDataForRequestL( stream );     

    // Commits data to the stream when closing.

    CleanupStack::PopAndDestroy( &stream );

    // If this leaves, ReceiveMessage will complete the message.

    // NOTE: that here we expect that the buffer contains at least

    // some data. So, make sure that ExternalizeDataForRequestL inserts

    // something to the buffer.

    aMessage.CompleteAndReleaseL( buf->Ptr( 0 ), KErrNone );        

    DLTRACE(("Deleting the buf"));

    CleanupStack::PopAndDestroy( buf );

    DLTRACEOUT((""));

    }

void CNcdSubscription::ExternalizeDataForRequestL( RWriteStream& aStream )

    {

    DLTRACEIN((""));

    ExternalizeOwnDataL( aStream );

    DLTRACEOUT((""));

    }