// Copyright (c) 2003-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 "LOGFILTQ.H"

#include <logcli.h>

#include <logcntdef.h>

#include "logservpanic.h"

#include "LogServDatabaseTransactionInterface.h"

#include <logfilterandeventconstants.hrh>

#include "LogServCacheStrings.h"

#include "LogServCacheTypes.h"

#include "LogServSqlStrings.h"

#ifdef _DEBUG

#  define __LOGFILTQ_INVARIANT()  Invariant()

#else

#  define __LOGFILTQ_INVARIANT()  void(0)

#endif

/**

KFilterFields array contains all fields that can participate in a filter.

The term "field" refers a constant, which value is power of two.

Every "field" uniquely identifies one of the event properties.

The field values are used in the implementation of the TLogFilterExprBuilder class for initializing the 

iField data member, used to identify the currently processed event property value.  

@internalComponent 

*/

const TUint16 KFilterFields[] = 

	{

	ELogContactField,

	ELogDirectionField,

	ELogDurationTypeField,

	ELogEventTypeField,

	ELogNumberField,

	ELogRemotePartyField,

	ELogStatusField,

	ELogStartTimeField,

	ELogEndTimeField,

#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

	ELogSimIdField,		//The new ELogSimIdField must be before the flags: see 

						//DoNextProcessFieldByFieldFilterByFilterL() implementation and the assert.

#endif	

	ELogFlagsField

	};

/**

The size of the KFilterFields array.

@internalComponent 

*/

const TInt KFilterFieldsSize = sizeof(KFilterFields) / sizeof(KFilterFields[0]);

// Constants

const TInt KLogBlockSize = 128;

const TInt KLogPredicateListGranuality = 10;

const TInt KLogMaxPredicateLength = 128;

const TInt KLogNumberCharsToMatch = 9;

/**

Sets the iDatabase data member.

The rest of the data member is left uninitialized. They will be initialized later by the BuildExprLC() call.

@param aDatabase A reference to MLogServDatabaseTransactionInterface interface.  

*/

TLogFilterExprBuilder::TLogFilterExprBuilder(MLogServDatabaseTransactionInterface& aDatabase) :

    iDatabase(aDatabase)

	{

	}

/**

Builds the WHERE expresssion of an SQL statement used later to filter events from the Event table.

How the builder works? - BuildExprLC() gets as a parameter list of filters: CLogFilterList.

Each filter is an object of CLogFilter type. The CLogFilter class contains the same set of properties as the CLogEvent

class: phone number, SIM id, call type, etc. Some of the filter property values are set, defining the desired set

of events that can pass the filter.

For example, the filter list has two filters:

 - Filter 1: number is "1011", SimId is 200;

 - Filter 2: duration type is 2;

BuildExprLC() takes the filter list and depending on passed TLogFilterConstructionType type:

 - ELogFilterConstructFilterByFilterFieldByField

   Organises two loops: the outer loop iterates over all field types, the inner loop iterates over the filters;

 - ELogFilterConstructFieldByFieldFilterByFilter  

   Organises two loops: the outer loop iterates over the filters, the inner loop iterates over all field types;

On each inner loop iteration the current field value of the filter will be checked and if it is not null then a predicate 

will be created of form "<column name> = <field value>" and added to the list of predicates.

If the field value is null but it is allowed to include that field in the expression (the related bit of 

CLogFilter::iNullFields is set. This is tested by using CLogFilter::NullFields()), then the predicate format will be

"<column name> IS NULL".

So using the example filters above, the predicates lists will be:

 - "Number = '1011'", "SimId - 200";

 - "DType = 2";

At the end of each outer loop iteration the predicates will be "linked" using either "AND" if the field type is "flags"

or "OR" for the rest of the fields types.

So, after the first outer loop iteration, the constructed part of the WHERE expression will be:

 "Number = '1011' OR SimId = 200". 

After the second outer loop iteration the expression will be: "DType = 2".

Also, depending on the TLogFilterConstructionType type these expressions will be "linked" either by "AND" or "OR":

 "(Number = '1011' OR SimId = 200) AND (DType = 2)".

On the first outer loop iteration, the predicates expression will be prefixed by the string refered by the aInitial

parameter (that could be "WHERE " or " AND " or " OR ").

When the processing of the filters finishes, the ready for use expression will be in the aExpr out parameter.

@param aExpr Out parameter. If BuildExprLC() completes successfully, aExpr contrains the generated expression.

             The caller is responsible for the destruction of aExpr. BuildExprLC() will create aExpr and put it on

             the cleanup stack; 

       aFilterList Filters list;

       aInitial String that has to be added in front of the generated expresssion;

       aType Defines the order of the processing of the filters and the fields;

@leave KErrNoMemory Out of memory condition has occured.             

*/

