/*

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

#include "c12keypredictivesearchtable.h"

#include "cqwertypredictivesearchtable.h"

#include "cpredictivesearchsettingstable.h"

#include "dbsqlconstants.h"

// This macro suppresses log writes

//#define NO_PRED_SEARCH_LOGS

#include "predictivesearchlog.h"

_LIT(KFirstQwertyTableName, "qm0");

CPredictiveSearchSynchronizer*

CPredictiveSearchSynchronizer::NewL(RSqlDatabase& aDatabase,

									C12keyPredictiveSearchTable& a12keyTable,

									CQwertyPredictiveSearchTable& aQwertyTable,

									CPredictiveSearchSettingsTable& aSettingsTable)

	{

	PRINT(_L("CPredictiveSearchSynchronizer::NewL"));

	CPredictiveSearchSynchronizer* self =

		CPredictiveSearchSynchronizer::NewLC(aDatabase, a12keyTable,

											 aQwertyTable, aSettingsTable);

	CleanupStack::Pop(self);

	PRINT(_L("CPredictiveSearchSynchronizer::NewL ends"));

	return self;

	}

CPredictiveSearchSynchronizer*

CPredictiveSearchSynchronizer::NewLC(RSqlDatabase& aDatabase,

									 C12keyPredictiveSearchTable& a12keyTable,

									 CQwertyPredictiveSearchTable& aQwertyTable,

									 CPredictiveSearchSettingsTable& aSettingsTable)

	{

	PRINT(_L("CPredictiveSearchSynchronizer::NewLC"));

	CPredictiveSearchSynchronizer* self =

		new (ELeave) CPredictiveSearchSynchronizer(aDatabase, a12keyTable,

												   aQwertyTable, aSettingsTable);

	CleanupStack::PushL(self);

	self->ConstructL();

	PRINT(_L("CPredictiveSearchSynchronizer::NewLC ends"));

	return self;

	}

CPredictiveSearchSynchronizer::~CPredictiveSearchSynchronizer()

	{

	PRINT(_L("CPredictiveSearchSynchronizer dtor"));

	PRINT(_L("CPredictiveSearchSynchronizer dtor ends"));

	}

void CPredictiveSearchSynchronizer::ConstructL()

	{

	}

/**

Constructor

*/

CPredictiveSearchSynchronizer::CPredictiveSearchSynchronizer(

	RSqlDatabase& aDatabase,

	C12keyPredictiveSearchTable& a12keyTable,

	CQwertyPredictiveSearchTable& aQwertyTable,

	CPredictiveSearchSettingsTable& aSettingsTable) :

	iDatabase(aDatabase),

	i12keyTable(a12keyTable),

	iQwertyTable(aQwertyTable),

	iSettingsTable(aSettingsTable)

	{

	}

// There are 3 cases:

// - none of the pred.search tables exist

// - just 12-key pred.search tables exist

// - all pred.search tables exist (12-key, QWERTY, settings)

// There is no case where QWERTY tables exist but settings table does not,

// since such a version was not released.

void CPredictiveSearchSynchronizer::SynchronizeTablesL()

	{

	PRINT(_L("CPredictiveSearchSynchronizer::SynchronizeTablesL"));

	if (CheckIfPredSearchTableExistsL(KSqlContactPredSearchTable0))

		{

		if (CheckIfPredSearchTableExistsL(KFirstQwertyTableName))

			{

			// All tables exist, check if language has been changed

			if (!iSettingsTable.IsLanguageValidL())

				{

				PRINT(_L("language has changed, re-create QWERTY tables"));

				DeletePredSearchTableL(iQwertyTable);

				CreatePredSearchTablesL(EFalse);

				iSettingsTable.StoreCurrentLanguageL();

				}

			}

		else

			{

			PRINT(_L("QWERTY and settings tables missing, re-create all tables"));

			DeletePredSearchTablesL();

			CreatePredSearchTablesL();

			}

		}

	else

		{

		// All predictive search tables missing, create all

		CreatePredSearchTablesL();

		}

	PRINT(_L("CPredictiveSearchSynchronizer::SynchronizeTablesL ends"));

	}

