/*

* 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:  This is the client side interface for the predictive search

*                server.

*

*/

// SYSTEM INCLUDES

#include <MPsResultsObserver.h>

#include <CPsRequestHandler.h>

#include <RPsSession.h>

// USER INCLUDE

#include "CPsPropertyHandler.h"

#include "CPsUpdateHandler.h"

#include "CPcsDebug.h"

#include "CPsPattern.h"

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

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

// CPSRequestHandler::NewL()

// Two-phased constructor.

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

EXPORT_C CPSRequestHandler* CPSRequestHandler::NewL()

    {

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

    CPSRequestHandler* self = NewLC();

    CleanupStack::Pop(self);

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

    return self;

    }

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

// CPSRequestHandler::NewLC()

// Two-phased constructor.

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

EXPORT_C CPSRequestHandler* CPSRequestHandler::NewLC()

    {

    PRINT ( _L("Enter CPSRequestHandler::NewLC") );

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

    CleanupStack::PushL(self);

    self->ConstructL();

    PRINT ( _L("End CPSRequestHandler::NewLC") );

    return self;

    }

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

// CPSRequestHandler::ConstructL()

// Symbian 2nd phase constructor can leave.

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

void CPSRequestHandler::ConstructL()

    {

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

    User::LeaveIfError(iSession.Connect());

    // Initiate the property handler

    iPropertyHandler = CPsPropertyHandler::NewL(this);

    // Initiate handlers for cache updating

    iContactAddedHandler = CPsUpdateHandler::NewL( *this, EPsKeyContactAddedCounter );

    iContactModifiedHandler = CPsUpdateHandler::NewL( *this, EPsKeyContactModifiedCounter );

    iContactRemovedHandler = CPsUpdateHandler::NewL( *this, EPsKeyContactRemovedCounter );

    // Initialize the contact id converter

    iConverter = NULL;

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

    }

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

// CPSRequestHandler::CCSAsyncRequestHandler()

// C++ default constructor can NOT contain any code, that might leave.

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

CPSRequestHandler::CPSRequestHandler() :

    CActive(EPriorityStandard)

    {

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

    CActiveScheduler::Add(this);

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

    }

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

// CPSRequestHandler::~CPSRequestHandler()

// Destructor.

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

CPSRequestHandler::~CPSRequestHandler()

    {

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

    Cancel(); // Causes call to DoCancel()

    // Close the session

    iSession.Close();

    delete iSearchQueryBuffer;

    delete iPendingSearchQueryBuffer;

    delete iSearchDataBuffer;

    delete iSearchResultsBuffer;

    delete iPropertyHandler;

    delete iContactAddedHandler;

    delete iContactModifiedHandler;

    delete iContactRemovedHandler;

    delete iConverter;

    iObservers.Reset();

    iObservers.Close();

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

    }

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

// CPSRequestHandler::AddObserverL()

// 

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

EXPORT_C void CPSRequestHandler::AddObserverL(MPsResultsObserver* aObserver)

    {

    iObservers.InsertInAddressOrderL(aObserver);

    }

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

// CPSRequestHandler::RemoveObserver()

// 

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

EXPORT_C TInt CPSRequestHandler::RemoveObserver(MPsResultsObserver* aObserver)

    {

    TInt index = iObservers.FindInAddressOrder(aObserver);

    if (index != KErrNotFound)

        {

        iObservers.Remove(index);

        return KErrNone;

        }

    else

        {

        return KErrNotFound;

        }

    }

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

// CPSRequestHandler::SetSearchSettingsL()

// Send the search settings to the predictive search engine

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

