/*

* Copyright (c) 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:  Contact matching class

*

*/

// System includes

#include <e32base.h>

#include <bamdesca.h>

#include <cntitem.h>

#include <eikenv.h>

#include <bautils.h>

#include <fbs.h>

#include <imageconversion.h>

#include <data_caging_path_literals.hrh>

#include <CVPbkContactManager.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStore.h>

#include <CVPbkContactStoreUriArray.h>

#include <MVPbkContactLinkArray.h>

#include <MVPbkContactLink.h>

#include <MVPbkFieldType.h>

#include <MVPbkStoreContact.h>

#include <MVPbkStoreContactField.h>

#include <MVPbkStoreContactFieldCollection.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldUriData.h>

#include <MVPbkContactFieldDateTimeData.h>

#include <MVPbkContactFieldBinaryData.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactStoreProperties.h>

#include <TVPbkContactStoreUriPtr.h>

#include <VPbkContactStoreUris.h>

#include <MPbk2ContactNameFormatter.h>

#include <CVPbkFieldTypeSelector.h>

#include <TVPbkFieldVersitProperty.h>

#include <CVPbkFieldTypeRefsList.h>

#include <TVPbkWordParserCallbackParam.h>

#include <CVPbkContactViewDefinition.h>

#include <MVPbkContactViewBase.h>

#include <coemain.h>

#include <CPbk2SortOrderManager.h>

#include <Pbk2ContactNameFormatterFactory.h>

#include "hgctxcontactmatcher.h"

#include "hgctxutilslogging.h"

// ================= Static Constant Data ===================

typedef const TDesC& (*UriFuncPtr)();

// Number match store URIs in priority order.

// When doing number matching, order of the stores in the uri array will

// determine which stores are searched first (sequential match). We stop

// the search when first match is found.

static const UriFuncPtr NumberMatchStoreUris[] =

    {

    VPbkContactStoreUris::DefaultCntDbUri,

    // If we don't manage to open some store, we remove it from our array

    VPbkContactStoreUris::SimGlobalAdnUri,

    VPbkContactStoreUris::SimGlobalSdnUri,

    NULL,   // end marker

    };

// All store URIs except own number store

static const UriFuncPtr AllStoreUris[] =

    {

    VPbkContactStoreUris::DefaultCntDbUri,

    // If we don't manage to open some store, we remove it from our array

    VPbkContactStoreUris::SimGlobalAdnUri,

    VPbkContactStoreUris::SimGlobalSdnUri,

    VPbkContactStoreUris::SimGlobalFdnUri,

    NULL,   // end marker

    };

// Own number store URIs

static const UriFuncPtr OwnNumberStoreUris[] =

    {

    VPbkContactStoreUris::SimGlobalOwnNumberUri,

    NULL,   // end marker

    };

// number of digits that must match from the right side of a phone number

const TInt KNumberMatchLenFromRight = 7;

// granularity for CDesCArray

const TInt KArrayGranularity = 4;

//               YYYYMMDD:HHMMSS.MMMMMM

_LIT(KNullTime, "11110000:010101.00000");

// ================= STATIC FUNCTIONS =======================

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

// FindWordSplitterL

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

//

static TInt FindWordSplitterL( TAny* aParams )

	{

	TVPbkWordParserCallbackParam* parser = 

        static_cast<TVPbkWordParserCallbackParam*>( aParams );

    const TText* ptr = parser->iStringToParse->Ptr();

	const TText* end = ptr + parser->iStringToParse->Length();

	const TText* startOfWord=NULL;

	for ( ; ; )

		{

		if ( ptr==end || TChar(*ptr).IsSpace() || *ptr == ',' || *ptr == ';' )

			{

			if ( startOfWord )

				{

				TPtrC addWord( startOfWord,ptr - startOfWord );

				parser->iWordArray->AppendL( addWord );

				startOfWord = NULL;

				}

			if ( ptr == end )

                {

				break;

                }

			}

		else if ( !startOfWord )

            {

			startOfWord = ptr;

            }

		ptr++;

		}

	return( KErrNone );

	}

static HBufC* CombineStringsLC( CDesCArray& aArray )

    {

    TInt len = 0;

    for ( TInt i = 0, ie = aArray.Count(); i != ie; ++i )

        {

        len += aArray[i].Length() + 1;

        }

    HBufC* result = HBufC::NewLC( len );

    TPtr p( result->Des() );

    for ( TInt i = 0, ie = aArray.Count(); i != ie; ++i )

        {

        if ( i )

            {

            p.Append( ' ' );

            }

        p.Append( aArray[i] );

        }

    return result;

    }

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

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

// Two-phase constructor for CHgCtxContactMatcher class.

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

