/*

* 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 <VPbkEng.rsg>

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

// UID used for Publish and Subscribe mechanism

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

const TUid KCStatus =

    {

    0x2000B5B6

    };

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

    iFindUtil = CFindUtil::NewL();

    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( 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("**********************************************."));

        }

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

    delete iPluginLauncher;

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

    }

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

// CPcsAlgorithm2::ReplaceZeroWithSpaceL

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

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

TBool CPcsAlgorithm2::ReplaceZeroWithSpaceL(CPsQuery& aQuery)

    {

    TChar space(KSpace); // ascii value for space

    TBool queryModified = EFalse;

    // Skip initial zeros in query

    TInt index = 0;

    for (index = 0; index < aQuery.Count()

            && aQuery.GetItemAtL(index).Character().GetNumericValue() == 0; ++index)

        {

        }

    if (aQuery.KeyboardModeL() != EQwerty)

        {

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

            {

            CPsQueryItem& item = aQuery.GetItemAtL(beg);

            if (item.Character().GetNumericValue() == 0 && item.Mode()== EItut)

                {

                if (beg != 0)

                    {

                    CPsQueryItem& item1 = aQuery.GetItemAtL(beg - 1);

                    if (item1.Character().GetNumericValue() != 0

                            && !item1.Character().IsSpace())

                        {

                        item.SetCharacter(space);

                        queryModified = ETrue;

                        }

                    }

                else

                    {

                    item.SetCharacter(space);

                    queryModified = ETrue;

                    }

                }

            }

        }

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

    // Get the current language

    TLanguage lang = User::Language();

    // Check if the language is supported and the keyboard mode is not qwerty.

    // Local arrays to hold the search results 

    RPointerArray<CPsData> tempSearchResults;

    RPointerArray<CPsData> tempSearchResults1;

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

    DoSearchL(aSettings, aQuery, tempSearchResults, aSearchSeqs);

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

    // ------------------- Perform advanced search if needed ------------------

    // Substitute "0" with space

    TBool queryModified = ReplaceZeroWithSpaceL(aQuery);

    // If query got modified and the search query translated to more than 1 query

    // perform a multi search again

    if (queryModified)

        {

        // Split query

        RPointerArray<CPsQuery> queryList = iMultiSearchHelper->MultiQueryL(aQuery);

        //  Perform seach again

        if (queryList.Count() > 1)

            {

            DoSearchL(aSettings, aQuery, tempSearchResults1, aSearchSeqs);

            }

        // Sort rule        

        TLinearOrder<CPsData> rule(CPcsAlgorithm2Utils::CompareDataBySortOrder);

        // Avoid duplicates and add new results

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

        if (aSettings.GetSortType() != EAlphabetical)

            {

            TInt insertPos = 0;

            for (int i = 0; i < tempSearchResults1.Count(); i++)

                {

                if (tempSearchResults.Find(tempSearchResults1[i],

                                           identityRule) == KErrNotFound)

                    {

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

                    insertPos++;

                    }

                }

            }

        else

            {

            for (int i = 0; i < tempSearchResults1.Count(); i++)

                {

                if (tempSearchResults.Find(tempSearchResults1[i],

                                           identityRule) == KErrNotFound)

                    {

                    tempSearchResults.InsertInOrderAllowRepeats(tempSearchResults1[i], 

                                                                rule);

                    }

                }

            }

        queryList.ResetAndDestroy();

        }

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

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

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

            {

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

            }

        }

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

    // Cleanup local results array

    tempSearchResults.Reset(); // Don't destroy

    tempSearchResults1.Reset(); // 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)

    {

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

    // Get the current language

    TLanguage lang = User::Language();

    // Check if the language is supported and the keyboard mode is not qwerty.

    // Print input query for debug

    aQuery.PrintQuery();

    // Print received search data

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

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

    DoSearchInputL(aQuery, aData, aMatchSet, aMatchLocation);

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

    // ------------------- Perform advanced search if needed ------------------

    // Substitute "0" with space

    TBool queryModified = ReplaceZeroWithSpaceL(aQuery);

    // If query got modified and the search query translated to more than 1 query

    // perform a multi search again

    if (queryModified)

        {

        RPointerArray<CPsQuery> queryList = iMultiSearchHelper->MultiQueryL(aQuery);

        if (queryList.Count() > 1)

            {

            DoSearchInputL(aQuery, aData, aMatchSet, aMatchLocation);

            }

        queryList.ResetAndDestroy();

        }

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

    // Sort match set

    iHelper->SortSearchSeqsL(aMatchSet);

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

    }

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

// CPcsAlgorithm2::SearchMatchStringL

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

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

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

                            TDesC& /*aSearchData*/,

                            TDes& /*aMatch*/ )

    {

    //NOT IMPLEMENTED YET

    }

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

