/*

* Copyright (c) 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:  Supports initial search feature. 

*

*/

// INCLUDES

#include "CPcsAlgorithm1MultiSearchHelper.h"

#include "CPcsAlgorithm1Utils.h"

#include "CPcsDefs.h"

#include <collate.h>

#include <biditext.h>

#ifdef _DEBUG

_LIT( KPanicMultiSearchHelper, "CPcsAlgorithm1MultiSearchHelper" );

static void Panic( TInt aReason )

    {

    User::Panic( KPanicMultiSearchHelper, aReason );

    }

#endif

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

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

// CPcsAlgorithm1MultiSearchHelper::NewL

// Two Phase Construction

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

CPcsAlgorithm1MultiSearchHelper* CPcsAlgorithm1MultiSearchHelper::NewL(CPcsAlgorithm1* aAlgorithm)

{

    PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::NewL") );

	CPcsAlgorithm1MultiSearchHelper* self = new ( ELeave ) CPcsAlgorithm1MultiSearchHelper();

	CleanupStack::PushL( self );

	self->ConstructL(aAlgorithm);

	CleanupStack::Pop( self );

    PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::NewL") );

	return self;

}

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

// CPcsAlgorithm1MultiSearchHelper::CPcsAlgorithm1MultiSearchHelper

// Two Phase Construction

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

CPcsAlgorithm1MultiSearchHelper::CPcsAlgorithm1MultiSearchHelper()

{		

    PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::CPcsAlgorithm1") );

    PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::CPcsAlgorithm1") );

}

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

// CPcsAlgorithm1MultiSearchHelper::ConstructL

// Two Phase Construction

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

void CPcsAlgorithm1MultiSearchHelper::ConstructL(CPcsAlgorithm1* aAlgorithm)

{

    PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::ConstructL") );

    iAlgorithm = aAlgorithm;

    iKeyMap = iAlgorithm->GetKeyMap();

    PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::ConstructL") );

} 	

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

// CPcsAlgorithm1MultiSearchHelper::CPcsAlgorithm1MultiSearchHelper

// Destructor

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

CPcsAlgorithm1MultiSearchHelper::~CPcsAlgorithm1MultiSearchHelper()

{

    PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::~CPcsAlgorithm1MultiSearchHelper") );        

    iMultiSearchResultsArr.ResetAndDestroy();          

    PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::~CPcsAlgorithm1MultiSearchHelper") );

}

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

// CPcsAlgorithm1MultiSearchHelper::SearchMultiL

// Initial search feature.

// Flow of steps in initial search is explained below.

// (1) Extract the pool elements corresponding to one of the queries.

// (2) Always the first query is used here.

// (3) Get pool elements from all caches corresponding to the data stores.

// (4) Convert each query to mode specific form.

// (5) Parse each data element.

// (6) Check for every search query atleast one data element matches.

// (7) If NOT ignore the result.

// (8) If so perform an additional check that number of data matches is

//     atleast equal to number of search queries. This will ensure that same

//     data element has not matched for multiple queries.

// (9) Now include the element in the result.

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

void  CPcsAlgorithm1MultiSearchHelper::SearchMultiL(const CPsSettings& aSettings,

	                                     RPointerArray<CPsQuery>& aPsQuery,

	                                     TBool aIsSearchInGroup,

	                                     RArray<TInt>& aContactsInGroup,

	                                     RPointerArray<CPsData>& aSearchResults,

	                                     RPointerArray<CPsPattern>& aSearchSeqs )

