/*

* 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:  ?Description

*

*/

// [INCLUDE FILES] - do not remove

#include <mdeobject.h>

#include <mdeobjectquery.h>

#include <mdeconstants.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include "MdETestScripter.h"

const TInt KRootCond = -1;

// -----------------------------------------------------------------------------

// CMdETestScripter::FindL

// -----------------------------------------------------------------------------

//

TInt CMdETestScripter::FindL( CStifItemParser& aItem )

	{

	TInt maxCount;

	User::LeaveIfError( aItem.GetNextInt( maxCount ) );

	TInt notifyCount;

	User::LeaveIfError( aItem.GetNextInt( notifyCount ) );

	iQuery->FindL( maxCount, notifyCount );

	return KErrNone;

	}

// -----------------------------------------------------------------------------

// CMdETestScripter::QueryObjectL

// -----------------------------------------------------------------------------

//

TInt CMdETestScripter::QueryObjectL( CStifItemParser& aItem )

    {

    TPtrC objectString;

    CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

    User::LeaveIfError( aItem.GetNextString( objectString ));

	CMdEObjectDef& objdef = space->GetObjectDefL( objectString );

	delete iQuery;

	iQuery = NULL;

	iQuery = iMdeSession->NewObjectQueryL( *space, objdef, this );

	iQuery->SetResultMode( EQueryResultModeId );

	iQuery->FindL(1);

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CMdETestScripter::NewObjectQueryL

// -----------------------------------------------------------------------------

//

TInt CMdETestScripter::NewObjectQueryL( CStifItemParser& aItem )

	{

    TPtrC name;

	User::LeaveIfError( aItem.GetNextString( name )); 

    CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );	 		

    TPtrC modeString;

    User::LeaveIfError( aItem.GetNextString( modeString ));

    TQueryResultMode modeEnum = ResultModeL( modeString );

    TPtrC objectString;

    User::LeaveIfError( aItem.GetNextString( objectString ));

	CMdEObjectDef& objdef = space->GetObjectDefL( objectString );

	delete iQuery;

	iQuery = NULL;

	TPtrC type;

	User::LeaveIfError( aItem.GetNextString( type ));

	if ( type.Compare(_L("Object")) == 0 )

		{

		iQuery = iMdeSession->NewObjectQueryL( *space, objdef, this );			

		}		

	else if ( type.Compare(_L("LookupObject")) == 0 )

		{		

		RPointerArray<CMdEObjectDef> *objDefs = new (ELeave) RPointerArray<CMdEObjectDef>;

		TPtrC startMark;

		User::LeaveIfError( aItem.GetNextString( startMark ));

		if ( startMark.Compare(_L("{")) == 0)

			{

			TInt index;

			while( ETrue )

				{

				index = GetObjectDefIndexL( aItem );

				if ( index == KErrCompletion )

					{

					break;

					}

				objDefs->Append( iObjectDefArray[ index ] );

				}	

			}

		iQuery = iMdeSession->NewObjectQueryL( objdef, objDefs, this );	

		}

	else

        {

    	User::Leave( KErrArgument );

        }

	iQuery->SetResultMode( modeEnum );

	CMdELogicCondition* rootLogicCondition = &iQuery->Conditions();

    iLogicConditionArray.Append( rootLogicCondition );

    AppendNameL( iLogicConditionNameArray, name );		

	return KErrNone;	

	}

// -----------------------------------------------------------------------------

// CMdETestScripter::NewRelationQueryL

// -----------------------------------------------------------------------------

//

TInt CMdETestScripter::NewRelationQueryL( CStifItemParser& aItem )

	{	

    TPtrC name;

	User::LeaveIfError( aItem.GetNextString( name ));  	

	delete iQuery;

	iQuery = NULL;

	CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );

    TPtrC modeString;

    User::LeaveIfError( aItem.GetNextString( modeString ));

    TQueryResultMode modeEnum = ResultModeL( modeString );

	iQuery = iMdeSession->NewRelationQueryL( *space, this );

	iQuery->SetResultMode( modeEnum );

	CMdELogicCondition* rootLogicCondition = &iQuery->Conditions();

    iLogicConditionArray.Append( rootLogicCondition );

    AppendNameL( iLogicConditionNameArray, name );	

	return KErrNone;		

	}

// -----------------------------------------------------------------------------

// CMdETestScripter::NewEventQueryL

// -----------------------------------------------------------------------------

//

