/*

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

const TText KSpace = ' ';

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

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

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

    DefinePropertyL( EPsKeyCacheStatus );

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

    DefinePropertyL( EPsKeyCacheError );

    // Define properties for notifying about cache updates

    DefinePropertyL( EPsKeyContactRemovedCounter );

    DefinePropertyL( EPsKeyContactModifiedCounter );

    DefinePropertyL( EPsKeyContactAddedCounter );

    // Initialize key map and pti engine

    TInt keyMapErr = KErrNone;

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

    if ( keyMapErr != KErrNone )

    {

        PRINT ( _L("**********************************************."));

        PRINT1( _L("CPcsAlgorithm1::ConstructL() KeyMap construction error. The keymap crashed with error code %d."),keyMapErr );

        PRINT ( _L("Please check the keypad/language for which keymap got crashed.") );

        PRINT ( _L("**********************************************."));

        User::Leave( keyMapErr ); // we can't go on without a key map; constructing cache needs it

    }

    // 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::DefinePropertyL

// Define a P&S property with given key under the internal category 

// UID of PCS. Leave if definition fails for any other reason than

// key already existing. 

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

void CPcsAlgorithm1::DefinePropertyL( TPcsInternalKeyCacheStatus aPsKey )

    {

    TInt err = RProperty::Define( KPcsInternalUidCacheStatus, 

                                  aPsKey, 

                                  RProperty::EInt );

    if ( err != KErrAlreadyExists )

        {

        User::LeaveIfError(err);

        }

    }

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

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

// Replace all "0"s in a search query with " "s if those characters are on

// the same key.

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

TBool  CPcsAlgorithm1::ReplaceZeroWithSpaceL(CPsQuery& aQuery)

{   

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

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

    TBool queryModified = EFalse;    

    /* In phones like E52 and E55, where the "0" and the " " characters are on

     * the same key, the "0"s have to be considered as possible separators.

     *

     * In phones like N97 and E72, where the "0" and the " " characters are on

     * different keys, the "0"s must not be considered as possible separators.

     */

    // Skip initial "0"s, they are not replaced into spaces

    TInt skipIndex = 0;

    while ( (skipIndex < aQuery.Count()) && 

            (aQuery.GetItemAtL(skipIndex).Character().GetNumericValue() == 0) )

    {

        skipIndex++;

    }

    // Replace remaining "0"s into spaces in case they are entered with a keyboard

    // that has "0" and " " on the same key.

    for ( TInt index = skipIndex; index < aQuery.Count(); index++ )

    {

        CPsQueryItem& item = aQuery.GetItemAtL(index);

        if ( iKeyMap->GetSpaceAndZeroOnSameKey( item.Mode() ) &&

             item.Character().GetNumericValue() == 0 )

        {

            item.SetCharacter(KSpace);

            queryModified = ETrue;

        }

    }

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

    // Check aSettings   

    RPointerArray<TDesC> searchUris;

    CleanupResetAndDestroyPushL( searchUris );

    aSettings.SearchUrisL(searchUris);

    if ( searchUris.Count() <= 0)

    {

        PRINT ( _L("searchUris.Count() <= 0, Leave from CPcsAlgorithm1::PerformSearchL") );

        User::Leave(KErrArgument); 

    }

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

	// Local arrays to hold the search results 

	RPointerArray<CPsData> tempSearchResults;

	CleanupClosePushL( tempSearchResults );

    RPointerArray<CPsData> tempSearchResultsIni;

    CleanupClosePushL( tempSearchResultsIni );

    RPointerArray<CPsData> tempSearchResultsMod;

    CleanupClosePushL( 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 maxNumToDisplay = aSettings.MaxResults();

    TInt resultSetCount = tempSearchResults.Count();

    TInt numToDisplay = 0;

    if ( maxNumToDisplay == -1 )

        {

        numToDisplay = resultSetCount;

        }

    else

        {

        numToDisplay = Min( maxNumToDisplay, resultSetCount );

        }

    // Copy desired number of results from tempSearchResults to the results stream

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

        {

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

        }

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

    // Cleanup local results array

    CleanupStack::PopAndDestroy( &tempSearchResultsMod ); // Close, don't destroy

    CleanupStack::PopAndDestroy( &tempSearchResultsIni ); // Close, don't destroy

    CleanupStack::PopAndDestroy( &tempSearchResults );    // Close, don't destroy

	__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 duplicate 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 duplicate 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 )