{

    PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::SearchMultiL") );

    __LATENCY_MARK ( _L("CPcsAlgorithm1MultiSearchHelper::SearchMultiL") );

    PRINTQUERYLIST ( _L("CPcsAlgorithm1MultiSearchHelper::SearchMultiL: "), aPsQuery );

    // Create CPcsAlgorithm1FilterHelper object to be used for filtering the results

	TSortType sortType = aSettings.GetSortType();

    CPcsAlgorithm1FilterHelper* filterHelper = CPcsAlgorithm1FilterHelper::NewL(sortType);

    CleanupStack::PushL( filterHelper );

    RPointerArray<CPcsPoolElement> elements;

    CleanupClosePushL( elements );

    iMultiSearchResultsArr.ResetAndDestroy();

    // Get the data stores  

    RPointerArray<TDesC> dataStores;

    CleanupResetAndDestroyPushL( dataStores );

    aSettings.SearchUrisL(dataStores);

    // Get the required display fields from the client

    RArray<TInt> requiredDataFields;

    CleanupClosePushL( requiredDataFields );

    aSettings.DisplayFieldsL(requiredDataFields);

    // Search from cache based on first character of 1st item in query list

    const CPsQueryItem& firstCharItem = aPsQuery[0]->GetItemAtL(0);

    TInt cachePoolId = iKeyMap->PoolIdForCharacter( firstCharItem.Character(), firstCharItem.Mode() );

    // Get the elements from all the databases

    for ( TInt dsIndex = 0; 

			dsIndex < dataStores.Count(); 

			dsIndex++ )

	{

	    RPointerArray<CPsData> *temp = new (ELeave) RPointerArray<CPsData> ();

	    iMultiSearchResultsArr.Append(temp);

	    // Get the contents for this data store

	    TInt arrayIndex = iAlgorithm->GetCacheIndex(*(dataStores[dsIndex]));

		if ( arrayIndex < 0 ) continue;

		CPcsCache* cache = iAlgorithm->GetCache(arrayIndex);

	    cache->GetContactsForKeyL(cachePoolId, elements);

	    // Get the supported data fields for this data store

        RArray<TInt> supportedDataFields;

        CleanupClosePushL( supportedDataFields );

		cache->GetDataFields(supportedDataFields);

		// Get the filtered data fields for this data store

        TUint8 filteredDataMatch = CPcsAlgorithm1Utils::FilterDataFieldsL(requiredDataFields,

                                                                          supportedDataFields);

	    // Filter the results now

	    FilterResultsMultiL(filterHelper,

	    			   elements, 

		               aPsQuery, 

		               filteredDataMatch,

		               aIsSearchInGroup,

		               aContactsInGroup);

		// If alphabetical sorting, get the results for this datastore               

		if ( sortType == EAlphabetical )

		{

			filterHelper->GetResults(*(iMultiSearchResultsArr[dsIndex]));

		}

	    elements.Reset();

	    CleanupStack::PopAndDestroy( &supportedDataFields ); // Close

	}

    CleanupStack::PopAndDestroy( &requiredDataFields ); // Close

    CleanupStack::PopAndDestroy( &dataStores );         // ResetAndDestroy

	// If alphabetical sorting, merge the result sets of all datastores

  	if ( sortType == EAlphabetical )

  	{

  		// Form the complete searchResults array

    	CPcsAlgorithm1Utils::FormCompleteSearchResultsL(iMultiSearchResultsArr,

    											   	    aSearchResults);

  	}

  	else

  	{

  		// Results are already sorted patternbased

  		filterHelper->GetResults(aSearchResults);

  	}

  	// Get the sorted match sequence list

	filterHelper->GetPatternsL(aSearchSeqs);

	PRINT1 ( _L("CPcsAlgorithm1MultiSearchHelper::SearchMultiL: Number of search results = %d"), aSearchResults.Count() );

	// Cleanup             

    for(TInt i = 0; i < iMultiSearchResultsArr.Count(); i++)

    {

    	iMultiSearchResultsArr[i]->Reset();

    	delete iMultiSearchResultsArr[i];

        iMultiSearchResultsArr[i] = NULL;

    }

    iMultiSearchResultsArr.Reset();

    CleanupStack::PopAndDestroy( &elements ); // Close

    CleanupStack::PopAndDestroy( filterHelper );

    __LATENCY_MARKEND ( _L("CPcsAlgorithm1MultiSearchHelper::SearchMultiL") );

    PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::SearchMultiL") );

}

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

// CPcsAlgorithm1MultiSearchHelper::SearchMatchSeqMultiL

// Function adds matches, and locations based on multi query, and data

// Duplicate locations are allowed (as they are removed later anyway)

// Post condition locations in index order

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