TInt CMdETestScripter::NewEventQueryL( CStifItemParser& aItem )

	{	

    TPtrC name;

	User::LeaveIfError( aItem.GetNextString( name ));	

	delete iQuery;

	iQuery = NULL;

    CMdENamespaceDef* space = SanitizeArrayIndexL( iNamespaceDefArray, *iNamespaceDefNameArray, aItem );	

    TPtrC modeString;

    User::LeaveIfError( aItem.GetNextString( modeString ));

    TQueryResultMode modeEnum = ResultModeL( modeString );

	iQuery = iMdeSession->NewEventQueryL( *space, this );

	iQuery->SetResultMode( modeEnum );

	CMdELogicCondition* rootLogicCondition = &iQuery->Conditions();

    iLogicConditionArray.Append( rootLogicCondition );

    AppendNameL( iLogicConditionNameArray, name );		

	return KErrNone;	

	}

// -----------------------------------------------------------------------------	

// CMdEObjectQuery::AddPropertyFilterL

// -----------------------------------------------------------------------------

// 

TInt CMdETestScripter::AddPropertyFilterL( CStifItemParser& aItem )

	{

	CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem);

	((CMdEObjectQuery *)iQuery)->AddPropertyFilterL( propertyDef );

	return KErrNone;

	}	

// -----------------------------------------------------------------------------	

// CMdEObjectQuery::AppendOrderRuleL

// -----------------------------------------------------------------------------

// 

TInt CMdETestScripter::AppendOrderRuleL( CStifItemParser& aItem )

	{

	TInt ascending;

	User::LeaveIfError( aItem.GetNextInt( ascending ) );

	TInt orderRule;

	User::LeaveIfError( aItem.GetNextInt( orderRule ) );

	if ( orderRule == EOrderRuleTypeProperty )

		{

		CMdEPropertyDef* propertyDef = SanitizeArrayIndexL( iPropertyDefArray, *iPropertyDefNameArray, aItem);

		((CMdEObjectQuery *)iQuery)->AppendOrderRuleL( TMdEOrderRule( *propertyDef, ascending ));

		}

	else

		{

		((CMdEObjectQuery *)iQuery)->AppendOrderRuleL( TMdEOrderRule( (TOrderRuleType) orderRule, ascending ));	

		}

	return KErrNone;	

	}

// -----------------------------------------------------------------------------

// CMdETestScripter::HandleQueryNewResults

// -----------------------------------------------------------------------------

//    

void CMdETestScripter::HandleQueryNewResults( CMdEQuery& /*aQuery*/,

    TInt /*aFirstNewItemIndex*/, TInt aNewItemCount )

	{

	_LIT( KMessage, "Query new results count: " );

	_LIT( KMessage2, " new count: " );

	TBuf<128> buf( KMessage );

	buf.Append( KMessage2 );

	buf.AppendNum( aNewItemCount );

	}

// -----------------------------------------------------------------------------

// CMdETestScripter::QueryRelationL

// -----------------------------------------------------------------------------

//

TInt CMdETestScripter::QueryRelationL( CStifItemParser& aItem )

    {

    TPtrC relationString;

    User::LeaveIfError( aItem.GetNextString( relationString ));

	CMdERelationDef& reldef = iNamespaceDefArray[0]->GetRelationDefL( relationString );

	delete iQuery;

	iQuery = NULL;	

	iQuery = iMdeSession->NewRelationQueryL( *iNamespaceDefArray[0], this );

	iQuery->SetResultMode( EQueryResultModeId );

	iQueryRoot = &iQuery->Conditions();

	iQueryRoot->AddRelationConditionL( reldef );	

	iQuery->FindL(1);

    return KErrNone;

    }	

// -----------------------------------------------------------------------------

// CMdETestScripter::QueryEventL

// -----------------------------------------------------------------------------

//

TInt CMdETestScripter::QueryEventL( CStifItemParser& aItem )    

    {

    TPtrC eventString;

    User::LeaveIfError( aItem.GetNextString( eventString ));

	CMdEEventDef& evdef = iNamespaceDefArray[0]->GetEventDefL( eventString );

	delete iQuery;

	iQuery = NULL;

	iQuery = iMdeSession->NewEventQueryL( *iNamespaceDefArray[0], this );

	iQuery->SetResultMode( EQueryResultModeId );

	iQueryRoot = &iQuery->Conditions();

	iQueryRoot->AddEventConditionL( evdef );	

	iQuery->FindL(1);

    return KErrNone;

    }

_LIT(KAND , "AND");

_LIT(KOR , "OR");	

// -----------------------------------------------------------------------------	

// CMdETestScripter::NewLogicConditionL

