/*

* Copyright (c) 2006-2007 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 CNcdConfigurationManager

*

*/

#include <e32math.h>

#include "ncderrors.h"

#include "ncdconfigurationmanagerimpl.h"

#include "catalogsdebug.h"

#include "catalogscontext.h"

#include "catalogsutils.h"

#include "ncdstoragemanager.h"

#include "ncddatabasestorage.h"

#include "ncdstorage.h"

#include "ncdkeyvaluemap.h"

#include "ncdkeyvaluepair.h"

#include "ncdproviderdefines.h"

#include "ncdstorageitem.h"

#include "ncdserveraddress.h"

#include "ncdconfigurationkeys.h"

#include "ncdutils.h"

#include "catalogsconstants.h"

#include "ncdconfigurationobserver.h"

#include "ncdserverdetailsimpl.h"

#include "ncdproviderutils.h"

#include "ncdgeneralmanager.h"

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

// CContextConfigurationId

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

//    

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

// NewLC

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

//         

CNcdConfigurationManager::CContextConfiguration* 

    CNcdConfigurationManager::CContextConfiguration::NewLC( 

        const MCatalogsContext& aContext, 

        const TDesC& aId )

    {

    CContextConfiguration* self = new( ELeave ) CContextConfiguration(

        aContext );

    CleanupStack::PushL( self );

    self->ConstructL( aId );

    return self;

    }

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

// FindNewL

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

//         

CNcdConfigurationManager::CContextConfiguration* 

    CNcdConfigurationManager::CContextConfiguration::FindNewL( 

        const MCatalogsContext& aContext )

    {

    CContextConfiguration* self = new( ELeave ) CContextConfiguration(

        aContext );

    return self;

    }

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

// Constructor

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

//         

CNcdConfigurationManager::CContextConfiguration::CContextConfiguration( 

    const MCatalogsContext& aContext ) : 

    iFamilyId( aContext.FamilyId() ), 

    iId( NULL ),

    iConfigurationGeneral( NULL ), 

    iConfigurationClientInfo( NULL ),

    iSsid( NULL ),

    iMasterServer( NULL )    

    {

    }

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

// ConstructL

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

//         

void CNcdConfigurationManager::CContextConfiguration::ConstructL(

    const TDesC& aId )

    {

    DLTRACEIN((""));

    iId = aId.AllocL();

    iSsid = KNullDesC8().AllocL();

    iConfigurationGeneral = CNcdKeyValueMap::NewL();

    iConfigurationClientInfo = CNcdKeyValueMap::NewL();        

    DLTRACEOUT((""));

    }

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

// Destructor

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

//         

CNcdConfigurationManager::CContextConfiguration::~CContextConfiguration()

    {

    delete iId;

    delete iConfigurationGeneral;

    delete iConfigurationClientInfo;

    delete iSsid;

    delete iMasterServer;

    iServerDetails.ResetAndDestroy();

    iObservers.Close();

    }

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

// ServerDetailsL

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

//         

MNcdServerDetails& 

    CNcdConfigurationManager::CContextConfiguration::ServerDetailsL( 

    const TDesC& aServerUri,

    const TDesC& aNamespace )

    {

    DLTRACEIN((""));

    CNcdServerDetails* details = ServerDetails( aServerUri, aNamespace );

    if ( !details ) 

        {        

        DLTRACE(("Creating new details"));

        details = CNcdServerDetails::NewLC( aServerUri,

            aNamespace );

        iServerDetails.AppendL( details );

        CleanupStack::Pop( details );

        }

    return *details;

    }

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

// ServerDetailsL

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

//         

CNcdServerDetails*

    CNcdConfigurationManager::CContextConfiguration::ServerDetails( 

    const TDesC& aServerUri,

    const TDesC& aNamespace )

    {

    DLTRACEIN((""));

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

        {

        if ( iServerDetails[i]->ServerUri() == aServerUri &&

             iServerDetails[i]->Namespace() == aNamespace ) 

            {

            DLTRACEOUT(("Found details"));

            return iServerDetails[i];

            }

        }

    DLTRACEOUT(("Details not found"));

    return NULL;

    }

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

// ClearServerDetails

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

void CNcdConfigurationManager::CContextConfiguration::ClearServerDetails() 

    {

    DLTRACEIN((""));

    iServerDetails.ResetAndDestroy();

    }

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

// Notifies the observers.

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

