/*

* 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 "cqwertypredictivesearchtable.h"

#include "cqwertykeymap.h"

#include "dbsqlconstants.h"

#include <QStringList>

// This macro suppresses own logs

//#define NO_PRED_SEARCH_LOGS

#include "predictivesearchlog.h"

// Max amount of tokens stored from contact

const TInt KMaxTokens = 7;

// Max amount of mail addresses stored from contact

const TInt KMaxMailAddresses = 3;

// How many characters are stored at most in the tokens

// Since BIGINT is a signed 64-bit integer, store only 10 characters

// to prevent overflow when comparing upper and lower limits.

const TInt KMaxTokenLength = 10;

// Template for table names

const TInt KMaxTableNameLength = 4;

_LIT(KTableNameFormat, "qm%d");

// Template for create table commands

_LIT(KPredSearchCreateQwertyMailTableFormat,

"CREATE TABLE %S (contact_id INTEGER PRIMARY KEY,\

 n BIGINT NULL, n2 BIGINT NULL, n3 BIGINT NULL, n4 BIGINT NULL,\

 n5 BIGINT NULL, n6 BIGINT NULL, n7 BIGINT NULL,\

 first_name CHAR(16) NULL, last_name CHAR(16) NULL);");

// Template for index names

// e.g. index0_n2

_LIT(KIndexNameFormat, "index%d_%S");

// Template for create index commands

// CREATE INDEX <index name> on <table> (<column>);");

_LIT(KPredSearchCreateQwertyMailIndexFormat, "CREATE INDEX %S on %S (%S);");

const QString KMailPrefix = "mailto:";

/**

@param aDatabase A handle to the database.

@param aProperties A contact properties object.

@return A pointer to a new CQwertyPredictiveSearchTable object.

*/

CQwertyPredictiveSearchTable*

CQwertyPredictiveSearchTable::NewL(RSqlDatabase& aDatabase)

	{

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

	CQwertyPredictiveSearchTable* self = CQwertyPredictiveSearchTable::NewLC(aDatabase);

	CleanupStack::Pop(self);

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

	return self;

	}

/**

@param aDatabase A handle to the database.

@param aProperties A contact properties object.

@return A pointer to a new CQwertyPredictiveSearchTable object.

*/

CQwertyPredictiveSearchTable*

CQwertyPredictiveSearchTable::NewLC(RSqlDatabase& aDatabase)

	{

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

	CQwertyPredictiveSearchTable* self =

		new (ELeave) CQwertyPredictiveSearchTable(aDatabase);

	CleanupStack::PushL(self);

	self->ConstructL();

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

	return self;

	}

/**

Destructor

*/

CQwertyPredictiveSearchTable::~CQwertyPredictiveSearchTable()

	{

	PRINT(_L("CQwertyPredictiveSearchTable dtor"));

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

	}

/**

Create the QWERTY tables and its indexes in the database.

*/

void CQwertyPredictiveSearchTable::CreateTableL()

	{

	PRINT(_L("CQwertyPredictiveSearchTable::CreateTableL"));

	// How many columns have index

    const TInt KIndexedColumnCount = 9;

    // Names of columns that have index

    const TDesC* indexColumns[] = {

        &KPredSearchQwertyMailNameAsNumber,

        &KPredSearchQwertyMailNameAsNumber2,

        &KPredSearchQwertyMailNameAsNumber3,

        &KPredSearchQwertyMailNameAsNumber4,

        &KPredSearchQwertyMailNameAsNumber5,

        &KPredSearchQwertyMailNameAsNumber6,

        &KPredSearchQwertyMailNameAsNumber7,

        &KPredSearchQwertyMailFirstName,

        &KPredSearchQwertyMailLastName};

    TInt maxColumnLength(0); // Length of longest column name

    for (TInt column = 0; column < KIndexedColumnCount; ++column)

        {

        TInt columnNameLength = indexColumns[column]->Length();

        if (columnNameLength > maxColumnLength)

            {

            maxColumnLength = columnNameLength;

            }

        }    

	// Space needed to represent number CQwertyKeyMap::EAmountOfKeysInQwertyKeypad

	const TInt KCharsNeededForTableNumber = 2;

	const TInt KMaxIndexNameLength =

		KIndexNameFormat().Length() + maxColumnLength + KCharsNeededForTableNumber;

	HBufC* tableName = HBufC::NewLC(KMaxTableNameLength);

	TPtr ptrTableName = tableName->Des();

	HBufC* createTableCmd =

		HBufC::NewLC(KPredSearchCreateQwertyMailTableFormat().Length() +

					 KMaxTableNameLength);

	TPtr ptrCreateTableCmd = createTableCmd->Des();

	HBufC* indexName = HBufC::NewLC(KMaxIndexNameLength);

	TPtr ptrIndexName = indexName->Des();

	HBufC* createIndexCmd = HBufC::NewLC(KPredSearchCreateQwertyMailIndexFormat().Length() +

									  KMaxIndexNameLength +

									  KMaxTableNameLength +

									  maxColumnLength);

	TPtr ptrCreateIndexCmd = createIndexCmd->Des();

	for (TInt table = 0; table < CQwertyKeyMap::EAmountOfKeysInQwertyKeypad; ++table)

		{

		ptrTableName.Format(KTableNameFormat, table);

		ptrCreateTableCmd.Format(KPredSearchCreateQwertyMailTableFormat, tableName);

		PRINT1(_L("SQL command: %S"), createTableCmd);

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

		// Create indexes for each required column of the current table

		for (TInt column = 0; column < KIndexedColumnCount; ++column)

			{

			ptrIndexName.Format(KIndexNameFormat, table, indexColumns[column]);

			ptrCreateIndexCmd.Format(KPredSearchCreateQwertyMailIndexFormat,

								     indexName, tableName, indexColumns[column]);

//			PRINT1(_L("SQL command: %S"), createIndexCmd);

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

			}

		}

	CleanupStack::PopAndDestroy(createIndexCmd);

	CleanupStack::PopAndDestroy(indexName);

	CleanupStack::PopAndDestroy(createTableCmd);

	CleanupStack::PopAndDestroy(tableName);

	PRINT(_L("CQwertyPredictiveSearchTable::CreateTableL ends"));

	}

