/*

* Copyright (c) 2007-2008 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:  An operation for importing and updating contacts to the store

*

*/

#include "CVPbkImportToContactsMergeOperation.h"

#include "VPbkVCardEngError.h"

#include "CVPbkVCardImporter.h"

// Virtual Phonebook

#include <MVPbkStoreContact.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactLink.h>

#include <CVPbkVCardEng.h>

#include <CVPbkContactManager.h>

#include <MVPbkFieldType.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldUriData.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkSingleContactOperationObserver.h>

const TInt KGranularity = 4;

namespace{

    #ifdef _DEBUG

    enum TPanic

        {

        EPanicInvalidState = 1,

        EPanicInvalidToRetrieve,

        EPanicInvalidToLock,

        EPanicInvalidToCommit,

        EPanicInvalidToUpdate,

        };

    void Panic(TPanic aPanic)

        {

        _LIT(KPanicCat, "CVPbkImportToContactsMergeOperation");

        User::Panic(KPanicCat, aPanic);

        }

    #endif // _DEBUG

} //namespace

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

// CVPbkImportToContactsMergeOperation::CVPbkImportToContactsMergeOperation

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

//

CVPbkImportToContactsMergeOperation::CVPbkImportToContactsMergeOperation(

        const MVPbkContactLink& aReplaceContact,

        MVPbkSingleContactOperationObserver& aObserver,

        MVPbkContactStore& aTargetStore,

        CVPbkVCardData& aData

        )

        :   CActive( EPriorityStandard ),

            iState ( EImport ),

            iTargetStore( aTargetStore ),

            iReplaceContact( aReplaceContact ),

            iObserver( aObserver ),

            iData(aData)

    {

    CActiveScheduler::Add(this);

    iGroupcardHandler = NULL;

    iOperationImpl = NULL;

    iVPbkOperation = NULL;

    }

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

// CVPbkImportToContactsMergeOperation::ConstructL

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

//

void CVPbkImportToContactsMergeOperation::ConstructL( TVPbkImportCardType aType, RReadStream& aSourceStream)

    {

    if ( aType == EVCard )

        {

        iOperationImpl = CVPbkVCardImporter::NewL(iImportedContacts, aSourceStream, iTargetStore, iData );

        }

    else

        {

        User::Leave( KErrArgument );

        }    

    iGroupcardHandler = CVPbkGroupCardHandler::NewL(iData);   

    }

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

// CVPbkImportToContactsMergeOperation::NewL

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

//

CVPbkImportToContactsMergeOperation * CVPbkImportToContactsMergeOperation::NewL( 

             TVPbkImportCardType aType,

             CVPbkVCardData& aData, 

             const MVPbkContactLink& aReplaceContact, 

             MVPbkContactStore& aTargetStore, 

             RReadStream& aSourceStream, 

             MVPbkSingleContactOperationObserver& aObserver )

    {

    CVPbkImportToContactsMergeOperation* self =

    new( ELeave ) CVPbkImportToContactsMergeOperation( aReplaceContact,aObserver, aTargetStore, aData);

    CleanupStack::PushL( self );

    self->ConstructL( aType, aSourceStream);

    CleanupStack::Pop( self );

    return self;

    }

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

// CVPbkImportToContactsMergeOperation::~CVPbkImportToContactsMergeOperation

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

//

CVPbkImportToContactsMergeOperation::~CVPbkImportToContactsMergeOperation()

    {

    if(iOperationImpl)

        {

        delete iOperationImpl;

        iOperationImpl = NULL;

        }

    if (iGroupcardHandler)

        {

        delete iGroupcardHandler;

        iGroupcardHandler = NULL;

        }

    if(iVPbkOperation)

        delete iVPbkOperation;

    if( iSetAttributeOperation )

        {

        delete iSetAttributeOperation;

        iSetAttributeOperation = NULL;

        }

    if( iDefaultAttributes )

        {

        delete iDefaultAttributes;

        iDefaultAttributes = NULL;

        }

    iImportedContacts.ResetAndDestroy();

    CActive::Cancel();

    }

void CVPbkImportToContactsMergeOperation::StartL()

    {

    __ASSERT_DEBUG( iOperationImpl, VPbkVCardEngError::Panic(

        VPbkVCardEngError::EPreCond_CVPbkImportToStoreOperation_StartL ) );

    iOperationImpl->SetObserver( *this );

    iOperationImpl->StartL();

    }

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

// From class MVPbkContactOperation

// CVPbkImportToStoreOperation::Cancel

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

