/*

* 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:  Comparator algorithms for notifier*

*/

#include "mdsnotifycomparator.h"

#include "mdcresult.h"

#include "mdcitem.h"

#include "mdccommon.pan"

#include "mdcserializationbuffer.h"

#include "mderange.h"

#include "mdscommoninternal.h"

#include "mdcquery.h"

#include "mdccommon.h"

#include "mdeinternalerror.h"

CMdSNotifyComparator* CMdSNotifyComparator::NewL()

    {

    CMdSNotifyComparator* that = CMdSNotifyComparator::NewLC();

    CleanupStack::Pop( that );

    return that;

    }

CMdSNotifyComparator* CMdSNotifyComparator::NewLC()

	{

	CMdSNotifyComparator* that = new(ELeave) CMdSNotifyComparator();

	CleanupStack::PushL( that );

	that->ConstructL();

	return that;

	}

CMdSNotifyComparator::~CMdSNotifyComparator()

    {

    }

CMdSNotifyComparator::CMdSNotifyComparator()

    {

    }

void CMdSNotifyComparator::ConstructL()

    {

    }

TBool CMdSNotifyComparator::MatchL(

	TDefId aNamespaceDefId, TUint32 aType,

    CMdCSerializationBuffer& aSerializedCondition,

    CMdCSerializationBuffer& aSerializedItems,

    CMdCSerializationBuffer& aSerializedItemIds,

    RArray<TItemId>& aMatchingItemIdArray,

    TBool aAllowConfidential)

    {

    const TMdCItems& items = TMdCItems::GetFromBufferL( aSerializedItems );

    const TMdCItemIds& itemIds = TMdCItemIds::GetFromBufferL( aSerializedItemIds );

	// check if some namespace definitions are not the same

    if( itemIds.iNamespaceDefId != aNamespaceDefId )

    	{

    	return EFalse;

    	}

    if( ( items.iObjects.iPtr.iCount > 0 ) && 

    	( itemIds.iObjectIds.iPtr.iCount > 0 ) && 

    	( aType & ( EObjectNotifyAdd | EObjectNotifyModify ) ) )

    	{

    	// object ID count and object item count should match

		__ASSERT_DEBUG( items.iObjects.iPtr.iCount == itemIds.iObjectIds.iPtr.iCount, MMdCCommon::Panic( KErrCorrupt ) );

    	aSerializedItemIds.PositionL( itemIds.iObjectIds.iPtr.iOffset );

    	for( TUint32 i = 0; i < itemIds.iObjectIds.iPtr.iCount; i++ )

    		{

    		TItemId objectId;

    		aSerializedItemIds.ReceiveL( objectId );

    		if( aSerializedCondition.Size() > 0 )

    			{

	            TBool results( EFalse );

	            TBool succeed( EFalse );

	            // move condition buffer's position beginnig of the buffer

	            aSerializedCondition.PositionL( KNoOffset  );

	            const TMdCLogicCondition& logicCondition = 

	            		TMdCLogicCondition::GetFromBufferL( aSerializedCondition );

	            for ( TUint32 j = 0; j < logicCondition.iChildConditions.iPtr.iCount; j++ )

	                {

		    		// set correct position to item buffer

	    	    	aSerializedItems.PositionL( items.iObjects.iPtr.iOffset + 

	    	    			i * sizeof(TMdCObject) );

	    	    	// set correct positin to condition buffer

	    	    	aSerializedCondition.PositionL( 

	    	    			logicCondition.iChildConditions.iPtr.iOffset + 

	    	    			j * CMdCSerializationBuffer::KRequiredSizeForTUint32 );

	    	    	TUint32 conditionOffset;

	    	    	aSerializedCondition.ReceiveL( conditionOffset );

	    	    	aSerializedCondition.PositionL( conditionOffset );

	                results = MatchObjectL( aSerializedCondition, 

	                		aSerializedItems, objectId, aAllowConfidential );

	                succeed = results;

	                if ( logicCondition.iOperator == ELogicConditionOperatorAnd )

	                    {

	                    if( !results )

	                        {

	                        break;

	                        }

	                    }

	                if ( logicCondition.iOperator == ELogicConditionOperatorOr )

	                    {

	                    if( results )

	                        {

	                        break;

	                        }

	                    }

	                }

	            if ( logicCondition.iNegated )    

	                {

	                succeed = !( succeed );

	                }

	    	    if ( succeed )    

	                {

	                aMatchingItemIdArray.AppendL( objectId );

	                }

    			}

    		else

    			{

    			aMatchingItemIdArray.AppendL( objectId );

    			}

    		}

    	}

    else if( ( items.iEvents.iPtr.iCount > 0 ) && 

    		 ( itemIds.iEventIds.iPtr.iCount > 0 ) && 

    		 ( aType & ( EEventNotifyAdd /*| EEventNotifyRemove*/ ) ) )

    	{

    	// event ID count and event item count should match

		__ASSERT_DEBUG( items.iEvents.iPtr.iCount == itemIds.iEventIds.iPtr.iCount, MMdCCommon::Panic( KErrCorrupt ) );

		aSerializedItemIds.PositionL( itemIds.iEventIds.iPtr.iOffset );

    	for( TUint32 i = 0; i < itemIds.iEventIds.iPtr.iCount; i++ )

    		{

    		TItemId eventId;

    		aSerializedItemIds.ReceiveL( eventId );

    		if( aSerializedCondition.Size() > 0 )

    			{

	    		// set correct position to item buffer

	    		aSerializedItems.PositionL( items.iEvents.iPtr.iOffset + i * sizeof(TMdCEvent) );

	    		// move condition buffer's position to the begin of the buffer

	    		aSerializedCondition.PositionL( KNoOffset );

	    		if( MatchEventL( aSerializedCondition, aSerializedItems, eventId ) )

	    			{

	    			aMatchingItemIdArray.AppendL( eventId );

	    			}

    			}

    		else

    			{

    			aMatchingItemIdArray.AppendL( eventId );

    			}

    		}

    	}

    else if( ( items.iRelations.iPtr.iCount > 0 ) && 

    		 ( itemIds.iRelationIds.iPtr.iCount > 0 ) && 

    		 ( aType & ( ERelationNotifyAdd | ERelationNotifyModify /*| ERelationNotifyRemove*/ ) ) )

    	{

    	// relation ID count and relation item count should match

		__ASSERT_DEBUG( items.iRelations.iPtr.iCount == itemIds.iRelationIds.iPtr.iCount, MMdCCommon::Panic( KErrCorrupt ) );

    	aSerializedItemIds.PositionL( itemIds.iRelationIds.iPtr.iOffset );

    	for( TUint32 i = 0; i < itemIds.iRelationIds.iPtr.iCount; i++ )

    		{

    		TItemId relationId;

    		aSerializedItemIds.ReceiveL( relationId );

			if( aSerializedCondition.Size() > 0 )

				{

	    		// set correct position to item buffer

	    		aSerializedItems.PositionL( items.iRelations.iPtr.iOffset

	    				+ i * sizeof(TMdCRelation) );

	    		// move condition buffer's position to the begin of the buffer

	    		aSerializedCondition.PositionL( KNoOffset );

	    		if( MatchRelationL( aSerializedCondition, aSerializedItems, relationId ) )

	    			{

	    			aMatchingItemIdArray.AppendL( relationId );

	    			}

				}

			else

				{

				aMatchingItemIdArray.AppendL( relationId );

				}

    		}

    	}

    if( aMatchingItemIdArray.Count() > 0 )

    	{

    	return ETrue;

    	}

    else

    	{

    	return EFalse;

    	}

    }