TBool CQwertyPredictiveSearchTable::IsValidChar(const QChar aChar) const

	{

#if defined(USE_ORBIT_KEYMAP)

	return static_cast<CQwertyKeyMap*>(iKeyMap)->IsValidChar(aChar);

#else

	const QChar PAD_CHAR = '!'; // This is a hack, must have same value as in cqwertykeymap.cpp

	return static_cast<CQwertyKeyMap*>(iKeyMap)->UseHardcodedKeyMap(aChar) != PAD_CHAR;

#endif

	}

HBufC* CQwertyPredictiveSearchTable::TableNameL(const QChar aCh) const

	{

	TInt tableNumber = static_cast<CQwertyKeyMap*>(iKeyMap)->MapKeyNameToValue(aCh);

	if (tableNumber == CQwertyKeyMap::KPadCharValue)

		{

		User::Leave(KErrArgument);

		}

	HBufC* tableName = HBufC::NewL(KMaxTableNameLength);

	TPtr ptrTableName = tableName->Des();

	ptrTableName.Format(KTableNameFormat, tableNumber);

	return tableName;

	}

QList<QChar> CQwertyPredictiveSearchTable::FillAllTables() const

	{

	QList<QChar> tables;

	for (TInt key = 0; key < CQwertyKeyMap::EAmountOfKeysInQwertyKeypad; ++key)

		{

		tables.append(iKeyMap->ArrayIndexToMappedChar(key));

		}

	return tables;

	}

void CQwertyPredictiveSearchTable::FillKeyboardSpecificFieldsL(

	RSqlStatement& aSqlStatement,

	QStringList aTokens)

	{

	const TDesC* paramNames[] = {

		&KPredSearchQwertyMailNameAsNumberParam,

		&KPredSearchQwertyMailNameAsNumberParam2,

		&KPredSearchQwertyMailNameAsNumberParam3,

		&KPredSearchQwertyMailNameAsNumberParam4,

		&KPredSearchQwertyMailNameAsNumberParam5,

		&KPredSearchQwertyMailNameAsNumberParam6,

		&KPredSearchQwertyMailNameAsNumberParam7};

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

		{

		// TODO: It'd be better to add new fn into CQwertyKeyMap, that computes

		// the qint64 value like CQwertyKeyMap::ComputeValue().

		QString dummyLowerLimit;

		QString upperLimit;

		User::LeaveIfError(iKeyMap->GetNumericLimits(aTokens[i],

													 dummyLowerLimit,

													 upperLimit));

		bool ok(false);

		qint64 value(0); // qint64 is same as qlonglong

		QT_TRYCATCH_LEAVING(value = upperLimit.toLongLong(&ok));

		if (!ok)

			{

			User::Leave(KErrArgument);

			}

		// Decrement by one to get the correct value

		User::LeaveIfError(aSqlStatement.BindInt64(

			User::LeaveIfError(aSqlStatement.ParameterIndex(*paramNames[i])), --value));

		}

	}

