/*

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

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

	                                     RArray<TInt>& aContactsInGroup,

{

    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;

    // Get the data stores  

    // Get the required display fields from the client

    RArray<TInt> requiredDataFields;

    aSettings.DisplayFieldsL(requiredDataFields);

    // Get the elements from all the databases

			dsIndex++ )

	{

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

	    iMultiSearchResultsArr.Append(temp);

	    // Get the contents for this data store

	    // Get the supported data fields for this data store

        RArray<TInt> supportedDataFields;

		cache->GetDataFields(supportedDataFields);

		TUint8 filteredDataMatch = FilterDataFieldsL(requiredDataFields, 

		                                             supportedDataFields);

	    // Filter the results now

	    FilterResultsMultiL(filterHelper,

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

		if ( sortType == EAlphabetical )

		{

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

		}

	    elements.Reset();

	}

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

  	if ( sortType == EAlphabetical )

  	{

  		// Form the complete searchResults array

    	CPcsAlgorithm1Utils::FormCompleteSearchResultsL(iMultiSearchResultsArr,

  	}

  	else

  	{

  		// Results are already sorted patternbased

  	}

  	// Get the sorted match sequence list

	// Cleanup             

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

    {

    	iMultiSearchResultsArr[i]->Reset();

    	delete iMultiSearchResultsArr[i];

        iMultiSearchResultsArr[i] = NULL;

    }

    iMultiSearchResultsArr.Reset();

    __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::MyCompareKeyAndString(convertedWord, *currentQuery, *aPsQuery[queryIndex]) )

            {

                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(CPcsAlgorithm1Utils::CompareExact);

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

    {

        TBuf<KPsQueryMaxLen> dataWithKeys;

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

    }

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

}

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

// CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL

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

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

void  CPcsAlgorithm1MultiSearchHelper::FilterResultsMultiL(

        CPcsAlgorithm1FilterHelper* aAlgorithmFilterHelper,

        TUint8 aFilteredDataMatch,

        RArray<TInt>& aContactsInGroup)

{

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

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

    // Convert the individual queries to string form

    // 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( CPcsAlgorithm1Utils::CompareByLength );

	queryList.Sort(rule);

    // To hold the match results

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

	{

		CPsData* psData = poolElement->GetPsData();

		psData->ClearDataMatches();

		TBool isMatch = ETrue;		

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

		    {

		        // Filter off data fields not required in search