/*

* 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:  Predictive Contact Search Algorithm 1 main class

*

*/

// INCLUDES

#include "CPcsAlgorithm1.h"

#include "CPcsAlgorithm1Helper.h"

#include "CPcsAlgorithm1MultiSearchHelper.h"

#include "CPcsAlgorithm1Utils.h"

#include "CPcsDebug.h"

#include "CPcsCache.h"

#include "CPcsKeyMap.h"

#include "CPsData.h"

#include "CWords.h"

#include "CPsQuery.h"

#include "CPsDataPluginInterface.h"

#include "CPcsDefs.h"

// UID used for Publish and Subscribe mechanism

// This should be same as the one defined in CPsPropertyHandler.cpp

const TUid KCStatus = {0x2000B5B6};

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

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

// CPcsAlgorithm1::NewL

// Two Phase Construction

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

CPcsAlgorithm1* CPcsAlgorithm1::NewL()

{

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

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

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

	return self;

}

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

// CPcsAlgorithm1::CPcsAlgorithm1

// Two Phase Construction

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

CPcsAlgorithm1::CPcsAlgorithm1()

{		

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

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

}

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

// CPcsAlgorithm1::ConstructL

// Two Phase Construction

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

void CPcsAlgorithm1::ConstructL()

{

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

    iCacheStatus = ECachingNotStarted;  // Starting status

    iCacheError = KErrNone;             // No error

    iCacheCount = 0;                    // No data

    iPluginLauncher = CIdle::NewL( CActive::EPriorityStandard );

    // Define cache status property used to inform clients about the caching status.

    TInt err = RProperty::Define(KCStatus,0, RProperty::EInt);      

    if ( err != KErrAlreadyExists )

    {

    	User::LeaveIfError(err);

    }

    // Define cache error property used to inform client about the errors.

    err = RProperty::Define(KCStatus,1, RProperty::EInt);

    if ( err != KErrAlreadyExists )

    {

    	User::LeaveIfError(err);

    }

    // Initialize key map and pti engine

    TInt keyMapErr = KErrNone;

    TRAP( keyMapErr, iKeyMap = CPcsKeyMap::NewL());

    if ( keyMapErr != KErrNone )

    {

    }

    // Initialize helpers

    iHelper = CPcsAlgorithm1Helper::NewL(this);

    iMultiSearchHelper = CPcsAlgorithm1MultiSearchHelper::NewL(this);

    if(!iPluginLauncher->IsActive())

        {

        iPluginLauncher->Start(TCallBack(CPcsAlgorithm1::DoLaunchPluginsL, this));

        }

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

} 

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

// CPcsAlgorithm1::~CPcsAlgorithm1

// Destructor

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

CPcsAlgorithm1::~CPcsAlgorithm1()

{

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

    // Clear TLS

    Dll::SetTls(NULL);

    // Cleanup cache

    iPcsCache.ResetAndDestroy();

    // Cleanup adapters interface and key handling

    delete iKeyMap;

    delete iPsDataPluginInterface;

    // Cleanup helpers

    delete iHelper;

    delete iMultiSearchHelper;

    delete iPluginLauncher;

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

}

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

// CPcsAlgorithm1::RemoveSpacesL

// Remove leading and trailing spaces of search query

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

void  CPcsAlgorithm1::RemoveSpacesL(CPsQuery& aQuery)

{

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

    //PRINTQUERY ( _L("CPcsAlgorithm1::RemoveSpacesL (BEFORE): "), aQuery );

    // Remove all leading " "

    while ( aQuery.Count() > 0 )

    {

        CPsQueryItem& item = aQuery.GetItemAtL(0); // First

        if ( !item.Character().IsSpace() )

        {

            break;

        }

        aQuery.Remove(0);

    }

    // Remove all trailing " "

    while ( aQuery.Count() > 0 )

    {

        CPsQueryItem& item = aQuery.GetItemAtL(aQuery.Count()-1); // Last

        if ( !item.Character().IsSpace() )

        {

            break;

        }

        aQuery.Remove(aQuery.Count()-1);

    }

    //PRINTQUERY ( _L("CPcsAlgorithm1::RemoveSpacesL (AFTER): "), aQuery );

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

}    

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