//

void CVPbkImportToContactsMergeOperation::Cancel()

    {

    if(iOperationImpl)

    delete iOperationImpl;

    iOperationImpl = NULL;

    }

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

// CVPbkImportToContactsMergeOperation::RunL

// from CActive

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

//

void CVPbkImportToContactsMergeOperation::RunL()

    {

    if ( iStatus == KErrNone)

        {

        switch( iState )

            {

            case ERetrieve:

                {

                RetrieveContactL();

                break;

                }

            case    ELock:

                {

                LockContactL();

                break;

                }

            case EUpdateContact:

                {

                UpdateContactL();

                break;

                }

            case EReplaceFields:

                {

                ReplaceFieldL( *(iImportedContacts[0]), *iContact );

                break;

                }

            case ESetAttributes:

                {

                SetNextL();

                break;

                }

            case ECommit:

                {

                CommitContactL();

                break;

                }

            case EReRetrieve:

                {

                ReRetrieveContactL();

                break;

                }

            case EComplete:

                {

                    {

                    iGroupcardHandler->BuildContactGroupsHashMapL(iContact->ParentStore());

                    const MVPbkContactLink* contact = iContact->CreateLinkLC();

                    iGroupcardHandler->GetContactGroupStoreL(*contact);

                    CleanupStack::PopAndDestroy(); // For contact

                    iGroupcardHandler->DecodeContactGroupInVCardL(((CVPbkVCardImporter *)iOperationImpl)->GetGroupcardvalue());

                    }

                iObserver.VPbkSingleContactOperationComplete( *this, iContact );

                iContact = NULL;

                break;

                }

            default:

                __ASSERT_DEBUG( EFalse, Panic(EPanicInvalidState) );

            }

        }

    }

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

// CVPbkImportToContactsMergeOperation::RunError

// from CActive

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

//

TInt CVPbkImportToContactsMergeOperation::RunError( TInt aError )

    {

    HandleError( aError );

    return KErrNone;

    }

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

// CVPbkImportToContactsMergeOperation::DoCancel

// from CActive

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

//

void CVPbkImportToContactsMergeOperation::DoCancel()

    {

    delete iOperationImpl;

    iOperationImpl = NULL;

    }

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

// From class MVPbkImportOperationObserver

// CVPbkImportToStoreOperation::ContactsImported

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

//

void CVPbkImportToContactsMergeOperation::ContactsImported()

    {

    if (iVPbkOperation)

        delete iVPbkOperation;

    iVPbkOperation = NULL;

    //At the Start of contact replace,aContact will be Null, it will be retrived later

    HandleContactReplacing(NULL); 

    }

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

// From class MVPbkImportOperationObserver

// CVPbkImportToStoreOperation::ContactsImportedCompleted

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

//

void CVPbkImportToContactsMergeOperation::ContactsImportingCompleted()

    {

    //not used

    }

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

// From class MVPbkImportOperationObserver

// CVPbkImportToStoreOperation::ContactImportingFailed

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

//

void CVPbkImportToContactsMergeOperation::ContactImportingFailed( TInt aError )

    {

    if(iVPbkOperation)

        delete iVPbkOperation;

    iVPbkOperation = NULL;

    HandleError( aError );

    }

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

// CVPbkImportToContactsMergeOperation::HandleContactReplacing

// To initiate and start contact replacing

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

//

void CVPbkImportToContactsMergeOperation::HandleContactReplacing(MVPbkStoreContact* aContact)

    {

    switch( iState )

        {

        case EImport:

            {

            // initiate contact replacing

            if ( iImportedContacts.Count() == 1 )

                {

                NextState( ERetrieve );

                }

            else

                {

                // invalid arguments

                HandleError( KErrArgument );

                }

            break;

            }

        case ERetrieve:

            {

            delete iContact;

            iContact = aContact;

            NextState( ELock );

            break;

            }

        case EReRetrieve:

            {

            delete iContact;

            iContact = aContact;

            NextState( EComplete );

            break;

            }

        default:

            __ASSERT_DEBUG( EFalse, Panic(EPanicInvalidState) );

            HandleError( KErrGeneral );

        }

    }

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

// CVPbkImportToContactsMergeOperation::VPbkSingleContactOperationComplete

// from class MVPbkSingleContactOperationObserver

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

//

void CVPbkImportToContactsMergeOperation::VPbkSingleContactOperationComplete(

                MVPbkContactOperationBase& /*aOperation*/,

                MVPbkStoreContact* aContact )

    {

    if (iVPbkOperation)

        delete iVPbkOperation;

    iVPbkOperation = NULL;

    HandleContactReplacing(aContact);

    }

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

