// 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 "HLPDB.H"

// System includes

#include <fbs.h>

// User includes

#include "HLPMODEL.H"

#include "hlppanic.h"

#include "Hlpsqlconsts.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "hlpmodel_internal.h"

#endif

// Constants

const TInt KHlpModelNumberOfImageTableColumnsForV6Point0HelpFile = 2;

const TInt KHlpModelNumberOfImagesInV6Point0HelpFile = 1;

//

// ----> CHlpDatabase  

//

CHlpDatabase::CHlpDatabase(RFs& aFs)

:	iFs(aFs)

	{

	}

CHlpDatabase::~CHlpDatabase()

	{

	Close();

	iImageTable.Close();

	delete iView;

	delete iDatabase;

	delete iStore;

	delete iUids;

	}

void CHlpDatabase::ConstructL()

	{

	iView = new(ELeave) RDbView;

	iUids = new(ELeave) CArrayFixFlat<TUid>(2);

	iDatabase = new(ELeave) RDbStoreDatabase;

	}

CHlpDatabase* CHlpDatabase::NewLC(RFs& aFs)

	{

	CHlpDatabase* self = new(ELeave) CHlpDatabase(aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CHlpDatabase* CHlpDatabase::NewLC(RFs& aFs, const TDesC& aFileName)

	{

	CHlpDatabase* self = CHlpDatabase::NewLC(aFs);

	self->OpenL(aFileName);

	return self;

	}

//

//

//

void CHlpDatabase::OpenL(const TDesC& aFileName)

	{

	iFileName = aFileName;

	iStore = CPermanentFileStore::OpenL(iFs, aFileName, EFileRead);

	// Restore the dictionary

	CStreamDictionary* dictionary = CStreamDictionary::NewLC();

	RStoreReadStream in;

	in.OpenLC(*iStore, iStore->Root());

	dictionary->InternalizeL(in);

	CleanupStack::PopAndDestroy(); // in

	// Restore the database

	iDatabase->OpenL(iStore, dictionary->At(KUidHlpDbStream));

	// Open image table

	_LIT(KImageTable, "IMAGE");

	_LIT(KImageIndex, "IMAGEIDX");

	User::LeaveIfError(iImageTable.Open(*iDatabase, KImageTable, RDbRowSet::EReadOnly));

	User::LeaveIfError(iImageTable.SetIndex(KImageIndex));

	// Fetch the image row

	CDbColSet* columnSet = iImageTable.ColSetL();

	// We can identify v6 help files by the number of columns in the image table.

	// Since v6 help files only have one image for all zoom sizes, then we 

	// can identify this via the number of columns being 2.

	iOldHelpFileFormat = (columnSet->Count() == KHlpModelNumberOfImageTableColumnsForV6Point0HelpFile);

	delete columnSet;

	// Restore the Uid list

	TStreamId uidStream = dictionary->At(KUidHlpUidStream);

	in.OpenLC(*iStore, uidStream);

	TUid uid;

	TKeyArrayFix key(_FOFF(TUid, iUid), ECmpTUint32);

	const TInt count = in.ReadInt32L();

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

		{

		uid.iUid = in.ReadInt32L();

#ifdef _DEBUG

		iUids->InsertIsqL(uid, key);

#else

		iUids->InsertIsqAllowDuplicatesL(uid, key);

#endif

		}

	CleanupStack::PopAndDestroy(2); // in, dictionary

	TEntry entry;

	User::LeaveIfError(iFs.Entry(aFileName, entry));

	iHelpFileUid = entry.MostDerivedUid();

	}

void CHlpDatabase::Close()

	{

	if	(iView)

		iView->Close();

	if	(iDatabase)

		iDatabase->Close();

	}

//

//

//

void CHlpDatabase::AppendCategoryListL(CDesCArray& aList)

	{

	_LIT(KCategoryTable, "TOPIC");

	// Open the topic table so that we can use it to build the category list

	RDbTable table;

	User::LeaveIfError(table.Open(*iDatabase, KCategoryTable, RDbRowSet::EReadOnly));

	CleanupClosePushL(table);

	// Now build the list

	if (table.FirstL())

		{

		// Get the column of the category

		CDbColSet* columnSet = table.ColSetL();

		TDbColNo categoryColumn = columnSet->ColNo(KSQLCategoryColumn);

		delete columnSet;

		TInt posNotReferenced = KErrNotFound;

		TBuf<KMaxTitleColumn> title;

		do

			{

			// Add the stuff

			table.GetL();

			title = table.ColDes(categoryColumn);

			if	(aList.Find(title, posNotReferenced)) // Returns something other than 0 if not found

				aList.AppendL(title); // Not found, so append

			}

		while (table.NextL());

		}

	// Finally, close the table

	CleanupStack::PopAndDestroy(&table);

	}

TInt CHlpDatabase::TopicIdSearchL(const TUid aCategoryUid, const TUint aTopicId)

	{

	const TInt KNumLength = 20;

	const TInt KMaxParamLength = (2*KNumLength) + 20; // 20 for numbers, + 20 for ' = ' and ' AND ' etc.

	TBuf<KNumLength> num;

	HBufC* sqlStatement = HBufC::NewLC(KSQLTopicSearchProlog().Length() + KMaxParamLength);

	TPtr pSql(sqlStatement->Des());

	pSql.Append(KSQLTopicSearchProlog);

	pSql.Append(KSQLTopicIdColumn);

	pSql.Append(KSQLEqualOperator);

	num.Num(aTopicId);

	pSql.Append(num);

	pSql.Append(KSQLAndOperator);

	pSql.Append(KSQLCategoryUidColumn);

	pSql.Append(KSQLEqualOperator);

	num.Num(STATIC_CAST(TUint, aCategoryUid.iUid));

	pSql.Append(num);

	iView->Close();

	User::LeaveIfError(iView->Prepare(Database(), TDbQuery(pSql, EDbCompareFolded), TDbWindow::EUnlimited, RDbRowSet::EReadOnly));

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

	CleanupStack::PopAndDestroy(); // sqlStatement

	if	(iView->CountL())

		{

		iView->FirstL();

		iView->GetL();

		return ETopicAvailable; // View is prepared

		}

	return ETopicNotFound;

	}

TInt CHlpDatabase::ContextSearchL(const TDesC& aContext)

	{

	_LIT(KContextSearch,	"SELECT CONTEXT, TOPICID FROM CONTEXT");

	_LIT(KSpecificContext,	" WHERE CONTEXT='%S'");

	TInt specificContextLength = aContext.Length();

	HBufC* sqlStatement = HBufC::NewLC(KContextSearch().Length() + KSpecificContext().Length() + specificContextLength);

	TPtr pStatement = sqlStatement->Des();

	pStatement.Append(KContextSearch);

	if	(specificContextLength)

		{

		HBufC* specificContext = HBufC::NewLC(KSpecificContext().Length() + specificContextLength);

		TPtr pContext = specificContext->Des();

		pContext.Format(KSpecificContext, &aContext);

		pStatement.Append(pContext);

		CleanupStack::PopAndDestroy(specificContext);

		}

	iView->Close();

	User::LeaveIfError(iView->Prepare(Database(), TDbQuery(pStatement, EDbCompareFolded), TDbWindow::EUnlimited, RDbRowSet::EReadOnly));

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

	CleanupStack::PopAndDestroy(sqlStatement);

	if	(iView->CountL())

		{

		// Get the topic id from the context table

		CDbColSet* columnSet = iView->ColSetL();

		TDbColNo topicIdCol = columnSet->ColNo(KSQLTopicIdColumn);

		delete columnSet;

		// Get the topic id as a descriptor

		iView->FirstL();

		iView->GetL();

		TUint topicId = iView->ColUint(topicIdCol);

		_LIT(KTopicSearch, "SELECT TOPICTITLE, TOPICID, CATEGORY, TOPICTEXT, TOPICMARKUP FROM TOPIC WHERE TOPICID=%d");

		sqlStatement = HBufC::NewLC(KTopicSearch().Length() + 16); // 16 for the topic id

		pStatement.Set(sqlStatement->Des());

		pStatement.Format(KTopicSearch, topicId);

		// Prepare the topic table with the correct record...

		iView->Close(); // Finished with this view now

		User::LeaveIfError(iView->Prepare(Database(), TDbQuery(pStatement, EDbCompareFolded), TDbWindow::EUnlimited, RDbRowSet::EReadOnly));

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

		CleanupStack::PopAndDestroy(); // sqlStatement

		return ETopicAvailable;

		}

	return ETopicNotFound;

	}

/** This method is called within the CHlpPicture::RestoreL() method and 

is responsible for finding the right bitmap to be retrieved and for reading 

in a pointer to that bitmap.

@param aImageId The ID of the bitmap to be retrieved.

@param aZoomState The current zoom state.

@return A pointer to a CFbsBitmap object.

@pre A valid zoom state is passed to the function.

@post A pointer to the referenced bitmap is returned. */

CFbsBitmap* CHlpDatabase::ImageForIdLC(TInt aImageId, THlpZoomState aZoomState)

{

	if	(!iImageTable.FirstL())

		User::Leave(KErrNotFound);

	if	(!iImageTable.SeekL(aImageId))

		User::Leave(KErrNotFound);

	// Fetch the image row

	iImageTable.GetL();

	// Work out which column the image is in

	CDbColSet* columnSet = iImageTable.ColSetL();

	CleanupStack::PushL(columnSet);

	TDbColNo imageColumn = KDbNullColNo;

	if	(iOldHelpFileFormat)

		{

		// OLD HELP FILE FORMAT

		// Retrieve bitmap from bitmap column in image table

		// and store it in the 'imageColumn variable'

		imageColumn = columnSet->ColNo(KSQLImageColumn);

		}

	else

		{

		// NEW HELP FILE FORMAT

		// Depending on whether the number of bitmaps is 1 or 3,

		// the bitmap from the appropriate column is retrieved 

		// and stored in the 'imageColumn' variable

		// Stores the number of bitmaps per image table row.

		const TInt bitmapCount = ImageCountForIdL(aImageId);

		__ASSERT_DEBUG(bitmapCount <= KHlpModelMaximumNumberOfImagesForV6Point2Files, User::Invariant());

		if	(bitmapCount == KHlpModelDefaultNumberOfImagesForV6Point2Files)

			imageColumn = columnSet->ColNo(KSQLImage0Column);

		else if (bitmapCount == KHlpModelMaximumNumberOfImagesForV6Point2Files)

			{

			switch(aZoomState) 

				{

				case EHlpZoomStateSmall:

					imageColumn = columnSet->ColNo(KSQLImage0Column);

					break;

				default:

				case EHlpZoomStateMedium:

					imageColumn = columnSet->ColNo(KSQLImage1Column);

					break;

				case EHlpZoomStateLarge:

					imageColumn = columnSet->ColNo(KSQLImage2Column);

					break;

				}

			}

		}

	CleanupStack::PopAndDestroy(columnSet);

	// Load the image from the blob

	CFbsBitmap* bitmap = new(ELeave) CFbsBitmap();

	CleanupStack::PushL(bitmap);

	// Read the column from the blob

	RDbColReadStream blob;

	blob.OpenLC(iImageTable, imageColumn);

	blob >> *bitmap;

	CleanupStack::PopAndDestroy(); // blob

	return bitmap;

	}

/** This method is called within the CHlpDatabase::ImageForIdLC() 

method and is responsible for returning the number of bitmaps stored 

in the image-table row, as referenced by the aImageId argument.

@param aImageId The ID of the bitmap, used for retrieving image-table 

column information.

@return An integer value that reflects the number of bitmaps within a 

particular image-table row.

@pre None.

@post The integer number at the image-table row referenced by 

aImageId is returned.

@see RDbTable::GetL()

@see RDbTable::ColSetL() */

TInt CHlpDatabase::ImageCountForIdL(TInt aImageId)

	{

	if	(!iImageTable.FirstL())

		User::Leave(KErrNotFound);

	if	(!iImageTable.SeekL(aImageId))

		User::Leave(KErrNotFound);

	// Fetch the image row

	iImageTable.GetL();

	TInt count = KErrNotFound;

	if	(iOldHelpFileFormat)

		count = KHlpModelNumberOfImagesInV6Point0HelpFile;

	else

		{

		// Work out which column the image count is in, 

		// and assign it to 'imageCountColumn'.

		CDbColSet* columnSet = iImageTable.ColSetL();

		TDbColNo imageCountColumn = columnSet->ColNo(KSQLImageCountColumn);

		delete columnSet;

		//

		count = iImageTable.ColUint(imageCountColumn);

		}

	return count;

	}

//

//

//

TBool CHlpDatabase::MatchUidL(TUid aUid)

	{

	__ASSERT_ALWAYS(iUids, Panic(EHlpFault));

	TInt index = KErrNotFound;

	TKeyArrayFix key(_FOFF(TUid, iUid), ECmpTUint32);

	// For some bizare reason, findisq returns 0 when the item was found.

	return (iUids->FindIsq(aUid, key, index) == KErrNone);

	}