/*

* Copyright (c) 2005 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:  Contact Id handling tools

*

*/

// INCLUDE FILES

#include <e32std.h>

#include "PEngContactIdsTools.h"

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

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

// AssertDomain()

// Checks domain of the contact id

// If domain is same as passed, it is removed from the id.

//

//

// @param aContactId The contact id from where to check the domain.

// @param aUserDomain The user domain.

// @param aDomain Return paramater for extracted domain.

// @return 1 if the domain was updated. Else 0.

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

//

TInt DoAssertDomain( TPtrC& aContactId,

                     const TDesC& aUserDomain,

                     TPtrC& aDomain )

    {

    TChar domainSeparator( '@' );

    TInt offset( aContactId.Locate( domainSeparator ) );

    if ( ( KErrNotFound != offset ) &&

         ( !aUserDomain.Length()    ||

           ( KErrNone == aContactId.Mid( offset ).CompareF( aUserDomain ) ) ) )

        {

        aDomain.Set( aContactId.Mid( offset + 1 ) ); // storing the domain too

        aContactId.Set( aContactId.Left( offset ) ); // cause we need length

        return 1; // as described in description

        }

    return 0; // nothing was updated

    }

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

// CleanContactListName()

// Removes slash from the beginning of the contact list id if it is there

//

// @param aCntListId Contact list id to clean.

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

//

void DoCleanContactListName( TPtrC& aCntListId )

    {

    // look for the slash as first character->1

    if ( aCntListId.Left( 1 ).Compare( KPEngWVResourceSeparator ) == KErrNone )

        {

        // ignore slash on the beginning, 1 character

        aCntListId.Set( aCntListId.Mid( 1 ) );

        }

    }

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

// DoCompareContactIdsCommon()

// Compare two Contact Ids

//

// @param aContactId1 Contact Id 1. Possible "WV:" prefix is stripped away.

// @param aContactId2 Contact Id 2. Possible "WV:" prefix is stripped away.

// @param aUserDomain user domain

// @return KErrNone if they contact IDs are same, other non zero number if not

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

//

TInt DoCompareContactIdsCommon( TPtrC& aContactId1,

                                TPtrC& aContactId2 )

    {

    // get name without wv: part on the beginning

    if ( KErrNone

         ==

         aContactId1.Left( KPEngWVIDPrefixLength ).CompareF( KPEngWVIDPrefix ) )

        {

        aContactId1.Set( aContactId1.Mid( KPEngWVIDPrefixLength ) );

        }

    if ( KErrNone

         ==

         aContactId2.Left( KPEngWVIDPrefixLength ).CompareF( KPEngWVIDPrefix ) )

        {

        aContactId2.Set( aContactId2.Mid( KPEngWVIDPrefixLength ) );

        }

    return aContactId1.CompareF( aContactId2 );

    }

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

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

// NContactIdsTools::FindContactIdInArray()

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

//

TInt NContactIdsTools::FindContactIdInArray( const MDesCArray& aArray,

                                             const TDesC& aContactId,

                                             TInt& aIndex,

                                             const TDesC& aUserDomain )

    {

    TInt l( 0 );

    TInt r( aArray.MdcaCount() );

    TInt ret( KErrNotFound );

    while ( r > l )

        {

        TInt inx = ( l + r ) >> 1;

        TInt k ( CompareContactIds( aContactId,

                                    aArray.MdcaPoint( inx ),

                                    aUserDomain ) );

        if ( k == 0 )

            {

            aIndex = inx;

            return KErrNone;

            }

        else if ( k > 0 )

            l = inx + 1;

        else

            r = inx;

        }

    aIndex = r;

    return ret;

    }

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

// NContactIdsTools::FindContactIdInArray()

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

//

TInt NContactIdsTools::FindContactIdInArray( const MDesCArray& aArray,

                                             const TDesC& aContactId,

                                             const TDesC& aUserDomain )

    {

    TInt index( 0 );

    if ( KErrNone == NContactIdsTools::FindContactIdInArray( aArray,

                                                             aContactId,

                                                             index,

                                                             aUserDomain ) )

        {

        return index;

        }

    return KErrNotFound;

    }

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