// CVPbkImportToContactsMergeOperation::VPbkSingleContactOperationFailed

// from class MVPbkSingleContactOperationObserver

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

//

void CVPbkImportToContactsMergeOperation::VPbkSingleContactOperationFailed(

                MVPbkContactOperationBase& /*aOperation*/, 

                TInt aError )

    {

    delete iVPbkOperation;

    iVPbkOperation = NULL;

    HandleError( aError );

    }

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

// CVPbkImportToContactsMergeOperation::ContactOperationCompleted

// from class MVPbkContactObserver

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

//

void CVPbkImportToContactsMergeOperation::ContactOperationCompleted(

        TContactOpResult aResult)

    {

    delete aResult.iStoreContact;

    switch( iState )

        {

        case ELock:

            {

            NextState( EUpdateContact );

            break;

            }

        case ECommit:

            {

            NextState( EReRetrieve );

            break;

            }

        default:

            __ASSERT_DEBUG( EFalse, Panic(EPanicInvalidState) );

        }

    }

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

// CVPbkImportToContactsMergeOperation::ContactOperationFailed

// from class MVPbkContactObserver

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

//

void CVPbkImportToContactsMergeOperation::ContactOperationFailed(

        TContactOp    /*aOpCode*/, TInt aErrorCode, TBool /*aErrorNotified*/)

    {

    HandleError( aErrorCode );

    }

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

// CVPbkImportToContactsMergeOperation::HandleError

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

//

void CVPbkImportToContactsMergeOperation::HandleError(TInt aError)

    {

    iObserver.VPbkSingleContactOperationFailed( *this, aError );

    }

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

// CVPbkImportToContactsMergeOperation::RetrieveContactL

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

//

inline void CVPbkImportToContactsMergeOperation::RetrieveContactL()

    {

    iVPbkOperation = iData.GetContactManager().RetrieveContactL(iReplaceContact,*this );

    }

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

// CVPbkImportToContactsMergeOperation::ReRetrieveContactL

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

//

inline void CVPbkImportToContactsMergeOperation::ReRetrieveContactL()

    {

    __ASSERT_DEBUG( iContact, Panic(EPanicInvalidToRetrieve) );

    MVPbkContactLink* link = iContact->CreateLinkLC(); 

    iVPbkOperation = iData.GetContactManager().RetrieveContactL( *link, *this );

    CleanupStack::PopAndDestroy();

    }

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

// CVPbkImportToContactsMergeOperation::LockContactL

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

//

inline void CVPbkImportToContactsMergeOperation::LockContactL()

    {

    __ASSERT_DEBUG( iContact, Panic(EPanicInvalidToLock) );

    iContact->LockL( *this );

    }

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

// CVPbkImportToContactsMergeOperation::CommitContactL

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

//

inline void CVPbkImportToContactsMergeOperation::CommitContactL()

    {

    __ASSERT_DEBUG( iContact, Panic(EPanicInvalidToCommit) );

    iContact->CommitL( *this );

    }

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

// CVPbkImportToContactsMergeOperation::UpdateContactL

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

//

inline void CVPbkImportToContactsMergeOperation::UpdateContactL()

    {

    __ASSERT_DEBUG( iContact, Panic(EPanicInvalidToUpdate) );

    __ASSERT_DEBUG( iImportedContacts.Count()>0, Panic(EPanicInvalidToUpdate) );

    __ASSERT_DEBUG( iImportedContacts[0], Panic(EPanicInvalidToUpdate) );

    iContact->RemoveAllFields();

    iCurrentFieldIndex = 0;

    iFieldCount = iImportedContacts[0]->Fields().FieldCount();

    ReplaceFieldL( *(iImportedContacts[0]), *iContact );

    }

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

// From class MVPbkImportOperationObserver

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

//

void CVPbkImportToContactsMergeOperation::ReplaceFieldL(

        const MVPbkStoreContact& aSrc,

        MVPbkStoreContact& aTarget )

    {

    if( iCurrentFieldIndex < iFieldCount )

        {

        const MVPbkStoreContactFieldCollection& sourceFields = aSrc.Fields();

        const MVPbkFieldType* type = sourceFields.FieldAt(iCurrentFieldIndex).BestMatchingFieldType();

        if ( type )

            {

            TRAPD( err,

                CopyFieldL( sourceFields.FieldAt(iCurrentFieldIndex), *type, aTarget );