/*

* 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>

// Compare functions

TBool CompareByLength ( const HBufC& aFirst, const HBufC& aSecond )

{

   return ( aFirst.Length() > aSecond.Length() );

}

TBool Compare3 ( const TDesC& aFirst, const TDesC& aSecond )

{

	return aFirst == aSecond;     

}

// ============================== 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 isSearchInGroup,

	                                     RArray<TInt>& aContactsInGroup,

	                                     RPointerArray<CPsData>& searchResults,

	                                     RPointerArray<CPsPattern>& searchSeqs )

{

    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);

    RPointerArray<CPcsPoolElement> elements;

    iMultiSearchResultsArr.ResetAndDestroy();  

    // Get the data stores  

    RPointerArray<TDesC> aDataStores;

    aSettings.SearchUrisL(aDataStores);

    // Get the required display fields from the client

    RArray<TInt> requiredDataFields;

    aSettings.DisplayFieldsL(requiredDataFields);

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

    TInt numValue = iKeyMap->PoolIdForCharacter(aPsQuery[0]->GetItemAtL(0).Character());

    // Get the elements from all the databases

    for ( int dsIndex = 0; 

			dsIndex < aDataStores.Count(); 

			dsIndex++ )

	{

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

	    iMultiSearchResultsArr.Append(temp);

	    // Get the contents for this data store

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

		if ( arrayIndex < 0 ) continue;		

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

	    cache->GetContactsForKeyL(numValue,elements);

	    // Get the supported data fields for this data store

        RArray<TInt> supportedDataFields;

		cache->GetDataFields(supportedDataFields);

		// Get the filtered data fields for this data store    		

		TUint8 filteredDataMatch = FilterDataFieldsL(requiredDataFields, 

		                                             supportedDataFields);

	    // Filter the results now

	    FilterResultsMultiL(filterHelper,

                            elements,

                            aPsQuery,

                            filteredDataMatch,

                            isSearchInGroup,

                            aContactsInGroup);	

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

		if ( sortType == EAlphabetical )

		{

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

		}

	    elements.Reset();

	    supportedDataFields.Reset();

	}

	aDataStores.ResetAndDestroy();

    requiredDataFields.Reset(); 

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

  	if ( sortType == EAlphabetical )

  	{

  		// Form the complete searchResults array

    	CPcsAlgorithm1Utils::FormCompleteSearchResultsL(iMultiSearchResultsArr,

    											   	    searchResults);

  	}

  	else

  	{

  		// Results are already sorted patternbased

  		filterHelper->GetResults(searchResults);

  	}

  	// Get the sorted match sequence list

	filterHelper->GetPatternsL(searchSeqs);

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

	// Cleanup             

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

    {

    	iMultiSearchResultsArr[i]->Reset();

    	delete iMultiSearchResultsArr[i];

        iMultiSearchResultsArr[i] = NULL;

    }

    iMultiSearchResultsArr.Reset();

    delete 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;

    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::MyCompareC(convertedWord.Left(currentQuery->Length()), *currentQuery) == 0 )                

            {

                newLocation.length = currentQuery->Length();

                aMatchLocation.AppendL( newLocation );

                AppendMatchToSeqL( aMatchSeq, currentWord.Left(newLocation.length) );

            }

        }

    }

    descriptorsQueryList.ResetAndDestroy();

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

}

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

// CPcsAlgorithm1MultiSearchHelper::AppendMatchToSeqL

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

void CPcsAlgorithm1MultiSearchHelper::AppendMatchToSeqL( 

        RPointerArray<TDesC>& aMatchSeq, const TDesC& aMatch  )

    {

    HBufC* seq = aMatch.AllocLC();

    seq->Des().UpperCase();

    TIdentityRelation<TDesC> rule(Compare3);

    if ( aMatchSeq.Find(seq, rule) == KErrNotFound )

        {

        aMatchSeq.Append(seq);

        CleanupStack::Pop( seq );

        }

    else 

        {

        CleanupStack::PopAndDestroy( seq );

        }

    }

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

// 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::MyCompareC( convertedQueriesAsDes[i], convertedDataWord ) == 0 )

                {

                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") );

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

    {

        TBuf<KPsQueryMaxLen> dataWithKeys;

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

        HBufC* dWKToAppend = HBufC::NewL(KPsQueryMaxLen);

        TPtr tPtr(dWKToAppend->Des());

        tPtr.Copy(dataWithKeys);

        aQueryList.Append( dWKToAppend );

    }

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

}

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

// CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL

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

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

void  CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL(

        CPcsAlgorithm1FilterHelper* aAlgorithmFilterHelper,

        RPointerArray<CPcsPoolElement>& searchSet,

        RPointerArray<CPsQuery>& searchQuery,

        TUint8 aFilteredDataMatch,

        TBool isSearchInGroup,

        RArray<TInt>& aContactsInGroup)

{

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

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

    // Convert the individual queries to string form

    RPointerArray<HBufC> queryList;    

    RPointerArray<HBufC> tempqueryList;   

    ConvertQueryToListL(searchQuery, queryList);

    // Remember a temporary copy of query list

    // since we sort the queries

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

	{

		tempqueryList.Append(queryList[i]);

	}

	// Sort the query items before we search them

	TLinearOrder<HBufC> rule( CompareByLength );

	queryList.Sort(rule);

    // To hold the match results

    RPointerArray<TDesC> tmpMatchSet;  

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

	for ( int index = 0; index < searchSet.Count(); index++ )

	{

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

		CPsData* psData = poolElement->GetPsData();

		psData->ClearDataMatches();

		TBool isMatch = ETrue;		

		TUint8 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);

		     for ( TInt dataIndex = 0; dataIndex < psData->DataElementCount(); dataIndex++ )

		     {

		         // Filter off data fields not required in search

		         TReal bitIndex;

		         Math::Pow(bitIndex, 2, dataIndex);

                 TUint8 filter = (TUint8)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(*searchQuery[modeIndex], tmpData, data);

				     // Compare the data against query

                     if ( CPcsAlgorithm1Utils::MyCompareC(data.Left(tmpQuery->Length()),

                                                          *tmpQuery) == 0 )