TBool CMdSNotifyComparator::MatchObjectL(

		CMdCSerializationBuffer& aSerializedCondition,

		CMdCSerializationBuffer& aSerializedItem, TItemId aObjectId, 

		TBool aAllowConfidential )

	{

 	// check if object is failed

	if( aObjectId == KNoId )

		{

		return EFalse;

		}

	// Check type

	const TMdCCondition& condition = 

			TMdCCondition::GetFromBufferL( aSerializedCondition );

	switch( condition.iConditionType )

		{

	    case EConditionTypeObject:

	        {

	    	return ( CheckObjectL( aSerializedCondition, aSerializedItem, 

	    			aAllowConfidential ) );

	    	}

		case EConditionTypeProperty:

		case EConditionTypePropertyIntRange:

		case EConditionTypePropertyInt64Range:

		case EConditionTypePropertyUintRange:

		case EConditionTypePropertyRealRange:

		case EConditionTypePropertyTimeRange:

	    case EConditionTypePropertyText:

    	case EConditionTypePropertyBool:

	        {

   			return ( CheckPropertyL( aSerializedCondition, aSerializedItem ) );

	    	}

    	default:

#ifdef _DEBUG

    		User::Panic( _L("MdSNCMaO") , KErrMdEUnknownConditionType );

#endif    		

    	    break;

		}

	return EFalse;

	}