void  CPcsAlgorithm1MultiSearchHelper::SearchMatchSeqMultiL(RPointerArray<CPsQuery>& aPsQuery,

                                                            const TDesC& aData,

                                                            RPointerArray<TDesC>& aMatchSeq,

                                                            RArray<TPsMatchLocation>& aMatchLocation )

{

    PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::SearchMatchSeqMultiL") );

    RPointerArray<HBufC> descriptorsQueryList;

    CleanupResetAndDestroyPushL( descriptorsQueryList );

    ConvertQueryToListL(aPsQuery, descriptorsQueryList);

    TLex lex(aData);

    while ( !lex.Eos() ) // Search thru all words

    {

        TPtrC currentWord = lex.NextToken(); // next word

        TPsMatchLocation newLocation = { lex.Offset() - currentWord.Length(), //start index

                                         0, TBidiText::TextDirectionality(currentWord) };

        for ( TInt queryIndex = 0; queryIndex < aPsQuery.Count(); ++queryIndex )

        {

            HBufC* currentQuery = descriptorsQueryList[queryIndex];

            TBuf<KPsQueryMaxLen> convertedWord;

            // Convert the data to required form (mode specific)

            iKeyMap->GetMixedKeyStringForDataL(*aPsQuery[queryIndex], currentWord, convertedWord);

            if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(convertedWord, *currentQuery, *aPsQuery[queryIndex]) )

            {

                newLocation.length = currentQuery->Length();

                aMatchLocation.AppendL( newLocation );

                TPtrC matchPart = currentWord.Left(newLocation.length);

                CPcsAlgorithm1Utils::AppendMatchToSeqL( aMatchSeq, matchPart );

            }

        }

    }

    CleanupStack::PopAndDestroy( &descriptorsQueryList ); // ResetAndDestroy

    PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::SearchMatchSeqMultiL") );

}

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

// CPcsAlgorithm1MultiSearchHelper::LookupMatchL

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

void CPcsAlgorithm1MultiSearchHelper::LookupMatchL( CPsQuery& aSearchQuery,

        const TDesC& aData,

        TDes& aMatchedData )

