/*

* Copyright (c) 2002-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:  Virtual phonebook view implementation

*

*/

#include "CContactView.h"

// VPbkSimStore

#include "CFieldTypeMappings.h"

#include "CContactStore.h"

#include "CViewContact.h"

#include "CRemoteStore.h"

#include "CRemoteView.h"

#include "CContactLink.h"

#include "VPbkSimStoreError.h"

#include "CSupportedFieldTypes.h"

#include "CFindView.h"

#include "RemoteViewPreferences.h"

#include "CSortOrderAcquirerList.h"

// VPbkEngUtils

#include <CVPbkAsyncOperation.h>

#include <CVPbkAsyncCallback.h>

// VPbkEng

#include <CVPbkSortOrder.h>

#include <CVPbkContactViewDefinition.h>

#include <CVPbkFieldTypeSelector.h>

#include <CVPbkFieldTypeRefsList.h>

#include <MVPbkContactViewObserver.h>

#include <MVPbkFieldType.h>

#include <MVPbkContactStoreProperties.h>

#include <VPbkSendEventUtility.h>

#include <VPbkError.h>

// VPbkSimStoreImpl

#include <CVPbkSimFieldTypeFilter.h>

#include <CVPbkSimContactView.h>

#include <RVPbkStreamedIntArray.h>

#include <MVPbkSimContact.h>

namespace VPbkSimStore {

// ============================= LOCAL FUNCTIONS ===============================

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

// ConvertSortOrderL

// Converts VPbk sort order to native sort order

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

//

void ConvertSortOrderL( const MVPbkFieldTypeList& aSource, 

    RVPbkSimFieldTypeArray& aTarget, CFieldTypeMappings& aMappings )

    {

    TInt typeCount = aSource.FieldTypeCount();

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

        {

        const MVPbkFieldType& vpbkType = aSource.FieldTypeAt( i );

        TVPbkSimCntFieldType simType = 

            aMappings.Match( vpbkType );

        if ( simType != EVPbkSimUnknownType )

            {

            aTarget.AppendL( simType );

            }

        }

    __ASSERT_DEBUG( aTarget.Count() > 0, 

        VPbkSimStore::Panic( VPbkSimStore::EZeroSortOrder ) );

    }

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

// ConvertSortOrderL

// Converts VPbk sort order to native sort order

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

//

void ConvertSortOrderL( const RVPbkSimFieldTypeArray& aSource, 

        CVPbkFieldTypeRefsList& aTarget, CFieldTypeMappings& aMappings )

    {

    TInt typeCount = aSource.Count();

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

        {

        const MVPbkFieldType* vpbkType = aMappings.Match( aSource[i] );

        if ( vpbkType )

            {

            aTarget.AppendL( *vpbkType );

            }

        }

    __ASSERT_DEBUG( aTarget.FieldTypeCount() > 0, 

        VPbkSimStore::Panic( VPbkSimStore::EZeroSortOrder ) );

    }

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

// ConvertFieldTypeFilter

// Converts VPbk field type filter to native filter

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

//

void ConvertFieldTypeFilter( CVPbkFieldTypeSelector& aSource,

        CVPbkSimFieldTypeFilter& aTarget,

        const MVPbkFieldTypeList& aFieldTypeList,

        CFieldTypeMappings& aMappings )

