/*
* Copyright (c) 2005-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:  Copy contacts operation
*
*/


#include "CVPbkCopyContactsOperation.h"

#include <MVPbkBatchOperationObserver.h>
#include <MVPbkStoreContactFieldCollection.h>
#include <MVPbkStoreContactField.h>
#include <MVPbkStoreContact.h>
#include <MVPbkContactStore.h>
#include <MVPbkContactFieldData.h>
#include <MVPbkFieldType.h>
#include <CVPbkContactManager.h>
#include <MVPbkContactStoreProperties.h>
#include <MVPbkContactLinkArray.h>
#include <MVPbkContactLink.h>
#include <CVPbkContactCopyPolicyManager.h>
#include <MVPbkContactCopyPolicy.h>
#include <MVPbkContactOperationBase.h>
#include <CVPbkContactCopier.h>
#include <CVPbkContactDuplicatePolicy.h>

namespace {

const TInt KOneStep = 1;
const TInt KDuplicatesToFind = 1;

TInt CurNumberOfField( MVPbkStoreContact& aContact,
        const MVPbkFieldType& aFieldType )
    {
    MVPbkStoreContactFieldCollection& fields = aContact.Fields();
    TInt res = 0;
    const TInt count = fields.FieldCount();
    for (TInt i = 0; i < count; ++i)
        {
        const MVPbkFieldType* type = fields.FieldAt(i).BestMatchingFieldType();
        if (type && type->IsSame(aFieldType))
            {
            ++res;
            }
        }
    return res;
    }
}

CVPbkCopyContactsOperation::CVPbkCopyContactsOperation(
        CVPbkContactManager& aContactManager,
        const MVPbkContactLinkArray& aLinks,
        MVPbkContactStore* aTargetStore,
        CVPbkContactLinkArray* aCopiedContactLinks,
        MVPbkBatchOperationObserver& aObserver)
        :   CActive( EPriorityStandard ),
            iContactManager( aContactManager ),
            iLinks( aLinks ),
            iTargetStore( aTargetStore ),
            iCopiedContactLinks( aCopiedContactLinks ),
            iObserver( aObserver ),
            iState( ERetrieveNextContact )
    {
    CActiveScheduler::Add(this);
    }

inline void CVPbkCopyContactsOperation::ConstructL( TUint32 aCopyContactFlags )
    {
    // If client gave NULL target store then contacts are duplicated
    if ( !iTargetStore )
        {
        iDuplicateContacts = ETrue;
        }

    SetTargetStoreL();

    const TUint32 copyPolicyFlags =
        CVPbkContactCopier::EVPbkUseStoreSpecificCopyPolicy |
        CVPbkContactCopier::EVPbkUsePlatformSpecificDuplicatePolicy;
    const TUint32 duplicatePolicyFlags =
        CVPbkContactCopier::EVPbkUsePlatformSpecificDuplicatePolicy;

    // Check if copy policy is needed
    if ( aCopyContactFlags & copyPolicyFlags )
        {
        iCopyPolicyManager = CVPbkContactCopyPolicyManager::NewL();
        if ( iTargetStore )
            {
            iCopyPolicy = iCopyPolicyManager->GetPolicyL( iContactManager,
                iTargetStore->StoreProperties().Uri() );
            }
        }

    // Check if duplicate policy is needed
    if ( aCopyContactFlags & duplicatePolicyFlags && iCopyPolicy &&
         iCopyPolicy->SupportsContactMerge() )
        {
        CVPbkContactDuplicatePolicy::TParam param( iContactManager );
        TRAPD( res, iDuplicatePolicy = CVPbkContactDuplicatePolicy::NewL( param ));
        // Don't leave if duplicate policy is not found -> duplicate checking
        // is not used.
        if ( res != KErrNone && res != KErrNotFound )
            {
            User::LeaveIfError( res );
            }
        }
    }

CVPbkCopyContactsOperation* CVPbkCopyContactsOperation::NewLC(
        TUint32 aCopyContactFlags,
        CVPbkContactManager& aContactManager,
        const MVPbkContactLinkArray& aLinks,
        MVPbkContactStore* aTargetStore,
        CVPbkContactLinkArray* aCopiedContactLinks,
        MVPbkBatchOperationObserver& aObserver)
    {
    CVPbkCopyContactsOperation* self = new(ELeave) CVPbkCopyContactsOperation(
            aContactManager,
            aLinks,
            aTargetStore,
            aCopiedContactLinks,
            aObserver);
    CleanupStack::PushL(self);
    self->ConstructL( aCopyContactFlags );
    return self;
    }

CVPbkCopyContactsOperation::~CVPbkCopyContactsOperation()
    {
    Cancel();
    delete iDuplicatePolicy;
    delete iCopyPolicyManager;
    delete iStoreContact;
    delete iOperation;
    iDuplicates.ResetAndDestroy();
    iSourceContactsForMerge.ResetAndDestroy();
    }

