/*

 * Copyright (c) 2009 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:  Phonebook 2 merge contacts resolver.

 *

 */

// INCLUDE FILES

//Phonebook2

#include "CPbk2MergeResolver.h"

#include <CPbk2PresentationContact.h>

#include <CPbk2PresentationContactFieldCollection.h>

#include <CPbk2PresentationContactField.h>

#include <MPbk2FieldProperty.h>

//Virtual Phonebook

#include <MVPbkStoreContact.h>

#include <MVPbkStoreContactFieldCollection.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldDateTimeData.h>

#include <MVPbkContactFieldUriData.h>

#include <MVPbkContactFieldBinaryData.h>

// Debugging headers

#include <Pbk2Debug.h>

#include <Pbk2Profile.h>

/// Unnamed namespace for local definitions

namespace 

    {

    enum TPbk2PanicCodes

        {

        EPbk2WrongArgument,

        EPbk2FieldTypeNotExists

        };

    void Panic(TPbk2PanicCodes aReason)

        {

        _LIT( KPanicText, "CPbk2_Merge_Resolver" );

        User::Panic(KPanicText,aReason);

        }

#ifdef _DEBUG

    #define DEBUG_PRINT_FIELD( field ) PrintFieldL( field );

    const TInt KEndLine = '\0';

#else

    #define DEBUG_PRINT_FIELD( field ) 

#endif

    } /// namespace

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

// CPbk2MergeResolver::CPbk2MergeResolver

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

//

CPbk2MergeResolver::CPbk2MergeResolver(

        CPbk2PresentationContact* aFirstContact, 

        CPbk2PresentationContact* aSecondContact )

    :iFirstContact( aFirstContact ), 

     iSecondContact( aSecondContact )

    {

    }

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

// CPbk2MergeResolver::~CPbk2MergeResolver

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

//

CPbk2MergeResolver::~CPbk2MergeResolver()

    {

    iConflicts.ResetAndDestroy();

    iMerged.Close();

    delete iFirstContact;

    delete iSecondContact;

    }

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

// CPbk2MergeResolver::NewL

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

//

CPbk2MergeResolver* CPbk2MergeResolver::NewL( 

        CPbk2PresentationContact* aFirstContact, 

        CPbk2PresentationContact* aSecondContact )

    {

    CPbk2MergeResolver* self = 

        new ( ELeave ) CPbk2MergeResolver( aFirstContact, aSecondContact );

    return self;

    }

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

// CPbk2MergeResolver::MergeL

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

//