    {

    TInt typeCount = aFieldTypeList.FieldTypeCount();

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

        {

        const MVPbkFieldType& fieldType =

            aFieldTypeList.FieldTypeAt( i );

        if ( aSource.IsFieldTypeIncluded( fieldType ) )

            {

            // Match was found, now find out the which

            // SIM field type maps to the match

            TVPbkSimCntFieldType simType = EVPbkSimUnknownType;

            const TVPbkFieldVersitProperty* versitProperty =

                aSource.MatchingVersitProperty( fieldType );

            if ( versitProperty )

                {

                simType = aMappings.Match( *versitProperty );

                }

            else

                {

                TVPbkNonVersitFieldType nonVersitType =

                    aSource.MatchingNonVersitType( fieldType );

                if ( nonVersitType != EVPbkNonVersitTypeNone )

                    {

                    simType = aMappings.Match( nonVersitType );

                    }

                }

            // Construct a filter based on the SIM field type

            TUint16 filteringFlag =

                aTarget.FilteringFlagForSimFieldType( simType );

            aTarget.AppendFilteringFlag( filteringFlag );

            // Add also additional number to the filtering

            // if main number is included

            if ( filteringFlag &

                CVPbkSimFieldTypeFilter::ESimFilterCriteriaGsmNumber )

                {

                aTarget.AppendFilteringFlag(

                    CVPbkSimFieldTypeFilter::ESimFilterCriteriaAdditionalNumber );

                }            

            }

        }

    }

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

// ConvertSortPolicy

// Convert between EVPbkSortedSimView and EVPbkUnsortedContactView

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

//

TVPbkSimViewConstructionPolicy ConvertSortPolicy( 

        TVPbkContactViewSortPolicy aVPbkSortPolicy )

    {

    TVPbkSimViewConstructionPolicy sortPolicy = EVPbkSortedSimView;

    if ( aVPbkSortPolicy == EVPbkUnsortedContactView )

        {

        sortPolicy = EVPbkUnsortedSimView;

        }

    return sortPolicy;

    }

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

// FindFieldTypeIndex

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

//    

TInt FindFieldTypeIndex( const MVPbkFieldTypeList& aTypeList, 

        const MVPbkFieldType& aType )

    {

    TInt result = KErrNotFound;

    const TInt count = aTypeList.FieldTypeCount();

    for ( TInt i = 0; i < count && result == KErrNotFound; ++i )

        {

        if ( aTypeList.FieldTypeAt(i).IsSame( aType ) )

            {

            result = i;

            }

        }

    return result;

    }

// ============================ MEMBER FUNCTIONS ============================

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

// CContactView::CContactView

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

inline CContactView::CContactView(CContactStore& aParentStore) :

    iParentStore(aParentStore),

    iViewState( ENotReady )

    {

    }

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

// CContactView::~CContactView

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

//

CContactView::~CContactView()

    {

    delete iViewDefinition;

    delete iObserverOp;

    delete iFilterObsOp;

    delete iCurrentContact;

    delete iSortOrder;

    if ( iNativeView )

        {

        iNativeView->Close( *this );

        delete iNativeView;

        }

    iObservers.Close();

    iFilteringObservers.Close();

    }

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

// CContactView::NewLC

// Two-phased constructor.

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

//

CContactView* CContactView::NewLC(MVPbkContactViewObserver& aObserver,

    CContactStore& aParentStore,

    const MVPbkFieldTypeList& aSortOrder,

    const CVPbkContactViewDefinition& aViewDefinition)

    {

    CContactView* self = new(ELeave) CContactView(aParentStore);

    CleanupStack::PushL(self);

    self->ConstructL(aSortOrder, aViewDefinition);

    self->AddObserverL(aObserver);

    return self;

    }

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

// CContactView::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CContactView::ConstructL( const MVPbkFieldTypeList& aSortOrder,

