/*

* 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 <PtiEngine.h>

#include <centralrepository.h>

#include <AknFepInternalCRKeys.h>

#include "CPcsAlgorithm2.h"

#include "CPcsAlgorithm2Helper.h"

#include "CPcsAlgorithm2MultiSearchHelper.h"

#include "CPcsAlgorithm2Utils.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"

#include "FindUtilChineseECE.h"

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

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

// CPcsAlgorithm2::NewL

// Two Phase Construction

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

CPcsAlgorithm2* CPcsAlgorithm2::NewL()

    {

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

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

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

    return self;

    }

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

// CPcsAlgorithm2::CPcsAlgorithm2

// Two Phase Construction

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

CPcsAlgorithm2::CPcsAlgorithm2()

    {

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

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

    }

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

// CPcsAlgorithm2::ConstructL

// Two Phase Construction

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

void CPcsAlgorithm2::ConstructL()

    {

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

    iCacheStatus = ECachingNotStarted; // Starting status

    iCacheError = KErrNone; // No error

    iCacheCount = 0; // No data

    iFindUtilECE = CFindUtilChineseECE::NewL(this);

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

    if (keyMapErr != KErrNone)

        {

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

        PRINT1 ( _L("CPcsAlgorithm2::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 = CPcsAlgorithm2Helper::NewL(this);

    iMultiSearchHelper = CPcsAlgorithm2MultiSearchHelper::NewL(this);

    if(!iPluginLauncher->IsActive())

        {

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

        }

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

    }

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

// CPcsAlgorithm2::~CPcsAlgorithm2

// Destructor

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

CPcsAlgorithm2::~CPcsAlgorithm2()

    {

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

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

    delete iPluginLauncher;

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

    }

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

// CPcsAlgorithm2::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 CPcsAlgorithm2::DefinePropertyL( TPcsInternalKeyCacheStatus aPsKey )

    {

    TInt err = RProperty::Define( KPcsInternalUidCacheStatus, 

                                  aPsKey, 

                                  RProperty::EInt );

    if ( err != KErrAlreadyExists )

        {

        User::LeaveIfError(err);

        }

    }

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

// CPcsAlgorithm2::RemoveSpacesL

// Remove leading and trailing spaces of search query

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

void  CPcsAlgorithm2::RemoveSpacesL(CPsQuery& aQuery)

    {

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

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

        }

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

    }    

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

// CPcsAlgorithm2::ReplaceZeroWithSpaceL

// Replace first occurance of '0' in a sequence of '0's in ITU-T with space

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

TBool CPcsAlgorithm2::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.

       const TInt queryCount = aQuery.Count();

       for ( TInt index = skipIndex; index < queryCount; 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;

    }

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

// CPcsAlgorithm2::PerformSearchL

// Search function for cache

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

void CPcsAlgorithm2::PerformSearchL(const CPsSettings& aSettings, 

                                    CPsQuery& aQuery, 

                                    RPointerArray<CPsClientData>& aSearchResults,

                                    RPointerArray<CPsPattern>& aSearchSeqs)

    {

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

    //__LATENCY_MARK ( _L("CPcsAlgorithm2::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> tempSearchResults1;

    CleanupClosePushL( tempSearchResults1 );

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

    RemoveSpacesL(aQuery);

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

    DoSearchL(aSettings, aQuery, tempSearchResults, 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.

     */

    TBool queryModified = ReplaceZeroWithSpaceL(aQuery);

    RemoveSpacesL(aQuery);

    // Perform query again if query got modified. 

    if (queryModified)

        {

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

        DoSearchL(aSettings, aQuery, tempSearchResults1, aSearchSeqs);

        // Sort rule        

        // Avoid duplicates and add new results

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

        const TInt tempSearchResults1Count = tempSearchResults1.Count();

        if (aSettings.GetSortType() != EAlphabetical)

            {

            TInt insertPos = 0;

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

                {

                if (tempSearchResults.Find(tempSearchResults1[i],

                                           identityRule) == KErrNotFound)

                    {

                    tempSearchResults.Insert(tempSearchResults1[i], insertPos);

                    insertPos++;

                    }

                }

            }

        else

            {

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

                {

                if (tempSearchResults.Find(tempSearchResults1[i],

                                           identityRule) == KErrNotFound)

                    {

                    tempSearchResults.InsertInOrderAllowRepeats(tempSearchResults1[i], 

                                                                rule);

                    }

                }

            }

        }

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

    // ---------------------- 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( &tempSearchResults1 ); // Close, don't destroy

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

    // __LATENCY_MARKEND ( _L("CPcsAlgorithm2::PerformSearchL") );

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

    }

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

