// 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: Neeraj Nayan

//

// Description: The class provides interface to read/write header and

// body entry from the database.

//

/**

 * HEADER FILES

 */

#include "msvpreferreddrivelist.h"		// Preferred drive list.

#include "msvmessagedbadapter.h"		// Header file for this class.

#include "msvindexadapter.h"			// For GetDriveId()

#include "msvdbadapter.h"				// For BindL() and handle to CMsvDBAdapter while constructing

/**

 * LITERAL DEFINITION

 */

const TInt KMaxQueryLength = 1000;

// Macros to wrap DB error. KErrGeneral is thrown for

// all DB error. Make sure you declare 'err' before 

// using these macros.

#define MSG_WRAP_DB_LEAVE(x) TRAP(err, x); \

							 if(err<=KSqlErrGeneral) User::Leave(KErrGeneral); \

							 User::LeaveIfError(err);							 

#define MSG_WRAP_DB_ERROR(errTxt) err = errTxt; \

							if(err<=KSqlErrGeneral) User::Leave(KErrGeneral); \

							else User::LeaveIfError(err);

/**

 * MEMBER FUNCTIONS OF CMsvMessageDBAdapter

 */

/**

 * CMsvMessageDBAdapter()

 * The default Constructor. 

 */

CMsvMessageDBAdapter::CMsvMessageDBAdapter(CMsvDBAdapter* aDBAdapter):

		iDBAdapter(aDBAdapter), iDatabaseRef(aDBAdapter->iDatabase)

	{

	}

/**

 * ~CMsvMessageDBAdapter()

 * The default Destructor. 

 */

CMsvMessageDBAdapter::~CMsvMessageDBAdapter()

	{

	iHeaderDataList.ResetAndDestroy();

	}

/**

 * NewL()

 * 

 * @param CMsvDBAdapter* : A reference to database adapter class.

 * @return CMsvMessageDBAdapter* : A reference to CMsvMessageDBAdapter

 * class.

 * 

 * Allocates and constructs a new CMsvMessageDBAdapter object.

 */

CMsvMessageDBAdapter* CMsvMessageDBAdapter::NewL(CMsvDBAdapter* aDBAdapter,TBool aDbInCurrentDrive)

	{

	//Create the DBAdapter object.

	CMsvMessageDBAdapter* self = new(ELeave) CMsvMessageDBAdapter(aDBAdapter);

	CleanupStack::PushL(self);

	self->ConstructL(aDbInCurrentDrive);

	CleanupStack::Pop();

	return self;

	}

/*

 * ConstructL()

 * 

 * The function populates metadata structure. A metadata structure

 * contains information about metadata table which is later used to 

 * create and update header entries. The structure is updated whenever

 * a new header table is created in the database.

 */ 

void CMsvMessageDBAdapter::ConstructL(TBool aDbInCurrentDrive)

	{

	// check if the operation are required for only single drive

	// This is required for message store converter as it works only on 1 drive.

	if(aDbInCurrentDrive)

		{

		iNonAttachedDrive = ETrue;

		UpdateMetadataStructureL(KCurrentDriveId);

		}

	else

		{

		iNonAttachedDrive = EFalse;

		for(TInt index=1; index<KMaxNumberOfDrives; index++)

			{

			if((*(iDBAdapter->iDatabasePresent))[index])

				{

				UpdateMetadataStructureL(index);

				}

			}

		}

	}