EXPORT_C CHgCtxContactMatcher* CHgCtxContactMatcher::NewL(

    RFs* aFsSession )

    {

    CHgCtxContactMatcher* self = CHgCtxContactMatcher::NewLC( aFsSession );

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phase constructor for CHgCtxContactMatcher class.

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

EXPORT_C CHgCtxContactMatcher* CHgCtxContactMatcher::NewLC(

    RFs* aFsSession )

    {

    CHgCtxContactMatcher* self = new ( ELeave ) CHgCtxContactMatcher( aFsSession );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// C++ destructor.

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

EXPORT_C CHgCtxContactMatcher::~CHgCtxContactMatcher()

    {

    delete iNameFieldTypes;

    delete iNumberFieldTypes;

    delete iEmailFieldTypes;

    delete iXspIdFieldTypes;

    delete iAddressFieldTypes;

	delete iWebAddressFieldTypes;

    delete iHomeAddressFieldTypes;

    delete iWorkAddressFieldTypes;

    FreeOldOperation();

    CleanupNumberMatch();

    delete iStoreUris;

    delete iContactManager;

    delete iSortOrderManager;

    delete iNameFormatter;

    if ( iClientStatus )

        {

        User::RequestComplete( iClientStatus, KErrCancel );

        }

    if ( iASchedulerWait.IsStarted() )

        {

        iASchedulerWait.AsyncStop();

        }

    iContactObservers.Close();

    if ( iFsSessionOwned && iFsSession )

        {

        iFsSession->Close();

        delete iFsSession;

        }

    }

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

// C++ Constructor.

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

CHgCtxContactMatcher::CHgCtxContactMatcher( RFs* aFsSession) : iFsSession( aFsSession )

    {

    }

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

// Second phase constructor

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

void CHgCtxContactMatcher::ConstructL()

    {

    if ( !iFsSession )

        {

        // The contact manager would be okay with NULL but some of our own functions

        // need an RFs.

        iFsSessionOwned = ETrue;

        iFsSession = new ( ELeave ) RFs;

        User::LeaveIfError( iFsSession->Connect() );

        }

    iContactManager = CVPbkContactManager::NewL(

        *CVPbkContactStoreUriArray::NewLC(), iFsSession );

    CleanupStack::PopAndDestroy(); // CVPbkContactStoreUriArray

    // No stores open yet

    iStoreUris = CVPbkContactStoreUriArray::NewL();

    }

//******************* API-methods *********************************************

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

// Synchronous version

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

EXPORT_C void CHgCtxContactMatcher::OpenStoreL(

    const CVPbkContactStoreUriArray& aUriArray )

    {

    InitOperationL( EOpenStore );

    OpenStoreCommonL( aUriArray );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        // Wait until stores are open

        iASchedulerWait.Start();

        }

    User::LeaveIfError( iError );

    }

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

// Asynchronous version

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

EXPORT_C void CHgCtxContactMatcher::OpenStoreL(

    const CVPbkContactStoreUriArray& aUriArray, TRequestStatus&  aStatus )

    {

    InitOperationL( EOpenStore );

    OpenStoreCommonL( aUriArray );

    InitOperation( &aStatus );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        }

    }

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

// Common code to sync/async versions.

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

void CHgCtxContactMatcher::OpenStoreCommonL(

    const CVPbkContactStoreUriArray& aUriArray )

    {

    if (iStoreUris->Count())

        {

        // Opening more stores when some stores are already open is not

        // supported. Support would require managing iStoreUris properly

        // so that it contains all open stores.

        User::Leave(KErrGeneral);

        }

    const TInt count = aUriArray.Count();

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

        {

        // Appended Uri:s to the array. If store fails to open it is removed

        // from the array. This keeps Uri's in priority order in the array.

        TVPbkContactStoreUriPtr uriPtr = aUriArray[i];

        iStoreUris->AppendL( uriPtr );

        iContactManager->LoadContactStoreL( uriPtr );

        }

    MVPbkContactStoreList& storeList = iContactManager->ContactStoresL();

    storeList.OpenAllL( *this );

    }

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

// Synchronous version

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

EXPORT_C void CHgCtxContactMatcher::OpenAllStoresL()

    {

    OpenStoreL(AllStoreUris);

    }

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

// Asynchronous version

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

EXPORT_C void CHgCtxContactMatcher::OpenAllStoresL( TRequestStatus& aStatus )

    {

    OpenStoreL(AllStoreUris, aStatus);

    }

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

// Synchronous version

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

EXPORT_C void CHgCtxContactMatcher::OpenDefaultMatchStoresL()

    {

    OpenStoreL(NumberMatchStoreUris);

    }

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

// Asynchronous version

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

EXPORT_C void CHgCtxContactMatcher::OpenDefaultMatchStoresL( TRequestStatus& aStatus )

    {

    OpenStoreL(NumberMatchStoreUris, aStatus);

    }

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

// Open OwnNumber stores.

// Synchronous version

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

EXPORT_C void CHgCtxContactMatcher::OpenOwnNumberStoresL()

    {

    OpenStoreL(OwnNumberStoreUris);

    }

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

