/*
* Copyright (c) 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:  ?Description
*
*/

#include "mderelationcondition.h"
#include "mderelationdef.h"
#include "mdelogiccondition.h"
#include "mdscommoninternal.h"
#include "mdcserializationbuffer.h"
#include "mdcquery.h"

CMdERelationCondition* CMdERelationCondition::NewL( TItemId aRelationId,
		const RArray<TItemId>* aRelationIds, TRelationConditionSide aSide,
		const CMdERelationDef* aRelationDef, 
		const TMdEIntRange* aParameterRange )
	{
	CMdERelationCondition* self = CMdERelationCondition::NewLC(
			aRelationId, aRelationIds, aSide, aRelationDef, aParameterRange );
    CleanupStack::Pop( self );
    return self;
	}

CMdERelationCondition* CMdERelationCondition::NewLC( TItemId aRelationId,
		const RArray<TItemId>* aRelationIds, TRelationConditionSide aSide,
		const CMdERelationDef* aRelationDef, 
		const TMdEIntRange* aParameterRange )
	{
	CMdERelationCondition* self = new ( ELeave ) CMdERelationCondition( 
			aRelationId, aSide, aRelationDef );
    CleanupStack::PushL( self );
    self->ConstructL( aRelationIds, aParameterRange );
    return self;
	}

CMdERelationCondition::CMdERelationCondition( TItemId aRelationId, 
		TRelationConditionSide aSide, const CMdERelationDef* aRelationDef )
		: CMdECondition( EConditionTypeRelation ), iRelationId( aRelationId ),
		  iRelationDef( aRelationDef ), iSide( aSide )
	{
	iRelationIds = NULL;
	iParameterRange = NULL;
	iRightCondition = NULL;
	iLeftCondition = NULL;
	}

void CMdERelationCondition::ConstructL(const RArray<TItemId>* aRelationIds, 
		const TMdEIntRange* aParameterRange)
    {
    // Base class construction.
    ConditionConstruct();

    if( aRelationIds )
    	{
    	iRelationIds = new (ELeave) RArray<TItemId>();
    	
    	const TInt relationIdCount = aRelationIds->Count();
    	iRelationIds->ReserveL( relationIdCount );
    	
    	for( TInt i = 0; i < relationIdCount; i++ )
    		{
    		iRelationIds->AppendL( (*aRelationIds)[i] );
    		}
    	}

    if( aParameterRange )
        {
        // Make a copy of the parameter range.
        iParameterRange = new (ELeave) TMdEIntRange(*aParameterRange);
        }
    }

CMdERelationCondition::~CMdERelationCondition()
    {
   	delete iLeftCondition;
   	delete iRightCondition;
   	delete iParameterRange;
	delete iLastModifiedDateRange;

	if( iRelationIds )
		{
		iRelationIds->Close();
		delete iRelationIds;
		}
    }

EXPORT_C TItemId CMdERelationCondition::RelationId() const
    {   
    return iRelationId;
    }

EXPORT_C const RArray<TItemId>* CMdERelationCondition::RelationIds() const
	{   
	return iRelationIds;
	}

EXPORT_C const CMdERelationDef* CMdERelationCondition::RelationDef() const
    {   
    return iRelationDef;
    }

EXPORT_C CMdELogicCondition& CMdERelationCondition::LeftL()
    {
    if ( !iLeftCondition )
    	{
    	iLeftCondition = CMdELogicCondition::NewL(ELogicConditionOperatorAnd);
    	}
    
    return *iLeftCondition;
    }

EXPORT_C CMdELogicCondition& CMdERelationCondition::RightL()
    {
    if ( !iRightCondition )
    	{
    	iRightCondition = CMdELogicCondition::NewL(ELogicConditionOperatorAnd);
    	}

    return *iRightCondition;
    }

TRelationConditionSide CMdERelationCondition::Side() const
	{
	return iSide;
	}

EXPORT_C void CMdERelationCondition::SetSide(TRelationConditionSide aSide)
    {
    iSide = aSide;
    }


EXPORT_C const TMdEIntRange* CMdERelationCondition::ParameterRange() const
    {
    return iParameterRange;
    }

EXPORT_C void CMdERelationCondition::SetGuid(const TInt64& aGuidHigh, const TInt64& aGuidLow)
	{
	iGuidHigh = aGuidHigh;
	iGuidLow = aGuidLow;
	}

EXPORT_C TBool CMdERelationCondition::Guid(TInt64& aGuidHigh, TInt64& aGuidLow) const
	{
	if( iGuidHigh == 0 && iGuidLow == 0 )
		{
		return EFalse;
		}
	
	aGuidHigh = iGuidHigh;
	aGuidLow = iGuidLow;
	return ETrue;
	}

EXPORT_C void CMdERelationCondition::SetLastModifiedDateRangeL(const TMdETimeRange& aLastModifiedDateRange)
	{
	if( !iLastModifiedDateRange )
		{
		iLastModifiedDateRange = new (ELeave) TMdETimeRange( aLastModifiedDateRange );
		}
	}