void CPredictiveSearchSynchronizer::CreatePredSearchTablesL(TBool aAllTables)

	{

	PRINT1(_L("CPredictiveSearchSynchronizer::CreatePredSearchTablesL all=%d"), aAllTables);

	if (aAllTables)

		{

		i12keyTable.CreateTableL();

		iSettingsTable.CreateTableL();

		iSettingsTable.StoreCurrentLanguageL();

		}

	iQwertyTable.CreateTableL();

	_LIT(KSelectAllContactsFormat, "SELECT %S,%S,%S FROM %S;");

	TInt bufSize = KSelectAllContactsFormat().Length() +

				   KContactId().Length() +

				   KContactFirstName().Length() +

				   KContactLastName().Length() +

				   KSqlContactTableName().Length();

	HBufC* sqlStatement = HBufC::NewLC(bufSize);

	sqlStatement->Des().AppendFormat(KSelectAllContactsFormat,

		&KContactId,

		&KContactFirstName,

		&KContactLastName,

		&KSqlContactTableName);

	RSqlStatement stmnt;

	CleanupClosePushL(stmnt);

	PRINT1(_L("CreatePredSearchTablesL prepare SQL statement:%S"), sqlStatement);

    stmnt.PrepareL(iDatabase, *sqlStatement);

	const TInt KContactIdIndex = 0;

	const TInt KFirstNameIndex = 1;

	const TInt KLastNameIndex = 2;

	TInt err(KErrNone);

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

        {

		PRINT(_L("CreatePredSearchTablesL create CContactItem"));

		TInt id = KUidContactCardValue;

		TUid uid;

		uid.iUid = id;

		CContactItem* contact = CContactItem::NewLC(uid);

		contact->SetId(stmnt.ColumnInt(KContactIdIndex));

		// If first name exists, write it to contact item

		TPtrC firstName;

		if (stmnt.ColumnText(KFirstNameIndex, firstName) == KErrNone)

			{

			CContactItemField* field =

				CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);

			CContactTextField* textfield = field->TextStorage();

			textfield->SetTextL(firstName);

			contact->AddFieldL(*field); // Takes ownership

			CleanupStack::Pop(field);

			}

		TPtrC lastName;

		if (stmnt.ColumnText(KLastNameIndex, lastName) == KErrNone)

			{

			CContactItemField* field =

				CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);

			CContactTextField* textfield = field->TextStorage();

			textfield->SetTextL(lastName);

			contact->AddFieldL(*field); // Takes ownership

			CleanupStack::Pop(field);

			}

		PRINT(_L("CreatePredSearchTablesL create entry to tables"));

		if (aAllTables)

			{

			i12keyTable.CreateInDbL(*contact);

			}

		if (ReadMailAddressesL(*contact))

			{

			iQwertyTable.CreateInDbL(*contact);

			}

		CleanupStack::PopAndDestroy(contact);

        }

    // Leave if we didn't complete going through the results properly

    if (err != KSqlAtEnd)

        {

		PRINT1(_L("CreatePredSearchTablesL SQL err=%d"), err);

        User::Leave(err);

        }

    CleanupStack::PopAndDestroy(&stmnt);

	CleanupStack::PopAndDestroy(sqlStatement);

	PRINT(_L("CPredictiveSearchSynchronizer::CreatePredSearchTablesL ends"));

	}

void CPredictiveSearchSynchronizer::DeletePredSearchTablesL()

	{

	PRINT(_L("CPredictiveSearchSynchronizer::DeletePredSearchTablesL"));

	DeletePredSearchTableL(i12keyTable);

	DeletePredSearchTableL(iQwertyTable);

	DeletePredSearchTableL(iSettingsTable);

	PRINT(_L("CPredictiveSearchSynchronizer::DeletePredSearchTablesL ends"));

	}

