// Copyright (c) 2001-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 "tstore.h"

// System includes

#include "DBWRITER.H"

#include <txtrich.h>

#include <txtfmlyr.h>

#include <txtmrtsr.h>

#include <gdi.h>

// Constants

const TUint32 KBaseCategoryUID = 1;

const TUint32 KHelpFileUID = 0;

const TUint32 KNumberHelpTopics = 20;

// Literal constants

_LIT(KProgressText, ".");

// Classes

CTestWriter::CTestWriter(RFs& aFs)

:	iFs(aFs), iCategoryUID(KBaseCategoryUID)

	{

	}

CTestWriter::~CTestWriter()

	{

	delete iWriter;

	delete iRichText;

	delete iCharFormatLayer;

	delete iParaFormatLayer;

	}

CTestWriter* CTestWriter::NewL(RFs& aFs)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CTestWriter::ConstructL()

	{

	iWriter = CHlpDbWriter::NewL(iFs);

	iCharFormatLayer = CCharFormatLayer::NewL();

	iParaFormatLayer = CParaFormatLayer::NewL();

	iRichText = CRichText::NewL(iParaFormatLayer, iCharFormatLayer);	

	}

void CTestWriter::BuildFilesL()

	{

	//SinceDBWriter can not add/remove files from the protected rsc directory we put the file in the public area

	_LIT(KHelpFileNameFormatString, "C:\\Public\\Help\\file%d.dat");

	TheFsSession.MkDirAll(KHelpFileNameFormatString);

	DeleteFilesL();

	TInt i = 0;

	TFileName fileName;

	TInt numberOfFiles=25;

	// build 25 1UID database files 

	TheTest.Next(_L("Creating 25 databases with 1 category"));

	for (i=0; i<numberOfFiles; i++)

		{

		iFileCount=i;

		fileName.Format(KHelpFileNameFormatString, i);

		BuildFileL(fileName, TUid::Uid(KHelpFileUID + i), 1);

		}

	// build 25 3UID database files 

	TheTest.Next(_L("\nCreating 25 databases with 3 categories"));

	for (i=0; i<numberOfFiles; i++)

		{

		iFileCount=i;

		fileName.Format(KHelpFileNameFormatString, (i+numberOfFiles));

		BuildFileL(fileName, TUid::Uid(KHelpFileUID + i), 3);

		}

	// build 25 15UID database files 

	TheTest.Next(_L("\nCreating 25 databases with 15 categories"));

	for (i=0; i<numberOfFiles; i++)

		{

		iFileCount=i;

		fileName.Format(KHelpFileNameFormatString, (i+2*numberOfFiles));

		BuildFileL(fileName, TUid::Uid(KHelpFileUID + i), 15);

		}

	}

void CTestWriter::BuildFileL(const TDesC& aFileName, TUid aUid, TUint aNumberCategoryUID)

	{

	// Pre writing

	iWriter->CreateFileL(aFileName);

	iWriter->SetDatabaseUidL(aUid);

	iWriter->CreateDatabaseL();

	// Writing

	WriteUidTableL(aNumberCategoryUID);

	WriteTopicTableL(aNumberCategoryUID);

	WriteContextTableL();

	WriteTopicIndexTableL();

	WriteIndexTableL();

	// Post writing

	iWriter->CompressDatabaseL();

	iWriter->CloseFileL();

	}

// write out the uid table 

void CTestWriter::WriteUidTableL(TUint aNumberCategoryUID)

	{

	for (TUint i=0; i < aNumberCategoryUID; i++)

		{

		TUid uid;

		uid.iUid=iCategoryUID+i;

		iWriter->SetUidL(uid);

		}

	}

void CTestWriter::WriteTopicTableL( TUint aNumberCategoryUID)

	{

	iWriter->BeginTransaction();

	// loop for the number of categories in the database

	for( TUint i = 0; i < aNumberCategoryUID;i++)

		{

		// write out a set of topics

		WriteTopicsL(i);

		iCategoryUID++;

		}

	// commit the transaction

	iWriter->CommitTransaction();

	TheTest.Printf(KProgressText);

	}

// write out a set of topics

void CTestWriter::WriteTopicsL(TUint aTopicIDMultiplier)

	{

	TBuf<32> buf;

	TBuf<1042> buf2;

	CHlpTable* table = iWriter->TopicTable();

	for(TUint i=0; i<KNumberHelpTopics; i++)

		{

		// create and write out a title

		table->InsertL();

		buf.Zero();

		buf.Format(KTopicTitle, (KNumberHelpTopics*aTopicIDMultiplier)+i+(1000*iFileCount), iFileCount);

		table->SetColL(KTopicTblTopicTitle,buf);

		// add the title to the body text

		buf2.Append(buf);

		buf2.Append(TChar(2029));

		// create and write the category string

		buf.Zero();

		buf.Format(KCategory, iCategoryUID);

		table->SetColL(KTopicTblCategoryTitle, buf);

		// add the category to the body text

		buf2.Append(buf);

		buf2.Append(TChar(2029));

		buf2.Append(KBodyText);

		iRichText->Reset();

		iRichText->InsertL(0, buf2);

		// write out the body text

		table->SetColL(KTopicTblTopicText, KTopicTblTopicMarkup, *iRichText);

		// write out some synonyms

		buf2.Zero();

		table->SetColL(KTopicTblSynonym, CONST_CAST(TDesC&, KSynonymText()));

		// calculate and write out the topicID

		TInt id;

		id=(KNumberHelpTopics*aTopicIDMultiplier)+i+(1000*iFileCount);

		table->SetColL(KTopicTblTopicId, id);

		// set the category UID

		table->SetColL(KTopicTblCategoryUID, iCategoryUID);

		table->PutL();

		}

	TheTest.Printf(KProgressText);

	}