void CVPbkCopyContactsOperation::DoCancel()
    {
    }

void CVPbkCopyContactsOperation::RunL()
    {
    switch (iState)
        {
        case ERetrieveNextContact:
            {
            RetrieveNextContactL();
            break;
            }
        case EDefaultCopy:
            {
            DefaultCopyL();
            break;
            }
        case ECopyUsingPolicy:
            {
            CopyUsingPolicyL();
            break;
            }
        case EFindDuplicates:
            {
            FindDuplicatesL();
            break;
            }
        case EComplete:
            {
            iObserver.OperationComplete(*this);
            break;
            }
        }
    }

TInt CVPbkCopyContactsOperation::RunError(TInt aError)
    {
    ContinueAfterFailure( aError );
    return KErrNone;
    }

void CVPbkCopyContactsOperation::StartL()
    {
    IssueRequest();
    }

void CVPbkCopyContactsOperation::Cancel()
    {
    CActive::Cancel();
    }

void CVPbkCopyContactsOperation::VPbkSingleContactOperationComplete(
        MVPbkContactOperationBase& /*aOperation*/,
        MVPbkStoreContact* aContact)
    {
    delete iOperation;
    iOperation = NULL;
    delete iStoreContact;
    iStoreContact = aContact;

    // Default action is own copy logic
    iState = EDefaultCopy;
    if ( iDuplicatePolicy && iCopyPolicy )
        {
        // But if the duplicate policy exists it's done before copying
        iState = EFindDuplicates;
        }
    else if ( iCopyPolicy )
        {
        // Duplicate checking was not defined but copy policy was.
        // Make more advanced copy using the policy
        iState = ECopyUsingPolicy;
        }
    IssueRequest();
    }

void CVPbkCopyContactsOperation::VPbkSingleContactOperationFailed(
        MVPbkContactOperationBase& /*aOperation*/,
        TInt aError)
    {
    delete iOperation;
    iOperation = NULL;

    ContinueAfterFailure( aError );
    }

void CVPbkCopyContactsOperation::ContactsSaved(
        MVPbkContactOperationBase& aOperation,
        MVPbkContactLinkArray* aResults)
    {
    delete iOperation;
    iOperation = NULL;
    delete iStoreContact;
    iStoreContact = NULL;

    TRAPD( res,
        {
        CleanupDeletePushL( aResults );
        AppendResultsL( *aResults );
        CleanupStack::PopAndDestroy(); // aResults
        });

    if ( res == KErrNone )
        {
        // One contact copied, notify observer and start retrieve next contact.
        iObserver.StepComplete( *this, KOneStep );

        iState = ERetrieveNextContact;
        IssueRequest();
        }
    else
        {
        ContactsSavingFailed( aOperation, res );
        }
    }

void CVPbkCopyContactsOperation::ContactsSavingFailed(
        MVPbkContactOperationBase& /*aOperation*/,
        TInt aError)
    {
    ContinueAfterFailure( aError );
    }

void CVPbkCopyContactsOperation::ContactOperationCompleted(
        TContactOpResult aResult )
    {
    // Default copy successfully done -> continue with next contact
    delete iOperation;
    iOperation = NULL;

    TRAPD( res,
        {
        if ( iCopiedContactLinks )
            {
            iCopiedContactLinks->AppendL( iStoreContact->CreateLinkLC() );
            CleanupStack::Pop(); // link
            }
        });

    if ( res == KErrNone )
        {
        iObserver.StepComplete( *this, KOneStep );
        iState = ERetrieveNextContact;
        IssueRequest();
        }
    else
        {
        ContactOperationFailed( aResult.iOpCode, res, EFalse );
        }
    }

void CVPbkCopyContactsOperation::ContactOperationFailed( TContactOp /*aOpCode*/,
        TInt aErrorCode, TBool /*aErrorNotified*/ )
    {
    // Default copy failed -> send step failed and continue with next contact
    ContinueAfterFailure( aErrorCode );
    }

void CVPbkCopyContactsOperation::FindCompleteL( MVPbkContactLinkArray* aResults )
    {
    delete aResults;
    delete iOperation;
    iOperation = NULL;

    if ( iDuplicates.Count() > 0 )
        {
        // Merge iStoreContact to the duplicate.
        iSourceContactsForMerge.ResetAndDestroy();
        /// Ownership of the iStoreContact changes
        iSourceContactsForMerge.AppendL( iStoreContact );
        iStoreContact = NULL;
        iOperation = iCopyPolicy->MergeAndSaveContactsL(
            iSourceContactsForMerge, *iDuplicates[0], *this );
        }
    else
        {
        // No duplicates found -> use copy policy to copy contact
        iState = ECopyUsingPolicy;
        IssueRequest();
        }
    }