// CPcsAlgorithm1::ReplaceZeroWithSpaceL

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

TBool  CPcsAlgorithm1::ReplaceZeroWithSpaceL(CPsQuery& aQuery)

{   

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

    //PRINTQUERY ( _L("CPcsAlgorithm1::ReplaceZeroWithSpaceL (BEFORE): "), aQuery );

    TBool queryModified = EFalse;    

        {

    }

    //PRINTQUERY ( _L("CPcsAlgorithm1::ReplaceZeroWithSpaceL (AFTER): "), aQuery );

    PRINT1 ( _L("CPcsAlgorithm1::ReplaceZeroWithSpaceL: Query modified (0=not, 1=yes): %d"), queryModified );

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

    return  queryModified;

}  

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

// CPcsAlgorithm1::PerformSearchL

// Search function for cache

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

void  CPcsAlgorithm1::PerformSearchL(const CPsSettings& aSettings,

                                     CPsQuery& aQuery,

                                     RPointerArray<CPsClientData>& aSearchResults,

                                     RPointerArray<CPsPattern>& aSearchSeqs)                                    

{

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

	__LATENCY_MARK ( _L("CPcsAlgorithm1::PerformSearchL") );

	// Local arrays to hold the search results 

	RPointerArray<CPsData> tempSearchResults;

    RPointerArray<CPsData> tempSearchResultsIni;

    RPointerArray<CPsData> tempSearchResultsMod;

    // ----------------------- Perform the basic search -----------------------

	/* Even before replacing zeroes with spaces the query can have multiple words

	 * Some phones support infact double keyboards with possibility to type a space in qwerty mode

	 * A space in qwerty mode can even be typed disabling temporarily PCS

	 */

    RemoveSpacesL(aQuery);

    PRINTQUERY ( _L("CPcsAlgorithm1::PerformSearchL: 1st search query: "), aQuery );

	DoSearchL(aSettings, aQuery, tempSearchResultsIni, aSearchSeqs );

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

    // ---- Perform new search after "0" replacement if query is not empty ----

    /* Examples:

     * - If the original search string is "Abc0" then we will search again with "Abc".

     * - If the original search string is "00" then we will not search again.

     * - If the original search string is "00Zxc" then we will search again with "Zxc".

     */

    TBool isQueryModified = ReplaceZeroWithSpaceL(aQuery);

    RemoveSpacesL(aQuery);

    if ( isQueryModified && (aQuery.Count() > 0) )

    {

        PRINTQUERY ( _L("CPcsAlgorithm1::PerformSearchL: 2nd search query: "), aQuery );

        DoSearchL(aSettings, aQuery, tempSearchResultsMod, aSearchSeqs );

    }

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

    // ------------------ Merge and sort the search results -------------------

	if ( tempSearchResultsIni.Count() + tempSearchResultsMod.Count() > 0)

	{

		// Sort rule        

		TLinearOrder<CPsData> rule( CPcsAlgorithm1Utils::CompareDataBySortOrderL );

		// Avoid duplicates and add new results

		TIdentityRelation<CPsData> identityRule(CPsData::CompareById);

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

        {

            if ( tempSearchResults.Find( tempSearchResultsIni[i],identityRule ) == KErrNotFound )

            {

                if (aSettings.GetSortType() == EAlphabetical)

                {

                    tempSearchResults.InsertInOrderAllowRepeats(tempSearchResultsIni[i], rule);

                }

                else

                {

                    tempSearchResults.AppendL(tempSearchResultsIni[i]);

                }

            }

        }

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

        {

            if ( tempSearchResults.Find( tempSearchResultsMod[i],identityRule ) == KErrNotFound )

            {

                if (aSettings.GetSortType() == EAlphabetical)

                {

                    tempSearchResults.InsertInOrderAllowRepeats(tempSearchResultsMod[i], rule);

                }

                else

                {

                    tempSearchResults.AppendL(tempSearchResultsMod[i]);

                }

            }

        }

	}

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

    // ------------------ Write result objects to the stream ------------------

	// Truncate the result set if required

	TInt numToDisplay = aSettings.MaxResults();

	TInt resultSet = tempSearchResults.Count();

	if( resultSet > numToDisplay && numToDisplay != -1)

	{

		// Copy the top N contents from tempSearchResults to the results stream

		for(int i = 0; i < numToDisplay; i++)

		{

			aSearchResults.Append(WriteClientDataL(*(tempSearchResults[i])));

		}

	}

	else

	{

		// Copy all the contents from tempSearchResults to the results stream

		{

			aSearchResults.Append(WriteClientDataL(*(tempSearchResults[i])));

		}

	}

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

    // Cleanup local results array

	__LATENCY_MARKEND ( _L("CPcsAlgorithm1::PerformSearchL") );

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

}

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