// NContactIdsTools::AddContactIdToArrayL()

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

//

TInt NContactIdsTools::AddContactIdToArrayL( CDesCArray& aArray,

                                             const TDesC& aContactId,

                                             const TDesC& aUserDomain )

    {

    TInt index( 0 );

    if ( KErrNone == NContactIdsTools::FindContactIdInArray( aArray,

                                                             aContactId,

                                                             index,

                                                             aUserDomain ) )

        {

        return KErrAlreadyExists;

        }

    aArray.InsertL( index , aContactId );

    return index;

    }

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

// NContactIdsTools::RemoveContactIdFromArray()

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

//

TInt NContactIdsTools::RemoveContactIdFromArray( CDesCArray& aArray,

                                                 const TDesC& aContactId,

                                                 const TDesC& aUserDomain )

    {

    TInt posToDelete( NContactIdsTools::FindContactIdInArray( aArray,

                                                              aContactId,

                                                              aUserDomain ) );

    if ( posToDelete != KErrNotFound )

        {

        aArray.Delete( posToDelete );

        return KErrNone;

        }

    return KErrNotFound;

    }

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

// NContactIdsTools::CompareWVIDs()

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

//

TInt NContactIdsTools::CompareContactIds( const TDesC& aContactId1,

                                          const TDesC& aContactId2,

                                          const TDesC& aUserDomain )

    {

    // get contact ids without wv: prefix

    TPtrC contactId1( aContactId1 );

    TPtrC contactId2( aContactId2 );

    TInt err = DoCompareContactIdsCommon( contactId1, contactId2 );

    if ( err == KErrNone )

        {

        return KErrNone;

        }

    // try to compare them without domain if domain is missing or is same as user one

    // remove domain from contactId1

    TPtrC domain1;

    TPtrC domain2;

    TInt domainCount = DoAssertDomain( contactId1, aUserDomain, domain1 );

    domainCount += DoAssertDomain( contactId2, aUserDomain, domain2 );

    // if none of then or both have domain, no need to compare

    if ( ( domainCount == 0 ) ||

         ( domainCount == 2 ) )

        {

        // compare domains, if match continue, else return the error

        if ( domain1.CompareF( domain2 ) != KErrNone )

            {

            return err;

            }

        }

    return contactId1.CompareF( contactId2 );

    }

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

// NContactListIdsTools::ExtractPureContactListName()

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

//

void NContactListIdsTools::ExtractPureContactListName( TPtrC& aContactListId,

                                                       const TDesC& aPlainContactId )

    {

    TChar domainSeparator( '@' );

    TInt offset( aContactListId.Locate( domainSeparator ) );

    // remove domain

    if ( KErrNotFound != offset )

        {

        aContactListId.Set( aContactListId.Left( offset ) );

        }

    // remove wv prefix

    if ( KErrNone

         ==

         aContactListId.Left( KPEngWVIDPrefixLength ).CompareF( KPEngWVIDPrefix ) )

        {

        aContactListId.Set( aContactListId.Mid( KPEngWVIDPrefixLength ) );

        }

    // remove user part

    if ( KErrNone

         ==

         aContactListId.Left( aPlainContactId.Length() ).CompareF( aPlainContactId ) )

        {

        aContactListId.Set( aContactListId.Mid( aPlainContactId.Length() ) );

        }

    }

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

// NContactListIdsTools::CompareContactListIds()

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

//

TInt NContactListIdsTools::CompareContactListIds( const TDesC& aContactListId1,

                                                  const TDesC& aContactListId2 )

    {

    // extract pure list name, free from domain and possibly user part

    TPtrC id1( aContactListId1 );

    TPtrC id2( aContactListId2 );

    DoCleanContactListName( id1 );

    DoCleanContactListName( id2 );

    // do the compare

    return id1.CompareF( id2 );

    }

//  End of File