void CPbk2MergeResolver::MergeL()

    {

    iConflicts.ResetAndDestroy();

    iMerged.Close();

    CPbk2PresentationContactFieldCollection & firstCollection = iFirstContact->PresentationFields();

    CPbk2PresentationContactFieldCollection & secondCollection = iSecondContact->PresentationFields();

    RArray<TInt> duplicatesInFirst;

    CleanupClosePushL(duplicatesInFirst);

    RArray<TInt> duplicatesInSecond;

    CleanupClosePushL(duplicatesInSecond);

    TInt countFirst = firstCollection.FieldCount();

    TInt countSecond = secondCollection.FieldCount();

    TBool addressesMerged = EFalse;

    for( TInt idxFirst = 0; idxFirst < countFirst; idxFirst++)

        {

        const MVPbkStoreContactField& fieldFirst = firstCollection.FieldAt( idxFirst );

        for( TInt idxSecond = 0; idxSecond < countSecond; idxSecond++)

            {

            const MVPbkStoreContactField& fieldSecond = secondCollection.FieldAt( idxSecond );

            if( AddressField( fieldFirst ) )

                {

                if( !addressesMerged )

                    {

                    MergeAddressesL();

                    addressesMerged = ETrue;

                    }

                continue;

                }

            if( AddressField( fieldSecond ) )

                {

                continue;

                }

            TBool sameTypes = AreFieldsTypeSame( fieldFirst, fieldSecond );

            TBool sameValues = EqualsValues( fieldFirst, fieldSecond );

            PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

                ("CPbk2MergeResolver::MergeL - Fields:") );

            DEBUG_PRINT_FIELD( fieldFirst )

            DEBUG_PRINT_FIELD( fieldSecond )

            PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

                ("CPbk2MergeResolver::MergeL - Fields are the same:%d"), sameTypes);

            PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

                ("CPbk2MergeResolver::MergeL - Fields have the same values:%d"), sameValues);

            if( sameTypes )

                {

                if( IsTopContactField( fieldFirst ) )

                    {

                    if( CompareTopConactFields( fieldFirst, fieldSecond ) <= 0 )

                        {

                        duplicatesInSecond.AppendL( idxSecond );

                        }

                    else

                        {

                        duplicatesInFirst.AppendL( idxFirst );

                        }

                    }

                else

                    {

                    if( !sameValues && FieldMultiplicity( fieldFirst ) == EPbk2FieldMultiplicityOne  )

                        {

                        AddConflictL( fieldFirst, fieldSecond );

                        }

                    if( sameValues )

                        {

                        duplicatesInSecond.AppendL( idxSecond );

                        }

                    }

                }

            }

        }

    if( !addressesMerged )

        {

        MergeAddressesL();

        }

    CompleteMergeArrL( duplicatesInFirst, duplicatesInSecond );

    CleanupStack::PopAndDestroy( &duplicatesInSecond );

    CleanupStack::PopAndDestroy( &duplicatesInFirst );

    }

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

// CPbk2MergeResolver::MergeAddressesL

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

//

void CPbk2MergeResolver::MergeAddressesL()

    {

    for (TInt groupId = EPbk2FieldGroupIdPostalAddress; groupId

            <= EPbk2FieldGroupIdCompanyAddress; groupId++)

        {

        ECompareAddress compareAddresses = CompareAddresses(

                ( TPbk2FieldGroupId) groupId );

        switch ( compareAddresses )

            {

            case ECASame:

                CopyAddressToMergedL( *iFirstContact, 

                        ( TPbk2FieldGroupId) groupId );

                break;

            case ECAFirstIncludesSecond:

                CopyAddressToMergedL( *iFirstContact,

                        ( TPbk2FieldGroupId) groupId );

                break;

            case ECASecondIncludesFirst:

                CopyAddressToMergedL( *iSecondContact,

                        ( TPbk2FieldGroupId) groupId );

                break;

            case ECADifferent:

                AddAddressConflictL( (TPbk2FieldGroupId) groupId );

                break;

            case ECAUndefined:

                // Both addresses don't exist

                break;

            default:

                Panic( EPbk2WrongArgument );

            }

        }

    }

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

// CPbk2MergeResolver::CompleteMergeArrL

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

//

void CPbk2MergeResolver::CompleteMergeArrL( 

        RArray<TInt>& aDuplicatesInFirst, 

        RArray<TInt>& aDuplicatesInSecond )

    {

    CPbk2PresentationContactFieldCollection & firstCollection = iFirstContact->PresentationFields();

    CPbk2PresentationContactFieldCollection & secondCollection = iSecondContact->PresentationFields();

    TInt countFirst = firstCollection.FieldCount();

    TInt countSecond = secondCollection.FieldCount();

    for( TInt idxFirst = 0; idxFirst < countFirst; idxFirst++)

        {

        const MVPbkStoreContactField& fieldFirst = firstCollection.FieldAt( idxFirst );

        if( FindConflictByFieldL( fieldFirst ) == KErrNotFound &&

            aDuplicatesInFirst.Find( idxFirst ) == KErrNotFound  &&

            !AddressField( fieldFirst ) )

            {

            iMerged.AppendL( &fieldFirst );

            PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

                ("CPbk2MergeResolver::MergeL - Field added to merged(first contact):"));

            DEBUG_PRINT_FIELD( fieldFirst )

            }

        }

    for( TInt idxSecond = 0; idxSecond < countSecond; idxSecond++)

        {

        const MVPbkStoreContactField& fieldSecond = secondCollection.FieldAt( idxSecond );

        if( FindConflictByFieldL( fieldSecond ) == KErrNotFound && 

            aDuplicatesInSecond.Find( idxSecond ) == KErrNotFound  && 

            !AddressField( fieldSecond ) )

            {

            iMerged.AppendL( &fieldSecond );

            PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

                ("CPbk2MergeResolver::MergeL - Field added to merged(second contact):"));

            DEBUG_PRINT_FIELD( fieldSecond )

            }

        }

    }

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

