/*

* 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 CNcdServerDetails

*

*/

#include <e32std.h>

#include "ncdserverdetailsimpl.h"

#include "catalogsdebug.h"

#include "ncd_cp_cookieimpl.h"

#include "ncddatabasestorage.h"

#include "ncdstorageitem.h"

#include "catalogsutils.h"

#include "ncd_cp_cookie.h"

#include "ncd_cp_cookieimpl.h"

#include "catalogsconstants.h"

// ---------------------------------------------------------------------------

// CNcdServerDetails

// ---------------------------------------------------------------------------

//    

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

//         

CNcdServerDetails* 

    CNcdServerDetails::NewLC(

            const TDesC& aServerUri, const TDesC& aNamespace )

    {

    CNcdServerDetails* self = new( ELeave ) CNcdServerDetails();

    CleanupStack::PushL( self );

    self->ConstructL( aServerUri, aNamespace );

    return self;

    }

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

CNcdServerDetails* CNcdServerDetails::NewL( RReadStream& aStream ) 

    {

    CNcdServerDetails* self = new( ELeave ) CNcdServerDetails();

    CleanupStack::PushL( self );

    self->ConstructL( aStream );

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//         

CNcdServerDetails::~CNcdServerDetails()

    {

    delete iServerUri;    

    delete iNamespace;

    delete iCapabilities;

    iCookies.ResetAndDestroy();

    }

// ---------------------------------------------------------------------------

// Externalizes the object

// ---------------------------------------------------------------------------

//

void CNcdServerDetails::ExternalizeL( RWriteStream& aStream ) const 

    {

    DLTRACEIN(( _L("ServerURI: %S, Namespace: %S"), iServerUri,

        iNamespace ));

    ExternalizeDesL( *iServerUri, aStream );

    ExternalizeDesL( *iNamespace, aStream );

    TInt count = iCapabilities->MdcaCount();

    DLTRACE(("Externalizing %d capabilities", count ));

    aStream.WriteInt32L( count );

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

        {

        DLTRACE(( _L("Cap: %S"), &iCapabilities->MdcaPoint( i ) ));

        ExternalizeDesL( iCapabilities->MdcaPoint( i ), aStream );

        }

    count = iCookies.Count();

    DLTRACE(("Externalizing %d cookies", count ));

    aStream.WriteInt32L( count );

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

        {

        iCookies[i]->ExternalizeL( aStream );

        }

    }                       

// ---------------------------------------------------------------------------

// Adds a new capability

// ---------------------------------------------------------------------------

//         

void CNcdServerDetails::AddCapabilityL( 

    const TDesC& aCapability )

    {

    DLTRACEIN(( _L("Server cap: %S to server: %S"), &aCapability,

        iServerUri ));

    iCapabilities->AppendL( aCapability );

    }

// ---------------------------------------------------------------------------

// Clears capabilities

// ---------------------------------------------------------------------------

//         

void CNcdServerDetails::ClearCapabilitiesL()

    {

    DLTRACEIN((""));

    delete iCapabilities;

    iCapabilities = NULL;

    iCapabilities = new( ELeave ) CDesCArrayFlat( KListGranularity );    

    DLTRACEOUT(("Capabilities cleared"));

    }

// ---------------------------------------------------------------------------

// Check if the server supports the given capability

// ---------------------------------------------------------------------------

//         

TBool CNcdServerDetails::IsCapabilitySupported( 

    const TDesC& aCapability ) const

    {

    TInt pos = 0;

    return ( iCapabilities->Find( aCapability, pos, ECmpNormal ) == 0 );

    }

// ---------------------------------------------------------------------------

// Server URI getter

// ---------------------------------------------------------------------------

//         

const TDesC& CNcdServerDetails::ServerUri() const

    {

    DASSERT( iServerUri );

    return *iServerUri;

    }

// ---------------------------------------------------------------------------

// Namespace getter

// ---------------------------------------------------------------------------

//         

const TDesC& CNcdServerDetails::Namespace() const

    {

    DASSERT( iNamespace );

    return *iNamespace;

    }

// ---------------------------------------------------------------------------

// AddCookieL

// ---------------------------------------------------------------------------

//         

void CNcdServerDetails::AddCookieL( 

    const MNcdConfigurationProtocolCookie& aCookie,

    const TDesC8& aSim )

    {

    DLTRACEIN(( _L("Key: %S, type: %S"), &aCookie.Key(), &aCookie.Type() ));

    TInt index = FindCookie( aCookie );

    if ( aCookie.Type() == NcdConfigurationProtocolCookieTypes::KRemove ) 

        {

        DLINFO(("Removing cookie"));

        if ( index != KErrNotFound )

            {

            delete iCookies[index];

            iCookies.Remove( index );            

            }

        return;

        }

    CNcdConfigurationProtocolCookie* cookie =

        CNcdConfigurationProtocolCookie::NewLC( aCookie );

    // Set SIM identification

    AssignDesL( cookie->iSim, aSim );

    if ( index == KErrNotFound )

        {

        DLINFO(("Adding a new cookie"));

        iCookies.AppendL( cookie );

        }

    else

        {

        DLINFO(("Replacing an existing cookie"));

        delete iCookies[index];

        iCookies[index] = cookie;

        }

    CleanupStack::Pop( cookie );    

    // Convert expiration delta to expiration time and put it to the cookie

    if ( cookie->ExpirationDelta() )

        {        

        DLINFO(("Expiration delta: %d", cookie->ExpirationDelta() ));

        TTimeIntervalMinutes delta( cookie->ExpirationDelta() );

        TTime currentTime;

        currentTime.HomeTime();

        currentTime += delta;

        cookie->iExpirationTime = currentTime;

        }

    }

// ---------------------------------------------------------------------------

// CookiesL

// ---------------------------------------------------------------------------

//         

RPointerArray<const MNcdConfigurationProtocolCookie> 

    CNcdServerDetails::CookiesL(

    const TDesC8& aSim ) const

    {

    DLTRACEIN((""));

    RPointerArray<const MNcdConfigurationProtocolCookie> array;

    CleanupClosePushL( array );        

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

        {

        if ( iCookies[i]->Scope() != 

            NcdConfigurationProtocolCookieScopes::KSim ||

            iCookies[i]->Sim() == aSim )

            {

            DLTRACE(("Found a suitable cookie"));

            array.AppendL( iCookies[i] );

            }

        }

    CleanupStack::Pop( &array );

    DLTRACEOUT(("Found %d suitable cookies", array.Count() ));

    return array;

    }

// ---------------------------------------------------------------------------

// Removes cookies that have expired

// ---------------------------------------------------------------------------

//         

TInt CNcdServerDetails::RemoveExpiredCookies()

    {

    DLTRACEIN((""));

    TInt removed = 0;

    TTime time;

    time.UniversalTime();

    TInt i = 0;

    while ( i < iCookies.Count() )

        {

        if ( iCookies[i]->ExpirationDelta() && 

             iCookies[i]->ExpirationTime() < time )

            {

            DLINFO(( _L("Cookie %S has expired"), &iCookies[i]->Key() ));

            delete iCookies[i];

            iCookies.Remove( i );

            removed++;

            }

        else

            {

            ++i;

            }

        }

    DLTRACEOUT(("Removed %d cookies", removed));

    return removed;

    }

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//         

CNcdServerDetails::CNcdServerDetails()

    {

    }

// ---------------------------------------------------------------------------

// 2nd phase constructor

// ---------------------------------------------------------------------------

//         

void CNcdServerDetails::ConstructL( 

    const TDesC& aServerUri,

    const TDesC& aNamespace )

    {

    iServerUri = aServerUri.AllocL();

    iNamespace = aNamespace.AllocL();

    iCapabilities = new( ELeave ) CDesCArrayFlat( KListGranularity );

    }

// ---------------------------------------------------------------------------

// 2nd phase constructor

// ---------------------------------------------------------------------------

//         

void CNcdServerDetails::ConstructL( RReadStream& aStream ) 

    {

    DLTRACEIN((""));

    InternalizeDesL( iServerUri, aStream );

    InternalizeDesL( iNamespace, aStream );

    DLTRACE(( _L("ServerURI: %S, Namespace: %S"), iServerUri, iNamespace ));

    iCapabilities = new( ELeave ) CDesCArrayFlat( KListGranularity );

    TInt32 capabilityCount = aStream.ReadInt32L();

    DLTRACE(("Internalizing %d capabilities", capabilityCount ));

    HBufC* capability( NULL );

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

        {        

        InternalizeDesL( capability, aStream );

        CleanupStack::PushL( capability );

        DLTRACE(( _L("Cap: %S"), capability ));

        iCapabilities->AppendL( *capability );

        CleanupStack::PopAndDestroy( capability );

        capability = NULL;

        }

    TInt32 cookieCount = aStream.ReadInt32L();

    DLTRACE(("Internalizing %d cookies", cookieCount ));

    iCookies.ReserveL( cookieCount );

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

        {

        CNcdConfigurationProtocolCookie* cookie = 

            CNcdConfigurationProtocolCookie::NewLC();

        cookie->InternalizeL( aStream );

        iCookies.AppendL( cookie );

        CleanupStack::Pop( cookie );        

        }

    DLTRACEOUT(("Internalization successful"));

    }

// ---------------------------------------------------------------------------

// Find cookie

// ---------------------------------------------------------------------------

//         

TInt CNcdServerDetails::FindCookie( const

    MNcdConfigurationProtocolCookie& aCookie ) const

    {

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

        {

        if ( aCookie.Key() == iCookies[i]->Key() ) 

            {

            return i;

            }

        }

    return KErrNotFound;

    }