/*
* 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:   Implementation of CNcdCookieHandler
*
*/


#include "ncd_cp_cookieimpl.h"
#include "ncdprotocolutils.h"
#include "catalogsdebug.h"
#include "catalogsutils.h"

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CNcdConfigurationProtocolCookie::CNcdConfigurationProtocolCookie()
    {
    }


// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CNcdConfigurationProtocolCookie* 
    CNcdConfigurationProtocolCookie::NewL()
    {
    CNcdConfigurationProtocolCookie* self = new(ELeave) 
        CNcdConfigurationProtocolCookie();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// NewLC
// ---------------------------------------------------------------------------
//
CNcdConfigurationProtocolCookie* 
    CNcdConfigurationProtocolCookie::NewLC()
    {
    CNcdConfigurationProtocolCookie* self = 
        new (ELeave) CNcdConfigurationProtocolCookie();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------------------------
// Copy constructor
// ---------------------------------------------------------------------------
//
CNcdConfigurationProtocolCookie* 
    CNcdConfigurationProtocolCookie::NewLC( 
    const MNcdConfigurationProtocolCookie& aCookie )
    {
    CNcdConfigurationProtocolCookie* self = 
        new (ELeave) CNcdConfigurationProtocolCookie();
    CleanupStack::PushL( self );
    self->ConstructL( aCookie );
    return self;    
    }

                                             
// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CNcdConfigurationProtocolCookie::ConstructL()
    {
    NcdProtocolUtils::AssignEmptyDesL( iKey );
    NcdProtocolUtils::AssignDesL( iType, 
        NcdConfigurationProtocolCookieTypes::KSaveAndSend );
    NcdProtocolUtils::AssignDesL( iScope, 
        NcdConfigurationProtocolCookieScopes::KClient );
    NcdProtocolUtils::AssignEmptyDesL( iSim );
    }


// ---------------------------------------------------------------------------
// ConstructL 
// ---------------------------------------------------------------------------
//
void CNcdConfigurationProtocolCookie::ConstructL( 
    const MNcdConfigurationProtocolCookie & aCookie )
    {
    NcdProtocolUtils::AssignDesL( iKey, aCookie.Key() );
    NcdProtocolUtils::AssignDesL( iType, aCookie.Type() );
    NcdProtocolUtils::AssignDesL( iScope, aCookie.Scope() );
    iExpirationDelta = aCookie.ExpirationDelta();
    iValues.ReserveL( aCookie.ValueCount() );
    for ( TInt i = 0; i < aCookie.ValueCount(); ++i )
        {
        HBufC* value = aCookie.Value( i ).AllocL();
        iValues.Append( value );
        }
    NcdProtocolUtils::AssignDesL( iSim, aCookie.Sim() );
    }
    
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CNcdConfigurationProtocolCookie::~CNcdConfigurationProtocolCookie()
    {
    delete iKey;
    delete iType;
    delete iScope;
    iValues.ResetAndDestroy();
    delete iSim;
    }

// ---------------------------------------------------------------------------
// Key
// ---------------------------------------------------------------------------
//
const TDesC& CNcdConfigurationProtocolCookie::Key() const
    {
    DASSERT( iKey );
    return *iKey;
    }

// ---------------------------------------------------------------------------
// Type
// ---------------------------------------------------------------------------
//
const TDesC& CNcdConfigurationProtocolCookie::Type() const
    {
    DASSERT( iType );
    return *iType;
    }


// ---------------------------------------------------------------------------
// Scope
// ---------------------------------------------------------------------------
//
const TDesC& CNcdConfigurationProtocolCookie::Scope() const
    {
    DASSERT( iScope );
    return *iScope;
    }

// ---------------------------------------------------------------------------
// ExpirationDelta
// ---------------------------------------------------------------------------
//
TInt CNcdConfigurationProtocolCookie::ExpirationDelta() const
    {
    return iExpirationDelta;
    }


// ---------------------------------------------------------------------------
// ValueCount
// ---------------------------------------------------------------------------
//
TInt CNcdConfigurationProtocolCookie::ValueCount() const
    {
    return iValues.Count();
    }

// ---------------------------------------------------------------------------
// Value
// ---------------------------------------------------------------------------
//
const TDesC& CNcdConfigurationProtocolCookie::Value( TInt aIndex ) const
    {
    DASSERT( aIndex >= 0 && aIndex < ValueCount() );
    return *( iValues[aIndex]);
    }


// ---------------------------------------------------------------------------
// Sim
// ---------------------------------------------------------------------------
//
const TDesC8& CNcdConfigurationProtocolCookie::Sim() const
    {
    return *iSim;
    }


// ---------------------------------------------------------------------------
// Expiration time getter
// ---------------------------------------------------------------------------
//
TTime CNcdConfigurationProtocolCookie::ExpirationTime() const
    {
    return iExpirationTime;
    }
    
    
// ---------------------------------------------------------------------------
// Identity
// ---------------------------------------------------------------------------
//
TBool CNcdConfigurationProtocolCookie::Identity( 
    const MNcdConfigurationProtocolCookie& aFirst,
    const MNcdConfigurationProtocolCookie& aSecond )
    {
    return aFirst.Key() == aSecond.Key();
    }

// ---------------------------------------------------------------------------
// ExternalizeL
// ---------------------------------------------------------------------------
//

void CNcdConfigurationProtocolCookie::ExternalizeL( RWriteStream& aStream )
    {
    DLTRACEIN((""));
    DASSERT( iKey );    
    DASSERT( iType );
    DASSERT( iScope );
    ExternalizeDesL( *iKey, aStream ); 
    
    DLTRACE(("Externalizing cookie values"));
    // Externalize values
    aStream.WriteInt32L( ValueCount() );
    for ( TInt i = 0; i < ValueCount(); ++i ) 
        {
        ExternalizeDesL( Value( i ), aStream );
        }
    
    DLTRACE(("Cookie values externalized"));
    ExternalizeDesL( *iType, aStream );
    ExternalizeDesL( *iScope, aStream );
    ExternalizeDesL( *iSim, aStream );
    aStream.WriteInt32L( iExpirationDelta );
    aStream << iExpirationTime.Int64();
    DLTRACEOUT((""));
    }


// ---------------------------------------------------------------------------
// InternalizeL
// ---------------------------------------------------------------------------
//
void CNcdConfigurationProtocolCookie::InternalizeL( RReadStream& aStream )
    {
    DLTRACEIN((""));
    InternalizeDesL( iKey, aStream );
    
    TInt valueCount = aStream.ReadInt32L();
    iValues.ResetAndDestroy();
    iValues.ReserveL( valueCount );
    
    DLTRACE(( "Internalizing cookie values, count: %d", valueCount ));
    for ( TInt i = 0; i < valueCount; ++i )
        {
        HBufC* value = NULL;
        InternalizeDesL( value, aStream );
        // "Can't" fail
        iValues.Append( value );        
        }
    DLTRACE(( "Cookies values internalized" ));
    
    InternalizeDesL( iType, aStream );
    InternalizeDesL( iScope, aStream );
    InternalizeDesL( iSim, aStream );
    iExpirationDelta = aStream.ReadInt32L();
    
    // Read expiration time
    TInt64 time( 0 );
    aStream >> time;
    iExpirationTime = TTime( time );
    DLTRACEOUT((""));
    }