/*

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

*

*/

#include <crcseprofileregistry.h>

#include <spsettings.h>

#include <spentry.h>

#include <spproperty.h>

#include <spsettingsvoiputils.h>

#include <pressettingsapi.h>

#include "scpsettinghandler.h"

#include "scpservice.h"

#include "scpsubservice.h"

#include "scplogger.h"

#include "scputility.h"

#include "scpservicehandlerbase.h"

#include "sipconnectionprovideruids.hrh"

#include "scpprofilehandler.h"

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

// CScpSettingHandler::CScpSettingHandler

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

//

CScpSettingHandler::CScpSettingHandler( CScpProfileHandler& aProfileHandler ) :

    iProfileHandler( aProfileHandler )

    {

    SCPLOGSTRING( "CScpSettingHandler::CScpSettingHandler" );

    }

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

// CScpSettingHandler::NewL

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

//

CScpSettingHandler* CScpSettingHandler::NewL( CScpProfileHandler& aProfileHandler )

    {

    SCPLOGSTRING( "CScpSettingHandler::NewL()" );

    CScpSettingHandler* self = new( ELeave ) CScpSettingHandler( aProfileHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CScpSettingHandler::~CScpSettingHandler

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

//

CScpSettingHandler::~CScpSettingHandler()

    {

    SCPLOGSTRING( "CScpSettingHandler::~CScpSettingHandler" );

    delete iSpsVoIPUtils;

    delete iSpSettings;

    delete iRcseProfileEntry;

    delete iRcseProfileRegistry;

    }

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

// CScpSettingHandler::ConstructL

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

//

void CScpSettingHandler::ConstructL()

    {

    SCPLOGSTRING("CScpSettingHandler::ConstructL" );

    iRcseProfileRegistry = CRCSEProfileRegistry::NewL();

    iRcseProfileEntry = CRCSEProfileEntry::NewL();

    iSpSettings = CSPSettings::NewL(); 

    iSpsVoIPUtils = CSPSettingsVoIPUtils::NewL();

    }

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

// CScpSettingHandler::GetSipProfileIdByTypeL

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

//

void CScpSettingHandler::GetSipProfileIdByTypeL( TUint32 aServiceId,

                                                 TCCHSubserviceType aSubServiceType, 

                                                 TUint32& aSipId ) const

    {

    SCPLOGSTRING3( "CScpSettingHandler::GetSipProfileIdByTypeL service id :%i type %d", 

                    aServiceId, aSubServiceType );

    switch ( aSubServiceType )

        {

        case ECCHVoIPSub:

        case ECCHIMSub:

            {

            GetVoipSipProfileIdL( aServiceId, aSipId );

            }

            break;

        case ECCHVMBxSub:

            {

            GetVmbxSipProfileIdL( aServiceId, aSipId );

            }

            break;

        case ECCHPresenceSub:

            {

            GetPresenceSipProfileIdL( aServiceId, aSipId );

            }

            break;

        case ECCHUnknown:

            {

            GetUnknownSipProfileIdL( aServiceId, aSipId );

            }

            break;

        default:

            __ASSERT_DEBUG( EFalse, User::Panic( KNullDesC, KErrGeneral ) );

            break;

        }

    }

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

// CScpSettingHandler::GetSPSettingsIntPropertyL

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

//    

 void CScpSettingHandler::GetSPSettingsIntPropertyL( TUint32 aServiceId,

                                                     TServicePropertyName aPropertyName, 

                                                     TInt& aProperty ) const

    {

    SCPLOGSTRING( "CScpSettingHandler::GetSPSettingsIntPropertyL" );

    CSPEntry* entry = CSPEntry::NewLC();

    TInt result = iSpSettings->FindEntryL( aServiceId, *entry );

    if ( result == KErrNone )

        {

        // Get asked property 

        const CSPProperty* property = NULL;

        result = entry->GetProperty( property, aPropertyName );

        if ( result == KErrNone && property )

            {

            TInt value( 0 );

            property->GetValue( value );

            aProperty = value;

            }

        else

            {

            User::Leave( KErrNotFound );

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( entry );        

    }

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

// CScpSettingHandler::GetVoipSipProfileIdL

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

//

void CScpSettingHandler::GetVoipSipProfileIdL( TUint32 aServiceId, 

                                               TUint32& aSipId ) const

    {

    SCPLOGSTRING( "CScpSettingHandler::GetVoipSipProfileIdL" );

    RPointerArray<CRCSEProfileEntry> entries;

    // Push entries to cleanup stack

    CleanupStack::PushL( TCleanupItem( TScpUtility::ResetAndDestroyEntries, 

                                       &entries ) );

    iRcseProfileRegistry->FindByServiceIdL( aServiceId, entries );

    if ( entries.Count() )

        {            

        CRCSEProfileEntry* entry = entries[0];

        if ( entry->iIds.Count() > 0 )

            {

            aSipId = entry->iIds[0].iProfileId;

            }

        else

            {

            User::Leave( KErrNotFound );

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( &entries );

    }

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

// CScpSettingHandler::GetVmbxSipProfileIdL

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

//

void CScpSettingHandler::GetVmbxSipProfileIdL( TUint32 aServiceId, 

                                               TUint32& aSipId ) const

    {

    SCPLOGSTRING( "CScpSettingHandler::GetVmbxSipProfileIdL" );

    TInt sipId;

    GetSPSettingsIntPropertyL( aServiceId, ESubPropertyVMBXSettingsId, sipId );

    aSipId = sipId;

    }

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

// CScpSettingHandler::GetPresenceSipProfileIdL

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

//

void CScpSettingHandler::GetPresenceSipProfileIdL( TUint32 aServiceId, 

                                                   TUint32& aSipId ) const

    {

    SCPLOGSTRING( "CScpSettingHandler::GetPresenceSipProfileIdL" );

    CSPEntry* entry = CSPEntry::NewLC();

    TInt result = iSpSettings->FindEntryL( aServiceId, *entry );

    if ( result == KErrNone )

        {

        // Get presence setting id for presence service

        const CSPProperty* property = NULL;

        result = entry->GetProperty( property, ESubPropertyPresenceSettingsId );

        if ( result == KErrNone && property )

            {

            TInt presId;

            property->GetValue( presId );

            //Found out what is sip id in presencesettings

            TPresSettingsSet mySet;

            User::LeaveIfError( PresSettingsApi::SettingsSetL( presId, mySet ));

            TInt sipId( 0 );

            sipId = mySet.iSipProfile;

            aSipId = (TUint32)(sipId);

            }

        else

            {

            User::Leave( KErrNotFound );

            }         

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( entry );

    }

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

// CScpSettingHandler::GetUnknownSipProfileIdL

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

//

void CScpSettingHandler::GetUnknownSipProfileIdL( TUint32 aServiceId, 

                                                  TUint32& aSipId ) const

    {

    SCPLOGSTRING( "CScpSettingHandler::GetVoipSipProfileIdL" );

    TInt result( KErrNone );

    TUint32 genericSipId( KErrNone );

    RArray< TInt > sipIds;

    CleanupClosePushL( sipIds );

    TRAP( result, GetSipProfileIdByTypeL( aServiceId, ECCHVoIPSub, genericSipId ) );

    if ( result == KErrNone )

        {

        sipIds.AppendL( genericSipId );

        }

    else if ( KErrNoMemory == result )

        {

        User::Leave( KErrNoMemory );

        }

    TRAP( result, GetSipProfileIdByTypeL( aServiceId, ECCHVMBxSub, genericSipId ) );

    if ( result == KErrNone )

        {

        sipIds.AppendL( genericSipId );

        }

    else if ( KErrNoMemory == result )

        {

        User::Leave( KErrNoMemory );

        }

    TRAP( result, GetSipProfileIdByTypeL( aServiceId, ECCHPresenceSub, genericSipId ) );

    if ( result == KErrNone )

        {

        sipIds.AppendL( genericSipId );

        }

    else if ( KErrNoMemory == result )

        {

        User::Leave( KErrNoMemory );

        }

    // Check if all the sip profiles ids for different subservice types

    // are the same

    if ( sipIds.Count() > 0 )

        {

        result = KErrNone;

        aSipId = sipIds[0];

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

            {

            if( sipIds[i] != aSipId )

                {

                result = KErrArgument;

                break;

                }

            }

        }

    else

        {        

        // There wasn't any sip profile ids

        result = KErrNotFound;

        }

    CleanupStack::PopAndDestroy( &sipIds );

    User::LeaveIfError( result );

    }

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

// CScpSettingHandler::UpdateSettingsL

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

//

void CScpSettingHandler::UpdateSettingsL( CScpService& aService,

                                          TCCHSubserviceType aSubServiceType ) const

    {

    SCPLOGSTRING4( "CScpSettingHandler::UpdateSettingsL: 0x%x id: %i type: %d", 

                   &aService, aService.ServiceId(), aSubServiceType );

    __ASSERT_DEBUG( aService.ServiceId() > KErrNotFound, 

                    User::Panic( KNullDesC, KErrNotFound ) );

    if ( !aService.ContainsSubServiceType( ECCHVoIPSub ) &&

        ( aSubServiceType == ECCHVoIPSub || aSubServiceType == ECCHUnknown ) )

        {

        SCPLOGSTRING( "CScpSettingHandler::UpdateSettingsL voip " );

        UpdateVoIPSettingsL( aService );

        }

    if ( !aService.ContainsSubServiceType( ECCHIMSub ) &&

        ( ECCHIMSub == aSubServiceType || ECCHUnknown == aSubServiceType ) )

        {

        SCPLOGSTRING( "CScpSettingHandler::UpdateSettingsL IM" );

        UpdateImSettingsL( aService );

        }

    if ( !aService.ContainsSubServiceType( ECCHVMBxSub ) &&

        ( aSubServiceType == ECCHVMBxSub || aSubServiceType == ECCHUnknown ) )

        {

        SCPLOGSTRING( "CScpSettingHandler::UpdateSettingsL vmbx " );

        UpdateVmbxSettingsL( aService );

        }

    if ( !aService.ContainsSubServiceType( ECCHPresenceSub ) &&

        (aSubServiceType == ECCHPresenceSub || aSubServiceType == ECCHUnknown ) )

        {

        SCPLOGSTRING( "CScpSettingHandler::UpdateSettingsL presence x " );

        UpdatePresenceSettingsL( aService );

        }

    if ( aService.SubServiceCount() == 0 )

        {

        User::Leave( KErrNotFound );

        }   

    }

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

// CScpSettingHandler::UpdateXdmUsernameL

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

//

void CScpSettingHandler::UpdateXdmUsernameL( CScpService& aService, 

    TCCHSubserviceType aSubServiceType, const TDesC8& aUsername )

    {

    SCPLOGSTRING2( "CScpSettingHandler::UpdateXdmUsernameL, service id: %d", 

        aService.ServiceId() );

    if ( aService.ContainsSubServiceType( ECCHPresenceSub ) &&

        ( aSubServiceType == ECCHPresenceSub || 

        aSubServiceType == ECCHUnknown ) )

        {

        CSPEntry* entry = CSPEntry::NewLC();

        User::LeaveIfError( iSpSettings->FindEntryL( 

            aService.ServiceId(), *entry ) );

        if ( ArePresenceSettingsValid( *entry ) )

            {                

            TInt presenceSettingsId = GetPresenceSettingsId( *entry );

            if ( presenceSettingsId != KErrNotFound )

                {                    

                // Find out the sip profile that the presence is using

                TPresSettingsSet mySet;

                TRAPD( result, 

                    PresSettingsApi::SettingsSetL( 

                         presenceSettingsId, mySet ) );

                if ( KErrNone == result && mySet.iSipProfile > 0 )

                    {                        

                    // check XDM settings are valid

                    CXdmSettingsCollection* xdmCollection = NULL;

                    TRAPD( xdmResult, xdmCollection = 

                        TXdmSettingsApi::SettingsCollectionL(

                             mySet.iXDMSetting ) );

                    if ( KErrNone == xdmResult && xdmCollection )

                        {

                        CleanupStack::PushL( xdmCollection );

                        if ( iProfileHandler.ProfileExists( 

                            mySet.iSipProfile ) )

                            {

                            RBuf8 formattedUsername;

                            CleanupClosePushL( formattedUsername );

                            if( !TScpUtility::CheckSipUsername( aUsername ) )

                                {

                                // Since username is returned with prefix and

                                // domain, it needs to be possible to also set

                                // it with prefix and domain.  Strip prefix

                                // and domain from user aor if found. Prefix

                                // might be sip or sips so search by colon.

                                User::LeaveIfError( 

                                    TScpUtility::RemovePrefixAndDomain(

                                        aUsername, formattedUsername ) );

                                }

                            else

                                {

                                formattedUsername.CreateL( 

                                    aUsername.Length() );

                                formattedUsername.Copy( aUsername );

                                }

                            RBuf userName;

                            CleanupClosePushL( userName );

                            userName.CreateL( formattedUsername.Length() );

                            userName.Copy( formattedUsername );

                            // Update username to XDM-setting.

                            TXdmSettingsApi::UpdatePropertyL( 

                                mySet.iXDMSetting,

                                userName,

                                EXdmPropAuthName );

                            CleanupStack::PopAndDestroy( &userName );

                            CleanupStack::PopAndDestroy( &formattedUsername );

                            SCPLOGSTRING( 

                            "CScpSettingHandler::UpdateXdmUsernameL - DONE" );

                            }

                        else

                            {

                            User::Leave( KErrNotFound );

                            }

                        CleanupStack::PopAndDestroy( xdmCollection );

                        }

                    }

                }

            }

        CleanupStack::PopAndDestroy( entry );

        }

    if ( aService.SubServiceCount() == 0 )

        {        

        User::Leave( KErrNotFound );

        }

    }

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

// CScpSettingHandler::UpdateXdmPasswordL

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

//

void CScpSettingHandler::UpdateXdmPasswordL( CScpService& aService, 

    TCCHSubserviceType aSubServiceType, const TDesC8& aPassword )

    {

    SCPLOGSTRING2( "CScpSettingHandler::UpdateXdmPasswordL, service id: %d",

        aService.ServiceId() );

    if ( aService.ContainsSubServiceType( ECCHPresenceSub ) &&

        ( aSubServiceType == ECCHPresenceSub || 

        aSubServiceType == ECCHUnknown ) )

        {

        SCPLOGSTRING( "CScpSettingHandler::UpdateXdmPasswordL, presence" );

        CSPEntry* entry = CSPEntry::NewLC();

        User::LeaveIfError( iSpSettings->FindEntryL( 

            aService.ServiceId(), *entry ) );

        if ( ArePresenceSettingsValid( *entry ) )

            {

            TInt presenceSettingsId = GetPresenceSettingsId( *entry );

            if ( presenceSettingsId != KErrNotFound )

                {

                // Find out the sip profile that the presence is using

                TPresSettingsSet mySet;

                TRAPD( result, 

                    PresSettingsApi::SettingsSetL(

                        presenceSettingsId, mySet ) );

                if ( KErrNone == result && mySet.iSipProfile > 0 )

                    {

                    // check XDM settings are valid

                    CXdmSettingsCollection* xdmCollection = NULL;

                    TRAPD( xdmResult, xdmCollection = 

                        TXdmSettingsApi::SettingsCollectionL(

                            mySet.iXDMSetting ) );