/*
* Copyright (c) 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:   Utility class to handle SIP client resolver cenrep table.
*
*/




#include "musavaclientresolverutil.h"
#include "musuid.hrh"
#include "muslogger.h"
#include <centralrepository.h>
#include <sipprofile.h>

// SipMXResolverImplUid
const TUid KSipMXResolverImplUid = { 0x10283140 };


// <copied values>

// The following constant is defined in sipprofile.h in Sawfish.
// Since the constant is not defined in all releases, it must be copied here.

/** 
* A unique Contact-header's user-part 
* generated automatically by the SIP implementation.
* The value is of type TDesC8.
* This parameter is read-only and 
* trying to set it will fail with KErrAccessDenied.
*/
const TUint32 KCopyOfKSIPContactHeaderUser = 15;

// The following Uids and keys are defined in file 
// sipclientresolverconfigcrkeys.h in Sawfish. Since the header is not present
// in all releases, the values must be defined here.

/// Defines configuration parameters used by SIP Client Resolver
const TUid KCRUidSIPClientResolverConfig = { 0x10282EE7 };

/// Mask for the less significant bits in setting keys.
/// These bits are reserved for field type information.
const TUint32 KSIPClientResolverFieldTypeMask = 0xf0000000;

/// Mask for the most significant bits in setting keys.
/// These bits are reserved for the actual key part.
const TUint32 KSIPClientResolverKeyMask = 0x0fffffff;

/** 
* Mask for username field.
* Field type is TDesC8.
*/
const TUint32 KSIPClientResolverUserNameMask = 0x10000000;

/** 
* Mask for plug-in implementation UID field.
* Field type is TInt32.
*/
const TUint32 KSIPClientResolverPluginUIDMask = 0x20000000;

/** 
* Mask for client UID field.
* Field type is TInt32.
*/
const TUint32 KSIPClientResolverClientUIDMask = 0x30000000;

// </copied values>


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

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
CMusAvaClientResolverUtil::CMusAvaClientResolverUtil()
    {
    }


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


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
CMusAvaClientResolverUtil* CMusAvaClientResolverUtil::NewL()
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::NewL()" )
    CMusAvaClientResolverUtil* self = CMusAvaClientResolverUtil::NewLC();
    CleanupStack::Pop( self );
    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::NewL()" )
    return self;
    }


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
CMusAvaClientResolverUtil* CMusAvaClientResolverUtil::NewLC()
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::NewLC()" )
    CMusAvaClientResolverUtil* self = new( ELeave ) CMusAvaClientResolverUtil;
    CleanupStack::PushL( self );
    self->ConstructL();
    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::NewLC()" )
    return self;
    }


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
CMusAvaClientResolverUtil::~CMusAvaClientResolverUtil()
    {
    MUS_LOG( "mus: [MUSAVA]  -> ~CMusAvaClientResolverUtil()" )
    delete iRepository;
    MUS_LOG( "mus: [MUSAVA]  <- ~CMusAvaClientResolverUtil()" )
    }


// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CMusAvaClientResolverUtil::RegisterClientWithUserL( 
                                                CSIPProfile& aProfile ) const
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::RegisterClientWithUserL( profile )" )
    RBuf8 contactHeaderUser;
    contactHeaderUser.CleanupClosePushL();
    User::LeaveIfError( GetContactHeaderUser( aProfile, contactHeaderUser ) );
    
    RegisterClientWithUserL( TUid::Uid( KMusUiUid ), 
                             contactHeaderUser, 
                             KSipMXResolverImplUid );
    
    CleanupStack::PopAndDestroy( &contactHeaderUser );
    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::RegisterClientWithUserL( profile )" )
    }
    

// -----------------------------------------------------------------------------
// Add line to client resolver cenrep table
// -----------------------------------------------------------------------------
//
void CMusAvaClientResolverUtil::RegisterClientWithUserL(
    const TUid& aImplementation,
    const TDesC8& aProfileContactHeaderUser, 
    const TUid& aResolver ) const
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::RegisterClientWithUserL()" )
    
    if( aImplementation.iUid <= 0 || 
        aProfileContactHeaderUser.Length() <= 0 ||
        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 ) );

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::RegisterClientWithUserL()" )
    }