{

    RPointerArray<CPsQuery> queryList = MultiQueryL(aSearchQuery);

    TBuf<KPsQueryMaxLen> queryAsString = aSearchQuery.QueryAsStringLC();

    TBuf<KPsQueryMaxLen> convertedQuery;

    iKeyMap->GetMixedKeyStringForDataL( aSearchQuery, queryAsString, convertedQuery );

    RArray<TInt> dataWordIndexes;

    RArray<TInt> dataWordLengths;

    TLex lex( aData );

    while ( !lex.Eos() )

    {

        TPtrC currentWord = lex.NextToken();

        PRINT2( _L("idx len: %d %d"), lex.Offset() - currentWord.Length(), currentWord.Length() );

        dataWordIndexes.AppendL( lex.Offset() - currentWord.Length() );

        dataWordLengths.AppendL( currentWord.Length() );

    }

    RArray<TInt> queryIndexes;

    RArray<TPtrC> convertedQueriesAsDes;

    lex.Assign( queryAsString );

    while ( !lex.Eos() )

    {

        TPtrC currentWord = lex.NextToken();

        convertedQueriesAsDes.AppendL( 

                convertedQuery.Mid( lex.Offset() - currentWord.Length(), currentWord.Length()) );

        queryIndexes.AppendL( lex.Offset() - currentWord.Length() );

    }

    RPointerArray< RArray<TBool> > possibleMatches;

    for ( TInt i(0); i < queryList.Count(); ++i )

    {

        RArray<TBool>* matchesForCurrentQuery = new (ELeave) RArray<TBool>;

        possibleMatches.AppendL( matchesForCurrentQuery );

        CPsQuery* currentQuery = queryList[i];

        for ( TInt j(0); j < dataWordIndexes.Count(); j++ )

        {

            TPtrC currentDataWord = aData.Mid( dataWordIndexes[j], dataWordLengths[j] );

            RBuf convertedDataWord;

            convertedDataWord.CreateL( currentDataWord.Length() );

            CleanupClosePushL( convertedDataWord );

            iKeyMap->GetMixedKeyStringForDataL( *currentQuery, currentDataWord.Left(currentQuery->Count()), convertedDataWord );

            if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(convertedQueriesAsDes[i], convertedDataWord, *currentQuery) )

            {

                matchesForCurrentQuery->AppendL( ETrue );

            }

            else

            {

                matchesForCurrentQuery->AppendL( EFalse );

            }

            PRINT3( _L("CPcsAlgorithm1MultiSearchHelper::LookupMatchL: possibleMatches[%d][%d]=%d"),i,j, (*(possibleMatches[i]))[j] )

            CleanupStack::PopAndDestroy( &convertedDataWord );

        }

    }

    const TInt KUnapplied(-1);

    RArray<TInt> appliedMatches;

    appliedMatches.ReserveL( queryList.Count() );

    for ( TInt i(0); i < queryList.Count(); ++i )

    {

        appliedMatches.AppendL( KUnapplied );

    }

    //backtrack algorithm starts here to find fully applied match

    TInt currentQueryIndex(0);

    while ( currentQueryIndex < queryList.Count() && currentQueryIndex >= 0 )

    {

        TInt currentDataIndex = appliedMatches[ currentQueryIndex ] + 1;

        appliedMatches[ currentQueryIndex ] = KUnapplied;

        RArray<TBool>& matchesForCurrentQuery = *(possibleMatches[currentQueryIndex]);

        TBool doBacktrack( ETrue );

        while ( currentDataIndex < dataWordIndexes.Count() )

        {

            PRINT2(_L("CPcsAlgorithm1MultiSearchHelper::LookupMatchL: matchesForCurrentQuery[%d] = %d"), 

                    currentDataIndex, matchesForCurrentQuery[ currentDataIndex ] );

            if ( matchesForCurrentQuery[ currentDataIndex ] 

                     && (appliedMatches.Find( currentDataIndex ) == KErrNotFound) )

            {

                appliedMatches[ currentQueryIndex ] = currentDataIndex;

                doBacktrack = EFalse;

                break;

            }

            ++currentDataIndex;

        }

        if ( doBacktrack )

        {

            --currentQueryIndex;

        }

        else

        {

            ++currentQueryIndex;

        }

    }

    if ( currentQueryIndex >= 0 ) //found

    {

        aMatchedData = queryAsString;

        for ( TInt i(0); i < appliedMatches.Count(); ++i )

        {

            TInt matchedDataIndex = appliedMatches[i];

            TPtr resultFragment = aMatchedData.MidTPtr( 

                queryIndexes[ i ],

                convertedQueriesAsDes[i].Length() );

            resultFragment = aData.Mid(

                dataWordIndexes[ matchedDataIndex ],

                convertedQueriesAsDes[i].Length() );

        }

    }

    else

    {

        aMatchedData.Zero();

    }

    for ( TInt i(0); i < possibleMatches.Count(); ++i )

    {

        RArray<TBool>* pointerToDelete = possibleMatches[i];

        pointerToDelete->Close();

        delete pointerToDelete;

    }

    possibleMatches.Close();

    dataWordIndexes.Close();

    dataWordLengths.Close();

    queryIndexes.Close();

    convertedQueriesAsDes.Close();

    queryList.Close();

    appliedMatches.Close();

    CleanupStack::PopAndDestroy();  //result of queryAsStringLC

}

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

// CPcsAlgorithm1MultiSearchHelper::ConvertQueryToList

// Converts the multiple search queries to a list

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

void  CPcsAlgorithm1MultiSearchHelper::ConvertQueryToListL(RPointerArray<CPsQuery>& aSearchQuery,

                                                           RPointerArray<HBufC>& aQueryList)

