// Copyright (c) 2002-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 "LogServRecentList.h"
#include <barsread.h>
#include <logcntdef.h>
#include <logcli.h>
#include <logengdurations.h>
#include <logfilterandeventconstants.hrh>
#include <logwraplimits.h>
#include "logservpanic.h"
#include "LogServRecentCondition.h"
#include "LogServSqlStrings.h"

/////////////////////////////////////////////////////////////////////////////////////////
// -----> CLogServRecentList (source)
/////////////////////////////////////////////////////////////////////////////////////////

CLogServRecentList::~CLogServRecentList()
	{
	iConditions.ResetAndDestroy();
	iConditions.Close();
	}

void CLogServRecentList::ConstructL(TResourceReader& aReader)
	{
	iId = static_cast<TLogRecentList>(aReader.ReadInt8());
	iDuplicates = static_cast<TUint16>(aReader.ReadUint16());

	TInt count = aReader.ReadInt16();
	iConditions.ReserveL(count);
	while(count--)
		{
		CLogServRecentCondition* condition = CLogServRecentCondition::NewL(aReader);
		TInt err = iConditions.Append(condition);
        __ASSERT_ALWAYS(err == KErrNone, Panic(ELogArrayReserved));
		}
	}

CLogServRecentList* CLogServRecentList::NewL(TResourceReader& aReader)
	{
	CLogServRecentList* self = new(ELeave) CLogServRecentList;
	CleanupStack::PushL(self);
	self->ConstructL(aReader);
	CleanupStack::Pop();
	return self;
	}

#ifdef SYSLIBS_TEST

#pragma BullseyeCoverage off

//Used by the unit tests when SYSLIBS_TEST macro is defined.
//Creates a complex recent list with a lot of fields.
//This helps covering most of recent list related production code branches.
CLogServRecentList* CLogServRecentList::TestNewL()
	{
	CLogServRecentList* self = new(ELeave) CLogServRecentList;
	CleanupStack::PushL(self);
	self->TestConstructL();
	CleanupStack::Pop();
	return self;
	}

void CLogServRecentList::TestConstructL()
	{
	iId = KLogRctTListId;
	iDuplicates = ELogRemotePartyField | ELogNumberField | ELogDirectionField | ELogDurationTypeField |
	              ELogStatusField | ELogFlagsField | ELogSubjectField
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
	              | ELogSimIdField
#endif	
	              ;
	TInt count = 7;//7 test recent list conditions added in the code bellow
	iConditions.ReserveL(count);
	//1
	CLogServRecentCondition* condition1 = CLogServRecentCondition::TestNewL(ELogDirectionField);
	(void)iConditions.Append(condition1);
	//2
	CLogServRecentCondition* condition2 = CLogServRecentCondition::TestNewL(ELogDurationTypeField);
	(void)iConditions.Append(condition2);
	//3
	CLogServRecentCondition* condition3 = CLogServRecentCondition::TestNewL(ELogNumberField);
	(void)iConditions.Append(condition3);
	//4
	CLogServRecentCondition* condition4 = CLogServRecentCondition::TestNewL(ELogRemotePartyField);
	(void)iConditions.Append(condition4);
	//5
	CLogServRecentCondition* condition5 = CLogServRecentCondition::TestNewL(ELogStatusField);
	(void)iConditions.Append(condition5);
	//6
	CLogServRecentCondition* condition6 = CLogServRecentCondition::TestNewL(ELogFlagsField);
	(void)iConditions.Append(condition6);
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
	//7
	CLogServRecentCondition* condition7 = CLogServRecentCondition::TestNewL(ELogSimIdField);
	(void)iConditions.Append(condition7);
#endif	
	}

#pragma BullseyeCoverage on

#endif//SYSLIBS_TEST

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

