/*
* Copyright (c) 2007-2010 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:  SIP client resolver utility class
*
*/


#include <centralrepository.h>
#include <sipclientresolverconfigcrkeys.h>
#include <spsettings.h>
#include <spentry.h>
#include <spproperty.h>

#include "csipclientresolverutils.h"


// ======== LOCAL FUNCTIONS ========
// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CSipClientResolverUtils::CSipClientResolverUtils()
    {
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CSipClientResolverUtils::ConstructL()
    {
    iRepository = CRepository::NewL( KCRUidSIPClientResolverConfig );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSipClientResolverUtils* CSipClientResolverUtils::NewL()
    {
    CSipClientResolverUtils* self = CSipClientResolverUtils::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

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

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CSipClientResolverUtils::~CSipClientResolverUtils()
    {
    delete iRepository;
    }

// ---------------------------------------------------------------------------
// Add line to client resolver cenrep table
// ---------------------------------------------------------------------------
//
EXPORT_C void CSipClientResolverUtils::RegisterClientWithUserL(
    const TUid& aImplementation,
    const TDesC8& aProfileContactHeaderUser, 
    const TUid& aResolver ) const
    {
    __ASSERT_ALWAYS( aImplementation.iUid > 0, User::Leave( KErrArgument ) );
    __ASSERT_ALWAYS( aProfileContactHeaderUser.Length() > 0,
            User::Leave( KErrArgument ) );
    __ASSERT_ALWAYS( aResolver.iUid > 0, User::Leave( KErrArgument ));

    // Remove all earlier instances of client&user combination
    UnRegisterClientWithUserL( aImplementation, aProfileContactHeaderUser );

    User::LeaveIfError( 
        iRepository->StartTransaction( CRepository::EConcurrentReadWriteTransaction ) );
    TUint32 newKey = 0;
    CreateNewKeyL( newKey );
    // Add the new row
    TInt uid = aImplementation.iUid;
    User::LeaveIfError( 
        iRepository->Create(newKey|KSIPClientResolverClientUIDMask, uid ) );    
    User::LeaveIfError( 
        iRepository->Create(newKey|KSIPClientResolverUserNameMask, aProfileContactHeaderUser ) );
    uid = aResolver.iUid;    
    User::LeaveIfError( 
        iRepository->Create(newKey|KSIPClientResolverPluginUIDMask, uid ) ); 

    // Commit the transaction
    User::LeaveIfError( iRepository->CommitTransaction( newKey ) );
    }

// ---------------------------------------------------------------------------
// Remove line from client resolver cenrep table
// ---------------------------------------------------------------------------
//
EXPORT_C void CSipClientResolverUtils::UnRegisterClientWithUserL(
    const TUid& aImplementation, 
    const TDesC8& aProfileContactHeaderUser ) const
    {
    __ASSERT_ALWAYS( aImplementation.iUid > 0, User::Leave( KErrArgument ) );
    __ASSERT_ALWAYS( aProfileContactHeaderUser.Length() > 0,
            User::Leave( KErrArgument ) );  

    RArray<TUint32> keys;
    CleanupClosePushL( keys );
    GetClientWithUserL( aProfileContactHeaderUser, keys );
    for ( TInt i = 0; i < keys.Count(); i++ )
        {        
        if ( CheckImplementationUidL( keys[ i ], aImplementation ) )
            {
            TUint32 errorKey;
            User::LeaveIfError( 
                iRepository->StartTransaction( 
                    CRepository::EConcurrentReadWriteTransaction ) );
            iRepository->Delete( keys[i], KSIPClientResolverKeyMask, errorKey );
            // Commit the transaction
            User::LeaveIfError( iRepository->CommitTransaction( errorKey ) );            
            }
        }
    CleanupStack::PopAndDestroy( &keys );
    }

// ---------------------------------------------------------------------------
// Resolve correct implementation UID for contact header
// ---------------------------------------------------------------------------
//    
EXPORT_C void CSipClientResolverUtils::GetImplementationUidWithUserL( 
    const TDesC8& aProfileContactHeaderUser,
    TUid& aImplementation ) const
    {
    RArray<TUint32> keys;    
    CleanupClosePushL( keys );
    // Find all rows where KSIPClientResolverUserNameMask is aProfileContactHeaderUser
    iRepository->FindEqL( KSIPClientResolverUserNameMask, 
                    KSIPClientResolverFieldTypeMask,
                    aProfileContactHeaderUser, keys );
    
    TInt implementationValue = KErrNotFound;
    TInt count( keys.Count() );
    if ( count > 1 )
        {
        // Call provider UIDs should be read from spsettings table and if some
        // UID found from spsettings match one uid in client resolver cenrep,
        // that should be returned to caller.
        RArray<TUint> uidArray;
        CleanupClosePushL( uidArray );
        CallProviderUidsL( uidArray );
        __ASSERT_ALWAYS( uidArray.Count() > 0, User::Leave( KErrNotFound ) );
        TInt i( 0 );
        for( ; i < count; i++ )
            {
            // Get implementation uid of found user name
            iRepository->Get( ( keys[i]^KSIPClientResolverUserNameMask ) |
                    KSIPClientResolverClientUIDMask, implementationValue );
            
            User::LeaveIfError( implementationValue );
            if ( KErrNotFound != uidArray.Find( implementationValue ) )
                {
                aImplementation.iUid = implementationValue;
                break;
                }
            }
        CleanupStack::PopAndDestroy( &uidArray );
        if ( i == count && aImplementation.iUid != implementationValue )
            {
            // No matching Uid found
            User::Leave( KErrNotFound );            
            }
        }
        
    else if ( count == 1 )
        {        
        // Get implementation uid of found user name
        iRepository->Get( ( keys[0]^KSIPClientResolverUserNameMask ) |
        KSIPClientResolverClientUIDMask, implementationValue );

        User::LeaveIfError( implementationValue );
        aImplementation.iUid = implementationValue;
        }
    else
        {
        User::Leave( KErrNotFound );
        }

    CleanupStack::PopAndDestroy( &keys );    
    }

// ---------------------------------------------------------------------------
// Return all implementation Uids bases on contact header
// ---------------------------------------------------------------------------
//    
EXPORT_C void CSipClientResolverUtils::GetAllImplementationUidsWithUserL( 
    const TDesC8& aProfileContactHeaderUser,
    RArray<TUid>& aImplementationUids ) const
    {
    RArray<TUint32> keys;    
    CleanupClosePushL( keys );
    
    // Find all rows where KSIPClientResolverUserNameMask
    // is aProfileContactHeaderUser
    User::LeaveIfError( iRepository->FindEqL( KSIPClientResolverUserNameMask, 
        KSIPClientResolverFieldTypeMask,
        aProfileContactHeaderUser, keys ) );
    
    for( TInt i( 0 ) ; i < keys.Count() ; i++ )
        {
        TInt implementationValue = KErrNotFound;
        
        // Get implementation uid of found user name
        User::LeaveIfError( iRepository->Get( 
            ( keys[i]^KSIPClientResolverUserNameMask ) |
            KSIPClientResolverClientUIDMask, implementationValue ) );
        
        if ( implementationValue )
            { 
            TUid implementationUid;
            implementationUid.iUid = implementationValue;
            aImplementationUids.AppendL( implementationUid );
            }
        }
    CleanupStack::PopAndDestroy( &keys );
    }

// ---------------------------------------------------------------------------
// Find clients from resolver cenrep table
// ---------------------------------------------------------------------------
//
void CSipClientResolverUtils::GetClientWithUserL(
    const TDesC8& aProfileContactHeaderUser, 
    RArray<TUint32>& aFoundKeys ) const
    {
    RArray<TUint32> keys;
    
    CleanupClosePushL( keys );
    // Find all rows where KSIPClientResolverUserNameMask is aProfileUserName
    iRepository->FindEqL( KSIPClientResolverUserNameMask, 
                            KSIPClientResolverFieldTypeMask,
                            aProfileContactHeaderUser, keys );
    for ( TInt i = 0; i < keys.Count(); i++ )
        {
        // Identification is now done only by aProfileContactHeaderUser
        aFoundKeys.AppendL( keys[i]^KSIPClientResolverUserNameMask );
        }
    CleanupStack::PopAndDestroy( &keys );
    }

// ---------------------------------------------------------------------------
// Create a new key for the new row
// ---------------------------------------------------------------------------
//
void CSipClientResolverUtils::CreateNewKeyL(
    TUint32& aNewKey ) const
    {
    RArray<TUint32> keys;
    CleanupClosePushL( keys );
    TInt err = KErrNone;
    
    TRAPD( leaveCode, err = iRepository->FindL( KSIPClientResolverUserNameMask, 
                                  KSIPClientResolverFieldTypeMask, 
                                  keys ) );
    if ( KErrNotFound == leaveCode )
        {
        err = KErrNotFound;
        leaveCode = KErrNone;
        }
    User::LeaveIfError( leaveCode );
    if ( ( KErrNotFound == err ) || ( keys.Count() == 0 ) )
        {
        aNewKey = 1;
        }
    else
        {
        User::LeaveIfError( err );
        // Find the biggest key and increment it by one
        keys.SortUnsigned();
        aNewKey = KSIPClientResolverUserNameMask^keys[ keys.Count() - 1 ] + 1;       
        }
    CleanupStack::PopAndDestroy( &keys );
    }


// -----------------------------------------------------------------------------
// CSipClientResolverUtils::CallProviderUidsL
// -----------------------------------------------------------------------------
//    
 void CSipClientResolverUtils::CallProviderUidsL( RArray<TUint>& aUidArray ) const
    {
    CSPSettings* spSettings = CSPSettings::NewLC();
    CSPProperty* property = CSPProperty::NewLC();
    
    RArray<TUint> idArray;
    CleanupClosePushL( idArray );
    User::LeaveIfError( spSettings->FindServiceIdsL( idArray ) );
    TInt count = idArray.Count();
    TInt result( KErrNotFound );
    
    for( TInt i( 0 ); i < count; i++ )
        {
        result =  spSettings->FindPropertyL(
                idArray[i], EPropertyCallProviderPluginId, *property );
        
        if ( result == KErrNone && property )
            {
            TInt value( 0 );
            property->GetValue( value );
            aUidArray.Append( value );
            }
        }
    
    CleanupStack::PopAndDestroy( &idArray );
    CleanupStack::PopAndDestroy( property );
    CleanupStack::PopAndDestroy( spSettings );
    }
 
 // -----------------------------------------------------------------------------
 // CSipClientResolverUtils::CheckImplementationUidL
 // -----------------------------------------------------------------------------
 // 
 TBool CSipClientResolverUtils::CheckImplementationUidL( 
     const TUint32& aKey, const TUid& aImplementation ) const
     {     
     TBool match( EFalse );
     TInt implementationValue( KErrNotFound );
     
     iRepository->Get( ( aKey^KSIPClientResolverUserNameMask )  |
                         KSIPClientResolverClientUIDMask,
                         implementationValue );
      
     if ( implementationValue == aImplementation.iUid )
         { 
         match = ETrue;
         }
     
     return match;
     }