/*

* Copyright (c) 2010 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: 

*

*/

#include <S32MEM.H>

#include <e32svr.h>

#include <e32uid.h>

#include <common.h>

#include "CSearchServerSession.h"

#include "CSearchServerSubSession.h"

#include "CCPixAsyncronizer.h"

#include "CCPixIdxDb.h"

#include "CCPixSearch.h"

#include "CSearchDocument.h"

#include "SearchServerLogger.h"

#include "SearchServer.pan"

#include "CLogPlayerRecorder.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "csearchserversubsessionTraces.h"

#endif

// Contants

//_LIT8( KFileBaseAppClass, "root file" );

CSearchServerSubSession* CSearchServerSubSession::NewLC(CSearchServerSession* aSession)

{

	CSearchServerSubSession* self = new (ELeave)CSearchServerSubSession(aSession);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

CSearchServerSubSession* CSearchServerSubSession::NewL(CSearchServerSession* aSession)

{

	CSearchServerSubSession* self = CSearchServerSubSession::NewLC(aSession);

	CleanupStack::Pop();

	return self;

}

CSearchServerSubSession::CSearchServerSubSession(CSearchServerSession* aSession) : iSession(aSession)

{

    OstTrace0( TRACE_NORMAL, CSEARCHSERVERSUBSESSION_CSEARCHSERVERSUBSESSION, "Creating search server subsession" );

    CPIXLOGSTRING("Creating search server subsession");

    // Dont ask why but I seem to have a compulsion to set everything NULL in constructor - AL

	iIndexDb = NULL;

	iSearchDb = NULL;

	iNextDocument = NULL;

}

CSearchServerSubSession::~CSearchServerSubSession()

{

    OstTrace0( TRACE_NORMAL, DUP1_CSEARCHSERVERSUBSESSION_CSEARCHSERVERSUBSESSION, "Deleting search server subsession" );

    CPIXLOGSTRING("Deleting search server subsession");

	delete iIndexDb;

	delete iSearchDb;	

	delete iNextDocument;

}

void CSearchServerSubSession::ConstructL()

{

	iIndexDb = CCPixIdxDb::NewL();

	iSearchDb = CCPixSearch::NewL();

}

// CSearchServerSession::CancelAll()

void CSearchServerSubSession::CancelAll(const RMessage2& aMessage)

	{

	if (iSearchDb->IsOpen())

	    {

	    // Cancel searching 

	    iSearchDb->CancelAll(aMessage);

	    }

	else if (iIndexDb->IsOpen())

	    {

	    // Cancel indexing

	    iIndexDb->CancelAll(aMessage);

	    }

	else

	    {

	    // Nothing to cancel. Just complete request

	    aMessage.Complete(KErrNone);

	    }

	TRAP_IGNORE( LOG_PLAYER_RECORD( CLogPlayerRecorder::LogCancelL( reinterpret_cast<TUint>( this ) ) ) );

	}

void CSearchServerSubSession::OpenDatabaseL(const RMessage2& aMessage)

	{

	HBufC* baseAppClass = HBufC::NewLC(aMessage.GetDesLength(0));

	TPtr baseAppClassPtr = baseAppClass->Des();

	aMessage.ReadL(0, baseAppClassPtr);

	HBufC* defaultSearchField = HBufC::NewLC(aMessage.GetDesLength(1));

	TPtr defaultSearchFieldPtr = defaultSearchField->Des();

	aMessage.ReadL(1, defaultSearchFieldPtr);

	const TBool search = aMessage.Int2();

	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogDatabaseOpenL(reinterpret_cast<TUint>(this), search, *baseAppClass) );

	if (!search)

	{

    	iIndexDb->OpenDatabaseL(*baseAppClass);

	}

	else

	{

		iSearchDb->OpenDatabaseL(*baseAppClass, *defaultSearchField);

	}

	CleanupStack::PopAndDestroy(defaultSearchField);

	CleanupStack::PopAndDestroy(baseAppClass);

	// Complete the request

	aMessage.Complete(KErrNone);	

	}

void CSearchServerSubSession::SetAnalyzerL(const RMessage2& aMessage)

	{

	if (!iSearchDb->IsOpen() && !iIndexDb->IsOpen())

		{

		iSession->PanicClient(aMessage, EDatabaseNotOpen);

		return;

		}

	HBufC* analyzer = HBufC::NewLC(aMessage.GetDesLength(0));

	TPtr analyzerPtr = analyzer->Des();

	aMessage.ReadL(0, analyzerPtr);

	if (iSearchDb->IsOpen()) {

		iSearchDb->SetAnalyzerL( *analyzer ); 

	}

	if (iIndexDb->IsOpen()) {

		iIndexDb->SetAnalyzerL( *analyzer ); 

	}

	CleanupStack::PopAndDestroy( analyzer );

	// Complete the request

	aMessage.Complete(KErrNone);	

	}