TBool CMdSNotifyComparator::CheckPropertyL( 

		CMdCSerializationBuffer& aSerializedCondition,

    	CMdCSerializationBuffer& aSerializedItem )

    {

    const TMdCObject& object = TMdCObject::GetFromBufferL( aSerializedItem );

    const TMdCPropertyCondition& propertyCondition = 

    		TMdCPropertyCondition::GetFromBufferL( aSerializedCondition );

    for( TUint32 i=0; i < object.iProperties.iPtr.iCount; i++ )

        {

        aSerializedItem.PositionL( object.iProperties.iPtr.iOffset

        		+ i * sizeof(TMdCProperty) );

        const TMdCProperty& property = TMdCProperty::GetFromBufferL( aSerializedItem );

        // check propertyDefId doesn't match -> skip it

        if( property.iPropertyDefId == propertyCondition.iPropertyDefId )

            {

            // move condition buffer to begin of the condition

            aSerializedCondition.PositionL( propertyCondition.iCondition );

            switch( propertyCondition.iConditionType )

	            {

	            case EConditionTypeProperty:

	            	{

		            // check only if existing condition is negated

	            	if( propertyCondition.iNegated )

	            		{

	            		return EFalse;

	            		}

	            	else

	            		{

	            		return ETrue;

	            		}

	            	}

   	            case EConditionTypePropertyIntRange:

	                {

		            TInt32 rangeType32( 0 );

		            aSerializedCondition.ReceiveL( rangeType32 );

		            const TMdERangeType rangeType = ( TMdERangeType )rangeType32;

		            TMdCValueUnion minValue;

                    aSerializedCondition.ReceiveL( minValue );

                    TMdCValueUnion maxValue;

                    aSerializedCondition.ReceiveL( maxValue );

		            // init range for next test

                    TMdEIntRange range( minValue.iInt32, maxValue.iInt32, 

                    		rangeType );

   	                if( range.InRange( property.iValue.iInt32 ) == propertyCondition.iNegated )

                        {

                        return EFalse;

                        }   

	                break;

	                }

	            case EConditionTypePropertyInt64Range:

	                {

		            TInt32 rangeType32( 0 );

		            aSerializedCondition.ReceiveL( rangeType32 );

		            const TMdERangeType rangeType = ( TMdERangeType )rangeType32;

		            TMdCValueUnion minValue;

                    aSerializedCondition.ReceiveL( minValue );

                    TMdCValueUnion maxValue;

                    aSerializedCondition.ReceiveL( maxValue );

                    // init range for next test

                    TMdEInt64Range range( minValue.iInt64, maxValue.iInt64, 

                    		rangeType );

                    // test if valueType is in the range

                    if( range.InRange( property.iValue.iInt64 ) == propertyCondition.iNegated )

                        {

                        return EFalse;

                        }	                

	                break;

	                }

	            case EConditionTypePropertyUintRange:

	                {

		            TInt32 rangeType32( 0 );

		            aSerializedCondition.ReceiveL( rangeType32 );

		            const TMdERangeType rangeType = ( TMdERangeType )rangeType32;

		            TMdCValueUnion minValue;

                    aSerializedCondition.ReceiveL( minValue );

                    TMdCValueUnion maxValue;

                    aSerializedCondition.ReceiveL( maxValue );

                    // init range for next test

                    TMdEUintRange range( minValue.iUint32, maxValue.iUint32, 

                    		rangeType );

   	                if( range.InRange( property.iValue.iUint32 ) == propertyCondition.iNegated )

                        {

                        return EFalse;

                        }   

	                break;

	                }

	            case EConditionTypePropertyRealRange:

	                {

		            TInt32 rangeType32( 0 );

		            aSerializedCondition.ReceiveL( rangeType32 );

		            const TMdERangeType rangeType = ( TMdERangeType )rangeType32;

		            TMdCValueUnion minValue;

                    aSerializedCondition.ReceiveL( minValue );

                    TMdCValueUnion maxValue;

                    aSerializedCondition.ReceiveL( maxValue );

                    // init range for next test

                    TMdERealRange range( minValue.iReal, maxValue.iReal, rangeType );

                    // test if valueType is in the range

                    if( range.InRange( property.iValue.iReal ) == propertyCondition.iNegated )

                        {

                        return EFalse;

                        }	                

	                break;

	                }

	            case EConditionTypePropertyTimeRange:

                    {

		            TInt32 rangeType32( 0 );

		            aSerializedCondition.ReceiveL( rangeType32 );

		            TMdERangeType rangeType = ( TMdERangeType )rangeType32;

		            TMdCValueUnion minValue;

                    aSerializedCondition.ReceiveL( minValue );

                    TMdCValueUnion maxValue;

                    aSerializedCondition.ReceiveL( maxValue );

                    // init range for next test

                    TMdETimeRange range( minValue.iInt64, maxValue.iInt64, 

                    		rangeType );

	                TTime value( property.iValue.iInt64 );

                    // test if valueType is in the range

                    if( range.InRange( property.iValue.iInt64 ) == propertyCondition.iNegated )

                        {

                        return EFalse;

                        }	                

                    break;

                    }

                case EConditionTypePropertyText:

	                {

	                // SerializedItem

	                aSerializedItem.PositionL( property.iValue.iPtr.iOffset );

	                TPtrC16 value = aSerializedItem.ReceivePtr16L();

	                // ConditionItem

	                TUint32 condCompareMethod( 0 );

	                aSerializedCondition.ReceiveL( condCompareMethod );

	                TPtrC16 condValue = aSerializedCondition.ReceivePtr16L();

                    //Check, that compare method is in range

#ifdef _DEBUG

	                if( condCompareMethod <= ETextPropertyConditionCompareFirst || condCompareMethod >= ETextPropertyConditionCompareLast )

	                	{

						User::Panic( _L("MdSNCCP1") , KErrMdEUnknownConditionCompareMethod );

	                	}

#endif

	                TBool compareResult( EFalse );

	                switch( condCompareMethod )

		                {

	                    case ETextPropertyConditionCompareEquals:

	   		                {

	   		                if( (value == condValue ) )

	   		                    {

	   		                    compareResult = EFalse;

	   		                    }

	   		                break;

	   		                }

	                    case ETextPropertyConditionCompareContains:

	   		                {

	   		                compareResult = FindDes( value, condValue ); 

	   		                break;

	   		                }

	                    case ETextPropertyConditionCompareBeginsWith:

	   		                {

	   		                compareResult = CompareDesBeginsWith( value, condValue ); 

                            break;	   		               

	   		                }

	                    case ETextPropertyConditionCompareEndsWith:

	                        {

	   		                compareResult = CompareDesEndsWith( value, condValue );

                            break;	   		               

	   		                }

                        default: 

                            {

#ifdef _DEBUG

                            User::Panic( _L("MdSNCCP2") , KErrMdEUnknownConditionCompareMethod );

#endif

   		                    }

		                }          

	                if( compareResult == propertyCondition.iNegated )

	                    {

	                    return EFalse;

	                    }

	                break;

	                }

	            case EConditionTypePropertyBool:

    		        {

			        const TBool value( property.iValue.iInt32 );

			        TBool condValue( EFalse );

			        aSerializedCondition.ReceiveL( condValue );

			        if( ( value == condValue ) == propertyCondition.iNegated )

				        {

				        return EFalse;

				        }

			        break;

    		        }

	            default:

	            	{

#ifdef _DEBUG

                    User::Panic( _L("MdSNCCP3") , KErrMdEUnknownConditionType );

#endif

	            	User::Leave( KErrMdEUnknownConditionType );

	            	}

	            } // switch

            return ETrue;

            } // if

        } // for

    return EFalse;

    }

TBool CMdSNotifyComparator::CheckObjectL( CMdCSerializationBuffer& aSerializedCondition,

    			   						  CMdCSerializationBuffer& aSerializedItem,

    			   						  TBool aAllowConfidential )

    {

    const TMdCObject& object = TMdCObject::GetFromBufferL( aSerializedItem );

	const TBool confidential = object.iFlags & EMdEObjectFlagConfidential;

	// check if object is confidential and confidentials are not allowed

	if( confidential && ( aAllowConfidential == EFalse ) )

		{

		return EFalse;

		}

	// check if no condition defined

	if( aSerializedCondition.Size() <= 0 )

		{

		// pass all successful objects

		return ETrue;

		}

	const TMdCObjectCondition& condition = 

			TMdCObjectCondition::GetFromBufferL( aSerializedCondition );