void TLogFilterExprBuilder::BuildExprLC(RLogDynBuf& aExpr, const CLogFilterList& aFilterList, const TDesC& aInitial, 

                                        TLogFilterConstructionType aType)

	{

	aExpr.CreateLC(KLogBlockSize);

    iPredicateList = new (ELeave) CDesCArrayFlat(KLogPredicateListGranuality);

    CleanupStack::PushL(iPredicateList);

    iFilterList = &aFilterList;

    iInitial = &aInitial;

    iConstructionType = aType;

    iFilterIndex = 0;

    iField = KFilterFields[0];

    iFlagIndex = 0;

    __LOGFILTQ_INVARIANT();

    switch(iConstructionType)

        {

        case ELogFilterConstructFilterByFilterFieldByField:

            DoNextProcessFilterByFilterFieldByFieldL(aExpr);

            break;

        case ELogFilterConstructFieldByFieldFilterByFilter:

            DoNextProcessFieldByFieldFilterByFilterL(aExpr);

            break;

        default:

            __ASSERT_DEBUG(EFalse, Panic(ELogInvalidConstructionType));

            break;

        }

#ifdef _DEBUG

    iFilterList = NULL;

    iInitial = NULL;

    iFilterIndex = -1;

    iField = 0;

    iFlagIndex = -1;

#endif    

    CleanupStack::PopAndDestroy(iPredicateList);

	}

/**

Processes the filters and the fields.

Organises two loops:

 - the outer loop is on the fields;

 - the inner loop is on the filters; 

@param aExpr Out parameter. The place where the expression is generated. 

@leave KErrNoMemory Out of memory condition has occured.             

@see BuildExprLC() 

*/

void TLogFilterExprBuilder::DoNextProcessFilterByFilterFieldByFieldL(RLogDynBuf& aExpr)

	{

    __LOGFILTQ_INVARIANT();

	const TInt KCount = iFilterList->Count();

	for(TInt i=0;i<KFilterFieldsSize;++i)

	    {

	    iField = KFilterFields[i];

	    for(iFilterIndex=0; iFilterIndex<KCount; ++iFilterIndex)

	        {

	        iField != ELogFlagsField ? MakePredicatesL() : MakeFlagPredicatesL();  

	        }

        MakeConditionL(aExpr);

        iPredicateList->Reset();

	    }

	}

/**

Processes the filters and the fields.

Organises two loops:

 - the outer loop is on the filters; 

 - the inner loop is on the fields;

@param aExpr Out parameter. The place where the expression is generated. 

@leave KErrNoMemory Out of memory condition has occured.             

@see BuildExprLC() 

*/

void TLogFilterExprBuilder::DoNextProcessFieldByFieldFilterByFilterL(RLogDynBuf& aExpr)

	{

    __LOGFILTQ_INVARIANT();

    const TInt KCount = iFilterList->Count();

    for(iFilterIndex=0; iFilterIndex<KCount; ++iFilterIndex)

        {

        //Process all filter fields except flags.

    	for(TInt i=0;i<(KFilterFieldsSize-1);++i)

            {

    	    iField = KFilterFields[i];

            MakePredicatesL();

            }

    	//Process the flag fields last

	    iField = KFilterFields[KFilterFieldsSize - 1];

        __ASSERT_DEBUG(iField == ELogFlagsField, User::Invariant());

        MakeFlagPredicatesL();

        MakeConditionL(aExpr);

        iPredicateList->Reset();

        }

	}

/**

Called on each inner iteration from DoNextProcessFieldByFieldFilterByFilterL() and 

DoNextProcessFilterByFilterFieldByFieldL().

Generates a predicate in one of the following formats:

 - "<column name> = <field value>"

 - "<column name> IS NULL"

The generated predicate will be added to the predicates list (iPredicateList data member).

@leave KErrNoMemory Out of memory condition has occured.              

@see DoNextProcessFilterByFilterFieldByFieldL()

@see DoNextProcessFieldByFieldFilterByFilterL()

*/

void TLogFilterExprBuilder::MakePredicatesL()

	{

    __LOGFILTQ_INVARIANT();

	const CLogFilter* filter = iFilterList->At(iFilterIndex);

	__ASSERT_DEBUG(filter, Panic(ELogNullFilterInList1));

	// Check for null field in filter and if the field has already been used

	TBuf<KLogMaxPredicateLength> predicate;

	if (!IsFieldEmpty(*filter) && !IsDuplicateField(*filter))

		{

		MakePredicateL(predicate, *filter);

		if (predicate.Length() > 0)

			iPredicateList->AppendL(predicate);

		}

	// Add Null predicate if required and not already specified

	if (filter->NullFields() & iField && !IsDuplicateNullField())

		{

		predicate.Zero();

		MakeNullPredicate(predicate);

		if (predicate.Length() > 0)

			iPredicateList->AppendL(predicate);

		}

    __LOGFILTQ_INVARIANT();

	}