void CMsvMessageDBAdapter::UpdateMetadataStructureL(TUint aDriveId)

	{

	TInt err;

	_LIT(KCheckHeaderTableQuery0, "SELECT tbl_name FROM DB");

	_LIT(KCheckHeaderTableQuery1, ".sqlite_master WHERE type = 'table' AND tbl_name LIKE 'Header_%';");

	// 1. Get all the header table names from the SQLITE_MASTER table.

	RBuf headerTableQuery;

	CleanupClosePushL(headerTableQuery);

	headerTableQuery.CreateL(KMaxQueryLength);

	// Create the query string.

	if(!iNonAttachedDrive)

		{

		headerTableQuery.Append(KCheckHeaderTableQuery0);

		headerTableQuery.AppendNum(aDriveId);

		headerTableQuery.Append(KCheckHeaderTableQuery1);

		}

	else

		{

		_LIT(KCheckHeaderTableQuery2, "SELECT tbl_name FROM sqlite_master WHERE type = 'table' AND tbl_name LIKE 'Header_%';");

		headerTableQuery.Append(KCheckHeaderTableQuery2);

		}

	//Prepare a statement for the query.

	RSqlStatement sqlStmt;

	RPointerArray<HBufC> headerTableNames;

	CleanupClosePushL(sqlStmt);

	CleanupClosePushL(headerTableNames);

	MSG_WRAP_DB_ERROR(sqlStmt.Prepare(iDatabaseRef, headerTableQuery));

	// Prepare a list of header table names.

	HBufC* tableName = NULL;

	while((err = sqlStmt.Next()) == KSqlAtRow)

		{

		MSG_WRAP_DB_LEAVE(tableName = ColumnTextL(sqlStmt, 0));

		CleanupStack::PushL(tableName);

		headerTableNames.AppendL(tableName);

		CleanupStack::Pop();

		}

	MSG_WRAP_DB_ERROR(err);

	// 2. For each tablename read the table structure from the DB.

	_LIT(KGetHeaderSchema1, "SELECT * FROM DB");

	_LIT(KGetHeaderSchema2, ".");

	_LIT(KGetHeaderSchema3, ";");

	_LIT(KGetHeaderSchema4, "SELECT * FROM ");

	while(headerTableNames.Count())

		{

		HBufC* tableName = headerTableNames[0];

		TLex mtmId(tableName->Mid(tableName->Locate('_')+1));

		TUid uid;

		mtmId.Val(uid.iUid);

		// Don't insert meta-data if we already have it for this mtmId.

		if(GetMetadataEntryIndex(uid) != KErrNotFound)

			{

			delete tableName;

			headerTableNames.Remove(0);

			continue;

			}

		headerTableQuery.Zero();

		sqlStmt.Close();

		if(iNonAttachedDrive) // this is for msg converter. it refers to  a single drive

			{

			headerTableQuery.Append(KGetHeaderSchema4);

			}

		else

			{

			// This creates following string...

			// "SELECT * FROM DB<driveId>.HEADER_<MtmId>;" 

			headerTableQuery.Append(KGetHeaderSchema1);

			headerTableQuery.AppendNum(aDriveId);

			headerTableQuery.Append(KGetHeaderSchema2);

			}

		headerTableQuery.Append(tableName->Des());

		headerTableQuery.Append(KGetHeaderSchema3);

		MSG_WRAP_DB_ERROR(sqlStmt.Prepare(iDatabaseRef, headerTableQuery));

		CHeaderMetaData* headerMetaData = new(ELeave) CHeaderMetaData();

		CleanupStack::PushL(headerMetaData);

		TInt metadataIndex = 0;

		headerMetaData->iMtmId.iUid = uid.iUid;

		TInt colCnt = sqlStmt.ColumnCount();

		// Record the header structure, ignore first two fields (Id, UID).

		TRAPD(err, 

			for(TInt index=2; index<colCnt; index++)

				{			

				CFieldClass* fieldObj = new(ELeave) CFieldClass();

				CleanupStack::PushL(fieldObj);

				User::LeaveIfError(sqlStmt.DeclaredColumnType(index, fieldObj->iType));

				TPtrC fieldName;

				User::LeaveIfError(sqlStmt.ColumnName(index, fieldName));

				fieldObj->iName = fieldName.AllocL();

				headerMetaData->iFieldList.AppendL(fieldObj);

				CheckStdColumnsAdded(fieldObj->iName, headerMetaData->iStdColumnStatus);

				CleanupStack::Pop(fieldObj);

				}

			);

		if(err)

			{			

			MSG_WRAP_DB_ERROR(err);

			}

		iHeaderDataList.InsertL(headerMetaData, metadataIndex);

		CleanupStack::Pop();			// headerMetaData

		delete tableName;

		headerTableNames.Remove(0);

		}		// while(headerTableNames.Count())

	CleanupStack::PopAndDestroy(3); // headerTableQuery, sqlStmt, headerTableNames

	}

/*

 * IsHeaderTableExistsL()

 *

 * @param aMtmId: MTM ID of the header table.

 * @return TBool: ETrue/EFalse

 * 

 * The function returns ETrue if the header table for 

 * passed MTM ID already exists in the database. The 

 * function works for only message server current drive.

 */