// -----------------------------------------------------------------------------

//    

TInt CMdETestScripter::NewLogicConditionL( CStifItemParser& aItem )

	{

	TPtrC name;

	User::LeaveIfError( aItem.GetNextString( name ));

	TPtrC logicOperator;

	User::LeaveIfError( aItem.GetNextString( logicOperator ));

	TLogicConditionOperator logCondOperator = ELogicConditionOperatorAnd;

	if ( logicOperator.Compare( KAND ) == 0)

		{

		logCondOperator = ELogicConditionOperatorAnd;	

		}

	else if ( logicOperator.Compare( KOR ) == 0)

		{

		logCondOperator = ELogicConditionOperatorOr;		

		}

	else

        {

    	User::Leave( KErrArgument );

        }

	CMdELogicCondition* condition = CMdELogicCondition::NewL( logCondOperator );

	iLogicConditionArray.Append( condition );

	AppendNameL( iEventConditionNameArray, name );

	return KErrNone;	

	}

// -----------------------------------------------------------------------------	

// CMdETestScripter::RightL

// -----------------------------------------------------------------------------

//    

TInt CMdETestScripter::RightL( CStifItemParser& aItem )

	{

	TPtrC name;

	User::LeaveIfError( aItem.GetNextString( name ));

	CMdERelationCondition* relationCond = SanitizeArrayIndexL(

		 iRelationConditionArray, *iRelationConditionNameArray, aItem );			

	CMdELogicCondition* rightCond = &relationCond->RightL();

    iLogicConditionArray.Append( rightCond );

    AppendNameL( iLogicConditionNameArray, name );

    return KErrNone;

	}

// -----------------------------------------------------------------------------	

// CMdETestScripter::LeftL

// -----------------------------------------------------------------------------

//    

TInt CMdETestScripter::LeftL( CStifItemParser& aItem )

	{

	TPtrC name;

	User::LeaveIfError( aItem.GetNextString( name ));

	CMdERelationCondition* relationCond = SanitizeArrayIndexL( 

		iRelationConditionArray, *iRelationConditionNameArray, aItem );			

	CMdELogicCondition* leftCond = &relationCond->LeftL();

    iLogicConditionArray.Append( leftCond );

    AppendNameL( iLogicConditionNameArray, name );

    return KErrNone;

	}

// -----------------------------------------------------------------------------	

// CMdETestScripter::SetOperatorL

// -----------------------------------------------------------------------------

//    

TInt CMdETestScripter::SetOperatorL( CStifItemParser& aItem )

	{

	CMdELogicCondition* logicCondition = SanitizeArrayIndexL( iLogicConditionArray, *iLogicConditionNameArray, aItem );	

	TInt logicalOperator;

	User::LeaveIfError( aItem.GetNextInt( logicalOperator ));

	logicCondition->SetOperator( ( TLogicConditionOperator )logicalOperator );

    return KErrNone;

	}

// -----------------------------------------------------------------------------	

// CMdETestScripter::SetNegateL

// -----------------------------------------------------------------------------

//    

TInt CMdETestScripter::SetNegateL( CStifItemParser& aItem )

	{

	CMdEPropertyCondition* condition = SanitizeArrayIndexL( iPropertyConditionArray, *iPropertyConditionNameArray, aItem );	

	TInt boolean;

	User::LeaveIfError( aItem.GetNextInt( boolean ));

	((CMdECondition *)condition)->SetNegate( boolean );

    return KErrNone;

	}	

// -----------------------------------------------------------------------------	

// CMdETestScripter::AddLogicConditionL

// -----------------------------------------------------------------------------

//    