void CNcdConfigurationManager::CContextConfiguration::NotifyObserversL() const 

    {

    DLTRACEIN((""));

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

        {

        iObservers[i]->ConfigurationChangedL();

        }

    }

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

// Adds an observer.

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

void CNcdConfigurationManager::CContextConfiguration::AddObserverL(

    MNcdConfigurationObserver& aObserver ) 

    {

    DLTRACEIN((""));

    if ( iObservers.Find( &aObserver ) == KErrNotFound ) 

        {

        iObservers.AppendL( &aObserver );

        }

    }

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

// Removes an observer.

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

void CNcdConfigurationManager::CContextConfiguration::RemoveObserver(

    MNcdConfigurationObserver& aObserver ) 

    {

    DLTRACEIN((""));

    TInt index = iObservers.Find( &aObserver );

    if ( index != KErrNotFound ) 

        {

        iObservers.Remove( index );

        }

    }

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

// ExternalizeL

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

//         

void CNcdConfigurationManager::CContextConfiguration::ExternalizeL( 

    RWriteStream& aStream )

    {

    DLTRACEIN((""));    

    ExternalizeDesL( *iId, aStream );

    ExternalizeDesL( *iSsid, aStream );

    if ( iMasterServer ) 

        {

        DLTRACE(("Externalizing master server address"));

        aStream.WriteInt32L( 1 );

        iMasterServer->ExternalizeL( aStream );

        }

    else 

        {

        aStream.WriteInt32L( 0 );

        }

    DLTRACE(("Externalizing %d server details", iServerDetails.Count() ));    

    // Externalize server capabilities.

    aStream.WriteInt32L( iServerDetails.Count() );

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

        {

        iServerDetails[i]->ExternalizeL( aStream );

        }            

    DLTRACEOUT((""));

    }

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

// InternalizeL

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

//         

void CNcdConfigurationManager::CContextConfiguration::InternalizeL( 

    RReadStream& aStream )

    {

    DLTRACEIN((""));

    InternalizeDesL( iId, aStream );

    InternalizeDesL( iSsid, aStream );

    TInt32 masterServerExists = aStream.ReadInt32L();

    if ( masterServerExists ) 

        {

        DLTRACE(("Internalizing master server address"));

        CNcdServerAddress* newServer = CNcdServerAddress::NewL( aStream );

        delete iMasterServer;

        iMasterServer = newServer;

        }

    else 

        {

        delete iMasterServer;

        iMasterServer = NULL;

        }

    // Internalize server capabilities.

    iServerDetails.ResetAndDestroy();

    TInt32 serverDetailCount = aStream.ReadInt32L();

    DLTRACE(("Internalizing %d server details", serverDetailCount ));

    iServerDetails.ReserveL( serverDetailCount );

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

        {

        CNcdServerDetails* details = CNcdServerDetails::NewL( aStream );

        TInt err = iServerDetails.Append( details );

        DASSERT( err == KErrNone );

        }        

    DLTRACEOUT(("Internalization successful"));

    }

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

// CNcdConfigurationManager

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

//    

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

// Creator

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

//    