    const CVPbkContactViewDefinition& aViewDefinition )

    {

    // Copy the sort order

    iSortOrder = CVPbkSortOrder::NewL( aSortOrder );

    // Create current view contact

    iCurrentContact = CViewContact::NewL( *this, *iSortOrder );

    iViewDefinition = CVPbkContactViewDefinition::NewL( aViewDefinition );

    // Convert VPbk sort order to sim sort order

    RVPbkSimFieldTypeArray sortOrder;

    CleanupClosePushL( sortOrder );

    ConvertSortOrderL( aSortOrder, sortOrder, 

        iParentStore.FieldTypeMappings() );

    CVPbkSimFieldTypeFilter* filter = new ( ELeave ) CVPbkSimFieldTypeFilter;

    CVPbkFieldTypeSelector* selector = iViewDefinition->FieldTypeFilter();

    if ( selector )

	    {

        // First construct filter for supported SIM fields

        ConvertFieldTypeFilter( *selector, *filter,

	        iParentStore.MasterFieldTypeList(),

                iParentStore.FieldTypeMappings() );

	    }

    // Sorted or SIM index ordered view.

    TVPbkSimViewConstructionPolicy sortPolicy = ConvertSortPolicy( 

            iViewDefinition->SortPolicy() );

    if ( RemoteViewDefinition( *iViewDefinition ) )

        {

        // Create a remote view from remote store

        iNativeView = iParentStore.NativeStore().CreateViewL( sortOrder,

            sortPolicy, RemoteViewName( *iViewDefinition ), filter );

        }

    else

        {

        // Create a local view

         CVPbkSimContactView* view = CVPbkSimContactView::NewLC( sortOrder,

            sortPolicy, iParentStore.NativeStore(), 

            RemoteViewName( *iViewDefinition ), filter );

        CleanupStack::Pop( view );

        iNativeView = view;

        }  

    iNativeView->OpenL( *this );

    CleanupStack::PopAndDestroy(); // sortOrder

    iObserverOp = 

        CVPbkAsyncObjectOperation<MVPbkContactViewObserver>::NewL();

    iFilterObsOp = 

        CVPbkAsyncObjectOperation<MFilteredViewSupportObserver>::NewL();

    }

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

// CContactView::ParentObject

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

//

MVPbkObjectHierarchy& CContactView::ParentObject() const

    {

    return iParentStore;

    }

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

// CContactView::Type

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

//

TVPbkContactViewType CContactView::Type() const

    {

    return EVPbkContactsView;

    }

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

// CContactView::ChangeSortOrderL

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

//

void CContactView::ChangeSortOrderL( const MVPbkFieldTypeList& aSortOrder )

    {

    // Check that S60 shared view sort order is not changed illegally.

    LeaveIfIncorrectSortOrderL( aSortOrder );

    // Create a new sort order

    CVPbkSortOrder* sortOrder = CVPbkSortOrder::NewL( aSortOrder );

    CleanupStack::PushL( sortOrder );

    // Change remote view sort order

    RVPbkSimFieldTypeArray nativeOrder;

    CleanupClosePushL( nativeOrder );

    ConvertSortOrderL( *sortOrder, nativeOrder, 

        iParentStore.FieldTypeMappings() );

    iNativeView->ChangeSortOrderL( nativeOrder );

    CleanupStack::PopAndDestroy( &nativeOrder );

    // Swap

    delete iSortOrder;

    iSortOrder = sortOrder;

    CleanupStack::Pop( sortOrder );

    }

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

// CContactView::SortOrder

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

//

const MVPbkFieldTypeList& CContactView::SortOrder() const

    {

    return *iSortOrder;

    }

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

// CContactView::RefreshL

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

//

void CContactView::RefreshL()

    {

    // Rebuild view

    RVPbkSimFieldTypeArray sortOrder;

    CleanupClosePushL( sortOrder );

    ConvertSortOrderL( *iSortOrder, sortOrder, 

        iParentStore.FieldTypeMappings() );

    iNativeView->ChangeSortOrderL( sortOrder );

    CleanupStack::PopAndDestroy(); // sortOrder

    }

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

// CContactView::ContactCountL

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

//

TInt CContactView::ContactCountL() const

    {

    TInt res = 0;

    if ( State() == EReady )

        {

        res = iNativeView->CountL();    

        }

    return res;

    }

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

// CContactView::ContactAtL

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

//