EXPORT_C void CPSRequestHandler::SetSearchSettingsL(const CPsSettings& aSettings)

    {

    PRINT ( _L("Enter CPSRequestHandler::SetSearchSettingsL") );

    // Tmp buffer        

    CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen);

    CleanupStack::PushL(buf);

    // Stream over the temp buffer

    RBufWriteStream stream(*buf);

    stream.PushL();

    // Write the search query to the stream

    aSettings.ExternalizeL(stream);

    stream.CommitL();

    // Create a HBufC8 for IPC

    HBufC8* settingsBuffer = HBufC8::NewLC(buf->Size());

    TPtr8 ptr(settingsBuffer->Des());

    buf->Read(0, ptr, buf->Size());

    // Send the settings to the server

    iSession.SetSearchSettingsL(settingsBuffer->Des());

    CleanupStack::PopAndDestroy(3, buf); // buf, stream, settingsBuffer	                 

    PRINT ( _L("End CPSRequestHandler::SetSearchSettingsL") );

    }

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

// CPSRequestHandler::SearchL()

// Sends a request to the predictive search engine to perform a search.

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

EXPORT_C void CPSRequestHandler::SearchL(const CPsQuery& aSearchQuery)

    {

    // __LATENCY_MARK ( _L("CPSRequestHandler::SearchL  <--- INITIATE SEARCH") );

    PRINT ( _L("Enter CPSRequestHandler::SearchL") );

    // ----------------------- Search Query ----------------------

    iSearchRequestCancelled = EFalse;

    // Tmp buffer        

    CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen);

    CleanupStack::PushL(buf);

    // Stream over the temp buffer

    RBufWriteStream stream(*buf);

    stream.PushL();

    // Write the search query to the stream

    aSearchQuery.ExternalizeL(stream);

    stream.CommitL();

    // If there is no submitted request, then submits the new coming search request     

    if (!IsActive())

        {

        // Create a HBufC8 for IPC

        if (iSearchQueryBuffer)

            {

            delete iSearchQueryBuffer;

            iSearchQueryBuffer = NULL;

            }

        iSearchQueryBuffer = HBufC8::NewLC(buf->Size());

        CleanupStack::Pop(); // iSearchQueryBuffer

        TPtr8 ptr(iSearchQueryBuffer->Des());

        buf->Read(0, ptr, buf->Size());

        // Clear pending search query buffer

        if (iPendingSearchQueryBuffer)

            {

            delete iPendingSearchQueryBuffer;

            iPendingSearchQueryBuffer = NULL;

            }

        // ------------------------- Results Buffer ---------------------

        // Create a buffer to store the search results.    

        if (iSearchResultsBuffer)

            {

            delete iSearchResultsBuffer;

            iSearchResultsBuffer = NULL;

            }

        iSearchResultsBuffer = HBufC8::NewL(KSearchResultsBufferLen);

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

        // Initiate the search

        iSession.SearchL(iSearchQueryBuffer->Des(), iSearchResultsBuffer->Des(), iStatus);

        SetActive();

        }

    else // else holds it in iPendingSearchQueryBuffer( which will be submitted in HandleSearchResults() )

        {

        CancelSearch();

        iPendingSearchQueryBuffer = HBufC8::NewLC(buf->Size());

        CleanupStack::Pop();

        TPtr8 ptr(iPendingSearchQueryBuffer->Des());

        buf->Read(0, ptr, buf->Size());

        }

    CleanupStack::PopAndDestroy(2, buf); // buf, stream   

    PRINT ( _L("End CPSRequestHandler::SearchL") );

    }

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

// CPSRequestHandler::LookupL()

// Sends a request to the predictive search engine to perform a search.

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