// CPcsAlgorithm2::DoSearchL

// Search function helper

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

void CPcsAlgorithm2::DoSearchL(const CPsSettings& aSettings, CPsQuery& aQuery, 

                               RPointerArray<CPsData>& searchResults,

                               RPointerArray<CPsPattern>& searchSeqs)

    {

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

    // Print query for debug

    aQuery.PrintQuery();

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

    RArray<TInt> contactsInGroup;

    RArray<TInt> groupIdArray;

    // Create a new settings instance

    CPsSettings *tempSettings = aSettings.CloneL();

    TBool isGroupSearch = IsGroupSearchL(*tempSettings, groupIdArray);

    if (isGroupSearch)

        {

        // Replace groups URI with contacts DB URI in new search settings

        ReplaceGroupsUriL(*tempSettings);

        // List of contacts in this group	

        GetContactsInGroupL(groupIdArray[0], contactsInGroup);

        }

    groupIdArray.Close();

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

    // Extract query list. 

    RPointerArray<CPsQuery> queryList = iMultiSearchHelper->MultiQueryL(aQuery);

    // -(1)--------------------- No query return all contacts ----------------    

    if (queryList.Count() == 0)

        {

        GetAllContentsL(*tempSettings, searchResults);

        if (isGroupSearch)

            {

            FilterSearchResultsForGroupsL(contactsInGroup, searchResults);

            }

        }

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

    // -(2)------------------------ Perform a single query search -------------

    if (queryList.Count() == 1)

        {

        TInt mode = aQuery.KeyboardModeL();

        CPsQuery* query = queryList[0];

        iFindUtilECE->SetKeyboardMode(mode);

        switch (mode)

            {

            case EItut:

                PRINT ( _L("Query received is in ITU-T mode") );

                // Search results

                iHelper->SearchITUL(*tempSettings, *query, isGroupSearch,

                                    contactsInGroup, searchResults, searchSeqs);

                break;

            case EQwerty:

                PRINT ( _L("Query received is in QWERTY mode") );

                // Search results

                iHelper->SearchQWERTYL(*tempSettings, *query, isGroupSearch,

                                       contactsInGroup, searchResults, searchSeqs);

                break;

            case EModeUndefined:

                PRINT ( _L("Query received is in Mixed mode. Keyboard swap happened.") );

                // Search results

                iHelper->SearchMixedL(*tempSettings, *query, isGroupSearch,

                                      contactsInGroup, searchResults, searchSeqs);

                break;

            }

        }

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

    // -(3)---------------------------- Perform a multi query search ----------

    if (queryList.Count() > 1) // multiple query

        {

        PRINT ( _L("Query received is in multiple. Performing a multi search.") );

        TInt mode = aQuery.KeyboardModeL();

        iFindUtilECE->SetKeyboardMode(mode);

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

            {

            TPtrC queryPtr = queryList[i]->QueryAsStringLC();

            PRINT2 ( _L("Received Query, index = %d; value = %S"), i, &queryPtr );

            CleanupStack::PopAndDestroy();

            }

        // Search results

        iMultiSearchHelper->SearchMultiL(*tempSettings, queryList, isGroupSearch, 

                                         contactsInGroup, searchResults, searchSeqs, 

                                         mode);

        }

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

    // Cleanup

    delete tempSettings;

    tempSettings = NULL;

    groupIdArray.Close();

    contactsInGroup.Close();

    queryList.ResetAndDestroy();

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

    }

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

// CPcsAlgorithm2::DoSearchInputL

// Search function helper

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

void CPcsAlgorithm2::DoSearchInputL(CPsQuery& aQuery, TDesC& aData,

                                    RPointerArray<TDesC>& aMatchSet,

                                    RArray<TPsMatchLocation>& aMatchLocation)

    {

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

    // Check if any seperator is there in the query

    RPointerArray<CPsQuery> queryList = iMultiSearchHelper->MultiQueryL(aQuery);