void CSearchServerSubSession::SearchL(const RMessage2& aMessage)

	{

	OstTraceFunctionEntry0( CSEARCHSERVERSUBSESSION_SEARCHL_ENTRY );

	PERFORMANCE_LOG_START("CSearchServerSubSession::SearchL");

	// Sanity check

	if (!iSearchDb->IsOpen())

		{

		iSession->PanicClient(aMessage, EDatabaseNotOpen);

		OstTraceFunctionExit0( CSEARCHSERVERSUBSESSION_SEARCHL_EXIT );

		return;

		}

	// buf for the search terms

	HBufC* searchTerms = HBufC::NewLC(aMessage.GetDesLength(0));

	// read the search terms

	TPtr ptr = searchTerms->Des();

	aMessage.ReadL(0, ptr);

	// Commit search

	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogSearchL( reinterpret_cast<TUint>(this), *searchTerms ) );

	if (!iSearchDb->SearchL(*searchTerms, this, aMessage))

		{

		// Not commited, complete with zero count

		TPckgBuf<TInt> resultCountPackage(0);

		aMessage.WriteL(1, resultCountPackage);

		// Complete the request

		aMessage.Complete(KErrNone);	

		}

	// Cleanup search terms

	CleanupStack::PopAndDestroy(searchTerms);

	OstTraceFunctionExit0( DUP1_CSEARCHSERVERSUBSESSION_SEARCHL_EXIT );

	}

void CSearchServerSubSession::SearchCompleteL(const RMessage2& aMessage)

	{

	OstTraceFunctionEntry0( CSEARCHSERVERSUBSESSION_SEARCHCOMPLETEL_ENTRY );

	PERFORMANCE_LOG_START("CSearchServerSubSession::SearchCompleteL");

	// Complete search

	const TInt resultCount = iSearchDb->SearchCompleteL();

	// Return the size of the search results in first parameter

	TPckgBuf<TInt> resultCountPackage(resultCount);

	aMessage.WriteL(1, resultCountPackage);

	OstTraceFunctionExit0( CSEARCHSERVERSUBSESSION_SEARCHCOMPLETEL_EXIT );

	}

// CSearchServerSession::GetDocumentL().

// Client gets the next documents (result) when SearchL has completed

void CSearchServerSubSession::GetDocumentL(const RMessage2& aMessage)

	{

	OstTraceFunctionEntry0( CSEARCHSERVERSUBSESSION_GETDOCUMENTL_ENTRY );

	PERFORMANCE_LOG_START("CSearchServerSubSession::GetDocumentL");

	// Sanity check

	if (!iSearchDb->IsOpen())

		{

		iSession->PanicClient(aMessage, EDatabaseNotOpen);

		OstTraceFunctionExit0( CSEARCHSERVERSUBSESSION_GETDOCUMENTL_EXIT );

		return;

		}

	// buf for the search terms

	TInt index = aMessage.Int0();

	delete iNextDocument; 

	iNextDocument = NULL;

	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogGetDocumentL( reinterpret_cast<TUint>( this ), index ) );

	iSearchDb->GetDocumentL(index, this, aMessage);

	OstTraceFunctionExit0( DUP1_CSEARCHSERVERSUBSESSION_GETDOCUMENTL_EXIT );

	}

void CSearchServerSubSession::GetDocumentCompleteL(const RMessage2& aMessage)

	{

	OstTraceFunctionEntry0( CSEARCHSERVERSUBSESSION_GETDOCUMENTCOMPLETEL_ENTRY );

	PERFORMANCE_LOG_START("CSearchServerSubSession::GetDocumentCompleteL");

	iNextDocument = iSearchDb->GetDocumentCompleteL();	

	TPckgBuf<TInt> documentSizePackage(iNextDocument ? iNextDocument->Size() : 0);

	aMessage.WriteL(1, documentSizePackage);

	OstTraceFunctionExit0( CSEARCHSERVERSUBSESSION_GETDOCUMENTCOMPLETEL_EXIT );

	}

// CSearchServerSession::GetDocumentObjectL()

// Client gets the object after GetDocumentL() has completed 