/**

Called on each outer loop iteration.

At this time, all generated predicates are in the predicates list (iPredicateList data member).

The predicates will be "linked" into the expression using "AND" for the "flags" and "OR" for the rest of the fields.

Depending on the TLogFilterConstructionType type (iConstructionType data member) either "AND" or "OR" will be used 

to "link" pedicates from two different predicates lists.  

@param aExpr Out parameter. The place where the expression is generated. 

@leave KErrNoMemory Out of memory condition has occured.

@see DoNextProcessFilterByFilterFieldByFieldL()

@see DoNextProcessFieldByFieldFilterByFilterL()

@see MakePredicatesL()

*/

void TLogFilterExprBuilder::MakeConditionL(RLogDynBuf& aExpr)

	{

    __ASSERT_DEBUG(iFilterList != NULL, User::Invariant());

    __ASSERT_DEBUG(iInitial != NULL, User::Invariant());

    __ASSERT_DEBUG(iConstructionType == ELogFilterConstructFilterByFilterFieldByField || iConstructionType == ELogFilterConstructFieldByFieldFilterByFilter, User::Invariant());

    __ASSERT_DEBUG(iPredicateList != NULL, User::Invariant());

	// Are there any predicates to add?

	TInt total = iPredicateList->MdcaCount();

	if (total == 0)

		return;

	// Add separator between conditions

	if(aExpr.Length() == 0)

	    {

	    aExpr.AppendL(*iInitial);

	    }

	else

		{

		switch(iConstructionType)

			{

		case ELogFilterConstructFilterByFilterFieldByField:

			aExpr.AppendL(KLogAnd);

			break;

		case ELogFilterConstructFieldByFieldFilterByFilter:

			aExpr.AppendL(KLogOr);

			break;

		default:

            __ASSERT_DEBUG(EFalse, Panic(ELogInvalidConstructionType));

		    break;

			}

		}

	aExpr.AppendL(KLogOpenBracket);

	// Add Predicates

	TInt count = 0;

	while(count < total)

		{

		// Add separator between predicates

		if (count > 0)

			{

			if (iField != ELogFlagsField)

				aExpr.AppendL(KLogOr);

			else

				aExpr.AppendL(KLogAnd);

			}

		aExpr.AppendL((*iPredicateList)[count]);

		count++;

		}

	// Close the brackets

	aExpr.AppendL(KLogCloseBracket);

	}

/**

Called on each inner loop iteration.

Processes the "flags" filter fields and generates predicates.

@leave KErrNoMemory Out of memory condition has occured.

@see DoNextProcessFilterByFilterFieldByFieldL()

@see DoNextProcessFieldByFieldFilterByFilterL()

*/

void TLogFilterExprBuilder::MakeFlagPredicatesL()

    {

    __LOGFILTQ_INVARIANT();

    const CLogFilter* filter = iFilterList->At(iFilterIndex);

    __ASSERT_DEBUG(filter, Panic(ELogNullFilterInList2));

    // Return if no flags are set

    if (filter->Flags() == KLogNullFlags)

        return;

    TBuf<KLogMaxPredicateLength> predicate;

    // Go through each bit in turn

    iFlagIndex = KLogFlagsCount;

    while(iFlagIndex--)

        {

        // See if the current flag is set in filter and bit wasn't set in any previous filters

        if (filter->Flags() & 0x1 << iFlagIndex && !IsDuplicateField(*filter))

            {

            // Generate predicate - if null field flag set we don't want the flag to be set

            predicate.Format(KLogFlagPredicate, &KLogFlagString, iFlagIndex + 1, (filter->NullFields() & iField) ? 0 : 1);

            iPredicateList->AppendL(predicate);

            }

        }

    iFlagIndex = 0;

    __LOGFILTQ_INVARIANT();

    }

/**

Depending on the currently processed field (iField data member) the function returns the column name that

has to be used in the predicate being generated.

@return A const reference to the column name.

@see MakeNullPredicate()

@see MakePredicateL()   

*/