void CVPbkCopyContactsOperation::FindFailed( TInt aError )
    {
    ContinueAfterFailure( aError );
    }

void CVPbkCopyContactsOperation::IssueRequest()
    {
    TRequestStatus* status = &iStatus;
    User::RequestComplete(status, KErrNone);
    SetActive();
    }

void CVPbkCopyContactsOperation::SetTargetStoreL()
    {
    if ( iDuplicateContacts && iCurrentLinkIndex < iLinks.Count() )
        {
        // if duplicates are created then set the store to the store of the
        // current link
        iTargetStore = &iLinks.At( iCurrentLinkIndex ).ContactStore();
        if ( iTargetStore && iCopyPolicyManager )
            {
            iCopyPolicy = iCopyPolicyManager->GetPolicyL( iContactManager,
                    iTargetStore->StoreProperties().Uri() );
            }
        }
    }

void CVPbkCopyContactsOperation::RetrieveNextContactL()
    {
    // In duplicate mode target store is same as source store
    // so this needs to be checked every time
    SetTargetStoreL();

    delete iStoreContact;
    iStoreContact = NULL;

    if ( iCurrentLinkIndex < iLinks.Count() )
        {
        iOperation = iContactManager.RetrieveContactL(
                iLinks.At( iCurrentLinkIndex++ ), *this);
        }
    else
        {
        iState = EComplete;
        IssueRequest();
        }
    }

void CVPbkCopyContactsOperation::DefaultCopyL()
    {
    // Own simple copy logic. Copy the field if the target supports it and
    // store contact has space for the new field.
    // Copy labels if target field supports label.
    const MVPbkContactStoreProperties& props = iTargetStore->StoreProperties();
    const MVPbkFieldTypeList& supportedFields = props.SupportedFields();
    MVPbkStoreContact* newContact = iTargetStore->CreateNewContactLC();
    MVPbkStoreContactFieldCollection& fields = iStoreContact->Fields();
    const TInt fieldCount = fields.FieldCount();
    for (TInt i = 0; i < fieldCount; ++i)
        {
        MVPbkStoreContactField& field = fields.FieldAt(i);
        const MVPbkFieldType* fieldType = field.BestMatchingFieldType();
        if (fieldType && supportedFields.ContainsSame(*fieldType))
            {
            TInt maxNumber = newContact->MaxNumberOfFieldL(*fieldType);
            if (maxNumber == KVPbkStoreContactUnlimitedNumber ||
                CurNumberOfField(*newContact, *fieldType) < maxNumber)
                {
                MVPbkStoreContactField* newField =
                    newContact->CreateFieldLC(*fieldType);
                TPtrC label(field.FieldLabel());
                if (newField->SupportsLabel() &&
                    label.Length() > 0)
                    {
                    newField->SetFieldLabelL(label);
                    }
                newField->FieldData().CopyL(field.FieldData());
                newContact->AddFieldL(newField);
                CleanupStack::Pop(); // newField
                }
            }
        }

    if ( newContact->Fields().FieldCount() > 0 )
        {
        // Save the new contact if fields were copied
        delete iStoreContact;
        iStoreContact = newContact;
        CleanupStack::Pop(); // newContact
        iStoreContact->CommitL( *this );
        }
    else
        {
        // No fields were copied -> Continue with next contact.
        CleanupStack::PopAndDestroy(); // newContact
        // Return success.
        iObserver.StepComplete( *this, KOneStep );
        iState = ERetrieveNextContact;
        IssueRequest();
        }
    }

void CVPbkCopyContactsOperation::CopyUsingPolicyL()
    {
    iOperation = iCopyPolicy->CopyContactL( *iStoreContact, *iTargetStore,
        *this );
    }

void CVPbkCopyContactsOperation::FindDuplicatesL()
    {
    iDuplicates.ResetAndDestroy();
    iOperation = iDuplicatePolicy->FindDuplicatesL( *iStoreContact,
        *iTargetStore, iDuplicates, *this, KDuplicatesToFind );
    }

void CVPbkCopyContactsOperation::ContinueAfterFailure( TInt aError )
    {
    delete iOperation;
    iOperation = NULL;

    iState = EComplete;
    if ( iObserver.StepFailed( *this, KOneStep, aError ) )
        {
        // Continue only if ETrue is answered. This operation might be deleted
        // if EFalse is answered.
        iState = ERetrieveNextContact;
        IssueRequest();
        }
    }

void CVPbkCopyContactsOperation::AppendResultsL( MVPbkContactLinkArray& aLinks )
    {
    if ( iCopiedContactLinks )
        {
        const TInt count = aLinks.Count();
        for ( TInt i = 0; i < count; ++i )
            {
            iCopiedContactLinks->AppendL( aLinks.At(i).CloneLC() );
            CleanupStack::Pop(); // link
            }
        }
    }
// End of File