TBool CPredictiveSearchSynchronizer::CheckIfPredSearchTableExistsL(

	const TDesC& aTableName) const

	{

	PRINT1(_L("CPredictiveSearchSynchronizer::CheckIfPredSearchTableExistsL table='%S'"),

		   &aTableName);

	_LIT(KSelectFirstTableFormat,

		 "SELECT name FROM sqlite_master WHERE type='table' AND name='%S';");

	TInt bufSize = KSelectFirstTableFormat().Length() +

				   aTableName.Length();

	HBufC* select = HBufC::NewLC(bufSize);

	select->Des().AppendFormat(KSelectFirstTableFormat, &aTableName);

	RSqlStatement stmnt;

	CleanupClosePushL(stmnt);

    stmnt.PrepareL(iDatabase, *select);

	TBool tableExists = (stmnt.Next() == KSqlAtRow);

	CleanupStack::PopAndDestroy(&stmnt);

	CleanupStack::PopAndDestroy(select);

	PRINT1(_L("CPredictiveSearchSynchronizer::CheckIfPredSearchTablesExistL return %d"),

		   tableExists);

	return tableExists;

	}

void CPredictiveSearchSynchronizer::DeletePredSearchTableL(CPplPredictiveSearchTableBase& aTable)

	{

	PRINT(_L("CPredictiveSearchSynchronizer::DeletePredSearchTableL"));

	// IF EXISTS suppresses error that would occur if table does not exist

	_LIT(KDropTable, "DROP TABLE IF EXISTS %S;");

	QList<QChar> tables;

	QT_TRYCATCH_LEAVING(tables = aTable.FillAllTables());

	HBufC* tableName(NULL);

	while ((tableName = aTable.GetNextTableNameL(tables)) != NULL)

		{

		CleanupStack::PushL(tableName);

		HBufC* dropTable = HBufC::NewLC(KDropTable().Length() + tableName->Length());

        dropTable->Des().Format(KDropTable, tableName);

		User::LeaveIfError(iDatabase.Exec(*dropTable));

        CleanupStack::PopAndDestroy(dropTable);

		CleanupStack::PopAndDestroy(tableName);

		}

	PRINT(_L("CPredictiveSearchSynchronizer::DeletePredSearchTableL ends"));

	}

TBool CPredictiveSearchSynchronizer::ReadMailAddressesL(CContactItem& aContact)

	{

	PRINT(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL"));

	// SELECT value FROM comm_addr

	//	 WHERE contact_id = [contact id value] AND type = [type value];

    _LIT(KSelectMailAddrFormat, "SELECT %S FROM %S WHERE %S = %d AND %S = %d;");

	const TInt KContactIdLength = 10;

	const TInt KCommAddrTypeLength = 2; // CPplCommAddrTable::EEmailAddress is enum

	TInt bufSize = KSelectMailAddrFormat().Length() +

				   KCommAddrValue().Length() +

				   KSqlContactCommAddrTableName().Length() +

				   KCommAddrContactId().Length() +

				   KContactIdLength +

				   KCommAddrType().Length() +

				   KCommAddrTypeLength;

	HBufC* sqlStatement = HBufC::NewLC(bufSize);

	sqlStatement->Des().AppendFormat(KSelectMailAddrFormat,

		&KCommAddrValue,

		&KSqlContactCommAddrTableName,

		&KCommAddrContactId,

		aContact.Id(),

		&KCommAddrType,

		CPplCommAddrTable::EEmailAddress);

	RSqlStatement stmnt;

	CleanupClosePushL(stmnt);

	PRINT1(_L("prepare SQL statement:%S"), sqlStatement);

    stmnt.PrepareL(iDatabase, *sqlStatement);

	const TInt KValueIndex = 0;

	TBool foundMailAddress(EFalse);

	TInt err(KErrNone);

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

        {

		TPtrC value;

		if (stmnt.ColumnText(KValueIndex, value) == KErrNone)

			{

			PRINT2(_L("  id=%d, found mail address=%S"), aContact.Id(), &value);

			CContactItemField* field =

				CContactItemField::NewLC(KStorageTypeText, KUidContactFieldEMail);

			CContactTextField* textfield = field->TextStorage();

			textfield->SetTextL(value);

			aContact.AddFieldL(*field); // Takes ownership

			CleanupStack::Pop(field);

			foundMailAddress = ETrue;

			}

        }

    if (err != KSqlAtEnd)

        {

		PRINT1(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL SQL err=%d"), err);

        User::Leave(err);

        }

    CleanupStack::PopAndDestroy(&stmnt);

	CleanupStack::PopAndDestroy(sqlStatement);

	PRINT1(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL return %d"), foundMailAddress);

	return foundMailAddress;

	}