EXPORT_C void CPSRequestHandler::LookupL(const CPsQuery& aSearchQuery, 

                                         const TDesC& aSearchData,

                                         CDesCArray& aMatchSet, 

                                         RArray<TPsMatchLocation>& aMatchLocation)

    {

    PRINT ( _L("Enter CPSRequestHandler::LookupL") );

    // ----------------------- Search Query ----------------------

    // Tmp buffer        

    CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen);

    CleanupStack::PushL(buf);

    // Stream over the temp buffer

    RBufWriteStream stream(*buf);

    stream.PushL();

    // Write the search query to the stream

    aSearchQuery.ExternalizeL(stream);

    stream.CommitL();

    // Create a HBufC8 for IPC

    HBufC8* searchQueryBuffer = HBufC8::NewL(buf->Size());

    TPtr8 ptr(searchQueryBuffer->Des());

    buf->Read(0, ptr, buf->Size());

    CleanupStack::PopAndDestroy(2, buf); // buf, stream

    CleanupStack::PushL(searchQueryBuffer);

    // ----------------------- Search Data ----------------------

    // Tmp buffer        

    CBufFlat* dataBuf = CBufFlat::NewL(KBufferMaxLen);

    CleanupStack::PushL(dataBuf);

    // Stream over the temp buffer

    RBufWriteStream dataStream(*dataBuf);

    dataStream.PushL();

    // Write the search data to the stream

    dataStream.WriteUint16L(aSearchData.Size());

    dataStream << aSearchData;

    // Create a HBufC8 for IPC

    HBufC8* searchDataBuffer = HBufC8::NewL(dataBuf->Size());

    TPtr8 dataPtr(searchDataBuffer->Des());

    dataBuf->Read(0, dataPtr, dataBuf->Size());

    CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, dataStream

    CleanupStack::PushL(searchDataBuffer);

    // ------------------------- Results Buffer ---------------------

    // Create a buffer to store the search results.    

    HBufC8* searchResultsBuffer = HBufC8::NewLC(KBufferMaxLen);

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

    // Initiate the search

    iSession.SearchL(searchQueryBuffer->Des(), searchDataBuffer->Des(),

                     searchResultsBuffer->Des());

    // Parse the results

    RDesReadStream resultStream(searchResultsBuffer->Des());

    resultStream.PushL();

    // Number of results

    TInt seqCount = resultStream.ReadUint16L();

    PRINT1 ( _L("CPSRequestHandler::LookupL: Number of search seqs received = %d"), seqCount );

    // Internalize each char seq

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

        {

        // Size of sequence

        TInt szSeq = resultStream.ReadUint16L();

        // Character sequence

        HBufC* seq = HBufC::NewLC(resultStream, szSeq);

        aMatchSet.AppendL(seq->Des());

        CleanupStack::PopAndDestroy();

        }

    // --------- match sequence location ------------------    

    // number of results

    TInt count = resultStream.ReadUint16L();

    // read each data struct

    for (TInt k = 0; k < count; k++)

        {

        TPsMatchLocation matchLoc;

        matchLoc.index = resultStream.ReadUint16L();

        matchLoc.length = resultStream.ReadUint16L();

        matchLoc.direction  = (TBidiText::TDirectionality) (resultStream.ReadUint16L());

        aMatchLocation.Append(matchLoc);

        }

    //cleanup

    CleanupStack::PopAndDestroy(4, searchQueryBuffer); 

    // resultStream, searchResultsBuffer, searchDataBuffer, searchQueryBuffer

    PRINT1        ( _L("CPSRequestHandler::LookupL: Search Data: %S"), &aSearchData );

    PRINTMATCHSET ( _L("CPSRequestHandler::LookupL: "), aMatchSet );

    PRINTMATCHLOC ( _L("CPSRequestHandler::LookupL: "), aMatchLocation );

    PRINT ( _L("End CPSRequestHandler::LookupL") );

    }

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

// CPSRequestHandler::LookupMatchL()

// Sends a request to the predictive search engine to perform a search.

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