// CPbk2MergeResolver::IsTopContactField

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

//

TBool CPbk2MergeResolver::IsTopContactField( 

        const MVPbkStoreContactField& aField )

    {

    const MVPbkFieldType* fieldType = aField.BestMatchingFieldType();

        {

            {

            }

        }

    return topContact;

    }

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

// CPbk2MergeResolver::CompareTopConactFields

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

//

TInt CPbk2MergeResolver::CompareTopConactFields(

        const MVPbkStoreContactField& aFieldFirst,

        const MVPbkStoreContactField& aFieldSecond )

    {

    const MVPbkContactFieldData& dataFirst = aFieldFirst.FieldData();

    TVPbkFieldStorageType storageTypeFirst = dataFirst.DataType();

    const MVPbkContactFieldData& dataSecond = aFieldSecond.FieldData();

    TVPbkFieldStorageType storageTypeSecond = dataSecond.DataType();

    TInt ret = KErrGeneral;

    if( storageTypeFirst != storageTypeSecond ||

        storageTypeFirst != EVPbkFieldStorageTypeText )

        {

        return ret;

        }

    TInt valueFirst;

    TInt valueSecond;

    TInt errorCode;

    TLex lex( MVPbkContactFieldTextData::Cast( dataFirst ).Text() );

    errorCode = lex.Val( valueFirst );

    if( errorCode == KErrNone )

        {

        TLex lex( MVPbkContactFieldTextData::Cast( dataSecond ).Text() );

        errorCode = lex.Val( valueSecond );

        }

    if( errorCode == KErrNone )

        {

        if( valueFirst > valueSecond )

            {

            ret = 1;

            }

        else if( valueFirst < valueSecond )

            {

            ret = -1;

            }

        else

            {

            ret = 0;

            }

        }

    return ret;

    }

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

// CPbk2MergeResolver::CountConflicts

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

//

TInt CPbk2MergeResolver::CountConflicts()

    {

    return iConflicts.Count();

    }

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

// CPbk2MergeResolver::GetConflictAt

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

//

MPbk2MergeConflict& CPbk2MergeResolver::GetConflictAt( TInt aConflict )

    {

    __ASSERT_ALWAYS( aConflict >= 0 && aConflict < CountConflicts(), Panic( EPbk2WrongArgument ) );

    return *iConflicts[aConflict];

    }

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

// CPbk2MergeResolver::CountMerged

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

//

TInt CPbk2MergeResolver::CountMerged()

    {

    return iMerged.Count();

    }

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

// CPbk2MergeResolver::GetMergedAtL

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

//

MVPbkStoreContactField& CPbk2MergeResolver::GetMergedAt( TInt aMarged )

    {

    __ASSERT_ALWAYS( aMarged >= 0 && aMarged < CountMerged(), Panic( EPbk2WrongArgument ) );

    return *iMerged[aMarged];

    }

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

// CPbk2MergeResolver::CompareAddresses

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

//