const TDesC& TLogFilterExprBuilder::ColumnName() const

	{

    __LOGFILTQ_INVARIANT();

	switch (iField)

		{

		case ELogContactField:

			return KLogFieldEventContactString();

		case ELogDirectionField:

			return KLogFieldEventDirectionString();

		case ELogDurationTypeField:

			return KLogFieldEventDTypeString();

		case ELogEventTypeField:

			return KLogFieldEventTypeString();

		case ELogNumberField:

			return KLogFieldEventNumberString();

		case ELogRemotePartyField:

			return KLogFieldEventRemoteString();

		case ELogStatusField:

			return KLogFieldEventStatusString();

		case ELogSubjectField:

			return KLogFieldEventSubjectString();

		case ELogLinkField:

			return KLogFieldEventLinkString();

		case ELogDataField:

			return KLogFieldEventDataString();

		case ELogStartTimeField:

		case ELogEndTimeField:

			return KLogFieldEventTimeString();

#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

		case ELogSimIdField:

			return KLogFieldEventSimId();

#endif			

		default:

			__ASSERT_DEBUG(EFalse, Panic(ELogNoSuchState3));

			break;

		}

	return KLogUnknownString();

	}

/**

Generates a predicate of form "<column name> IS NULL" in the passed descriptor.

@param aDes Out parameter. The place where the predicate will be generated.

@see MakePredicatesL() 

*/

void TLogFilterExprBuilder::MakeNullPredicate(TDes& aDes)

    {

    __LOGFILTQ_INVARIANT();

    aDes.Format(KLogNullPredicate, &ColumnName());

    __LOGFILTQ_INVARIANT();

    }

/**

Generates a predicate of form "<column name> = <field value>" in the passed descriptor.

@param aDes Out parameter. The place where the predicate will be generated.

@param aFilter The filter where the field values will be picked from.

               The current field is identified by the value of the iField data member.

@leave The leaving codes from TTime::FormatL().

@see MakePredicatesL() 

*/

void TLogFilterExprBuilder::MakePredicateL(TDes& aDes, const CLogFilter& aFilter)

	{

    __LOGFILTQ_INVARIANT();

	const TDesC& columnName = ColumnName();

	switch (iField)

		{

		case ELogContactField:

			aDes.Format(KLogNumberPredicate, &columnName, aFilter.Contact());

			break;

		case ELogDirectionField:

			{

			TLogStringId id = iDatabase.DTICacheStrings().FindId(aFilter.Direction());

			aDes.Format(KLogNumberPredicate, &columnName, id);

			}

			break;

		case ELogDurationTypeField:

			aDes.Format(KLogNumberPredicate, &columnName, aFilter.DurationType());

			break;

		case ELogEventTypeField:

			{

			const TLogServCacheTypeEntry& entry = iDatabase.DTICacheTypes().FindByUid(aFilter.EventType());

			aDes.Format(KLogNumberPredicate, &columnName, entry.iEventTypeId);

			break;

			}

		// If the phone number in the filter is at least KLogNumberCharsToMatch long

		// then it does a wild card search for numbers that match the last KLogNumberCharsToMatch chars

		case ELogNumberField:

			{

			if (aFilter.Number().Length() < KLogNumberCharsToMatch)

				aDes.Format(KLogStringPredicate, &columnName, &aFilter.Number());

			else

				{

				TPtrC number(aFilter.Number().Right(KLogNumberCharsToMatch));

				aDes.Format(KLogLikePredicate, &columnName, &number);

				}

			break;

			}

		case ELogRemotePartyField:

			//We need to check RemoteParty string for any single quotes and 

			//add a second single quote to properly handle strings such as 

			//"Sam's Wife"	

		    {

			//If single quotes are found we need to modify the string

			TInt quoteIndex =  aFilter.RemoteParty().Locate('\'');			

			if( quoteIndex >= 0)

				{	

				//Allocate a buffer twice the length of the string to cater for 

				//the worst case when every character is a single quote

				TPtrC temp = aFilter.RemoteParty();

				TBuf<KLogMaxRemotePartyLength * 2> buf;

				//loop through and replace all single quotes

				//with two quote characters

				while(quoteIndex >= 0)

					{	

					_LIT(KQuoteStr, "''");

					//Append the characters before the single quote followed

					//by two quote characters

					buf.Append(temp.Left(quoteIndex));	

					buf.Append(KQuoteStr);

					//Set the substring to the remaining characters after the

					//single quote and look for the next single quote character

					temp.Set(temp.Mid(quoteIndex + 1));

					quoteIndex = temp.Locate('\'');

					}		

				//No quotes left so append the remaining data

				buf.Append(temp);

				aDes.Format(KLogStringPredicate, &columnName, &buf);

				}

			else

				{

				aDes.Format(KLogStringPredicate, &columnName, &aFilter.RemoteParty());

				}

		    }

			break;