/**

* Fetch up to 3 mail addresses

*/

QStringList CQwertyPredictiveSearchTable::GetTableSpecificFields(

	const CContactItem& aItem,

	TBool& aMandatoryFieldsPresent) const

	{

	PRINT(_L("CQwertyPredictiveSearchTable::GetTableSpecificFields"));

	QStringList mailAddresses;

	// Check that the contact item is a card, own card or ICC entry.

	const TUid KType = aItem.Type();

	if (KType != KUidContactCard &&

		KType != KUidContactOwnCard &&

		KType != KUidContactICCEntry)

		{

		aMandatoryFieldsPresent = EFalse;

		return mailAddresses;

		}

	TInt storedAddressCount(0);

	for (TInt i = aItem.CardFields().Count();

		 i > 0 && storedAddressCount < KMaxMailAddresses;

		 --i)

		{

		CContactItemField& field = aItem.CardFields()[i - 1];

		if (field.ContentType().ContainsFieldType(KUidContactFieldEMail) &&

			field.StorageType() == KStorageTypeText &&

			field.TextStorage()->IsFull()) // IsFull() returns true if field not empty

			{

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

			PRINT2(_L("contact id=%d has mail='%S'"), aItem.Id(), &mailAddress);

			QString wholeAddress((QChar*)mailAddress.Ptr(), mailAddress.Length());

			QString address = wholeAddress;

			if (wholeAddress.startsWith(KMailPrefix)) // Skip prefix

				{

				address = wholeAddress.mid(KMailPrefix.length());

#if defined(WRITE_PRED_SEARCH_LOGS)

				const TInt KLogLength = 40;

				TBuf<KLogLength> log(address.left(KLogLength).utf16());

				PRINT1(_L("prefix removed, mail='%S'"), &log);

#endif

				}

			mailAddresses.append(iKeyMap->GetMappedString(address));

			++storedAddressCount;

			}

		}

	PRINT1(_L("CQwertyPredictiveSearchTable::GetTableSpecificFields found %d mail addrs"),

		   mailAddresses.count());

	aMandatoryFieldsPresent = (mailAddresses.count() > 0);

	return mailAddresses;

	}

/**

Set up the CCntSqlStatement objects held by the class.

*/

void CQwertyPredictiveSearchTable::ConstructL()

	{

	PRINT(_L("CQwertyPredictiveSearchTable::ConstructL"));

	CPplPredictiveSearchTableBase::ConstructL();

	// Set details of INSERT

	iInsertStmnt->SetParamL(KPredSearchQwertyMailContactId,

	                        KPredSearchQwertyMailContactIdParam);

	iInsertStmnt->SetParamL(KPredSearchQwertyMailNameAsNumber,

							KPredSearchQwertyMailNameAsNumberParam);

	iInsertStmnt->SetParamL(KPredSearchQwertyMailNameAsNumber2,

							KPredSearchQwertyMailNameAsNumberParam2);

	iInsertStmnt->SetParamL(KPredSearchQwertyMailNameAsNumber3,

							KPredSearchQwertyMailNameAsNumberParam3);

	iInsertStmnt->SetParamL(KPredSearchQwertyMailNameAsNumber4,

							KPredSearchQwertyMailNameAsNumberParam4);

	iInsertStmnt->SetParamL(KPredSearchQwertyMailNameAsNumber5,

							KPredSearchQwertyMailNameAsNumberParam5);

	iInsertStmnt->SetParamL(KPredSearchQwertyMailNameAsNumber6,

							KPredSearchQwertyMailNameAsNumberParam6);

	iInsertStmnt->SetParamL(KPredSearchQwertyMailNameAsNumber7,

							KPredSearchQwertyMailNameAsNumberParam7);

	iInsertStmnt->SetParamL(KPredSearchQwertyMailFirstName,

							KPredSearchQwertyMailFirstNameParam);

	iInsertStmnt->SetParamL(KPredSearchQwertyMailLastName,

							KPredSearchQwertyMailLastNameParam);

	PRINT(_L("CQwertyPredictiveSearchTable::ConstructL create key map"));

	iKeyMap = CQwertyKeyMap::NewL();

	PRINT(_L("CQwertyPredictiveSearchTable::ConstructL ends"));

	}

/**

Constructor

*/

CQwertyPredictiveSearchTable::CQwertyPredictiveSearchTable(RSqlDatabase& aDatabase) :

	CPplPredictiveSearchTableBase(aDatabase, KMaxTokens, KMaxTokenLength)

	{

	}