/*

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

    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 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::ReplaceZeroWithSpaceL

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

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

TBool CPcsAlgorithm2::ReplaceZeroWithSpaceL(CPsQuery& aQuery)

    {

    }

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

// CPcsAlgorithm2::PerformSearchL

// Search function for cache

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

                                    RPointerArray<CPsClientData>& aSearchResults,

                                    RPointerArray<CPsPattern>& aSearchSeqs)

    {

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

    // Local arrays to hold the search results 

    RPointerArray<CPsData> tempSearchResults;

    RPointerArray<CPsData> tempSearchResults1;

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

    DoSearchL(aSettings, aQuery, tempSearchResults, aSearchSeqs);

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

    TBool queryModified = ReplaceZeroWithSpaceL(aQuery);

    if (queryModified)

        {

        // Sort rule        

        // Avoid duplicates and add new results

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

        if (aSettings.GetSortType() != EAlphabetical)

            {

            TInt insertPos = 0;

                {

                if (tempSearchResults.Find(tempSearchResults1[i],

                                           identityRule) == KErrNotFound)

                    {

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

                    insertPos++;

                    }

                }

            }

        else

            {

                {

                if (tempSearchResults.Find(tempSearchResults1[i],

                                           identityRule) == KErrNotFound)

                    {

                    tempSearchResults.InsertInOrderAllowRepeats(tempSearchResults1[i], 

                                                                rule);

                    }

                }

            }

        }

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

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

    // Truncate the result set if required

        {

        }

    else

        {

        }

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

    // Cleanup local results array

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

    }

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

// CPcsAlgorithm2::SearchInputL

// Search function for input string

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

                                  RPointerArray<TDesC>& aMatchSet,

                                  RArray<TPsMatchLocation>& aMatchLocation)

    {

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

    // Print input query for debug

    // Print received search data

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

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

    DoSearchInputL(aQuery, aData, aMatchSet, aMatchLocation);

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

    TBool queryModified = ReplaceZeroWithSpaceL(aQuery);

    // perform a multi search again

        {

        }

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

    // Sort match set

    iHelper->SortSearchSeqsL(aMatchSet);

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

    }

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

// CPcsAlgorithm2::SearchMatchStringL

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

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

    {

    }

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

// CPcsAlgorithm2::DoSearchL

// Search function helper

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

    {

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

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

    RArray<TInt> contactsInGroup;

    RArray<TInt> groupIdArray;

    // Create a new settings instance

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

        }

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

    // Extract query list. 

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

    if (queryList.Count() == 0)

        {

        if (isGroupSearch)

            {

            }

        }

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

        {

        CPsQuery* query = queryList[0];

        }

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

        {

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

        // Search results

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

        }

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