// CPcsAlgorithm1::SearchInputL

// Search function for input string

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

void  CPcsAlgorithm1::SearchInputL(CPsQuery& aQuery,

                                   TDesC& aData,

                                   RPointerArray<TDesC>& aMatchSet,

                                   RArray<TPsMatchLocation>& aMatchLocation )

{

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

    __LATENCY_MARK ( _L("CPcsAlgorithm1::SearchInputL") ); 

    // ----------------------- Perform the basic search -----------------------

    /* Even before replacing zeroes with spaces the query can have multiple words

     * Some phones support infact double keyboards with possibility to type a space in qwerty mode

     * A space in qwerty mode can even be typed disabling temporarily PCS

     */

    RemoveSpacesL(aQuery);

    DoSearchInputL(aQuery, aData, aMatchSet, aMatchLocation);

    PRINTQUERY    ( _L("CPcsAlgorithm1::SearchInputL: 1st search: "), aQuery );

    PRINT1        ( _L("CPcsAlgorithm1::SearchInputL: 1st search: Search Data: %S"), &aData );

    PRINTMATCHSET ( _L("CPcsAlgorithm1::SearchInputL: 1st search: "), aMatchSet );

    PRINTMATCHLOC ( _L("CPcsAlgorithm1::SearchInputL: 1st search: "), aMatchLocation );

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

    // ---- Perform new search after "0" replacement if query is not empty ----

    /* Examples:

     * - If the original search string is "Abc0" then we will search again with "Abc".

     * - If the original search string is "00" then we will not search again.

     */

    TBool isQueryModified = ReplaceZeroWithSpaceL(aQuery);

    RemoveSpacesL(aQuery);

    if ( isQueryModified && (aQuery.Count() > 0) )

    {

        DoSearchInputL(aQuery, aData, aMatchSet, aMatchLocation);

        PRINTQUERY    ( _L("CPcsAlgorithm1::SearchInputL: 2nd search: "), aQuery );

        PRINT1        ( _L("CPcsAlgorithm1::SearchInputL: 2nd search: Search Data: %S"), &aData );

        PRINTMATCHSET ( _L("CPcsAlgorithm1::SearchInputL: 2nd search: "), aMatchSet );

        PRINTMATCHLOC ( _L("CPcsAlgorithm1::SearchInputL: 2nd search: "), aMatchLocation );

    }

    /* In cases like we have a contact "Nik0 Abc" and the search query is "Nik0" we do:

     * - a 1st search with "Nik0" that matches "Nik0" (4 chars) of "Nik0 Abc",

     * - a 2nd search with "Nik" that matches "Nik" (3 chars) of "Nik0 Abc".

     * We have to remove from aMatchLocation the occurrence that has a shorter match length.

     * We have to remove the match ("Nik" in this case) even from aMatchSet if there is not

     * any other match for it than the one in "Nik0".

     */

    // --- Remove items from aMatchLocation ---

    TInt i = 0;

    TBool incrementFirstCursor;

    while ( i < aMatchLocation.Count() )

    {

        incrementFirstCursor = ETrue;

        TInt j = i+1;

        while ( j < aMatchLocation.Count() )

        {

            if (aMatchLocation[j].index == aMatchLocation[i].index)

            {

                // Remove match location item with smallest length if 2 items have same index

                if ( aMatchLocation[j].length <= aMatchLocation[i].length )

                {

                    aMatchLocation.Remove(j);

                    continue; // Do not increment j

                }

                else

                {

                    aMatchLocation.Remove(i);

                    incrementFirstCursor = EFalse; // Do not increment i

                    break;

                }

            }

            j++;

        }

        if ( incrementFirstCursor )

        {

            i++;

        }

    }

    // --- Remove items from aMatchSet ---

    HBufC* dataUpper = HBufC::NewLC(aData.Length());

    dataUpper->Des().Copy(aData);

    dataUpper->Des().UpperCase(); // Get uppercase, as aMatchSet is in upper case

    TInt k = 0;

    while ( k < aMatchSet.Count() )

    {

        TBool keepMatch = EFalse;

        TInt startCursor = -1;

        TInt offsetCursor;

        while ( KErrNotFound != (offsetCursor = dataUpper->Mid(startCursor + 1).Find(*aMatchSet[k])) )

        {

            // startCursor = index of match item *aMatchSet[k] into search string aData

            startCursor = offsetCursor + startCursor + 1;

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

            {

                // If match item was found in the location list, then keep it

                if ( (aMatchLocation[i].index == startCursor) &&

                     (aMatchLocation[i].length == aMatchSet[k]->Length()) )

                {

                    keepMatch = ETrue;

                    break;

                }

            }

        }

        if ( keepMatch )

        {

            k++;

        }

        else

        {

            aMatchSet.Remove(k); // Do not increment k

        }

        // --- Remove items End ---

    }

    CleanupStack::PopAndDestroy( dataUpper );

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

    // Sort match set

	iHelper->SortSearchSeqsL(aMatchSet);  

    PRINTQUERY    ( _L("CPcsAlgorithm1::SearchInputL: Final: "), aQuery );

    PRINT1        ( _L("CPcsAlgorithm1::SearchInputL: Final: Search Data: %S"), &aData );

    PRINTMATCHSET ( _L("CPcsAlgorithm1::SearchInputL: Final: "), aMatchSet );

    PRINTMATCHLOC ( _L("CPcsAlgorithm1::SearchInputL: Final: "), aMatchLocation );

	__LATENCY_MARKEND ( _L("CPcsAlgorithm1::SearchInputL") );

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

}

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