void CTestWriter::WriteContextTableL()

	{

	CHlpTable* table = iWriter->ContextTable();

	iWriter->BeginTransaction();

	TBuf<32> buf;

	for(TInt i=1; i <=20; i++)

		{

		buf = KContextText;

		buf.AppendNum(iFileCount);

		buf.AppendNum(i);

		table->InsertL();

		table->SetColL(KContextTblTopicId, i+(1000*iFileCount));

		table->SetColL(KContextTblContext, buf);

		table->PutL();

		}

	iWriter->CommitTransaction();

	TheTest.Printf(KProgressText);

	}

void CTestWriter::WriteIndexTableL()

	{

	CHlpTable* table = iWriter->IndexTable();

	iWriter->BeginTransaction();

	TBuf<120> buf;

	for(TInt i=1; i<=20; i++)

		{

		table->InsertL();

		buf.Format(KIndexPhrase, i, iFileCount);

		table->SetColL(KIndexTblIndex, buf);

		table->SetColL(KIndexTblIndexId, i);

		table->PutL();

		}

	iWriter->CommitTransaction();

	TheTest.Printf(KProgressText);

	}

void CTestWriter::WriteTopicIndexTableL()

	{

	CHlpTable* table = iWriter->TopicIndexTable();

	iWriter->BeginTransaction();

	for(TInt i=1; i<=20; i++)

		{

		table->InsertL();

		const TInt id = i+(1000*iFileCount);

		table->SetColL(KTopicIndexTblTopicId, id);

		table->SetColL(KTopicIndexTblIndexId, i);

		table->PutL();

		}

	iWriter->CommitTransaction();

	TheTest.Printf(KProgressText);

	}

void CTestWriter::DeleteFilesL()

	{

	_LIT(KHelpFileNameFormatString, "C:\\Public\\Help\\*.*");

	CFileMan* fileman = CFileMan::NewL(iFs);

	CleanupStack::PushL(fileman);

	TInt error = (fileman->Delete(KHelpFileNameFormatString)); 

	if	(error != KErrNone && error != KErrNotFound)

		User::Leave(error);

	CleanupStack::PopAndDestroy(fileman);

	}

static void StartTestL()

    {

	TheWriter = CTestWriter::NewL(TheFsSession);

	TRAPD(error,

		TheWriter->BuildFilesL();

	); 

	if	(error)

		TheTest.Printf(_L("leave code=%d\n"), error);

	else

		TheTest.Printf(_L("\nok"));

	TheTest(error == KErrNone || error == KErrNoMemory);

	TheTest.Printf(_L("Last category written %d\n"), TheWriter->CategoryUID());

	delete TheWriter;

    }

static void TidyFilesL(TAny*)

	{

	TheWriter = CTestWriter::NewL(TheFsSession);

	CleanupStack::PushL(TheWriter);

	TheWriter->DeleteFilesL();

	CleanupStack::PopAndDestroy(TheWriter);

	}

static void DoOOMTestL()

	{

	TInt error = KErrNoMemory;

	TInt failAt = 0;

	while(error!=KErrNone)

		{

		failAt++;

		__UHEAP_SETFAIL(RHeap::EDeterministic, failAt);

		__UHEAP_MARK;

		TRAP(error, StartTestL());

		if	(error != KErrNone)

			{

			__UHEAP_MARKEND;

			}

		__UHEAP_RESET;

		TheTest(error == KErrNoMemory || error == KErrNone);

		}

	}

static void doMainL()

	{

	TInt error = KErrNone;

	CleanupStack::PushL(TCleanupItem(TidyFilesL, 0));

	// Normal test

	TRAP(error, StartTestL());

	TheTest(error == KErrNone);

	// OOM test

	TRAP(error, DoOOMTestL());

	TheTest(error == KErrNone);

	CleanupStack::PopAndDestroy();

	}

/**

@SYMTestCaseID PIM-TSTORE-0001

*/	

GLDEF_C TInt E32Main()

    {

	__UHEAP_MARK;

	TheTest.Start(_L("@SYMTestCaseID PIM-TSTORE-0001 Creating cleanup objects"));

	CTrapCleanup* cleanup = CTrapCleanup::New();

	TheTest(TheFsSession.Connect() == KErrNone);

	TRAPD(error, doMainL());

	TheTest(error == KErrNone);

	// Cleanup & close

	delete cleanup;

	TheFsSession.Close();

	TheTest.End();

	TheTest.Close();

	__UHEAP_MARKEND;

	return KErrNone;

    }