TBool CMsvMessageDBAdapter::IsHeaderTableExistsL(const TUid& aMtmId)

	{

	_LIT16(KCheckHeaderTableQuery1, "SELECT COUNT(*) FROM DB");

	_LIT16(KCheckHeaderTableQuery2, ".SQLITE_MASTER WHERE NAME LIKE 'Header_");

	_LIT16(KCheckHeaderTableQuery3, "';");

	RBuf headerTableQuery;

	CleanupClosePushL(headerTableQuery);

	headerTableQuery.CreateL(KMaxQueryLength);

	// Create the query string.

	// Ex: SELECT COUNT(*) FROM DB<drive-id>.SQLITE_MASTER WHERE 

	// NAME LIKE 'Header_<mtm-id>';

	headerTableQuery.Append(KCheckHeaderTableQuery1);

	headerTableQuery.AppendNum(KCurrentDriveId);

	headerTableQuery.Append(KCheckHeaderTableQuery2);

	headerTableQuery.AppendNum(aMtmId.iUid);

	headerTableQuery.Append(KCheckHeaderTableQuery3);

	TInt count = 0;

	TSqlScalarFullSelectQuery query(iDatabaseRef);

	TRAPD(err, count = query.SelectIntL(headerTableQuery));

	CleanupStack::PopAndDestroy();			// headerTableQuery

	// If the table exists, count will have value 1.

	if(err == KErrNone && count == 1)

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

/*

 * CreateHeaderTableL()

 *

 * @param aMtmId: MTM ID of the table.

 * @param aFieldDetails: Table structure details.

 * @return aErrorMessage: Error message text, in case

 * header table creation fails.

 *

 * The function creates separate header table for each MTM type. 

 * If the table already exist, it simply exits without returning an error.

 */

void CMsvMessageDBAdapter::CreateHeaderTableL(const TUid& aMtmId, const RPointerArray<CFieldPair>& aFieldDetails, TPtrC& aErrorMessage)

	{

	RBuf headerTableQuery;

	CleanupClosePushL(headerTableQuery);

	headerTableQuery.CreateL(KMaxQueryLength);	

	CHeaderMetaData* headerMetaData = new(ELeave) CHeaderMetaData();

	CleanupStack::PushL(headerMetaData);

	TInt metadataIndex = GetMetadataEntryIndex(aMtmId);

	// Insert a new metadata entry if it doesn't already exist.

	if(metadataIndex == KErrNotFound)

		{

		iHeaderDataList.InsertL(headerMetaData, 0);

		}

	headerMetaData->iMtmId = aMtmId;

	if(iNonAttachedDrive)

		{

		_LIT16(KCreateHeaderTableQuery1, "CREATE TABLE IF NOT EXISTS ");

		_LIT16(KCreateHeaderTableQuery2, "Header_");

		// This creates following string...

		// "CREATE TABLE IF NOT EXISTS DB<DriveId>.Header_<MtmId> ( id INT, uid INT," 

		headerTableQuery.Append(KCreateHeaderTableQuery1);

		headerTableQuery.Append(KCreateHeaderTableQuery2);

		}

	else

		{

		_LIT16(KCreateHeaderTableQuery1, "CREATE TABLE IF NOT EXISTS DB");

		_LIT16(KCreateHeaderTableQuery2, ".Header_");

		// "CREATE TABLE IF NOT EXISTS DB<DriveId>.Header_<MtmId> ( id INT, uid INT," 

		headerTableQuery.Append(KCreateHeaderTableQuery1);

		headerTableQuery.AppendNum(KCurrentDriveId);

		headerTableQuery.Append(KCreateHeaderTableQuery2);

		}

	_LIT16(KCreateHeaderTableQuery3, " (id INT, uid INT, ");

	_LIT16(KCreateHeaderTableQuery4, "Details TEXT, PRIMARY KEY (id, uid));");	

	aErrorMessage.Set(_L(""));

	headerTableQuery.AppendNum(aMtmId.iUid);

	headerTableQuery.Append(KCreateHeaderTableQuery3);

	// Add the column details to the query.

	TRAPD(err, DoCreateHeaderTableCreationQueryL(aFieldDetails, headerTableQuery, headerMetaData));

	if(err)

		{

		CleanupStack::Pop(headerMetaData);

		delete headerMetaData;

		iHeaderDataList.Remove(0);

		User::Leave(err);

		}

	headerTableQuery.Append(KCreateHeaderTableQuery4);

	// Execute the query.

	// Ignore error if table already exist.

	err = iDatabaseRef.Exec(headerTableQuery);

	if(err < 0)

		{

		aErrorMessage.Set(iDatabaseRef.LastErrorMessage());

		CleanupStack::Pop(headerMetaData);

		delete headerMetaData;

		iHeaderDataList.Remove(0);

		MSG_WRAP_DB_ERROR(err);

		}

	CleanupStack::Pop(headerMetaData);					// headerMetaData

	if(metadataIndex != KErrNotFound)

		delete headerMetaData;

	CleanupStack::PopAndDestroy();						// headerTableQuery

	}

/*

 * DoCreateHeaderTableCreationQueryL()

 *

 * @param aFieldDetails: Table structure details.

 * @return aHeaderTableQuery: Header-table creation query string.

 * @return aHeaderMetaData: Header metadata structure.

 *

 * The function appends the column details to the header

 * creation query string. It also updates the metadata structure

 * for the header entry.

 */

void CMsvMessageDBAdapter::DoCreateHeaderTableCreationQueryL(const RPointerArray<CFieldPair>& aFieldDetails, RBuf& aHeaderTableQuery, CHeaderMetaData*& aHeaderMetaData)

	{

	_LIT16(KIntField, " INT, ");

	_LIT16(KTextField, " TEXT, ");

	_LIT16(KDateField, " INT64, ");

	_LIT16(KQuote, "\"");

	CFieldClass *fieldObj = NULL;

	// Browse through each column names in the field-list.

	TInt fieldDetailsCount = aFieldDetails.Count();

	for(TInt fieldIndex=0; fieldIndex<fieldDetailsCount; fieldIndex++)

		{			

		if(!aFieldDetails[fieldIndex]->iFieldName)

			{

			User::Leave(KErrArgument);

			}

		// Create a metadata entry.

		fieldObj = new(ELeave) CFieldClass;

		CleanupStack::PushL(fieldObj);

		fieldObj->iName = aFieldDetails[fieldIndex]->iFieldName->Des().AllocL();

		// Append column name under quotes.

		aHeaderTableQuery.Append(KQuote);

		aHeaderTableQuery.Append(aFieldDetails[fieldIndex]->iFieldName->Des());

		aHeaderTableQuery.Append(KQuote);

		// Append appropriate column type.

		switch(aFieldDetails[fieldIndex]->iFieldType)

			{

			case EIntegerField:

				aHeaderTableQuery.Append(KIntField);

				fieldObj->iType = ESqlInt;

				break;

			case ETextField:

				aHeaderTableQuery.Append(KTextField);

				fieldObj->iType = ESqlText;

				break;

			case EDateField:

				aHeaderTableQuery.Append(KDateField);

				fieldObj->iType = ESqlInt64;

				break;

			default:

				User::Leave(KErrArgument);

				break;

			}

		aHeaderMetaData->iFieldList.AppendL(fieldObj);

		CleanupStack::Pop();			// fieldObj

		// Update the status of standard header columns 

		// in the metadata structure.

		CheckStdColumnsAdded(aFieldDetails[fieldIndex]->iFieldName, aHeaderMetaData->iStdColumnStatus);

		}		// for(TInt fieldIndex=0; fieldIndex<aFieldDetails.Count(); fieldIndex++)

	// Adding the 'Details' column to the query string.

	_LIT(KDetails, "Details");

	fieldObj = new(ELeave) CFieldClass;

	CleanupStack::PushL(fieldObj);

	fieldObj->iType = ESqlText;

	fieldObj->iName = KDetails().AllocL();

	aHeaderMetaData->iFieldList.AppendL(fieldObj);		// Added for Details column.

	CleanupStack::Pop();								// fieldObj

	}

/*

 * CreateHeaderEntryL()

 *

 * @param aMtmId: MtmId to identify the header table.

 * @param aEntryId: Metadata Entry Id.

 * @param aFieldPairList: Header details.

 *

 * The function creates a new header entry in the header

 * table. The header details passed to the function in 

 * aFieldPairList should either have values for all the

 * columns in the header table or should have value for

 * only one column (The default column "Details").

 *

 * The function can accept multiple header portion (each 

 * associated with a unique UID. These header portion will 

 * be stored in a separate row in the header table.

 */

void CMsvMessageDBAdapter::CreateHeaderEntryL(const TUid& aMtmId, TMsvId aEntryId, const RPointerArray<CHeaderFields>& aFieldPairList)

	{

	TInt err = KErrNone;

	// Get the metadata entry index for the MTM.

	TInt metadataEntryIndex = GetMetadataEntryIndex(aMtmId);

	User::LeaveIfError(metadataEntryIndex);

	TBool isLocalTransaction = EFalse;

	// Open the DB transaction, if it is not already open.

	if(!iDBAdapter->isTransactionOpen && !iNonAttachedDrive)

		{

		MSG_WRAP_DB_LEAVE(iDBAdapter->BeginTransactionL());

		isLocalTransaction = ETrue;

		}

	// For each entry in header details, create a separate

	// row in the header table.

	TInt fieldPairListCount = aFieldPairList.Count();

	TRAP(err, 

		for(TInt index=0; index<fieldPairListCount; index++)

			{

			CHeaderFields* headerFields = aFieldPairList[index];

			DoInsertHeaderEntryL(aMtmId, aEntryId, headerFields, metadataEntryIndex);

			}		

		);

	// Handle error and close the transaction.