// CPcsAlgorithm2::SearchInputL

// Search function for input string

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

void CPcsAlgorithm2::SearchInputL(CPsQuery& aQuery, 

                                  TDesC& aData,

                                  RPointerArray<TDesC>& aMatchSet,

                                  RArray<TPsMatchLocation>& aMatchLocation)

    {

    // __LATENCY_MARK ( _L("CPcsAlgorithm2::SearchInputL: ") );

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

    // Print input query for debug

    PRINTQUERY ( _L("CPcsAlgorithm2::SearchInputL: Search query: "), aQuery );

    // Print received search data

    PRINT1 ( _L("Search data received = %S"), &aData);

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

    RemoveSpacesL(aQuery);

    DoSearchInputL(aQuery, aData, aMatchSet, 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 queryModified = ReplaceZeroWithSpaceL(aQuery);

    RemoveSpacesL(aQuery);

    // If query got modified and the search query still contains something

    // perform a multi search again

    if (queryModified && aQuery.Count() > 0 && aMatchSet.Count() == 0  && aMatchLocation.Count() == 0 )

        {

        DoSearchInputL(aQuery, aData, aMatchSet, aMatchLocation);

        }

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

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

    TInt i = 0;

    TBool incrementFirstCursor;

    while ( i < aMatchLocation.Count() )

        {

        incrementFirstCursor = ETrue;

        TInt j = i+1;

        while ( j < aMatchLocation.Count() )

            {

            if ( CPcsAlgorithm2Utils::MatchesOverlap( aMatchLocation[j], aMatchLocation[i] ) )

                {

                // 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 from aMatchSet items which no longer have corresponding item in aMatchLocation ---

    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;

            const TInt matchLocationCount = aMatchLocation.Count();

            for ( TInt i = 0; i < matchLocationCount; 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

            }

        }

    CleanupStack::PopAndDestroy( dataUpper );

    // --- Remove items End ---

    // Sort match set

    iHelper->SortSearchSeqsL(aMatchSet);

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

    //__LATENCY_MARKEND ( _L("CPcsAlgorithm2::SearchInputL") );

    }

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

// CPcsAlgorithm2::SearchMatchStringL

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

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

void CPcsAlgorithm2::SearchMatchStringL( CPsQuery& /*aSearchQuery*/,

                                         TDesC& /*aSearchData*/,

                                         TDes& /*aMatch*/ )

    {

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

    //__LATENCY_MARK ( _L("CPcsAlgorithm2::SearchMatchStringL") ); 

    // TODO: Implementation missing

    //__LATENCY_MARKEND ( _L("CPcsAlgorithm2::SearchMatchStringL") );

    PRINT ( _L("End CPcsAlgorithm2::SearchMatchStringL") );

    }

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

// CPcsAlgorithm2::DoSearchL

// Search function helper

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

void CPcsAlgorithm2::DoSearchL( const CPsSettings& aSettings, 

                                CPsQuery& aQuery, 

                                RPointerArray<CPsData>& aSearchResults,

                                RPointerArray<CPsPattern>& aSearchSeqs )

    {

    PRINT ( _L("Enter CPcsAlgorithm2::DoSearchL") );

    //__LATENCY_MARK ( _L("CPcsAlgorithm2::DoSearchL") ); 

    // -(0)----------------- Check if group search is required ---------------    

    RArray<TInt> contactsInGroup;

    CleanupClosePushL( contactsInGroup );

    RArray<TInt> groupIdArray;

    CleanupClosePushL( groupIdArray );

    // Create a new settings instance

    CPsSettings* tempSettings = aSettings.CloneL();

    CleanupStack::PushL( tempSettings );