// -----------------------------------------------------------------------------
// Remove line from client resolver cenrep table
// -----------------------------------------------------------------------------
//
void CMusAvaClientResolverUtil::UnRegisterClientWithUserL( 
                                                CSIPProfile& aProfile ) const
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::UnRegisterClientWithUserL( profile )" )

    RBuf8 contactHeaderUser;
    contactHeaderUser.CleanupClosePushL();
    User::LeaveIfError( GetContactHeaderUser( aProfile, contactHeaderUser ) );
    
    UnRegisterClientWithUserL( TUid::Uid( KMusUiUid ), contactHeaderUser );
    
    CleanupStack::PopAndDestroy( &contactHeaderUser );

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::UnRegisterClientWithUserL( profile )" )
    }
    

// -----------------------------------------------------------------------------
// Remove line from client resolver cenrep table
// -----------------------------------------------------------------------------
//
void CMusAvaClientResolverUtil::UnRegisterClientWithUserL(
    const TUid& aImplementation, 
    const TDesC8& aProfileContactHeaderUser ) const
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::UnRegisterClientWithUserL()" )

    if( aImplementation.iUid <= 0 || 
        aProfileContactHeaderUser.Length() <= 0 )
        {
        User::Leave( KErrArgument );
        }

    RArray<TUint32> keys;
    CleanupClosePushL( keys );
    GetClientWithUserL( aImplementation, aProfileContactHeaderUser, keys );
    for ( TInt i = 0; i < keys.Count(); i++ )
        {
        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 );
    
    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::UnRegisterClientWithUserL()" )
    }


// -----------------------------------------------------------------------------
// Resolve correct implementation UID for contact header
// -----------------------------------------------------------------------------
//    
void CMusAvaClientResolverUtil::GetImplementationUidWithUserL( 
	const TDesC8& aProfileContactHeaderUser,
    TUid& aImplementation ) const
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::GetImplementationUidWithUserL()" )

    RArray<TUint32> keys;    
    CleanupClosePushL( keys );
    // Find all rows where KSIPClientResolverUserNameMask is aProfileContactHeaderUser
    iRepository->FindEqL( KSIPClientResolverUserNameMask, 
                          KSIPClientResolverFieldTypeMask,
                          aProfileContactHeaderUser, 
                          keys );
    if (keys.Count() > 1)
        {
        //resolve correct Key
        }
    else if(keys.Count() == 1)
        {
        TInt implementationValue = KErrNotFound;
        // Get implmentation 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 );	
    
    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::GetImplementationUidWithUserL()" )
    }
    
    
// -----------------------------------------------------------------------------
// Find clients from resolver cenrep table
// -----------------------------------------------------------------------------
//
void CMusAvaClientResolverUtil::GetClientWithUserL(
    const TUid& aImplementation, 
    const TDesC8& aProfileContactHeaderUser, 
    RArray<TUint32>& aFoundKeys ) const
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::GetClientWithUserL()" )

    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++ )
        {
        TInt implementationValue = KErrNotFound;
        // Get implmentation uid of found user name
        iRepository->Get( ( keys[i]^KSIPClientResolverUserNameMask ) |
            KSIPClientResolverClientUIDMask, implementationValue );
        // If implementation uid matches given uid, add row to found keys
        if ( implementationValue == aImplementation.iUid )
            {
            aFoundKeys.Append( keys[i]^KSIPClientResolverUserNameMask );
            }

        }
    CleanupStack::PopAndDestroy( &keys );
    
    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::GetClientWithUserL()" )
    }
    
    
// -----------------------------------------------------------------------------
// Create a new key for the new row
// -----------------------------------------------------------------------------
//
void CMusAvaClientResolverUtil::CreateNewKeyL(
    TUint32& aNewKey ) const
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::CreateNewKeyL()" )

    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 );
    
    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::CreateNewKeyL()" )
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CMusAvaClientResolverUtil::GetContactHeaderUser(
            CSIPProfile& aProfile,
            RBuf8& aContactHeaderUser ) const
    {
    MUS_LOG( "mus: [MUSAVA]  -> CMusAvaClientResolverUtil::GetContactHeaderUser()" )

    TInt result( KErrNotFound );
    const TDesC8* contactHeaderUser( NULL );

    // Get SIP's Username    
    result = aProfile.GetParameter( KCopyOfKSIPContactHeaderUser, contactHeaderUser );
    
    if ( result == KErrNone && contactHeaderUser )
        {
        result = aContactHeaderUser.ReAlloc( contactHeaderUser->Length() );
        if ( KErrNone == result )
            {
            aContactHeaderUser.Copy( *contactHeaderUser );
            }
        }

    MUS_LOG( "mus: [MUSAVA]  <- CMusAvaClientResolverUtil::GetContactHeaderUser()" )

    return result;                
    }