CPbk2MergeResolver::ECompareAddress CPbk2MergeResolver::CompareAddresses( 

        TPbk2FieldGroupId aGroupId )

    {

    ECompareAddress retCompare = ECAUndefined;

    TInt countEquals = 0;

    CPbk2PresentationContactFieldCollection& firstCollection = iFirstContact->PresentationFields();

    CPbk2PresentationContactFieldCollection& secondCollection = iSecondContact->PresentationFields();

    TInt countFirst = firstCollection.FieldCount();

    TInt countSecond = secondCollection.FieldCount();

    TInt countAddressFieldsFirst = 0;

    TInt countAddressFieldsSecond = 0;

    for( TInt idxFirst = 0; idxFirst < countFirst && retCompare != ECADifferent; idxFirst++)

        {

        const CPbk2PresentationContactField& fieldFirst = firstCollection.At( idxFirst );

        const MPbk2FieldProperty& propFirst = fieldFirst.FieldProperty();

        if( !AddressField( fieldFirst ) || propFirst.GroupId() != aGroupId )

            {

            continue;

            }

        countAddressFieldsFirst++;

        for( TInt idxSecond = 0; idxSecond < countSecond; idxSecond++)

            {

            const CPbk2PresentationContactField& fieldSecond = secondCollection.At( idxSecond );

            const MPbk2FieldProperty& propSecond = fieldSecond.FieldProperty();

            if( !AddressField( fieldSecond ) || propSecond.GroupId() != aGroupId )

                {

                continue;

                }

            if( countAddressFieldsFirst == 1 )

                {

                countAddressFieldsSecond++;  

                }

            if( !AreAddressesSubTypeSame( fieldFirst, fieldSecond ) )

                {

                continue;

                }

            if( EqualsValues( fieldFirst, fieldSecond ) )

                {

                countEquals++;

                }

            else

                {

                return ECADifferent;

                }

            }

        }

    if( countAddressFieldsFirst == 0 )

        {

        for( TInt idxSecond = 0; idxSecond < countSecond; idxSecond++)

            {

            const CPbk2PresentationContactField& fieldSecond = secondCollection.At( idxSecond );

            const MPbk2FieldProperty& propSecond = fieldSecond.FieldProperty();

            if( AddressField( fieldSecond ) && propSecond.GroupId() == aGroupId )

                {

                countAddressFieldsSecond++; 

                }

            }

        }

    return DoCompareAddresses( countEquals, countAddressFieldsFirst, countAddressFieldsSecond );

    }

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

// CPbk2MergeResolver::CompareAddresses

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

//

CPbk2MergeResolver::ECompareAddress CPbk2MergeResolver::DoCompareAddresses( 

        TInt aCountEquals, 

        TInt aCountAddressFieldsFirst,

        TInt aCountAddressFieldsSecond )

    {

    ECompareAddress retCompare = ECAUndefined;

    if( aCountAddressFieldsFirst == 0 && aCountAddressFieldsSecond != 0 )

        {

        retCompare = ECASecondIncludesFirst;

        }

    else if( aCountAddressFieldsFirst != 0 && aCountAddressFieldsSecond == 0 )

        {

        retCompare = ECAFirstIncludesSecond;

        }

    else if( aCountAddressFieldsFirst != 0 && aCountAddressFieldsSecond != 0 )

        {

        if( aCountEquals == aCountAddressFieldsFirst && aCountEquals == aCountAddressFieldsSecond )

            {

            retCompare = ECASame;

            }

        else if( aCountEquals == aCountAddressFieldsFirst )

            {

            retCompare = ECASecondIncludesFirst;

            }

        else if( aCountEquals == aCountAddressFieldsSecond )

            {

            retCompare = ECAFirstIncludesSecond;

            }

        else

            {

            retCompare = ECADifferent;

            }

        }

    return retCompare;

    }

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

// CPbk2MergeResolver::AddressField

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

//

TBool CPbk2MergeResolver::AddressField( const MVPbkStoreContactField& aField )

    {

    const MVPbkFieldType* fieldType = aField.BestMatchingFieldType();