{

    PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::ConvertQueryToListL") );

    CleanupResetAndDestroyPushL( aQueryList );

    for ( TInt queryIndex = 0; queryIndex < aSearchQuery.Count(); queryIndex++ )

    {

        TBuf<KPsQueryMaxLen> dataWithKeys;

        iKeyMap->GetMixedKeyStringForQueryL( *aSearchQuery[queryIndex], dataWithKeys );

        HBufC* dWKToAppend = dataWithKeys.AllocLC();

        aQueryList.AppendL( dWKToAppend );

        CleanupStack::Pop( dWKToAppend ); // ownership transfered

    }

    CleanupStack::Pop( &aQueryList );

    PRINT ( _L("End CPcsAlgorithm1MultiSearchHelper::ConvertQueryToListL") );

}

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

// CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL

// Subset search function. Refer the above function for more description.

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

void  CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL(

        CPcsAlgorithm1FilterHelper* aAlgorithmFilterHelper,

        RPointerArray<CPcsPoolElement>& aSearchSet,

        RPointerArray<CPsQuery>& aSearchQuery,

        TUint8 aFilteredDataMatch,

        TBool aIsSearchInGroup,

        RArray<TInt>& aContactsInGroup)

{

    PRINT ( _L("Enter CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL") );

    __LATENCY_MARK ( _L("CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL") );

    // Convert the individual queries to string form

    RPointerArray<HBufC> queryList;

    CleanupResetAndDestroyPushL( queryList );

    RPointerArray<HBufC> tempqueryList;

    CleanupClosePushL( tempqueryList );

    ConvertQueryToListL(aSearchQuery, queryList);

    // Remember a temporary copy of query list

    // since we sort the queries

	for ( TInt i = 0; i < queryList.Count(); i++)

	{

		tempqueryList.AppendL(queryList[i]);

	}

	// Sort the query items before we search them

	TLinearOrder<HBufC> rule( CPcsAlgorithm1Utils::CompareByLength );

	queryList.Sort(rule);

    // To hold the match results

    RPointerArray<TDesC> tmpMatchSet;

    CleanupResetAndDestroyPushL( tmpMatchSet );

    // Parse thru each search set elements and filter the results    

	for ( TInt index = 0; index < aSearchSet.Count(); index++ )

	{

	    CPcsPoolElement* poolElement = static_cast<CPcsPoolElement*>(aSearchSet[index]);

		CPsData* psData = poolElement->GetPsData();

		psData->ClearDataMatches();

        // Skip the contact if we are doing a group search and contact doesn't belong to the group

        if ( aIsSearchInGroup && 

             aContactsInGroup.Find( psData->Id() ) == KErrNotFound )

            {

            continue;

            }

		TBool isMatch = ETrue;		

		TInt wordMatches = 0;

		// Reset iWordMatches to zero 

		ClearWordMatches();

		// Check for each query atleast one data element matches

		// Loop from the last query so that longest match is seen first

		for ( TInt queryIndex = queryList.Count() - 1; queryIndex >= 0; queryIndex-- )

		{

		    TBool queryMatch = EFalse;

		    HBufC* tmpQuery = queryList[queryIndex];

		    // Get the original query mode corresponding to this query

		    TInt modeIndex = tempqueryList.Find(tmpQuery);

		    TInt dataCount = psData->DataElementCount();

		    __ASSERT_DEBUG( dataCount < MAX_DATA_FIELDS, Panic(KErrOverflow) );

		    for ( TInt dataIndex = 0; dataIndex < dataCount; dataIndex++ )

		    {

		        // Filter off data fields not required in search

                TUint8 bitIndex = 1 << dataIndex;

                TUint8 filter = bitIndex & aFilteredDataMatch;

		        if ( filter == 0x0 )

		        {

		            // Move to next data

		        	continue;

		        }

		        TInt wordIndex = -1;

			    TLex lex(psData->Data(dataIndex)->Des());

			    // First word

			    TPtrC tmpData = lex.NextToken();

			    // Search thru multiple words

			    while ( tmpData.Length() != 0 ) 

			    {

			        wordIndex++;

			     	TBuf<KPsQueryMaxLen> data;

	                // Convert the data to required form (mode specific)

	                iKeyMap->GetMixedKeyStringForDataL(*aSearchQuery[modeIndex], tmpData, data);

				    // Compare the data against query

                    if ( CPcsAlgorithm1Utils::MyCompareKeyAndString(data, *tmpQuery, *aSearchQuery[modeIndex]) )