EXPORT_C TBool CMdERelationCondition::LastModifiedDateRange(TMdETimeRange& aLastModifiedDateRange) const
	{
	if( iLastModifiedDateRange )
		{		
		aLastModifiedDateRange.SetType( iLastModifiedDateRange->Type() );
		aLastModifiedDateRange.SetMin( iLastModifiedDateRange->Min() );
		aLastModifiedDateRange.SetMax( iLastModifiedDateRange->Max() );
		return ETrue;
		}
	
	return EFalse;
	}

TUint32 CMdERelationCondition::InternalQueryOptimizationFlags(TUint32& aFlags)
	{
	aFlags |= EContainsRelationCondition;
	return EContainsRelationCondition;
	}

TUint32 CMdERelationCondition::RequiredBufferSize() const
	{
	TUint32 bufferSize = sizeof( TMdCRelationCondition );

	if( iRelationIds )
		{
		// count and IDs
		bufferSize += CMdCSerializationBuffer::KRequiredSizeForTUint32 + 
			iRelationIds->Count() * CMdCSerializationBuffer::KRequiredSizeForTItemId;
		}	

	if( iGuidHigh != 0 || iGuidLow != 0 )
		{
		bufferSize += 2 * CMdCSerializationBuffer::KRequiredSizeForTInt64;
		}

	if ( iParameterRange )
		{
		bufferSize += iParameterRange->RequiredBufferSize();
		}

	if ( iLeftCondition && iLeftCondition->Count() > 0 )
		{
		bufferSize += iLeftCondition->RequiredBufferSize();
		}

	if ( iRightCondition && iRightCondition->Count() > 0  )
		{
		bufferSize += iRightCondition->RequiredBufferSize();
		}

	if( iLastModifiedDateRange )
		{
		bufferSize += iLastModifiedDateRange->RequiredBufferSize();
		}

	return bufferSize;
	}

void CMdERelationCondition::SerializeL(CMdCSerializationBuffer& aBuffer,
		TMdCOffset& aFreespaceOffset) const
	{
	TMdCRelationCondition condition;

	condition.iConditionType = iType;
	condition.iNegated = iNegated;
	condition.iObjectSide = iSide;

	if( iRelationDef )
		{
		condition.iRelationDefId = iRelationDef->Id();
		}
	else
		{
		condition.iRelationDefId = KNoDefId;
		}

	condition.iRelationId = iRelationId;

	// updated later, if relation IDs exists
	condition.iRelationIds.iPtr.iCount = 0;
	condition.iRelationIds.iPtr.iOffset = KNoOffset;
	// updated later, if GUID exists
	condition.iGuid = KNoOffset;
	// updated later, if parameter range exists
	condition.iParameterRange = KNoOffset;
	// updated later, if left object condition exists
	condition.iLeftObjectCondition = KNoOffset;
	// updated later, if right object condition exists
	condition.iRightObjectCondition = KNoOffset;
	// updated later, if last modified date range exists
	condition.iLastModifiedDateRange = KNoOffset;

	const TUint32 conditionOffset = aBuffer.Position();

	// get position after condition
	aFreespaceOffset = conditionOffset + sizeof( TMdCRelationCondition );
	aBuffer.PositionL( aFreespaceOffset );

	if( iRelationIds )
		{
		condition.iRelationIds.iPtr.iCount = iRelationIds->Count();
		condition.iRelationIds.iPtr.iOffset = aFreespaceOffset;
		
		const TInt relationIdCount = iRelationIds->Count();
		for( TInt i = 0; i < relationIdCount; i++ )
			{
			const TItemId relationId = (*iRelationIds)[i];
			aBuffer.InsertL( relationId );
			}
		
		aFreespaceOffset = aBuffer.Position();
		}
	
	if( iGuidHigh != 0 || iGuidLow != 0 )
		{
		condition.iGuid = aFreespaceOffset;

		aBuffer.InsertL( iGuidHigh );
		aBuffer.InsertL( iGuidLow );
		
		aFreespaceOffset = aBuffer.Position();
		}

	if ( iParameterRange )
		{
		condition.iParameterRange = aFreespaceOffset;

		iParameterRange->SerializeL( aBuffer );

		aFreespaceOffset = aBuffer.Position();
		}

	if ( iLeftCondition && iLeftCondition->Count() > 0  )
		{
		condition.iLeftObjectCondition = aFreespaceOffset;

		iLeftCondition->SerializeL( aBuffer, aFreespaceOffset );

		aFreespaceOffset = aBuffer.Position();
		}

	if ( iRightCondition && iRightCondition->Count() > 0  )
		{
		condition.iRightObjectCondition = aFreespaceOffset;

		iRightCondition->SerializeL( aBuffer, aFreespaceOffset );

		aFreespaceOffset = aBuffer.Position();
		}

	if ( iLastModifiedDateRange )
		{
		condition.iLastModifiedDateRange = aFreespaceOffset;

		iLastModifiedDateRange->SerializeL( aBuffer );

		aFreespaceOffset = aBuffer.Position();
		}

	aBuffer.PositionL( conditionOffset );
	
	condition.SerializeL( aBuffer );
	
	// move back to after sub condition
	aBuffer.PositionL( aFreespaceOffset );
	}