/*

* 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 command.

*

*/

// INCLUDE FILES

//Phonebook2

#include "CPbk2MergeContactsCmd.h"

#include "CPbk2MergeResolver.h"

#include <MPbk2CommandObserver.h>

#include <MPbk2ContactUiControl.h>

#include <MPbk2ApplicationServices.h>

#include <MPbk2AppUi.h>

#include <MPbk2DialogEliminator.h>

#include <MPbk2ContactLinkIterator.h>

#include <CPbk2FetchDlg.h>

#include <CPbk2ContactViewBuilder.h>

#include <CVPbkFilteredContactView.h>

#include <CPbk2ApplicationServices.h>

#include <CPbk2PresentationContact.h>

#include <CPbk2FieldPropertyArray.h>

#include <MPbk2ContactViewSupplier.h>

#include <CPbk2StoreConfiguration.h>

#include <CPbk2StorePropertyArray.h>

#include <CPbk2StoreProperty.h>

#include <Pbk2StoreProperty.hrh>

#include <Pbk2ProcessDecoratorFactory.h>

#include <CPbk2MergeConflictsDlg.h>

#include <CPbk2MergePhotoConflictDlg.h>

#include <Pbk2UIControls.rsg> 

#include <Pbk2CmdExtRes.rsg>

#include <Pbk2CommonUi.rsg>

//Virtual Phonebook

#include <MVPbkContactLink.h>

#include <MVPbkContactViewBase.h>

#include <CVPbkContactStoreUriArray.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactOperationBase.h>

#include <CVPbkContactManager.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactFieldBinaryData.h>

#include <MVPbkContactFieldTextData.h>

#include <VPbkEng.rsg>

#include <MVPbkContactGroup.h>

//System

#include <aknnotewrappers.h>

#include <StringLoader.h>

//#include <aknnavide.h>

#include <akntitle.h>

#include <imageconversion.h>

// Debugging headers

#include <Pbk2Debug.h>

#include <Pbk2Profile.h>

/// Unnamed namespace for local definitions

namespace {

const TInt KFirstContact = 0;

const TInt KSecondContact = 1;

const TInt KAmountToMerge = 2;

const TInt KDeletionDelay = 1000000; // 1s

_LIT( KLocalStore, "cntdb://c:contacts.cdb" );

enum TPbk2PanicCodes

        {

        EPbk2CommandObserverMissing,

        EPbk2WronglyActivated,

        EPbk2DuplicateCallToExecuteLD,

        EPbk2ViewsAlreadyCreated,

        EPbk2WrongTypeOfData,

		EPbk2PhotoConflictError

        };

    void Panic(TPbk2PanicCodes aReason)

        {

        _LIT( KPanicText, "CPbk2_Merge_Contacts" );

        User::Panic(KPanicText,aReason);

        }

} /// namespace

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

// CPbk2MergeContactsCmd::CPbk2MergeContactsCmd

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

//

CPbk2MergeContactsCmd::CPbk2MergeContactsCmd(

    MPbk2ContactUiControl& aUiControl ) :

        CActive( EPriorityStandard ),

        iNextPhase( EPhaseNone ),

        iUiControl( &aUiControl )

    {

    CActiveScheduler::Add( this );

    }

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

// CPbk2MergeContactsCmd::~CPbk2MergeContactsCmd

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

//

