/*

* Copyright (c) 2007-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 "pltables.h"

#include "dbsqlconstants.h"

#include "cntpersistenceutility.h"

#include <cntdef.h>

// forward declaration to allow this to compile. 

// Which header file is this declared in and do we actually still need the properties here?

class CLplContactProperties;

/**

NewL

@param aDatabase A handle to the database.

@param aProperties A contact properties object.

@return A pointer to a new CPplContactTable object.

*/

CPplContactTable* CPplContactTable::NewL(RSqlDatabase& aDatabase, CLplContactProperties& aProperties)

	{

	CPplContactTable* self = CPplContactTable::NewLC(aDatabase, aProperties);

	CleanupStack::Pop(self);

	return self;

	}

/**

NewLC

@param aDatabase A handle to the database.

@param aProperties A contact properties object.

@return A pointer to a new CPplContactTable object.

*/

CPplContactTable* CPplContactTable::NewLC(RSqlDatabase& aDatabase, CLplContactProperties& aProperties)

	{

	CPplContactTable* self = new (ELeave) CPplContactTable(aDatabase, aProperties);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

Set up the CCntSqlStatement objects held by the class.

*/

void CPplContactTable::ConstructL()

	{	

	iCardTemplateIds = CContactIdArray::NewL();

	// Statement types

	TCntSqlStatementType insertType(EInsert, KSqlContactTableName);

	TCntSqlStatementType selectType(ESelect, KSqlContactTableName);

	TCntSqlStatementType updateType(EUpdate, KSqlContactTableName);

	TCntSqlStatementType deleteType(EDelete, KSqlContactTableName);

	// Where clause

	// sizes of the clause

	const TInt KWhereClauseBufSize(KContactId().Size() + 

		KWhereStringEqualsStringFormatText().Size() + KContactIdParam().Size() );

	// for WHERE contact_id = [contact id value]

	HBufC* whereIdClause = HBufC::NewLC(KWhereClauseBufSize);

	whereIdClause->Des().AppendFormat(KWhereStringEqualsStringFormatText, &KContactId, 

		&KContactIdParam );

	// INSERT

	// insert record into contact table

	// For a statement in the following format:

	// 	INSERT INTO contact 

	//		(contact_id, template_id...[etc...], binary_fields) 

	//		VALUES (NULL, 37, .......);

	//

	// Actual parameters are added when inserting a contact based

	// in available fields

	iInsertStmnt = TSqlProvider::GetSqlStatementL(insertType);

	// SELECT

	// delete select

	// For a statement in the following format:

	// 	SELECT type_flags, access_count, template_id FROM contact 

	//		WHERE contact_id = [contact id value];

	//

	iDeleteSelectStmnt = TSqlProvider::GetSqlStatementL(selectType);	

	iDeleteSelectStmnt->SetParamL(KContactTypeFlags, KNullDesC() );

	iDeleteSelectStmnt->SetParamL(KContactAccessCount, KNullDesC() );

	iDeleteSelectStmnt->SetParamL(KContactTemplateId, KNullDesC() );

	iDeleteSelectStmnt->SetConditionL(*whereIdClause);

	// UPDATE

	// update record from contact table

	// For a statement in the following format:

	// 	UPDATE contact SET template_id = [new template id value]

	//      ...,

	//      binary_fields = [new binary fields value]

	//		WHERE contact_id = [contact id value];

	//

	iUpdateStmnt = TSqlProvider::GetSqlStatementL(updateType);

	iUpdateStmnt->SetConditionL(*whereIdClause);

	// type_flags update

	// For a statement in the following format:

	// 	UPDATE contact SET type_flags = [new type flags value]

	//		WHERE contact_id = [contact id value];

	//

	iUpdateFlagsStmnt = TSqlProvider::GetSqlStatementL(updateType);	

	iUpdateFlagsStmnt->SetParamL(KContactTypeFlags, KContactTypeFlagsParam);

	iUpdateFlagsStmnt->SetConditionL(*whereIdClause);

	// AccessCount update

	// For a statement in the following format:

	// 	UPDATE contact SET access_count = [new access count value]

	//		WHERE contact_id = [contact id value];

	//

	iAccessCountUpdateStmnt = TSqlProvider::GetSqlStatementL(updateType);	

	iAccessCountUpdateStmnt->SetParamL(KContactAccessCount, KContactAccessCountParam);

	iAccessCountUpdateStmnt->SetConditionL(*whereIdClause);

	// DELETE

	// delete record from contact table

	// For a statement in the following format:

	// 	DELETE FROM contact WHERE contact_id = [contact id value];

	//

	iDeleteStmnt = TSqlProvider::GetSqlStatementL(deleteType);	

	iDeleteStmnt->SetConditionL(*whereIdClause);

	// Set up the field lookup table hash map

	iFieldMap.InsertL(KUidContactFieldGivenNameValue, KContactFirstNameParam() );

	iFieldMap.InsertL(KUidContactFieldGivenNamePronunciationValue, KContactFirstNamePrnParam() );

	iFieldMap.InsertL(KUidContactFieldFamilyNameValue, KContactLastNameParam() );

	iFieldMap.InsertL(KUidContactFieldFamilyNamePronunciationValue, KContactLastNamePrnParam() );

	iFieldMap.InsertL(KUidContactFieldCompanyNameValue, KContactCompanyNameParam() );

	iFieldMap.InsertL(KUidContactFieldCompanyNamePronunciationValue, KContactCompanyNamePrnParam() );

	CleanupStack::PopAndDestroy(); //whereIdClause

	}

/**

Destructor

Tidy up CCntSqlStatement objects

*/

CPplContactTable::~CPplContactTable()

	{

	delete iInsertStmnt;

	delete iDeleteSelectStmnt;

	delete iUpdateFlagsStmnt;

	delete iUpdateStmnt;

	delete iAccessCountUpdateStmnt;

	delete iDeleteStmnt;

	iFieldMap.Close();

	delete iCardTemplateIds;

	}

/**

CPplContactTable constructor

*/

CPplContactTable::CPplContactTable(RSqlDatabase& aDatabase, CLplContactProperties& aProperties):

	iProperties(aProperties),

	iDatabase(aDatabase)

	{

	}

/**

Update the access count for the given template ID. If the template is marked for deletion and 

no one is referencing it any longer, it is deleted.

@param aTemplateRefId

@param aIncrement If ETrue increase the reference count otherwise decrease the reference count.

*/

void CPplContactTable::UpdateTemplateAccessCounterL(TContactItemId aTemplateRefId, TBool aIncrement)

	{

	if (aTemplateRefId == KGoldenTemplateId || aTemplateRefId == KNullContactId)

		{

		return;

		}

	// Get the access count and type flags for the template

	RSqlStatement selectStmnt;

	CleanupClosePushL(selectStmnt);

	selectStmnt.PrepareL(iDatabase, iDeleteSelectStmnt->SqlStringL() );

	const TInt KContactIdParamIndex(KFirstIndex); // first and only parameter in the query

	User::LeaveIfError(selectStmnt.BindInt(KContactIdParamIndex, aTemplateRefId) );

	TInt err(selectStmnt.Next() );

	if (err != KSqlAtRow)

		{

		User::Leave(err);

		}

	TInt oldAccessCount(selectStmnt.ColumnInt(iDeleteSelectStmnt->ParameterIndex(KContactAccessCount() ) ) );

	TInt newAccessCount = oldAccessCount + (aIncrement ? 1 : -1);

	TInt typeFlags(selectStmnt.ColumnInt(iDeleteSelectStmnt->ParameterIndex(KContactTypeFlags() ) ) );

	TInt attributes((typeFlags & EContactAttributes_Mask) >> EContactAttributes_Shift); 

	CleanupStack::PopAndDestroy(&selectStmnt);

	// set the new access count for the template

	RSqlStatement updateStmnt;

	CleanupClosePushL(updateStmnt);

	updateStmnt.PrepareL(iDatabase, iAccessCountUpdateStmnt->SqlStringL() );

	const TInt KAccessCountParamIndex(KFirstParam);					// first parameter in query...

	const TInt KTemplateIdParamIndex(KAccessCountParamIndex + 1);	// ...and the second.

	User::LeaveIfError(updateStmnt.BindInt(KAccessCountParamIndex, newAccessCount) );

	User::LeaveIfError(updateStmnt.BindInt(KTemplateIdParamIndex, aTemplateRefId) );

	User::LeaveIfError(updateStmnt.Exec() );

	CleanupStack::PopAndDestroy(&updateStmnt);

	// should the template be deleted  -- i.e. nobody accessing it and marked as deleted?

	if (newAccessCount <= 0 && (attributes & CContactItem::EDeleted) )

		{

		TBool lowDiskErr(EFalse);

		CContactItem* templ = DeleteLC(aTemplateRefId, lowDiskErr);

		CleanupStack::PopAndDestroy(templ);

		if (lowDiskErr)

			{

			User::Leave(KErrDiskFull);

			}

		}

	}

void CPplContactTable::CreateInDbL(CContactItem& aItem)

	{

	CreateInDbL(aItem, 0);

	}

/**

Add the given contact item to the database.

@param aItem The contact item to be added to the database. 

@param aSessionId The ID of the session that issued the request.  Used to

prevent Phonebook Synchroniser deadlock.

@return Contact item ID of the contact added to the database.

*/

void CPplContactTable::CreateInDbL(CContactItem& aItem, TUint aSessionId)

	{

	if (aItem.Type() != KUidContactTemplate) // Not creating system template?

		{

		// Make sure the System template is loaded.

		iProperties.SystemTemplateL();

		}

	if (aItem.Type() == KUidContactICCEntry) 

		{

		TInt ret = iProperties.ContactSynchroniserL(aSessionId).ValidateWriteContact(static_cast<CContactICCEntry&>(aItem) );

		User::LeaveIfError(ret);	

		}

	// Mark fields as template fields if the contact item is a contact card template.

	const TBool KIsTemplateCard = (aItem.Type() == KUidContactCardTemplate);

	CContactItemFieldSet& fieldset = aItem.CardFields();

	for (TInt i = fieldset.Count() - 1; i >= 0; --i)

		{

		fieldset[i].SetTemplateField(KIsTemplateCard);

		}

	// Set iLastModified and iCreationDate to current time.

	TTime lastModified = aItem.LastModified();

   	lastModified.UniversalTime();

   	aItem.SetLastModified(lastModified);

   	aItem.SetCreationDate(lastModified); 

	// ID of newly created item obtained from autoincrementing ID column.

	// -- get an id from the database	

	RSqlStatement selectIdStatement;

	CleanupClosePushL(selectIdStatement);

	User::LeaveIfError(selectIdStatement.Prepare(iDatabase, KSelectLastIdSqlStmnt()));

	TInt err;

	TInt lastId((-1));

	if((err = selectIdStatement.Next()) == KSqlAtRow)

		{

		lastId = selectIdStatement.ColumnInt(0);

		}

	if(err == KSqlAtEnd)

		{

		lastId = -1;

		}

	aItem.SetId(lastId + 1);

	CleanupStack::PopAndDestroy(&selectIdStatement);

	// Increment Template reference counter.

	UpdateTemplateAccessCounterL(aItem.TemplateRefId(), ETrue);

	// Write contact data to the database.

	WriteContactItemL(aItem, EInsert);

	}

/**

Updates the given contact item in the database.

@param aItem The contact item to be updated

*/

void CPplContactTable::UpdateL(const CContactItem& aItem)

	{

	// If contact is marked as deleted and access count is zero then delete the

	// contact otherwise update it.

	if (aItem.IsDeleted() && (aItem.AccessCount() == 0) )

		{

		//update access field in contact table

		RSqlStatement updateStmnt;

		CleanupClosePushL(updateStmnt);

		updateStmnt.PrepareL(iDatabase, iAccessCountUpdateStmnt->SqlStringL() );

		const TInt KAccessCountParamIndex(KFirstParam);					// first parameter in query...

		const TInt KContactIdParamIndex(KAccessCountParamIndex + 1);	// ...and the second.

		User::LeaveIfError(updateStmnt.BindInt(KAccessCountParamIndex, 0) );

		User::LeaveIfError(updateStmnt.BindInt(KContactIdParamIndex, aItem.Id()) );

		User::LeaveIfError(updateStmnt.Exec() );

		CleanupStack::PopAndDestroy(&updateStmnt);

		TBool lowDiskErr(EFalse);

		CContactItem* templ = DeleteLC(aItem.Id(), lowDiskErr);

		CleanupStack::PopAndDestroy(templ);

		if (lowDiskErr)

			{

			User::Leave(KErrDiskFull);

			}

		}

	else

		{

		WriteContactItemL(aItem, EUpdate);

		}

	}

/**

Performs database write operations for the given contact item.

@param aItem the contact item to be written

@param aType the type of operation (insert or update) to 

*/

void CPplContactTable::WriteContactItemL(const CContactItem& aItem, TCntSqlStatement aType)

	{

	// check the correct type of statement/operation has been supplied

	if (aType != EInsert && aType != EUpdate)

		{

		User::Leave(KErrArgument);

		}

	// temporary reference to the CCntSqlStatements member variables to take advantage 

	// of the commonality between update and insert operations.

	CCntSqlStatement* tempCntStmnt;

	if (aType == EInsert)

		{

        iInsertStmnt->ClearParams();

        iInsertStmnt->SetParamL(KContactId, KContactIdParam);

        iInsertStmnt->SetParamL(KContactTemplateId, KContactTemplateIdParam);

        iInsertStmnt->SetParamL(KContactTypeFlags, KContactTypeFlagsParam);

        iInsertStmnt->SetParamL(KContactAccessCount, KContactAccessCountParam);

        iInsertStmnt->SetParamL(KContactCreationDate, KContactCreationDateParam);

        iInsertStmnt->SetParamL(KContactLastModified, KContactLastModifiedParam);

        iInsertStmnt->SetParamL(KContactGuidString, KContactGuidStringParam);

        iInsertStmnt->SetParamL(KContactFirstNamePrn, KContactFirstNamePrnParam);

        iInsertStmnt->SetParamL(KContactLastNamePrn, KContactLastNamePrnParam);

        iInsertStmnt->SetParamL(KContactCompanyNamePrn, KContactCompanyNamePrnParam);

        iInsertStmnt->SetParamL(KContactTextFieldHeader, KContactTextFieldHeaderParam);

        iInsertStmnt->SetParamL(KContactBinaryFieldHeader, KContactBinaryFieldHeaderParam);

        iInsertStmnt->SetParamL(KContactTextFields, KContactTextFieldsParam);

        iInsertStmnt->SetParamL(KContactBinaryFields, KContactBinaryFieldsParam);

        for (TInt fieldNum = aItem.CardFields().Count() - 1; fieldNum >= 0; --fieldNum) 

            {

            const CContactItemField& field = aItem.CardFields()[fieldNum];

            const TInt nameFieldUid = NameFieldUid(field);

            if (nameFieldUid != KErrNotFound && field.StorageType() == KStorageTypeText)

                {

                TInt length = field.TextStorage()->Text().Length();

                // check if field should be stored in the Identity table.

                if (nameFieldUid == TInt(KUidContactFieldGivenNameValue) && length)

                    {

                    iInsertStmnt->SetParamL(KContactFirstName, KContactFirstNameParam);

                    }

                if (nameFieldUid == TInt(KUidContactFieldFamilyNameValue) && length)

                    {

                    iInsertStmnt->SetParamL(KContactLastName, KContactLastNameParam);

                    }

                if (nameFieldUid == TInt(KUidContactFieldCompanyNameValue) && length)

                    {

                    iInsertStmnt->SetParamL(KContactCompanyName, KContactCompanyNameParam);

                    }         

                }

            }

		tempCntStmnt = iInsertStmnt;

		}

	else

	    {

        iUpdateStmnt->ClearParams();

        iUpdateStmnt->SetParamL(KContactTemplateId, KContactTemplateIdParam);

        _LIT(KOwnCardInvariant, "((((%S>>%d==%d)*%d) | ((NOT(%S>>%d==%d))*%S))<<%d)| %S");

	    HBufC* typeFlagsParameter = HBufC::NewLC(KOwnCardInvariant().Size() + KContactTypeFlags().Size() + KContactTypeFlags().Size() + 

	            KContactTypeParam().Size() + KAttributesAndHintParam().Size() + 6*sizeof(TInt));

	    typeFlagsParameter->Des().AppendFormat(KOwnCardInvariant, &KContactTypeFlags, EContactType_Shift, EContactTypeFlags_OwnCard, EContactTypeFlags_OwnCard,

	            &KContactTypeFlags, EContactType_Shift, EContactTypeFlags_OwnCard, &KContactTypeParam, EContactType_Shift, &KAttributesAndHintParam);

	    iUpdateStmnt->SetParamL(KContactTypeFlags, *typeFlagsParameter);

	    iUpdateStmnt->SetParamL(KContactAccessCount, KContactAccessCountParam);

	    iUpdateStmnt->SetParamL(KContactLastModified, KContactLastModifiedParam);

	    iUpdateStmnt->SetParamL(KContactGuidString, KContactGuidStringParam);

	    iUpdateStmnt->SetParamL(KContactFirstNamePrn, KContactFirstNamePrnParam);

	    iUpdateStmnt->SetParamL(KContactLastNamePrn, KContactLastNamePrnParam);

	    iUpdateStmnt->SetParamL(KContactCompanyNamePrn, KContactCompanyNamePrnParam);

	    iUpdateStmnt->SetParamL(KContactTextFieldHeader, KContactTextFieldHeaderParam);

	    iUpdateStmnt->SetParamL(KContactBinaryFieldHeader, KContactBinaryFieldHeaderParam);

	    iUpdateStmnt->SetParamL(KContactTextFields, KContactTextFieldsParam);

	    iUpdateStmnt->SetParamL(KContactBinaryFields, KContactBinaryFieldsParam);

        for (TInt fieldNum = aItem.CardFields().Count() - 1; fieldNum >= 0; --fieldNum) 

            {

            const CContactItemField& field = aItem.CardFields()[fieldNum];

            const TInt nameFieldUid = NameFieldUid(field);

            if (nameFieldUid != KErrNotFound && field.StorageType() == KStorageTypeText)

                {

                TInt length = field.TextStorage()->Text().Length();

                // check if field should be stored in the Identity table.

                if (nameFieldUid == TInt(KUidContactFieldGivenNameValue) && length)

                    {

                    iUpdateStmnt->SetParamL(KContactFirstName, KContactFirstNameParam);

                    }

                if (nameFieldUid == TInt(KUidContactFieldFamilyNameValue) && length)

                    {

                    iUpdateStmnt->SetParamL(KContactLastName, KContactLastNameParam);

                    }

                if (nameFieldUid == TInt(KUidContactFieldCompanyNameValue) && length)

                    {

                    iUpdateStmnt->SetParamL(KContactCompanyName, KContactCompanyNameParam);

                    }         

                }

            }

        CleanupStack::PopAndDestroy(); //typeFlagsParameter

	    tempCntStmnt = iUpdateStmnt;

	    }

	RSqlStatement stmnt;

	CleanupClosePushL(stmnt);

 	stmnt.PrepareL(iDatabase, tempCntStmnt->SqlStringL() );

	// get the identity-type fields and build the hint fields

	THintField hint;

	const RArray<TUid>* custFiltFields = NULL;

	if (aItem.Type() != KUidContactTemplate)

		{

		custFiltFields = &iProperties.CustomFilterableFieldsL(); // doesn't take ownership

		}

	for (TInt fieldNum = aItem.CardFields().Count() - 1; fieldNum >= 0; --fieldNum) 

		{

		const CContactItemField& field = aItem.CardFields()[fieldNum];

		const TInt nameFieldUid = CPplContactTable::NameFieldUid(field);

		// check if field should be stored in the Identity table.

		if (nameFieldUid != KErrNotFound)

			{

			TPtrC textToSet = field.TextStorage()->Text();

			if(textToSet.Length() > 0)

			    {

			    const TInt KParamIndex(User::LeaveIfError(stmnt.ParameterIndex(iFieldMap.FindL(nameFieldUid) ) ) );

    			User::LeaveIfError(stmnt.BindText(KParamIndex, textToSet));

			    }			}

		else if (field.StorageType() == KStorageTypeText &&  // the field is textual

				 field.TextStorage()->Text().Length() &&     // ignore empty fields

				 custFiltFields != NULL)

			{

			// the field is not stored in contact table but potentially maps to a hint

			hint.UpdateHintL(field, *custFiltFields);

			}

		}

	// bind other values to statement

	if(aType == EInsert) 

		{

		TInt typeFlags(GenerateTypeFlags(aItem.Type(), aItem.Attributes(), hint.iValue) );

		User::LeaveIfError(stmnt.BindInt(

				User::LeaveIfError(stmnt.ParameterIndex(KContactTypeFlagsParam() ) ), typeFlags) );

		}

	else

		{

		User::LeaveIfError(stmnt.BindInt(

				User::LeaveIfError(stmnt.ParameterIndex(KContactTypeParam() ) ), TCntPersistenceUtility::ContactTypeUidToTypeFlags(aItem.Type()) >> EContactType_Shift ) );

		TInt attrHint = (aItem.Attributes() << EContactAttributes_Shift) & EContactAttributes_Mask;

		attrHint |= hint.iValue & EContactHintFlags_Mask;

		User::LeaveIfError(stmnt.BindInt(

				User::LeaveIfError(stmnt.ParameterIndex(KAttributesAndHintParam() ) ), attrHint ) );		

		}

	User::LeaveIfError(stmnt.BindInt(

		User::LeaveIfError(stmnt.ParameterIndex(KContactTemplateIdParam() ) ), aItem.TemplateRefId()) );

	User::LeaveIfError(stmnt.BindInt(

		User::LeaveIfError(stmnt.ParameterIndex(KContactAccessCountParam() ) ), aItem.AccessCount()) );