TInt CMdETestScripter::AddLogicConditionL( CStifItemParser& aItem )

	{

	TPtrC name;

	User::LeaveIfError( aItem.GetNextString( name ));			

	CMdELogicCondition* logicCondition = SanitizeArrayIndexL( iLogicConditionArray, *iLogicConditionNameArray, aItem );

	TPtrC logicOperator;

	User::LeaveIfError( aItem.GetNextString( logicOperator ));

	TLogicConditionOperator logCondOperator = ELogicConditionOperatorAnd;

	if ( logicOperator.Compare( KAND ) == 0)

		{

		logCondOperator = ELogicConditionOperatorAnd;	

		}

	else if ( logicOperator.Compare( KOR ) == 0)

		{

		logCondOperator = ELogicConditionOperatorOr;		

		}

	else

        {

    	User::Leave( KErrArgument );

        }

    CMdELogicCondition* condition = &logicCondition->AddLogicConditionL( logCondOperator );

    iLogicConditionArray.Append( condition );

    AppendNameL( iLogicConditionNameArray, name );

    return KErrNone;

	}

	_LIT(KRelationDef, "RelationDef");

	_LIT(KRelationDefRange, "RelationDefRange");

	_LIT(KAny, "Any");

	_LIT(KEqual, "Equal");

	_LIT(KNotEqual, "NotEqual");

	_LIT(KLess, "Less");

	_LIT(KLessOrEqual, "LessOrEqual");

	_LIT(KGreater, "Greater");

	_LIT(KGreaterOrEqual, "GreaterOrEqual");

	_LIT(KBetween, "Between");

	_LIT(KNotBetween, "NotBetween");

	_LIT(KObject , "Object");

	_LIT(KObjectDef , "ObjectDef");

	_LIT(KGuid , "Guid");

	_LIT(KNone , "None");

	_LIT(KId , "Id");

	_LIT(KIds , "Ids");

	_LIT(KUri , "Uri");

	_LIT(KUriBeginsWith , "UriBeginsWith");

	_LIT(KFreeText , "FreeText");

	_LIT(KFreeTextContains , "FreeTextContains");

	_LIT(KFreeTextBeginsWith , "FreeTextBeginsWith");

	_LIT(KFreeTextEndsWith , "FreeTextEndsWith");

	_LIT(KFreeTextUsageCount , "FreeTextUsageCount");

	_LIT(KCount , "Count");

	_LIT(KItem , "Item");

	_LIT(KDistinctValues , "DistinctValues");

	_LIT(KObjectWithFreetexts , "ObjectWithFreetexts");

TQueryResultMode CMdETestScripter::ResultModeL(TDesC& aModeString)

	{

	TQueryResultMode modeEnum = EQueryResultModeId;

	if ( aModeString.Compare( KId ) == 0 )

		{

		modeEnum = EQueryResultModeId;	

		}

	else if ( aModeString.Compare( KItem ) == 0 )

		{

		modeEnum = EQueryResultModeItem;	

		}

	else if ( aModeString.Compare( KCount ) == 0 )

		{

		modeEnum = EQueryResultModeCount;	

		}

	else if ( aModeString.Compare( KDistinctValues ) == 0 )

		{

		modeEnum = EQueryResultModeDistinctValues;	

		}

	else if ( aModeString.Compare( KObjectWithFreetexts ) == 0 )

		{

		modeEnum = EQueryResultModeObjectWithFreetexts;	

		}

	else

        {

    	User::Leave( KErrArgument );

        }

    return modeEnum;	

	}

CMdERelationDef& CMdETestScripter::GetRelationDefStrL( CStifItemParser& aItem )

	{

	TPtrC relationDefStr;

	User::LeaveIfError( aItem.GetNextString( relationDefStr ));

	TLex lex( relationDefStr );

	TInt integer;

	TInt err = lex.Val( integer );

	if ( err == KErrGeneral )

		{

		return iNamespaceDefArray[0]->GetRelationDefL( relationDefStr );		

		}

	else

		{

		return *iRelationDefArray[ integer ];	

		}

	}

TInt CMdETestScripter::GetObjectDefIndexL( CStifItemParser& aItem )

	{

	TPtrC objectDefStr;

	User::LeaveIfError( aItem.GetNextString( objectDefStr ));

	TLex lex( objectDefStr );

	TInt integer;

	TInt err = lex.Val( integer );

	if ( err == KErrGeneral )

		{

		if ( objectDefStr.Compare( _L("}")) == 0)

			{ 

			return KErrCompletion;	// indictes end of list

			}		

		for ( TInt i = 0; i < iObjectDefNameArray->Count(); i++)

			{

			if ( objectDefStr.Compare( (*iObjectDefNameArray)[i] ) == 0 )

				{

				return i;	

				}

			}

		return KErrNotFound;

		}

	else

		{

		return integer ;	

		}

	}

TInt CMdETestScripter::GetRelationDefIndexL( CStifItemParser& aItem )

	{

	TPtrC relationDefStr;

	User::LeaveIfError( aItem.GetNextString( relationDefStr ));

	TLex lex( relationDefStr );

	TInt integer;

	TInt err = lex.Val( integer );

	if ( err == KErrGeneral )

		{

		for ( TInt i = 0; i < iRelationDefNameArray->Count(); i++)

			{

			if ( relationDefStr.Compare( (*iRelationDefNameArray)[i] ) == 0 )

				{

				return i;	

				}

			}

		return KErrNotFound;

		}

	else