CPbk2MergeContactsCmd::~CPbk2MergeContactsCmd()

    {

    PBK2_DEBUG_PRINT(PBK2_DEBUG_STRING

        ("CPbk2NlxMergeContactsCmd(%x)::~CPbk2MergeContactsCmd()"), 

        this);

    Cancel();

    if ( iUiControl )

        {

        iUiControl->RegisterCommand( NULL );

        }

    CleanAfterFetching();

    iTimer.Cancel();

    iTimer.Close();

    delete iFirstContactString;

    delete iSecondContactString;

    delete iMergedContactString;

    delete iRetrieveOperation;

    delete iDeleteOperation;

    delete iCommitOperation;

	delete iDeleteMergedOperation;

    Release( iAppServices );

    delete iContactFirst;

    delete iContactSecond;

    delete iMergedContactLink;

    delete iStoreContactFirst;

    delete iStoreContactSecond;

    delete iMergedContact;

    delete iMergeResolver;

    delete iWaitDecorator;

    if( iGroupsToAdd )

        {

        iGroupsToAdd->ResetAndDestroy();

        delete iGroupsToAdd;

        }

    if ( iContactToCommit )

        {

        iContactToCommit->Reset();

        delete iContactToCommit;

        }

    if ( iContactsToDelete )

        {

        iContactsToDelete->Reset();

        delete iContactsToDelete;

        }

    if( iGroupLinksFirst )

        {

        iGroupLinksFirst->ResetAndDestroy();

        delete iGroupLinksFirst;

        }

    if( iGroupLinksSecond )

        {

        iGroupLinksSecond->ResetAndDestroy();

        delete iGroupLinksSecond;

        }

    TRAP_IGNORE( SetTitlePaneL( EFalse ) );

    }

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

// CPbk2MergeContactsCmd::NewL

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

//

