/*

* 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:  Top Contact opeartion

*

*/

// INCLUDES

#include "CVPbkTopContactOperation.h"

#include <barsc.h>

#include <barsread.h>

#include <MVPbkContactViewBase.h>

#include <VPbkStoreUriLiterals.h>

#include <CVPbkContactViewDefinition.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactLink.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactStoreList.h>

#include <CVPbkContactStoreUriArray.h>

#include <TVPbkFieldTypeMapping.h>

#include <MVPbkContactFieldTextData.h>

#include <CVPbkFieldTypeSelector.h>

#include <MVPbkFieldType.h>

#include <CVPbkContactManager.h>

#include <MVPbkContactStore.h>

#include <VPbkContactViewFilterBuilder.h>

#include <CVPbkSortOrder.h>

#include <VPbkDataCaging.hrh>

#include <RLocalizedResourceFile.h>

#include <TVPbkFieldVersitProperty.h>

#include "CVPbkContactEasyManager.h"

#include "VPbkDebug.h"

#include <CVPbkSortOrderAcquirer.h>

#include <CVPbkEComImplementationsList.h>

#include <VPbkSortOrderAcquirerUid.h>

namespace

	{

	const TInt KFirstTopOrderIndex = 1;

    const TInt KTcFieldLength = 10;

    _LIT( KAllContactsSortOrderDisplayName, "AllContacts" );

    /**

     * Custom cleanup function.

     *

     * @param aObj  Object to clean.

     */

    void CleanupResetAndDestroy( TAny* aObj )

        {

        if ( aObj )

            {

            static_cast<RImplInfoPtrArray*>( aObj )->ResetAndDestroy();

            }

        }    

#ifdef _DEBUG	

	enum TTopErrors

	    {

		ETopErrorWrongLogic1,

		ETopErrorWrongLogic2,

		ETopErrorWrongLogic3,

		EInvalidViewOperation,

		EInvalidLinksOperation,

		EInvalidTopOperation,

		ETopErrorAlreadyHaveAStore,

		ETopErrorAlreadyHaveAView,

		ETopErrorNoView,

		ETopErrorNoFieldData,

		ETopErrorNoLinks,

		ETopViewMissing,

		ETopErrorBadIndex,

		ETopErrorOldArrayExists,

		ETopErrorNoContacts,

        ETopErrorWrongState,

        ETopErrorWrongStateRun,

	    };

	_LIT( KPanicStrTopManagement, "VPbk_topManag");

	void Panic(TTopErrors aReason)

	    {

	    User::Panic(KPanicStrTopManagement,aReason);

	    }

#endif	

	}

///////////////////////////////////////////////////////////////////////////////