// CPcsAlgorithm1::SearchMatchStringL

// Search function for input string, result also as string

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

void CPcsAlgorithm1::SearchMatchStringL( CPsQuery& aSearchQuery,

                            TDesC& aSearchData,

                            TDes& aMatch )

    {

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

    __LATENCY_MARK ( _L("CPcsAlgorithm1::SearchMatchStringL") ); 

    // ---------------------- Perform the initial search ----------------------

    iMultiSearchHelper->LookupMatchL( aSearchQuery, aSearchData, aMatch );

    PRINTQUERY ( _L("CPcsAlgorithm1::SearchMatchStringL: 1st search: "), aSearchQuery );

    PRINT1     ( _L("CPcsAlgorithm1::SearchMatchStringL: 1st search: Search Data: %S"), &aSearchData );

    PRINT1     ( _L("CPcsAlgorithm1::SearchMatchStringL: 1st search: Result: %S"), &aMatch );

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

    // ---- Perform new search after "0" replacement if query is not empty ----

    /* Examples:

     * - If the original search string is "Abc0" then we will search again with "Abc".

     * - If the original search string is "00" then we will not search again.

     */

    if ( aMatch.Length() <= 0 )

    {

        TBool isQueryModified = ReplaceZeroWithSpaceL(aSearchQuery);

        if ( isQueryModified && (aSearchQuery.Count() > 0) )

        {

            iMultiSearchHelper->LookupMatchL( aSearchQuery, aSearchData, aMatch );

            PRINTQUERY ( _L("CPcsAlgorithm1::SearchMatchStringL: 2nd search: "), aSearchQuery );