const MVPbkViewContact& CContactView::ContactAtL( TInt aIndex ) const

    {

    __ASSERT_ALWAYS( aIndex >= KErrNotFound, 

        VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    if( aIndex == KErrNotFound)

	    {

		User::Leave( KErrNotFound );	

        }

    else if ( aIndex >= iNativeView->CountL() )

        {

        User::Leave( KErrArgument );

        }

    iCurrentContact->SetSimContactL( iNativeView->ContactAtL( aIndex ) );

    return *iCurrentContact; 

    }

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

// CContactView::CreateLinkLC

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

//

MVPbkContactLink* CContactView::CreateLinkLC( TInt aIndex ) const

    {

    __ASSERT_ALWAYS( aIndex >= 0, 

        VPbkError::Panic(VPbkError::EInvalidContactIndex) );

    if ( aIndex >= iNativeView->CountL() )

        {

        User::Leave( KErrArgument );

        }

    TInt simIndex = MapViewIndexToSimIndexL( aIndex );

    return CContactLink::NewLC( iParentStore, simIndex );

    }

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

// CContactView::IndexOfLinkL

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

//

TInt CContactView::IndexOfLinkL( const MVPbkContactLink& aContactLink ) const

    {

    if ( &aContactLink.ContactStore() == &iParentStore )

        {

        TInt simIndex = 

            static_cast<const CContactLink&>( aContactLink ).SimIndex();

        return iNativeView->MapSimIndexToViewIndexL( simIndex );

        }

    return KErrNotFound;

    }

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

// CContactView::AddObserverL

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

//

void CContactView::AddObserverL( MVPbkContactViewObserver& aObserver )

    {

    CVPbkAsyncObjectCallback<MVPbkContactViewObserver>* callback =

        VPbkEngUtils::CreateAsyncObjectCallbackLC(

            *this, 

            &CContactView::DoAddObserverL, 

            &CContactView::AddObserverError, 

            aObserver);

    iObserverOp->CallbackL( callback );

    CleanupStack::Pop( callback );

    /// Insert to first position because event are send in reverse order.

    /// Last inserted gets notifcation last.

    if ( iObservers.Find( &aObserver ) == KErrNotFound )

        {

        iObservers.InsertL( &aObserver, 0 );

        }

    }

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

// CContactView::RemoveObserver

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

//

void CContactView::RemoveObserver( MVPbkContactViewObserver& aObserver )

    {

    iObserverOp->CancelCallback( &aObserver );

    TInt pos = iObservers.Find( &aObserver );

    if ( pos != KErrNotFound )

        {

        iObservers.Remove( pos );

        }

    }

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

// CContactView::MatchContactStore

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

//

TBool CContactView::MatchContactStore(const TDesC& aContactStoreUri) const

    {

    return iParentStore.MatchContactStore(aContactStoreUri);

    }

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

// CContactView::MatchContactStoreDomain

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

//

TBool CContactView::MatchContactStoreDomain(

        const TDesC& aContactStoreDomain) const

    {

    return iParentStore.MatchContactStoreDomain(aContactStoreDomain);

    }

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

// CContactView::CreateBookmarkLC

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

//

MVPbkContactBookmark* CContactView::CreateBookmarkLC(TInt aIndex) const

    {

    __ASSERT_ALWAYS( aIndex >= 0, 

        VPbkError::Panic( VPbkError::EInvalidContactIndex ) );

    TInt simIndex = MapViewIndexToSimIndexL( aIndex );

    // This store implements bookmark as a link

    return CContactLink::NewLC( iParentStore, simIndex );

    }

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

// CContactView::IndexOfBookmarkL

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

//

TInt CContactView::IndexOfBookmarkL(

        const MVPbkContactBookmark& aContactBookmark) const

    {

    // Bookmark is implemented as a link in this store

    const CContactLink* link = 

        dynamic_cast<const CContactLink*>( &aContactBookmark );

    if ( link && ( &link->ContactStore() == &iParentStore ) )

        {

        return iNativeView->MapSimIndexToViewIndexL( link->SimIndex() );