// Copyright (c) 1999-2009 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 "HLPSRCH.H"

#include <d32dbms.h>

#include "Hlpsqlconsts.h"

#include "hlppanic.h"

//

// CHlpSQLSearch class

//

CHlpSQLSearch::CHlpSQLSearch(MHlpDbObserver& aObserver)

:	iObserver(&aObserver)

	{

	}

CHlpSQLSearch::~CHlpSQLSearch()

	{

	delete iSQLStatement;

	delete iSQLEvaluator;

	}

void CHlpSQLSearch::ConstructL()

	{

	iSQLStatement = new (ELeave) CHlpSQLBuffer();

	iSQLStatement->ConstructL(256);

	iSQLEvaluator = CHlpSQLEvaluator::NewL(CActive::EPriorityLow);

	}

CHlpSQLSearch* CHlpSQLSearch::NewL(MHlpDbObserver& aObserver)

	{

	CHlpSQLSearch* self = new(ELeave) CHlpSQLSearch(aObserver);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

void CHlpSQLSearch::SetDatabase(CHlpDatabase& aDatabase)

	{

	iDatabase = &aDatabase;

	iView = &aDatabase.View();

	}

void CHlpSQLSearch::CancelEvaluator()

	{

	Reset();

	}

void CHlpSQLSearch::Reset()

	{

	iSQLEvaluator->Cancel();

	iSQLStatement->Reset();

	iFlags &= (~EFlagsAsynchronousSearch|EFlagsPerformSearch);

	}

void CHlpSQLSearch::SearchL(TInt aType, const TDesC& aCriterion)

	{

	__ASSERT_ALWAYS(iDatabase, Panic(EHlpDatabaseNotInTransaction));

	Reset();

	switch(aType)

		{

	case EIndexList:

		IndexListL();

		break;

	case ECategoryList:

		CategoryListL();

		break;

	case ETopicListForCategory:

		TopicListForCategoryL(aCriterion);	

		break;

	case ETopicListForCategoryUID:

		TopicListForCategoryUIDL(aCriterion);	

		break;

	case EContextSearch:

		ContextSearchL(aCriterion);

		break;

	case EIndexSearch:

		IndexIdSearchL(aCriterion);

		break;

	case EQuickSearch:

		TextSearchL(aCriterion, EFalse);

		break;

	case EFullTextSearch:

		TextSearchL(aCriterion, ETrue);

		break;

	case ETopicIdSearch:

		TopicIdSearchL(aCriterion);

		break;

	default:

		Panic(EHlpInvalidQuery);

		break;

		}	

	BuildViewL();

	}

void CHlpSQLSearch::ContextSearchL(const TDesC& aCriterion)

	{

	iFlags |= EFlagsPerformSearch;

	iSQLStatement->AppendSQLL(KSQLContextSearch());

	iSQLStatement->AppendL(aCriterion);

	iSQLStatement->AppendSQLL(KSQLSingleInvComma());

	}

void CHlpSQLSearch::IndexIdSearchL(const TDesC& aCriterion)

	{

	iFlags |= EFlagsPerformSearch;

	iSQLStatement->AppendSQLL(KSQLIndexIdSearch());

	iSQLStatement->AppendL(aCriterion);

	}

void CHlpSQLSearch::TopicIdSearchL(const TDesC& aCriterion)

	{

	iSQLStatement->AppendSQLL(KSQLTopicSearchProlog());

	iSQLStatement->AppendSQLL(KSQLTopicIdColumn());

	iSQLStatement->AppendSQLL(KSQLEqualOperator());

	iSQLStatement->AppendL(aCriterion);

	}

void CHlpSQLSearch::TextSearchL(const TDesC& aCriterion, TBool aFullText)

	{

	// Text searching is asynchronous

	iFlags |= EFlagsAsynchronousSearch;

	iSQLStatement->AppendSQLL(KSQLTopicIdSearchProlog());

	iSQLStatement->AppendSQLL(KSQLTxtSrchTopicTitle());

	iSQLStatement->AppendL(aCriterion);

	if	(aFullText)

		{

		iSQLStatement->AppendSQLL(KSQLTxtSrchTopicText());

		iSQLStatement->AppendL(aCriterion);

		}

	iSQLStatement->AppendSQLL(KSQLTxtSrchCat());

	iSQLStatement->AppendL(aCriterion);

	iSQLStatement->AppendSQLL(KSQLTxtSrchSynonym());

	iSQLStatement->AppendL(aCriterion);

	iSQLStatement->AppendSQLL(KSQLLikeClosingInvComma());

	}

void CHlpSQLSearch::TopicIdSearchL()

	{

	iFlags &= (~EFlagsPerformSearch);

	if	(iView->CountL())

		{

		iSQLStatement->AppendSQLL(KSQLTopicIdSearchProlog());

		iView->FirstL();

		CDbColSet* colset = iView->ColSetL();

		TDbColNo topicCol = colset->ColNo(KSQLTopicIdColumn);

		delete colset;

		while(!iView->AtEnd())

			{

			iSQLStatement->AppendSQLL(KSQLTopicIdColumn());

			iSQLStatement->AppendSQLL(KSQLEqualOperator());

			iView->GetL();

			iSQLStatement->AppendL(iView->ColUint32(topicCol));

			iView->NextL();

			if	(!iView->AtEnd())

				iSQLStatement->AppendSQLL(KSQLOrOperator());

			}

		}

	}

void CHlpSQLSearch::CategoryListL()

	{

	iSQLStatement->AppendSQLL(KSQLCategoryList());

	iFlags &= (~EFlagsAsynchronousSearch);

	}

void CHlpSQLSearch::IndexListL()

	{

	iSQLStatement->AppendSQLL(KSQLIndexList());

	iFlags &= (~EFlagsAsynchronousSearch);

	}

void CHlpSQLSearch::TopicListForCategoryL(const TDesC& aCriterion)

	{

	iSQLStatement->AppendSQLL(KSQLTopicByCategoryProlog());

	iSQLStatement->AppendSQLL(KSQLSingleInvComma());

	iSQLStatement->AppendL(aCriterion);

	iSQLStatement->AppendSQLL(KSQLSingleInvComma());

	iFlags &= (~EFlagsAsynchronousSearch);

	}

void CHlpSQLSearch::TopicListForCategoryUIDL(const TDesC& aCriterion)

	{

	iSQLStatement->AppendSQLL(KSQLTopicByCategoryUIDProlog());

	iSQLStatement->AppendL(aCriterion);

	iFlags &= (~EFlagsAsynchronousSearch);

	}

void CHlpSQLSearch::HandleSearchEventL(TInt aEvent)

	{

	switch(aEvent)

		{

	case ESearchComplete:

		if	(iFlags & EFlagsPerformSearch)

			{

			ReportEventToObserverL(ESearchInProgress);

			Reset();

			TopicIdSearchL();

			BuildViewL();

			}

		else

			ReportEventToObserverL(ESearchComplete);

		break;

	default:

		ReportEventToObserverL(aEvent);

		break;

		}

	}

void CHlpSQLSearch::BuildViewL()

	{

	iView->Close();	

	TDbQuery query(iSQLStatement->SearchStatement(), EDbCompareFolded);

	User::LeaveIfError(iView->Prepare(iDatabase->Database(), query, TDbWindow::EUnlimited, RDbRowSet::EReadOnly));

	if	(iFlags & EFlagsAsynchronousSearch)

		iSQLEvaluator->Initialize(*iView, *this);

	else

		{

		User::LeaveIfError(iView->EvaluateAll());

		if	(iView->CountL())

			ReportEventToObserverL(ESearchComplete);

		else

			ReportEventToObserverL(ENoRecordsFound);

		}

	}

//

// CHlpSQLEvaluator class

//

CHlpSQLEvaluator::CHlpSQLEvaluator(TInt aPriority)

:	CActive(aPriority)

	{

	CActiveScheduler::Add(this);

	}

CHlpSQLEvaluator::~CHlpSQLEvaluator()

	{

	Cancel();

	}

CHlpSQLEvaluator* CHlpSQLEvaluator::NewLC(TInt aPriority)

	{

	CHlpSQLEvaluator* self = new (ELeave) CHlpSQLEvaluator(aPriority);

	CleanupStack::PushL(self);

	return self;

	}

CHlpSQLEvaluator* CHlpSQLEvaluator::NewL(TInt aPriority)

	{

	CHlpSQLEvaluator* self = CHlpSQLEvaluator::NewLC(aPriority);

	CleanupStack::Pop();

	return self;

	}

void CHlpSQLEvaluator::Initialize(RDbView& aView, MHlpPrivObserver& aObserver)

	{

	Cancel();

	iView = &aView;

	iObserver = &aObserver;

	Start();

	}

void CHlpSQLEvaluator::Start()

	{

	// Kludge an asynch request

	iStatus = KRequestPending;

	SetActive();

	TRequestStatus* pS = &iStatus;

	User::RequestComplete(pS, KErrNone);

	}

void CHlpSQLEvaluator::RunL()

	{

	if	(iStatus != KErrNone)

		{

		// Panic in debug mode

		__ASSERT_DEBUG(0, Panic(EHlpAsynchSearchError));

		// In release mode return nothing found

		iObserver->HandleSearchEventL(ENoRecordsFound);

		}

	else

		{

		TInt more = iView->Evaluate();

		TInt count = (more >= 0)? iView->CountL() : 0;

		if	(more > 0)

			{

			Start();

			iObserver->HandleSearchEventL(ESearchInProgress);

			}

		else 

			iObserver->HandleSearchEventL((count)? ESearchComplete : ENoRecordsFound);

		}

	}

void CHlpSQLEvaluator::DoCancel()

	{

	TRAP_IGNORE(iObserver->HandleSearchEventL(EHlpSearchCancelled)); // API is part of framework, could leave 

	}

//

// CHlpSQLBuffer class

//

void CHlpSQLBuffer::ConstructL(TInt aBufferSize)

	{

	iSQLStatement = HBufC::NewL(aBufferSize);

	}

CHlpSQLBuffer::CHlpSQLBuffer()

	{

	}

CHlpSQLBuffer::~CHlpSQLBuffer()

	{

	delete iSQLStatement;

	}

void CHlpSQLBuffer::AppendL(TInt aNum)

	{

	TBuf<32> buf;

	buf.AppendNum(aNum);

	AppendTextL(buf);

	}

void CHlpSQLBuffer::AppendL(const TDesC& aDes)

	{

	_LIT(KHlpModelInvertedComma, "'");

	// If the text contains inverted commas, then these must be escaped before

	// passing down to DBMS.

	TInt pos = aDes.Find(KHlpModelInvertedComma);

	if	(pos != KErrNotFound)

		{

		// Worst case scenario is that every character needs escaping...

		const TInt length = aDes.Length();

		HBufC* escapedText = HBufC::NewLC(length * 2);

		TPtr pText(escapedText->Des());

		pText.Copy(aDes);

		// Run through the text inserting extra apostrophes:

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

			{

			const TPtrC pChar(pText.Mid(i, 1));

			if	(pChar == KHlpModelInvertedComma)

				{

				pText.Insert(i, KHlpModelInvertedComma);

				// Skip over the newly inserted character

				++i;

				}

			}

		// Perform a normal append of the resulting escaped text:

		AppendTextL(*escapedText);

		CleanupStack::PopAndDestroy(escapedText);

		}

	else

		{

		// No apostrophes so no escaping needed:

		AppendTextL(aDes);

		}

	}

void CHlpSQLBuffer::AppendSQLL(const TDesC& aDes)

	{

	AppendTextL(aDes);

	}

void CHlpSQLBuffer::AppendTextL(const TDesC& aDes)

	{

	TPtr tempPtr(iSQLStatement->Des());

	const TInt KExtraBufferSize = 100;

	if ( (tempPtr.Length() + aDes.Length()) <= tempPtr.MaxLength() )

		{

		tempPtr.Append(aDes);

		}

	else

		{

		const TInt newSize = Max(KExtraBufferSize, aDes.Length()+iSQLStatement->Length());

		iSQLStatement = iSQLStatement->ReAllocL(newSize);

		iSQLStatement->Des().Append(aDes);

		}

	}

const TDesC& CHlpSQLBuffer::SearchStatement() const

	{

	return *iSQLStatement;

	}

void CHlpSQLBuffer::Reset()

	{

	iSQLStatement->Des().Zero();

	}