/*
* Copyright (c) 2006-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:  A class for finding contact duplicates from stores
*
*/


#include <CPbk2DuplicateContactFinder.h>

// From Phonebook2
#include <MPbk2DuplicateContactObserver.h>
#include <MPbk2ContactNameFormatter.h>

// From Virtual Phonebook
#include <MVPbkFieldType.h>
#include <MVPbkBaseContactFieldCollection.h>
#include <MVPbkStoreContact.h>
#include <MVPbkContactFieldTextData.h>
#include <MVPbkContactStore.h>
#include <CVPbkContactManager.h>
#include <MVPbkContactOperation.h>
#include <MVPbkContactLinkArray.h>

#include <VPbkEng.rsg>
namespace
    {
    #ifdef _DEBUG
        enum TPanicCode
            {
            EPanic_RetrieveContactL_OOB = 1
            };
            
        void Panic( TPanicCode aPanic )
            {
            _LIT( KPanicCat, "CPbk2DuplicateContactFinder" );
            User::Panic( KPanicCat(), aPanic );
            }
    #endif // _DEBUG    
    }
 
enum TPbk2DuplicateContactFinderState
    {
    ENoDuplicatesFound,
    EStartFind,
    ERetrieveContact,
    EComplete
    };

const TInt KNameFormattingFlags = 
    MPbk2ContactNameFormatter::EPreserveLeadingSpaces;
    
// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::CPbk2DuplicateContactFinder
// ---------------------------------------------------------------------------
//
CPbk2DuplicateContactFinder::CPbk2DuplicateContactFinder( 
        CVPbkContactManager& aContactManager, 
        MPbk2ContactNameFormatter& aNameFormatter,
        const MVPbkFieldTypeList& aFieldTypesForFind,
        RPointerArray<MVPbkStoreContact>& aDuplicateContacts ):
            CActive( EPriorityStandard ),
            iContactManager( aContactManager ),
            iNameFormatter( aNameFormatter ),
            iFieldTypesForFind( aFieldTypesForFind ),
            iFindText( KNullDesC ),
            iDuplicates( aDuplicateContacts )
    {
    }


// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::ConstructL
// ---------------------------------------------------------------------------
//
void CPbk2DuplicateContactFinder::ConstructL()
    {
    CActiveScheduler::Add( this );
    }

// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CPbk2DuplicateContactFinder* CPbk2DuplicateContactFinder::NewL(
        CVPbkContactManager& aContactManager, 
        MPbk2ContactNameFormatter& aNameFormatter,
        const MVPbkFieldTypeList& aFieldTypesForFind,
        RPointerArray<MVPbkStoreContact>& aDuplicateContacts )
    {
    CPbk2DuplicateContactFinder* self = 
        new( ELeave ) CPbk2DuplicateContactFinder( aContactManager, 
            aNameFormatter, aFieldTypesForFind, aDuplicateContacts );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// destructor
// ---------------------------------------------------------------------------
//
CPbk2DuplicateContactFinder::~CPbk2DuplicateContactFinder()
    {
    Cancel();
    delete iContactOperation;
    delete iFindResults;
    delete iContactTitle;
    }

// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::StartL
// ---------------------------------------------------------------------------
//
EXPORT_C void CPbk2DuplicateContactFinder::StartL( 
        const MVPbkBaseContact& aContact,
        MVPbkContactStore& aStore, 
        MPbk2DuplicateContactObserver& aObserver,
        TInt aMaxDuplicatesToFind )
    {
    iStore = &aStore;
    StartL( aContact, aObserver, aMaxDuplicatesToFind );
    }
    
// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::StartL
// ---------------------------------------------------------------------------
//
EXPORT_C void CPbk2DuplicateContactFinder::StartL( 
        const MVPbkBaseContact& aContact,
        MPbk2DuplicateContactObserver& aObserver,
        TInt aMaxDuplicatesToFind )
    {
    iObserver = &aObserver;
    iContactToCompare = &aContact;
    iContactIndex = 0;
    iMaxDuplicatesToFind = aMaxDuplicatesToFind;
    
    iState = ENoDuplicatesFound;
    iFindText.Set( FindText() );
    if ( iFindText.Length() > 0 )
        {
        iState = EStartFind;
        }
    IssueRequest();
    }
    
// ---------------------------------------------------------------------------
// From class CActive.
// CPbk2DuplicateContactFinder::RunL
// ---------------------------------------------------------------------------
//
void CPbk2DuplicateContactFinder::RunL()
    {
    switch ( iState )
        {
        case EStartFind:
            {
            StartFindL();
            break;
            }
        case ERetrieveContact:
            {
            RetrieveContactL();
            break;
            }
        case EComplete:
            {
            CompleteL();
            break;
            }
        case ENoDuplicatesFound: // FALLTHROUGH
        default:
            {
            iObserver->DuplicateFindComplete();
            break;
            }
        }
    }

// ---------------------------------------------------------------------------
// From class CActive.
// CPbk2DuplicateContactFinder::DoCancel
// ---------------------------------------------------------------------------
//    
void CPbk2DuplicateContactFinder::DoCancel()
    {
    DestroyOperation();
    }

// ---------------------------------------------------------------------------
// From class CActive.
// CPbk2DuplicateContactFinder::RunError
// ---------------------------------------------------------------------------
//        
TInt CPbk2DuplicateContactFinder::RunError( TInt aError )
    {
    iObserver->DuplicateFindFailed( aError );
    return KErrNone;
    }
    
// ---------------------------------------------------------------------------
// From class MVPbkContactFindObserver.
// CPbk2DuplicateContactFinder::FindCompleteL
// ---------------------------------------------------------------------------
//
void CPbk2DuplicateContactFinder::FindCompleteL( 
        MVPbkContactLinkArray* aResults )
    {
    iFindResults = aResults;
    iState = ENoDuplicatesFound;
    if ( !LastContactRetrieved() )
        {
        iState = ERetrieveContact;
        }
    
    IssueRequest();
    }

// ---------------------------------------------------------------------------
// From class MVPbkContactFindObserver.
// CPbk2DuplicateContactFinder::FindFailed
// ---------------------------------------------------------------------------
//
void CPbk2DuplicateContactFinder::FindFailed( TInt aError )
    {
    iObserver->DuplicateFindFailed( aError );
    }

// ---------------------------------------------------------------------------
// From class MVPbkSingleContactOperationObserver.
// CPbk2DuplicateContactFinder::VPbkSingleContactOperationComplete
// ---------------------------------------------------------------------------
//    
void CPbk2DuplicateContactFinder::VPbkSingleContactOperationComplete(
        MVPbkContactOperationBase& /*aOperation*/, 
        MVPbkStoreContact* aContact )
    {
    TRAPD( res, CheckDuplicateL( aContact ) );
        
    ++iContactIndex;
    if ( res != KErrNone )
        {
        iObserver->DuplicateFindFailed( res );
        }
    else if ( LastContactRetrieved() )
        {
        iState = EComplete;
        IssueRequest();
        }
    else
        {
        // Continue retrieving
        IssueRequest();
        }
    }

// ---------------------------------------------------------------------------
// From class MVPbkSingleContactOperationObserver.
// CPbk2DuplicateContactFinder::VPbkSingleContactOperationFailed
// ---------------------------------------------------------------------------
//    
void CPbk2DuplicateContactFinder::VPbkSingleContactOperationFailed( 
        MVPbkContactOperationBase& /*aOperation*/, TInt aError )
    {
    iObserver->DuplicateFindFailed( aError );
    }
    
// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::IssueRequest
// ---------------------------------------------------------------------------
//
void CPbk2DuplicateContactFinder::IssueRequest()
    {
    TRequestStatus* st = &iStatus;
    User::RequestComplete( st, KErrNone );
    SetActive();
    }
    
// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::FindText
// ---------------------------------------------------------------------------
//
TPtrC CPbk2DuplicateContactFinder::FindText()
    {
    const MVPbkBaseContactFieldCollection& fields = 
        iContactToCompare->Fields();
    // Find a text from the contact in the order of iFieldTypesForFind.
    // the first data that is found is used as a find text
    const TInt findTypeCount = iFieldTypesForFind.FieldTypeCount();
    for ( TInt i = 0; i < findTypeCount; ++i )
        {
        const MVPbkFieldType& findType = iFieldTypesForFind.FieldTypeAt( i );
        const TInt fieldCount = fields.FieldCount();
        for ( TInt j = 0; j < fieldCount; ++j )
            {
            const MVPbkFieldType* type = 
                fields.FieldAt( j ).BestMatchingFieldType();
            if ( type && findType.IsSame( *type ) )
                {
                const MVPbkContactFieldData& data = 
                    fields.FieldAt( j ).FieldData();
                if ( data.DataType() == EVPbkFieldStorageTypeText )
                    {
                    TPtrC text( MVPbkContactFieldTextData::Cast( 
                        data ).Text() );
                    if ( text.Length() > 0 )
                        {
                        return text;
                        }
                    }
                }
            }    
        }
    // No find text -> no duplicates for contact.
    return TPtrC( KNullDesC );
    }
    
// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::FindOperationL
// ---------------------------------------------------------------------------
//
MVPbkContactOperationBase* CPbk2DuplicateContactFinder::FindOperationL( 
        const TDesC& aFindText )
    {
    if ( iStore )
        {
        MVPbkContactOperation* op = iStore->CreateFindOperationL( aFindText, 
            iFieldTypesForFind, *this );
        CleanupDeletePushL( op );
        op->StartL();
        CleanupStack::Pop(); // op
        return op;
        }
    else
        {
        return iContactManager.FindL( aFindText,
            iFieldTypesForFind, *this );
        }
    }

// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::StartFindL
// ---------------------------------------------------------------------------
//
void CPbk2DuplicateContactFinder::StartFindL()
    {
    delete iFindResults;
    iFindResults = NULL;
    
    delete iContactTitle;
    iContactTitle = NULL;
    iContactTitle = iNameFormatter.GetContactTitleL( 
        iContactToCompare->Fields(), KNameFormattingFlags );
    
    DestroyOperation();
    iContactOperation = FindOperationL( iFindText );
    }

// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::RetrieveContactL
// ---------------------------------------------------------------------------
//    
void CPbk2DuplicateContactFinder::RetrieveContactL()
    {
    DestroyOperation();
    __ASSERT_DEBUG( iFindResults->Count() > iContactIndex,
        Panic( EPanic_RetrieveContactL_OOB ) );
    iContactOperation = iContactManager.RetrieveContactL(
        iFindResults->At( iContactIndex ), *this );
    }

// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::CompleteL
// ---------------------------------------------------------------------------
//        
void CPbk2DuplicateContactFinder::CompleteL()
    {
    iObserver->DuplicateFindComplete();
    }

// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::LastContactRetrieved
// ---------------------------------------------------------------------------
//        
TBool CPbk2DuplicateContactFinder::LastContactRetrieved()
    {
    if ( iDuplicates.Count() >= iMaxDuplicatesToFind ||
         iContactIndex >= iFindResults->Count() )
        {
        return ETrue;
        }
    return EFalse;
    }
    
// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::DestroyOperation
// ---------------------------------------------------------------------------
//        
void CPbk2DuplicateContactFinder::DestroyOperation()
    {
    delete iContactOperation;
    iContactOperation = NULL;
    }

// ---------------------------------------------------------------------------
// CPbk2DuplicateContactFinder::CheckDuplicateL
// ---------------------------------------------------------------------------
//            
void CPbk2DuplicateContactFinder::CheckDuplicateL( 
        MVPbkStoreContact* aContact )
    {    
    aContact->PushL();
    
    TBool duplicate = EFalse;
    HBufC* candidateTitle = iNameFormatter.GetContactTitleOrNullL( 
        aContact->Fields(), KNameFormattingFlags );
    // If the aContact is not a group and it has a title, compare it with iContactTitle.
    // This is because some group has the same name with the contact and they can't be
    // considered as duplicate.
    if ( !aContact->Group() && candidateTitle )
        {
        CleanupStack::PushL( candidateTitle );
        if ( iContactTitle->CompareF( *candidateTitle ) == 0 )
            {
            // Compare the first and last name.
            if ( IsFieldMatched( aContact, R_VPBK_FIELD_TYPE_FIRSTNAME ) && 
                    IsFieldMatched( aContact, R_VPBK_FIELD_TYPE_LASTNAME ) )
                {
                duplicate = ETrue;
                }
            }
        CleanupStack::PopAndDestroy( candidateTitle );
        }
    
    if ( duplicate )
        {
        iDuplicates.AppendL( aContact );
        CleanupStack::Pop(); // aContact
        }
    else
        {
        CleanupStack::PopAndDestroy(); // aContact
        }
    }

TBool CPbk2DuplicateContactFinder::IsFieldMatched( const MVPbkBaseContact* aContact, TInt aFieldId )
    {
    TBool result = EFalse;
    
    const MVPbkBaseContactField* compareContactField = FindFieldById( iContactToCompare, aFieldId );
    const MVPbkBaseContactField* contactField = FindFieldById( aContact, aFieldId );
    if ( NULL == compareContactField && NULL == contactField )
        {
        result = ETrue;
        }
    else if ( compareContactField && contactField )
        {
        const TDesC& compareContactFieldText = 
                MVPbkContactFieldTextData::Cast(compareContactField->FieldData()).Text();
        const TDesC& contactFieldText = 
                MVPbkContactFieldTextData::Cast(contactField->FieldData()).Text();
        if ( compareContactFieldText.CompareF( contactFieldText ) == 0 )
            {
            result = ETrue;
            }
        }
    
    return result;
    }

const MVPbkBaseContactField* CPbk2DuplicateContactFinder::FindFieldById( const MVPbkBaseContact* aContact,
        TInt aFieldId )
    {
    const TInt fieldCount = aContact->Fields().FieldCount();
    const MVPbkBaseContactFieldCollection& fieldSet = aContact->Fields();
    for ( TInt i = 0; i < fieldCount; ++i )
        {
        const MVPbkBaseContactField& field = fieldSet.FieldAt(i);
        if ( field.BestMatchingFieldType() )
            {
            TInt fieldTypeId = field.BestMatchingFieldType()->FieldTypeResId();
            if ( fieldTypeId == aFieldId )
                {
                return &field;
                }
            }
        }
    return NULL;
    }