CVPbkTopContactOperation* CVPbkTopContactOperation::NewLC(

        CVPbkContactManager& aContactManager,

        MVPbkOperationErrorObserver& aErrorObserver,

        TTopOperation aOperation)

    {

    CVPbkTopContactOperation* self = new (ELeave) CVPbkTopContactOperation(

            aContactManager,

            aErrorObserver,

            aOperation );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

void CVPbkTopContactOperation::ConstructL()

    {

    iContactEasyManager = CVPbkContactEasyManager::NewL( iContactManager );

    }

CVPbkTopContactOperation::CVPbkTopContactOperation(

        CVPbkContactManager& aContactManager,

        MVPbkOperationErrorObserver& aErrorObserver,

        TTopOperation aOperation )

    : CActive( EPriorityStandard ),

    iCurrentOperation(aOperation),

    iNextState(EStateOpenStore),

    iContactManager(aContactManager),

    iErrorObserver(&aErrorObserver)

    {

    CActiveScheduler::Add( this );

    CompleteOurself(); //start execution right away

    }

CVPbkTopContactOperation::~CVPbkTopContactOperation()

    {

    Cancel();

    delete iContactOperation;

    delete iContactEasyManager;

    iContacts.ResetAndDestroy();

    delete iInputLinks;

    delete iView;

    if ( iContactStore )

        {

        // Store is not owned by us.

        iContactStore->Close( *this );

        }

    }

MVPbkContactOperationBase* CVPbkTopContactOperation::NewGetViewOperationL(

        CVPbkContactManager& aContactManager,

        MVPbkOperationResultObserver<MVPbkContactViewBase*>& aObserver,

        MVPbkOperationErrorObserver& aErrorObserver,

        TTopOperation aOperation )

    {

    __ASSERT_DEBUG( aOperation == EGetTopContacts || 

                    aOperation == EGetNonTopContacts,

                    Panic(EInvalidViewOperation) );

    CVPbkTopContactOperation* self = NewLC(

            aContactManager,

            aErrorObserver,

            aOperation );

    self->iViewObserver = &aObserver;

    CleanupStack::Pop(self);

    return self;

    }

MVPbkContactOperationBase* CVPbkTopContactOperation::NewGetViewLinksOperationL(

        CVPbkContactManager& aContactManager,

        MVPbkOperationResultObserver<MVPbkContactLinkArray*>& aObserver,

        MVPbkOperationErrorObserver& aErrorObserver,

        TTopOperation aOperation )

    {

    __ASSERT_DEBUG( aOperation == EGetTopContactLinks || 

                    aOperation == EGetNonTopContactLinks,

                    Panic(EInvalidLinksOperation) );

    CVPbkTopContactOperation* self = NewLC(

            aContactManager,

            aErrorObserver,

            aOperation );

    self->iLinksObserver = &aObserver;

    CleanupStack::Pop(self);

    return self;

    }

MVPbkContactOperationBase* CVPbkTopContactOperation::NewTopOperationL(

        CVPbkContactManager& aContactManager,

        const MVPbkContactLinkArray& aContactLinks,

        MVPbkOperationObserver& aObserver,

        MVPbkOperationErrorObserver& aErrorObserver,

        TTopOperation aOperation,

        MVPbkContactViewBase* aViewRef)

    {

    __ASSERT_DEBUG( aOperation == EAddToTop || aOperation == ERemoveFromTop ||

            aOperation == EReorderTop,

            Panic(EInvalidTopOperation) );

    CVPbkTopContactOperation* self = NewLC(

            aContactManager,

            aErrorObserver,

            aOperation );

    self->iObserver = &aObserver;

    self->iInputLinks = CloneArrayL( aContactLinks ); 

    self->iViewRef = aViewRef;

    CleanupStack::Pop(self);

    return self;

    }

void CVPbkTopContactOperation::DoCancel()

	{

	delete iContactOperation;

	iContactOperation = NULL;

	iContactEasyManager->Cancel();

	}

void CVPbkTopContactOperation::RunL()

	{

	if ( iNextState == EStateAbortWithError )

	    {

	    NotifyError( iAbortError );

	    }

	else

	    {

    	switch ( iCurrentOperation )

    	    {

    	    case EAddToTop:

    	    case ERemoveFromTop:

    	    case EReorderTop:

        		{

        		Top_RunL();

        		break;

        		}

    	    case EGetNonTopContacts:

    	    case EGetTopContacts:

    	    case EGetTopContactLinks:

    	    case EGetNonTopContactLinks:

                {

        		GetView_RunL();

        		break;

                }

    	    default:

    	        __ASSERT_DEBUG( EFalse,

    	                Panic( ETopErrorWrongStateRun ) );

            }

	    }

	}

TInt CVPbkTopContactOperation::RunError( TInt aError )

	{

	NotifyError( aError );

	return KErrNone;

	}

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

// These are from MVPbkContactViewObserver

void CVPbkTopContactOperation::ContactViewReady(

    MVPbkContactViewBase& aView )

    {

    aView.RemoveObserver(*this);  

	CompleteOurself();

    }

void CVPbkTopContactOperation::ContactViewUnavailable(

    MVPbkContactViewBase& aView )

    {

    aView.RemoveObserver(*this);

	AbortWithError( KErrGeneral );

    }

void CVPbkTopContactOperation::ContactAddedToView(

    MVPbkContactViewBase& /*aView*/, 

    TInt /*aIndex*/, 

    const MVPbkContactLink& /*aContactLink*/ )

    {

    }

void CVPbkTopContactOperation::ContactRemovedFromView(

    MVPbkContactViewBase& /*aView*/, 

    TInt /*aIndex*/, 

    const MVPbkContactLink& /*aContactLink*/ )

    {

    }

void CVPbkTopContactOperation::ContactViewError(

        MVPbkContactViewBase& /*aView*/, 

        TInt aError, 

        TBool /*aErrorNotified*/ )

    {

    AbortWithError( aError );

    }

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

// These are from MVPbkContactStoreObserver

void CVPbkTopContactOperation::StoreReady(MVPbkContactStore& /*aContactStore*/)

	{

	CompleteOurself();

	}

void CVPbkTopContactOperation::StoreUnavailable(

	MVPbkContactStore& /*aContactStore*/, TInt aReason)

	{

	AbortWithError( aReason );

	}

void CVPbkTopContactOperation::HandleStoreEventL(

    MVPbkContactStore& /*aContactStore*/, 

    TVPbkContactStoreEvent /*aStoreEvent*/)

	{

	}

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

// These are from MVPbkBatchOperationObserver

void CVPbkTopContactOperation::StepComplete( 

    MVPbkContactOperationBase& /*aOperation*/,

    TInt /*aStepSize*/ )

    {

    // Ignore.

    }

TBool CVPbkTopContactOperation::StepFailed(

    MVPbkContactOperationBase& /*aOperation*/,

    TInt /*aStepSize*/, TInt aError )

    {

    AbortWithError( aError );

    delete iContactOperation;

    iContactOperation = NULL;

    return EFalse; // do not continue

    }

void CVPbkTopContactOperation::OperationComplete( 

    MVPbkContactOperationBase& /*aOperation*/ )

    {

    // Committing of contacts has completed.

    delete iContactOperation;

    iContactOperation = NULL;

    iContacts.ResetAndDestroy();

    //can leave only when returning links 

    TRAP_IGNORE(NotifyResultL());

    }

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

// From MVPbkContactEasyManagerObserver

void CVPbkTopContactOperation::VPbkOperationCompleted(

        MVPbkContactOperationBase* /*aOperation*/)

    {

    // Retrieving and locking of contacts is now complete.

    CompleteOurself();

    // Continue processing in RunL()

    }

void CVPbkTopContactOperation::VPbkOperationFailed(

        MVPbkContactOperationBase* /*aOperation*/,

        TInt aError )

    {

    AbortWithError( aError );

    }

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

// Creates contact link array from a contact view.

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

MVPbkContactLinkArray* CVPbkTopContactOperation::ViewToLinkArrayL(

        const MVPbkContactViewBase& aView )

    {

    CVPbkContactLinkArray* links = CVPbkContactLinkArray::NewLC(); 

    TInt count = aView.ContactCountL();

    for ( TInt n = 0; n  < count; ++n )

        {

        MVPbkContactLink* link = aView.CreateLinkLC( n );

        links->AppendL( link );

        CleanupStack::Pop(); // link

        }

    CleanupStack::Pop( links );

    return links;

    }

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

// Loads and opens contact store

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

void CVPbkTopContactOperation::OpenStoreL( const TVPbkContactStoreUriPtr& aUri )

    {

    // First need to open the store.

    iContactManager.LoadContactStoreL( aUri );

    iContactStore = iContactManager.ContactStoresL().Find( aUri );

    // Asynchronous opening call.

    iContactStore->OpenL(*this);

    }

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

// Loads and opens default contact store

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

void CVPbkTopContactOperation::OpenDefaultStoreL()

    {

    TVPbkContactStoreUriPtr uri( KVPbkDefaultCntDbURI );

    OpenStoreL( uri );

	}

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

// Requests a top contact view. The completion is signalled to this

// object through MVPbkContactViewObserver. The observer callback will pass

// the event on in a certain way that is dependent on the current iState

// value.

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

void CVPbkTopContactOperation::RequestTopContactsViewL()

	{

	__ASSERT_DEBUG( !iView, Panic(ETopErrorAlreadyHaveAView) );

    CVPbkContactViewDefinition* viewDef = CVPbkContactViewDefinition::NewLC();

    viewDef->SetUriL( KVPbkDefaultCntDbURI );

    CVPbkFieldTypeSelector* filter = CVPbkFieldTypeSelector::NewL(

        iContactManager.FieldTypes());

    CleanupStack::PushL(filter);         

    VPbkContactViewFilterBuilder::BuildContactViewFilterL( *filter, 

        TVPbkContactViewFilter(EVPbkContactViewFilterTopContact), iContactManager );

    viewDef->SetFieldTypeFilterL( filter ); 

    CleanupStack::PopAndDestroy( filter );  

    CVPbkSortOrderAcquirer* soa = AllContactsSortOrderL();

    CleanupStack::PushL(soa);

    iView = iContactManager.CreateContactViewLC(

        *this, *viewDef, soa->SortOrder() );

    CleanupStack::Pop(); // iView

    CleanupStack::PopAndDestroy( soa );

    CleanupStack::PopAndDestroy( viewDef );

	}

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

// Requests a top contact view. The completion is signalled to this

// object through MVPbkContactViewObserver. The observer callback will pass

// the event on in a certain way that is dependent on the current iState

// value.

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

void CVPbkTopContactOperation::RequestNonTopContactsViewL()

	{

	__ASSERT_DEBUG( !iView, Panic(ETopErrorAlreadyHaveAView) );

    CVPbkContactViewDefinition* viewDef = CVPbkContactViewDefinition::NewLC();

    viewDef->SetUriL( KVPbkDefaultCntDbURI );

    CVPbkSortOrderAcquirer* soa = AllContactsSortOrderL();

    CleanupStack::PushL(soa);

    // Add the Non-Top Contacts selector           

    // No filter (i.e. with a field x) is used

    // but a contact selector

    viewDef->SetContactSelector(this);   // ownership not transferred     

    iView = iContactManager.CreateContactViewLC(

        *this, *viewDef, soa->SortOrder() );

    CleanupStack::Pop(); // iView

    CleanupStack::PopAndDestroy( soa );

    CleanupStack::PopAndDestroy( viewDef );

	}

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

// The RunL handler for top operations.

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

inline void CVPbkTopContactOperation::Top_RunL()

	{

	if ( iNextState == EStateOpenStore )

        {

        if ( iInputLinks->Count() > 0 )

            {

            // If the top view was not passed as a reference, we needed to construct

            // own instance for AddToTop operation to get next top index

            if ( iCurrentOperation == EAddToTop && !iViewRef )

                {

                iNextState = EStateCreateView;

                }

            else

                {

                iNextState = EStateRetrieveLock;

                }

            OpenStoreL( iInputLinks->At(0).ContactStore().StoreProperties().Uri() );

            }

        else

            {

            // Empty input array is ok do nothing

            // just signal completion right away

            iNextState = EStateNone;

            NotifyResultL();

            }

        }

	else if ( iNextState == EStateCreateView )

		{

		iNextState = EStateRetrieveLock;

		RequestTopContactsViewL();

		// When view is ready, we come back to this function.

		}

	else if ( iNextState == EStateRetrieveLock )

		{

        iNextState = EStateModifyCommit;

        iContactEasyManager->RetrieveAndLockContactsL(

            *iInputLinks, iContacts, *this, *this );

        // The contacts are placed into iContacts.

        // Completion is signalled to our callback, which

        // will complete ourself so we come back here to the next state.

		}

    else if ( iNextState == EStateModifyCommit )

        {

        DoTopOperationL();

        iNextState = EStateNone;

        iContactOperation = iContactManager.CommitContactsL(

            iContacts.Array(), *this );

        // Completion is signalled to our callback, where our observer is

        // called for informing that everything is done.

        }