CPbk2MergeContactsCmd* CPbk2MergeContactsCmd::NewL(

    MPbk2ContactUiControl& aUiControl )

    {

    CPbk2MergeContactsCmd* self = 

        new ( ELeave ) CPbk2MergeContactsCmd( aUiControl );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2MergeContactsCmd::ConstructL

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

//

void CPbk2MergeContactsCmd::ConstructL()

    {    

    if( iUiControl )

        {

        iUiControl->RegisterCommand( this );

        }    

    iContactManager = &Phonebook2::Pbk2AppUi()->ApplicationServices().ContactManager();

    iAppServices = CPbk2ApplicationServices::InstanceL();

    iPhotoConflictIndex = KErrNotFound;

    User::LeaveIfError( iTimer.CreateLocal() );

    }

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

// CPbk2MergeContactsCmd::ExecuteLD

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

//

void CPbk2MergeContactsCmd::ExecuteLD()

    {

    __ASSERT_ALWAYS( iCommandObserver, Panic( EPbk2CommandObserverMissing ));	    

    __ASSERT_ALWAYS( !IsActive(), Panic( EPbk2WronglyActivated ));	

    __ASSERT_ALWAYS( iNextPhase == EPhaseNone, Panic( EPbk2DuplicateCallToExecuteLD ));

    if( iUiControl )

        {

        // Blank UI control to avoid flicker

        iUiControl->SetBlank( ETrue );

        }

    StartNext( EPhaseGetSelection );

    }

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

// CPbk2MergeContactsCmd::ResetUiControl

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

//

void CPbk2MergeContactsCmd::ResetUiControl( 

    MPbk2ContactUiControl& aUiControl )

    {

    if ( iUiControl == &aUiControl )

        {

        iUiControl = NULL;

        }

    }

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

// CPbk2MergeContactsCmd::AddObserver

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

//

void CPbk2MergeContactsCmd::AddObserver( 

    MPbk2CommandObserver& aObserver )

    {

    iCommandObserver = &aObserver;

    }        

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

// CPbk2MergeContactsCmd::AutomaticMergeL

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

//

void CPbk2MergeContactsCmd::AutomaticMergeL()

    {

    if(iStoreContactFirst && iStoreContactSecond)

        {

        iMergeResolver = CPbk2MergeResolver::NewL(

                CPbk2PresentationContact::NewL( *iStoreContactFirst, iAppServices->FieldProperties() ), 

                CPbk2PresentationContact::NewL( *iStoreContactSecond, iAppServices->FieldProperties() ) );

        iMergeResolver->MergeL();

        StartNext(EPhaseResolveConflicts);

        }

    else

        {

        Finish(KErrArgument);

        }

    }

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

// CPbk2MergeContactsCmd::AddGroupsL

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

//

void CPbk2MergeContactsCmd::AddGroupsL()

    {

    TInt countGroups = iGroupsToAdd->Count();

    if(countGroups)

        {

        MVPbkStoreContact *group = iGroupsToAdd->At(countGroups - 1);

        group->LockL(*this);

        }

    else

        {

        DeleteSourceContactsL();

        }

    }

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

// CPbk2MergeContactsCmd::RunL

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

//

void CPbk2MergeContactsCmd::RunL()

    {

    if( !iUiControl )

        {

        //UiControl reseted, so cancel all processing

        iNextPhase = EPhaseFinish ;

        }

    switch( iNextPhase )

    	{

    	case EPhaseGetSelection:

    	    {

    	    GetContactsFromUiFetchL();    	    

    	    }

    	    break;

    	case EPhaseGetStoreContacts:

            {

            GetStoreContacts();

            }   

            break;

    	case EPhaseMerge:

    	    {

            AutomaticMergeL();

    	    }

            break;

    	case EPhaseResolveConflicts:

            {

            ResolveConflictsL();

            }

            break;

        case EPhaseResolvePhotoConflict:

            {

            ResolvePhotoConflictL();

            }

            break;

    	case EPhaseCreateMergedContact:

        	{

        	iWaitDecorator = Pbk2ProcessDecoratorFactory::CreateWaitNoteDecoratorL

                                   ( R_QTN_MERGE_CONTACTS_WAIT_NOTE, EFalse );

        	iWaitDecorator->SetObserver( *this );

            iWaitDecorator->ProcessStartedL( 0 );

            FinalizeMergeL();

        	}

    		break;

    	case EPhaseGetGroups:

            {

            GetGroupsL();

            }

            break;

    	case EPhaseAddGroups:

            {

            AddGroupsL();

            }

            break;

    	case EPhaseFinish:

            {

            if ( iWaitDecorator )

                {

                // Decorator calls ProcessDismissed

                iWaitDecorator->ProcessStopped();

                }

            else

                {

                // In case Decorator wasn't initialized we invoke

                // ProcessDismissed to finish merge command execution

                ProcessDismissed( KErrNone );

                }

            }

            break;

    	default:

    		Panic( EPbk2WronglyActivated );

    		break;

    	}

    }    

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

// CPbk2MergeContactsCmd::RunError

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

//

TInt CPbk2MergeContactsCmd::RunError(TInt aError)

	{

	Finish( aError );

    return KErrNone;

	}

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

// CPbk2MergeContactsCmd::FinalizeMergeL

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

//

void CPbk2MergeContactsCmd::FinalizeMergeL()

    {

    if( !iMergeResolver ||  

            ( !iMergeResolver->CountMerged() && !iMergeResolver->CountConflicts() ) )

        {

        Finish( KErrNone );

        return;

        }

    MVPbkContactStore& store = iStoreContactFirst->ParentStore();

    iMergedContact = store.CreateNewContactLC();

    CleanupStack::Pop();

    TInt mergedFieldsCount = iMergeResolver->CountMerged();

    // add merged fields

    for ( TInt i = 0; i < mergedFieldsCount; i++ )

        {

        MVPbkStoreContactField& field = iMergeResolver->GetMergedAt( i );

        AddFieldToMergedContactL( field );

        }

    TInt conflictCount = iMergeResolver->CountConflicts();

    // add conflicted fields

    for ( TInt i = 0; i < conflictCount; i++ )

        {

        MPbk2MergeConflict& conflict = iMergeResolver->GetConflictAt( i );

        RPointerArray<MVPbkStoreContactField> fields;

        conflict.GetChosenFieldsL( fields );

        TInt newFields = fields.Count();

        /// if newFields == 0 not resolved conflict exist

        for ( TInt j = 0; j < newFields; j++ )

            {

            MVPbkStoreContactField* field = fields[ j ];

            AddFieldToMergedContactL( *field );

            }

        fields.Close();

        }

    iContactToCommit = new ( ELeave ) CArrayPtrFlat<MVPbkStoreContact>( 1 );

    iContactToCommit->AppendL( iMergedContact );

    iCommitOperation = iContactManager->CommitContactsL( iContactToCommit->Array(), *this );

    }

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

// CPbk2MergeContactsCmd::ShowContactsMergedNoteL

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

//

void CPbk2MergeContactsCmd::ShowContactsMergedNoteL()

    {

    HBufC* unnamed = StringLoader::LoadLC( R_QTN_PHOB_UNNAMED );

    CDesCArrayFlat* strings = new(ELeave) CDesCArrayFlat( 3 );

    CleanupStack::PushL( strings );

    HBufC* prompt = NULL;

    if ( (iFirstContactString->Length() > 0 || iSecondContactString->Length() > 0)

            && iMergedContactString->Length() > 0 )

        {

        if ( 0 != iFirstContactString->Length() )

            {

            strings->AppendL( *iFirstContactString );

            }

        else

            {

            strings->AppendL( *unnamed );

            }

        if ( 0 != iSecondContactString->Length() )

            {

            strings->AppendL( *iSecondContactString );

            }

        else

            {

            strings->AppendL( *unnamed );

            }

        strings->AppendL( *iMergedContactString );

        prompt = StringLoader::LoadLC( R_QTN_PHOB_NOTE_CONTACTS_WERE_MERGED, *strings );

        }

    else

        {

        strings->AppendL( *unnamed );

        prompt = StringLoader::LoadLC( R_QTN_PHOB_NOTE_UNNAMED_CONTACTS_WERE_MERGED , *strings );

        }

    CleanupStack::PopAndDestroy( prompt );

    CleanupStack::PopAndDestroy( strings );

    CleanupStack::PopAndDestroy( unnamed );

    }

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

// CPbk2MergeContactsCmd::ContactAsStringLC

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

//

HBufC* CPbk2MergeContactsCmd::ContactAsStringL( MVPbkStoreContact* aStoreContact )

    {

    _LIT(KResultFormat, "%S %S");

    TPtrC firstName( KNullDesC() );

    TPtrC lastName( KNullDesC() );

    MVPbkStoreContactFieldCollection& fields = aStoreContact->Fields();

    for ( TInt i(0); i < fields.FieldCount(); ++i )

        {

        MVPbkStoreContactField& field = fields.FieldAt( i );

        const MVPbkFieldType* fieldType = field.BestMatchingFieldType();

        if ( fieldType )

            {

            if ( fieldType->FieldTypeResId() == R_VPBK_FIELD_TYPE_FIRSTNAME )

                {

                MVPbkContactFieldData& data = field.FieldData();

                __ASSERT_DEBUG( data.DataType() == EVPbkFieldStorageTypeText, Panic( EPbk2WrongTypeOfData ) );

                MVPbkContactFieldTextData& textData = MVPbkContactFieldTextData::Cast( data );

                firstName.Set( textData.Text() );

                }

            else if ( fieldType->FieldTypeResId() == R_VPBK_FIELD_TYPE_LASTNAME )

                {

                MVPbkContactFieldData& data = field.FieldData();

                __ASSERT_DEBUG( data.DataType() == EVPbkFieldStorageTypeText, Panic( EPbk2WrongTypeOfData ) );

                MVPbkContactFieldTextData& textData = MVPbkContactFieldTextData::Cast( data );

                lastName.Set( textData.Text() );        

                }

            }

        }

    HBufC* result = NULL;

    if ( firstName.Length() > 0 && lastName.Length() > 0 )

        {

        result = HBufC::NewL( firstName.Length() + lastName.Length() + KResultFormat().Length() );

        TPtr resAsDes = result->Des();

        resAsDes.Format( KResultFormat, &firstName, &lastName );

        }

    else if ( firstName.Length() > 0 )

        {

        result = firstName.AllocL();