/**
Checks whether the aEvent field values satisfy the conditions described in 
in this CLogServRecentList object.

@param aEvent Reference to a CLogEvent object which field values will be tested.
@return True If the aEvent field values satisfy the conditions, false otherwise.
*/
TBool CLogServRecentList::IsRecent(const CLogEvent& aEvent) const
	{
	//The implemented algorithm is:
	//  usedFieldBitMask    - bit mask, where the "1" bits correspond to the fields used in the "recent condition" objects - 
	//                        the iConditions array. Each "recent condition" object has "field" and "value" data members,
	//                        where the "field" data member value is a power of 2.
	//                        Some of the iConditions elemens may have the same field value.
	//  matchedFieldBitMask - bit mask, where the "1" bits correspond to a "recent condition" object which field value is 
	//                        equal to the corresponding field value of the aEvent object.
	//
	//  For example, the iConditions array contains three elements initialised as:
	//            [2, "Incomming"]
	//            [8, 1000550D]
	//            [2, "Incomming Alternate"]
	//  The aEvent object contains these fields initialized:
	//            [2, "Incomming"]
	//            [8, 1000550D]
	//  Then usedFieldBitMask value will be:    0000000A -  (2 | 8).
	//       matchedFieldBitMask value will be: 0000000A -  (2 | 8).
	//  So, the operation performed on particular matchedFieldBitMask bit is bitwise OR -
	//      in case if two "recent condition" objects use the same field (but have different field values), then the result
	//      of the matching operation with the corresponding aEvent field value will be OR-ed in that matchedFieldBitMask bit.
	TUint16 usedFieldBitMask = 0;
	TUint16 matchedFieldBitMask = 0;
	for(TInt i=iConditions.Count()-1;i>=0;--i)
		{
		const CLogServRecentCondition& condition = *iConditions[i];
		usedFieldBitMask |= condition.Field();
		if(condition.IsMatch(aEvent))
			{
			matchedFieldBitMask |= condition.Field();
			}
		}
	//If both usedFieldBitMask and matchedFieldBitMask are 0, that means - the iConditions array is empty.
	//The function returns true in this case.
	return usedFieldBitMask == matchedFieldBitMask;
	}

void CLogServRecentList::GetFilter(const CLogEvent& aEvent, CLogFilter& aFilter) const
	{
	TUint16 nullFieldsBitMask = 0;
	if	(iDuplicates & ELogContactField)
		{
		aFilter.SetContact(aEvent.Contact());
      	if (aEvent.Contact() == KLogNullContactId) 
			nullFieldsBitMask |= ELogContactField;
		}

	if	(iDuplicates & ELogDirectionField)
		{
		aFilter.SetDirection(aEvent.Direction());
		if (aEvent.Direction().Length() == 0) 
			nullFieldsBitMask |= ELogDirectionField;
		}

	if	(iDuplicates & ELogDurationTypeField)
		{
		aFilter.SetDurationType(aEvent.DurationType());
		if (aEvent.DurationType() == KLogDurationNone) 
			nullFieldsBitMask |= ELogDurationTypeField;
		}

	if	(iDuplicates & ELogEventTypeField)
		{
		aFilter.SetEventType(aEvent.EventType());
		if (aEvent.EventType() == KNullUid) 
			nullFieldsBitMask |= ELogEventTypeField;
		}

	if	(iDuplicates & ELogNumberField)
		{
		aFilter.SetNumber(aEvent.Number());
		if (aEvent.Number().Length() == 0) 
			nullFieldsBitMask |= ELogNumberField;
		}

	if	(iDuplicates & ELogRemotePartyField)
		{
		aFilter.SetRemoteParty(aEvent.RemoteParty());
		if (aEvent.RemoteParty().Length() == 0) 
			nullFieldsBitMask |= ELogRemotePartyField;
		}

	if	(iDuplicates & ELogStatusField)
		{
		aFilter.SetStatus(aEvent.Status());
		if (aEvent.Status().Length() == 0) 
			nullFieldsBitMask |= ELogStatusField;
		}

	if	(iDuplicates & ELogFlagsField)
		{
		aFilter.SetFlags(aEvent.Flags());
		if (aEvent.Flags() == KLogNullFlags) 
			nullFieldsBitMask |= ELogFlagsField;
		}

#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
	if	(iDuplicates & ELogSimIdField)
		{
		aFilter.SetSimId(aEvent.SimId());
      	if (aEvent.SimId() == KLogNullSimId) 
			nullFieldsBitMask |= ELogSimIdField;
		}
#endif	
	
	aFilter.SetNullFields(nullFieldsBitMask); 
	// This is a special case, if all the fields are null
	// In this case we want to be a duplicate of other events where all the fields are null
	if	(IsFilterEmpty(aFilter))
		aFilter.SetNullFields(iDuplicates);
	}

TBool CLogServRecentList::IsFilterEmpty(const CLogFilter& aFilter) const
	{
	return aFilter.EventType() == KNullUid &&
	       aFilter.RemoteParty().Length() == 0 &&
	       aFilter.Direction().Length() == 0 &&
	       aFilter.Status().Length() == 0 &&
	       aFilter.Contact() == KLogNullContactId &&
	       aFilter.Number().Length() == 0 
#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	
	       &&
	       aFilter.SimId() == KLogNullSimId
#endif	       
	       ;
	}