CNcdConfigurationManager* CNcdConfigurationManager::NewL( 

    CNcdGeneralManager& aGeneralManager )

    {

    CNcdConfigurationManager* self = new( ELeave ) CNcdConfigurationManager(

        aGeneralManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

//        

CNcdConfigurationManager::~CNcdConfigurationManager()

    {

    DLTRACEIN((""));

    iConfigurations.ResetAndDestroy();

    DLTRACEOUT((""));

    }

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

// Adds a new observer

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

void CNcdConfigurationManager::AddObserverL(

    MNcdConfigurationObserver& aObserver,

    const MCatalogsContext& aContext ) 

    {

    DLTRACEIN((""));

    TInt index = CreateContextConfigurationL( aContext );

    CContextConfiguration* conf = iConfigurations[index];

    conf->AddObserverL( aObserver );

    }

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

// Removes a observer

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

void CNcdConfigurationManager::RemoveObserver(

    MNcdConfigurationObserver& aObserver )

    {

    DLTRACEIN((""));

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

        {

        iConfigurations[i]->RemoveObserver( aObserver );

        }

    }

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

// Master server address getter

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

//        

const TDesC& CNcdConfigurationManager::MasterServerAddressL( 

    const MCatalogsContext& aContext ) const

    {

    DLTRACEIN((""));

    TInt index = FindConfigurationL( aContext );

    if ( index != KErrNotFound )

        {

        // Context has a configuration        

        const CContextConfiguration& config( *iConfigurations[index] );

        // See if MSA exists and is valid

        if ( config.iMasterServer && config.iMasterServer->IsValid() ) 

            {

            DLINFO(( _L("Using master server address: %S"), 

                &config.iMasterServer->Address() ));

            return config.iMasterServer->Address();

            }

        // Check if the client has overridden master server address

        CNcdKeyValueMap::KeyValueIndex keyIndex = 

            config.iConfigurationGeneral->KeyExists( 

                NcdConfigurationKeys::KMasterServer );

        if ( keyIndex != KErrNotFound && !config.iUseHardcodedMasterServer ) 

            {

            DLINFO(( _L("Using Master Server Address from client: %S"), 

                &config.iConfigurationGeneral->ValueByIndex( keyIndex ) ));

            return config.iConfigurationGeneral->ValueByIndex( keyIndex );

            }

        }

    if ( !NcdProviderDefines::KMasterServerUri().Length() ) 

        {

        DLERROR(("No master server URI. Leaving with KNcdErrorNoMasterServerUri"));

        User::Leave( KNcdErrorNoMasterServerUri );

        }

    // Use hardcoded MSA     

    DLTRACEOUT(( _L("Using hardcoded: %S"), 

        &NcdProviderDefines::KMasterServerUri() ));

    return NcdProviderDefines::KMasterServerUri();    

    }

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

// Master server address validity checker

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

//            

TBool CNcdConfigurationManager::IsMasterServerAddressValidL( 

    const MCatalogsContext& aContext ) const

    {

    DLTRACEIN((""));

    TInt index = FindConfigurationL( aContext );

    if ( index != KErrNotFound )

        {

        // Context has a configuration        

        const CContextConfiguration& config( *iConfigurations[index] );

        // See if MSA exists

        if ( config.iMasterServer )

            {

            DLTRACE(("Context has set a Master server address"));            

            return config.iMasterServer->IsValid();

            }

        }

    // Other MSA's are always valid

    return ETrue;

    }

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

// Master server address & validity setter

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

//        

void CNcdConfigurationManager::SetMasterServerAddressL(

    const MCatalogsContext& aContext,

    const TDesC& aAddress, 

    const TInt64& aValidity )

    {

    DLTRACEIN(( _L("address: %S, validity: %d"), &aAddress, aValidity ));

    if ( !aAddress.Length() ) 

        {

        User::Leave( KErrArgument );

        }

    CNcdServerAddress* address = CNcdServerAddress::NewLC(

        aAddress, aValidity );

    SetMasterServerAddressL( aContext, address );

    CleanupStack::Pop( address );

    DLTRACEOUT((""));

    }

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

// Master server address & validity setter

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

//        

void CNcdConfigurationManager::SetMasterServerAddressL(

    const MCatalogsContext& aContext,

    CNcdServerAddress* aAddress )

    {

    DLTRACEIN((""));

    TInt index = CreateContextConfigurationL( aContext );    

    CContextConfiguration& config( *iConfigurations[index] );    

    delete config.iMasterServer;

    config.iMasterServer = aAddress;

    config.iUseHardcodedMasterServer = EFalse;

    // Save updated master server address

    SaveDataL( aContext.FamilyId().Name(), 

        NcdProviderDefines::ENcdContextData, config );

    config.NotifyObserversL();    

    }

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

// Resets the master server address

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

//        

void CNcdConfigurationManager::ResetMasterServerAddressL( 

    const MCatalogsContext& aContext )

    {

    DLTRACEIN((""));

    // Sets the current overriding master server address as invalid

    TInt index = FindConfigurationL( aContext );

    if ( index != KErrNotFound ) 

        {

        if ( iConfigurations[index]->iMasterServer ) 

            {

            DLINFO(("Reverting to client-set/hardcoded MasterServer"));

            delete iConfigurations[index]->iMasterServer;

            iConfigurations[index]->iMasterServer = NULL;

            }

        else 

            {             

            // Check if the client has overridden master server address

            CNcdKeyValueMap::KeyValueIndex keyIndex = 

                iConfigurations[index]->iConfigurationGeneral->KeyExists( 

                    NcdConfigurationKeys::KMasterServer );

            if ( keyIndex != KErrNotFound ) 

                {

                // Use hardcoded instead of the one set by the client

                iConfigurations[index]->iUseHardcodedMasterServer = ETrue;                

                }        

            }

        iConfigurations[index]->NotifyObserversL();

        }

    DLTRACEOUT((""));

    }

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

// Client ID getter

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

//