// Open OwnNumber stores.

// Asynchronous version

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

EXPORT_C void CHgCtxContactMatcher::OpenOwnNumberStoresL( TRequestStatus& aStatus )

    {

    OpenStoreL(OwnNumberStoreUris, aStatus);

    }

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

// Close all open stores.

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

EXPORT_C void CHgCtxContactMatcher::CloseStoresL()

    {

    // Closing stores does not work. MatchDataL() finds contacts from

    // closed stores.

    InitOperationL( ECloseStores );

    iApiMethodStatus = EExecuting;

    TRAPD( err, iContactManager->ContactStoresL().CloseAll( *this ) );

    iApiMethodStatus = EFinished;

    if ( err == KErrNone)

        {

        delete iStoreUris; iStoreUris = NULL;

        iStoreUris = CVPbkContactStoreUriArray::NewL();        

        }

    else

        {

        User::Leave(err);

        }

    }

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

// Synchronous version

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

EXPORT_C void CHgCtxContactMatcher::MatchPhoneNumberL(

    const TDesC& aData, TInt aDigits,

    CVPbkPhoneNumberMatchStrategy::TVPbkPhoneNumberMatchFlags aFlags,

    CVPbkContactLinkArray& aLinkArray )

    {

    InitOperationL( EMatchPhoneNumber );

    iResultContactLinkArray = &aLinkArray;

    // Start asynchronous matching and wait until results are ready

    MatchPhoneNumberCommonL( aData, aDigits, aFlags );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        iASchedulerWait.Start();

        }

    User::LeaveIfError( iError );

    }

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

// Asynchronous version

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

EXPORT_C void CHgCtxContactMatcher::MatchPhoneNumberL(

    const TDesC& aData, TInt aDigits,

    CVPbkPhoneNumberMatchStrategy::TVPbkPhoneNumberMatchFlags aFlags,

    CVPbkContactLinkArray& aLinkArray, TRequestStatus& aStatus )

    {

    InitOperationL( EMatchPhoneNumber );

    iResultContactLinkArray = &aLinkArray;

    // Start asynchronous matching

    MatchPhoneNumberCommonL( aData, aDigits, aFlags );

    InitOperation( &aStatus );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        }

    }

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

// Common code for sync and async versions

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

void CHgCtxContactMatcher::MatchPhoneNumberCommonL(

    const TDesC& aData, TInt aDigits,

    CVPbkPhoneNumberMatchStrategy::TVPbkPhoneNumberMatchFlags aFlags )

    {

    // Delete resources allocated for previous match

    CleanupNumberMatch();

    // iStoreUris is filled when stores are opened

    iStratConfig = new (ELeave) CVPbkPhoneNumberMatchStrategy::TConfig(

        aDigits,

        *iStoreUris,

        CVPbkPhoneNumberMatchStrategy::EVPbkSequentialMatch,

        aFlags);

    iMatchStrategy = CVPbkPhoneNumberMatchStrategy::NewL(

                *iStratConfig,

                *iContactManager,

                *this);

    // Start asynchronous matching

    iMatchStrategy->MatchL( aData );

    }

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

// Find from a store succeeded

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

void CHgCtxContactMatcher::FindFromStoreSucceededL( MVPbkContactStore& /*aStore*/,

        MVPbkContactLinkArray* aResultsFromStore )

    {

    __ASSERT_DEBUG( aResultsFromStore, HgContactMatcherPanics::Panic(

        HgContactMatcherPanics::EPanNullPointer ));

    // Take the ownership of the result immediately

    CleanupDeletePushL( aResultsFromStore );

    CopyFindResultsL( aResultsFromStore );

    CleanupStack::PopAndDestroy(); // aResultsFromStore

    }

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

// Copy the found results for a store into array

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

void CHgCtxContactMatcher::CopyFindResultsL( MVPbkContactLinkArray*

    aResults )

    {

    const TInt count = aResults->Count();

    if ( iResultContactLinkArray )

        {

        // Copy links to the member array

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

            {

            iResultContactLinkArray->AppendL( aResults->At( i ).CloneLC() );

            CleanupStack::Pop(); // cloned link

            }

        }

    else

        {

        iResultContactLinkCnt += count;

        }

    }

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

// Find failed

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

void CHgCtxContactMatcher::FindFromStoreFailed( MVPbkContactStore& /*aStore*/, TInt /*aError*/ )

    {

    //no operation, search to continue from the other stores

    }

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

// Find complete

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

void CHgCtxContactMatcher::FindFromStoresOperationComplete()

    {

    if (!iResultContactLinkArray)

        {

        // Links were not copied. Result is whether any links found or not.

        OperationComplete( iResultContactLinkCnt ? KErrNone:KErrNotFound );

        }

    else

        {

        OperationComplete();

        iResultContactLinkArray = NULL;