void CSearchServerSubSession::GetDocumentObjectL(const RMessage2& aMessage)

	{

	OstTraceFunctionEntry0( CSEARCHSERVERSUBSESSION_GETDOCUMENTOBJECTL_ENTRY );

	PERFORMANCE_LOG_START("CSearchServerSubSession::GetDocumentObjectL");

	// Sanity check

	if (!iSearchDb->IsOpen())

		{

		iSession->PanicClient(aMessage, EDatabaseNotOpen);

		OstTraceFunctionExit0( CSEARCHSERVERSUBSESSION_GETDOCUMENTOBJECTL_EXIT );

		return;

		}

	if (iNextDocument)

		{

		// Create long enough descriptor for serialized hits

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

		TPtr8 ptr = buf->Des();

		// Initialize a new stream

		RDesWriteStream stream;

		stream.Open(ptr);

		stream.PushL();

		// Externalize hits to the stream

		iNextDocument->ExternalizeL(stream);

		// Commit and destroy the stream

		stream.CommitL();

		CleanupStack::PopAndDestroy(&stream);

		// write the serialized hits in to the message

		aMessage.WriteL(0, ptr);

		// Delete descriptor

		CleanupStack::PopAndDestroy(buf);

		}

	else

		{

		// Empty

		aMessage.WriteL(0, KNullDesC8);

		}

	// Complete the request

	aMessage.Complete(KErrNone);		

	OstTraceFunctionExit0( DUP1_CSEARCHSERVERSUBSESSION_GETDOCUMENTOBJECTL_EXIT );

	}

void CSearchServerSubSession::AddL(const RMessage2& aMessage)

	{

	// Sanity check

	if (!iIndexDb->IsOpen())

		{

		iSession->PanicClient(aMessage, EDatabaseNotOpen);

		return;

		}

	// buf for the search terms

	HBufC8* serializedDocument = HBufC8::NewLC(aMessage.GetDesLength(0));

	// read the search terms

	TPtr8 ptr = serializedDocument->Des();

	aMessage.ReadL(0, ptr);

	RDesReadStream stream;

	stream.Open(ptr);

	stream.PushL();

	CSearchDocument* document = CSearchDocument::NewL(stream);

	CleanupStack::PopAndDestroy(&stream);

	CleanupStack::PushL(document);

	// Index the thing

	LOG_PLAYER_RECORD(

	if ( iIndexDb->BaseAppClass().Find( KFileBaseAppClass ) == KErrNotFound )

	    {

		CLogPlayerRecorder::LogAddL( reinterpret_cast<TUint>(this), *document );

	    }

	);

	//check if excerpt is more then maximum allowed

	LimitExcerptToMaxLengthL(document);

	iIndexDb->AddL(*document, this, aMessage);

	CleanupStack::PopAndDestroy(document);

	CleanupStack::PopAndDestroy(serializedDocument);

	}

void CSearchServerSubSession::LimitExcerptToMaxLengthL(CSearchDocument* aSearchDocument)

    {

    //check if excerpt is more then maximum allowed

    if(aSearchDocument->Excerpt().Length() > MAX_EXCERPT_LENGTH)

        {

        OstTraceExt1( TRACE_NORMAL, CSEARCHSERVERSUBSESSION_LIMITEXCERPTTOMAXLENGTHL, "CSearchServerSubSession::LimitExcerptToMaxLengthL;docuid=%S", (aSearchDocument->Id()) );

        CPIXLOGSTRING2("CSearchServerSubSession::AddL docuid=%S", &(aSearchDocument->Id()));

        OstTrace1( TRACE_NORMAL, DUP1_CSEARCHSERVERSUBSESSION_LIMITEXCERPTTOMAXLENGTHL, "CSearchServerSubSession::LimitExcerptToMaxLengthL;Excerpt Length=%d", aSearchDocument->Excerpt().Length() );

        CPIXLOGSTRING2("CSearchServerSubSession::AddL Excerpt Length =%d", aSearchDocument->Excerpt().Length());

        const TDesC& excerpt = aSearchDocument->Excerpt();

        HBufC* bufExcerpt = HBufC::NewLC(MAX_EXCERPT_LENGTH);

        TPtr ptrExcerpt = bufExcerpt->Des();

        ptrExcerpt.Append(excerpt.Ptr(),MAX_EXCERPT_LENGTH - 1);

        ptrExcerpt.Append(KNullDesC); //Append NULL

        aSearchDocument->AddExcerptL(*bufExcerpt);

        CleanupStack::PopAndDestroy(bufExcerpt);

        }

    }