EXPORT_C void CPSRequestHandler::LookupMatchL( const CPsQuery& aSearchQuery, 

                                               const TDesC& aSearchData,

                                               TDes& aMatch )

    {

    PRINT ( _L("Enter CPSRequestHandler::LookupMatchL") );

    // ----------------------- Search Query ----------------------

    // Tmp buffer        

    CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen);

    CleanupStack::PushL(buf);

    // Stream over the temp buffer

    RBufWriteStream stream(*buf);

    stream.PushL();

    // Write the search query to the stream

    aSearchQuery.ExternalizeL(stream);

    stream.CommitL();

    // Create a HBufC8 for IPC

    HBufC8* searchQueryBuffer = HBufC8::NewL(buf->Size());

    TPtr8 ptr(searchQueryBuffer->Des());

    buf->Read(0, ptr, buf->Size());

    CleanupStack::PopAndDestroy(2, buf); // buf, stream

    CleanupStack::PushL(searchQueryBuffer);

    // ----------------------- Search Data ----------------------

    // Tmp buffer        

    CBufFlat* dataBuf = CBufFlat::NewL(KBufferMaxLen);

    CleanupStack::PushL(dataBuf);

    // Stream over the temp buffer

    RBufWriteStream dataStream(*dataBuf);

    dataStream.PushL();

    // Write the search data to the stream

    dataStream.WriteUint16L(aSearchData.Size());

    dataStream << aSearchData;

    // Create a HBufC8 for IPC

    HBufC8* searchDataBuffer = HBufC8::NewL(dataBuf->Size());

    TPtr8 dataPtr(searchDataBuffer->Des());

    dataBuf->Read(0, dataPtr, dataBuf->Size());

    CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, dataStream

    CleanupStack::PushL(searchDataBuffer);      

    // Initiate the search

    iSession.SearchMatchStringL( 

            searchQueryBuffer->Des(), searchDataBuffer->Des(), aMatch );

    //cleanup

    CleanupStack::PopAndDestroy(searchDataBuffer);

    CleanupStack::PopAndDestroy(searchQueryBuffer); 

    PRINT1 ( _L("CPSRequestHandler::LookupMatchL: Search Data: %S"), &aSearchData );

    PRINT1 ( _L("CPSRequestHandler::LookupMatchL: Result Match: %S"), &aMatch );

    PRINT  ( _L("End CPSRequestHandler::LookupMatchL") );

    }

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

// CPSRequestHandler::SearchL()

// Sends a request to the predictive search engine to perform a search.

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

EXPORT_C void CPSRequestHandler::SearchL(const CPsQuery& aSearchQuery,

                                         RPointerArray<CPsClientData>& aMarkedContacts,

                                         CVPbkContactManager* aContactManager)

    {

    PRINT ( _L("Enter CPSRequestHandler::SearchL") );

    // Fire the normal search with the input search query

    SearchL(aSearchQuery);

    // Clear the bookmarked contacts if any

    iMarkedContacts.Reset();

    // Copy the contact manager

    iBookMarkContactManager = aContactManager;

    // Copy the bookmarked contacts

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

        {

        iMarkedContacts.Append(aMarkedContacts[i]);

        }

    PRINT ( _L("End CPSRequestHandler::SearchL") );

    }

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

// CPSRequestHandler::CancelSearch()

// Cancels ongoing search.

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

EXPORT_C void CPSRequestHandler::CancelSearch()

    {

    if( IsActive() )

        {

        iSearchRequestCancelled = ETrue;

        }

    if( iPendingSearchQueryBuffer )

        {

        delete iPendingSearchQueryBuffer;

        iPendingSearchQueryBuffer = NULL;

        }

    iSession.CancelSearch();

    }

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

// CPSRequestHandler::HandleSearchResultsL()

// Search is complete. Parse and send the results to the client.

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

void CPSRequestHandler::HandleSearchResultsL()

    {

    PRINT ( _L("Enter CPSRequestHandler::HandleSearchResultsL") );

    // No pending search query, process the search result

    RPointerArray<CPsClientData> searchResults;

    RPointerArray<CPsPattern> searchSeqs;

    if( !iSearchResultsBuffer )

        {

        return;

        }

    RDesReadStream stream(iSearchResultsBuffer->Des());

    stream.PushL();

    // Number of results

    TInt count = stream.ReadInt32L();

    PRINT1 ( _L("CPSRequestHandler::HandleSearchResultsL: Number of search results received = %d"), count );

    // Internalize each data element

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

        {

        CPsClientData* data = CPsClientData::NewL();

        CleanupStack::PushL(data);

        data->InternalizeL(stream);

        CleanupStack::Pop(data);