void CSearchServerSubSession::AddCompleteL(const RMessage2& /*aMessage*/)

	{

	iIndexDb->AddCompleteL();	

	}

void CSearchServerSubSession::UpdateL(const RMessage2& aMessage)

	{

	// Sanity check

	if (!iIndexDb->IsOpen())

		{

		iSession->PanicClient(aMessage, EDatabaseNotOpen);

		return;

		}

	// buf for the search terms

	HBufC8* serializedDocument = HBufC8::NewLC(aMessage.GetDesLength(0));

	// read the search terms

	TPtr8 ptr = serializedDocument->Des();

	aMessage.ReadL(0, ptr);

	RDesReadStream stream;

	stream.Open(ptr);

	stream.PushL();

	CSearchDocument* document = CSearchDocument::NewL(stream);

	CleanupStack::PopAndDestroy(&stream);

	CleanupStack::PushL(document);

	// Index the thing

	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogUpdateL( reinterpret_cast<TUint>(this), *document ) );

	LimitExcerptToMaxLengthL(document);

	iIndexDb->UpdateL(*document, this, aMessage);

	CleanupStack::PopAndDestroy(document);

	CleanupStack::PopAndDestroy(serializedDocument);

	}

void CSearchServerSubSession::UpdateCompleteL(const RMessage2& /*aMessage*/)

	{

	iIndexDb->UpdateCompleteL();	

	}

void CSearchServerSubSession::DeleteL(const RMessage2& aMessage)

	{

	// Sanity check

	if (!iIndexDb->IsOpen())

		{

		iSession->PanicClient(aMessage, EDatabaseNotOpen);

		return;

		}

	HBufC* docUid = HBufC::NewLC(aMessage.GetDesLength(0));

	TPtr ptr = docUid->Des();

	aMessage.ReadL(0, ptr);

	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogDeleteL( reinterpret_cast<TUint>(this), *docUid ) );

	iIndexDb->DeleteDocumentsL(*docUid, this, aMessage);

	CleanupStack::PopAndDestroy(docUid);

	}

void CSearchServerSubSession::DeleteCompleteL(const RMessage2& /*aMessage*/)

	{

	iIndexDb->DeleteDocumentsCompleteL();	

	}

void CSearchServerSubSession::FlushCompleteL(const RMessage2& /*aMessage*/)

	{

	iIndexDb->FlushCompleteL();	

	}

void CSearchServerSubSession::ResetL(const RMessage2& aMessage)

	{

	// Sanity check

	if (!iIndexDb->IsOpen())

		{

		iSession->PanicClient(aMessage, EDatabaseNotOpen);

		return;

		}

	// Reset database

	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogResetL( reinterpret_cast<TUint>(this) ) );

	iIndexDb->ResetL();

	// Complete the request

	aMessage.Complete(KErrNone);		

	}

void CSearchServerSubSession::FlushL(const RMessage2& aMessage)

    {

    // Sanity check

    if (!iIndexDb->IsOpen())

        {

        iSession->PanicClient(aMessage, EDatabaseNotOpen);

        return;

        }

    LOG_PLAYER_RECORD( CLogPlayerRecorder::LogFlushL( reinterpret_cast<TUint>(this) ) );

    iIndexDb->FlushL(this, aMessage);

    }

void CSearchServerSubSession::HandleAsyncronizerComplete(TCPixTaskType aType, TInt aError, const RMessage2& aMessage)

	{

	if (aError == KErrNone)

		{

		switch (aType)

			{

			case ECPixTaskTypeSearch:

				{

				TRAP(aError, SearchCompleteL(aMessage));

				break;

				}

			case ECPixTaskTypeGetDocument:

				{

				TRAP(aError, GetDocumentCompleteL(aMessage));

				break;

				}

			case ECPixTaskTypeAdd:

				{

				TRAP(aError, AddCompleteL(aMessage));

				break;

				}

			case ECPixTaskTypeUpdate:

				{

				TRAP(aError, UpdateCompleteL(aMessage));

				break;

				}

			case ECPixTaskTypeDelete:

				{

				TRAP(aError, DeleteCompleteL(aMessage));

				break;

				}

			case ECPixTaskTypeFlush:

				{

				TRAP(aError, FlushCompleteL(aMessage));

				break;

				}

			default:

				{

				// No need for completion code for the rest

				break;

				}

			}

		}

	// Complete the request

	aMessage.Complete(aError);		

	}