/* The documentation for the action */
Action:
	type=JvmTypeReference config=ActionConfiguration ";";

ActionConfiguration:
	{ActionConfiguration} (target=XMemberFeatureCall)? (":" data+=Datum+)?;

Datum:
	content=PropertyRef | Value;

			Click MyPage.element ;
			Fill MyPage.text : "How to use this" ;
			// Click MyPage.getValues(3); // error: no viable alternative at input '3'

  @Test
  public void testSearch() {
    (new Click (
    	<XFeatureCallImplCustom>.element
    )).exec(); 
    (new Fill (
    	<XFeatureCallImplCustom>.text
    )).exec(); 
  }

  @Test
  public void testSearch() {
    (new Click ( MyPage.element   )).exec(); 
    (new Fill ( MyPage.text , "How to use this"   )).exec(); 
    (new Click ( MyPage.getValues(3)   )).exec(); 
  }

		def JvmOperation createTestMethod(TestDefinition test) {
		test.toMethod(test.name, typeRef(void)) [
			annotations += annotationRef("org.junit.Test");
			body = ''' 
				«FOR a : test.actions»
				(new «a.type » (
					«IF a.config.target != null»
						«a.config.target»
					«ENDIF»
				)).exec(); 
					«ENDFOR»
			'''
		]
	}

Fill MyPage.text : "How to use this" ;

Click MyPage.getValues(3); // error: no viable alternative at input '3'

  @Test
  public void testSearch() {
    (new Click ( helper1()  )).exec(); 
    (new Fill ( helper2(), "How to use this" )).exec(); 
    (new Click ( MyPage.getValues(3)   )).exec(); 
  }

private ClickTarget helper1() {
    return MyPage.element;
}

private FillTarget helper2() {
return MyPage.text;
}
.....

Domainmodel:
//	moduleName=ModuleDeclaration
	"package" name=QualifiedName ";" //
	importSection=XImportSection? //
	suite=SuiteDeclaration;
SuiteDeclaration:
	'suite' name=ValidID ('using' '(' configFiles=Files ')')? '{' handlers+=EventHandlerDefinition* beforeActions+=Action*
	prepare=PrepareDeclaraion afterActions+=(Action)* '}';
PrepareDeclaraion:
	'prepare' ('using' '(' configFiles=Files ')')? '{' handlers+=EventHandlerDefinition* beforeActions+=Action*
	testCases+=TestDefinition+ afterActions+=Action* '}';
TestDefinition:
	"test" name=ValidID ('using' '(' configFiles=Files ')')? '{' actions+=(Action)+ '}';
Action:
	type=JvmTypeReference config=ActionConfiguration ";";

ActionConfiguration:
	{ActionConfiguration} targets+=(UIElement)* (":" data+=Datum+)?;

UIElement: //; returns xbase::XExpression:
	comp=(XMemberFeatureCall);

		test myTestCaseSample using (some.xml ) {
			Click MyPage.element ;
			Fill MyPage.text : "How to use this" ;
			 Fill new Xpath.id("username") : "myUserName" ;
			
			Click XpathBuilder.element("input").parent("div").att("id" , "submit") ; 
			 Click MyPage.getValues(3); // error: no viable alternative at input '3'
			
			DragNDrop Xpath.id("product-1") XpathBuilder.element("div").att("id" , "basket") ;
			
			Validate XpathBuilder.id("message") "Thank you for placing your order" ;
		}

NAMESPACE:
	ID;
// comment out char and digit

TestDefinition :
	 "test" name=ValidID ('using' '(' configFiles=Files ')')? '{' block = TestBlock '}';

TestBlock returns xbase::XBlockExpression :
	expressions+=ActionExpression+
;

ActionExpression returns xbase::XExpression:
	Action
;

Action:
	type=JvmTypeReference config=ActionConfiguration ";";

ActionConfiguration:
	{ActionConfiguration} targets+=(UIElement)* (":" data+=Datum+)?;

UIElement:
	{UIElement} block=XExpression;

TestDefinition:
	"test" name=ValidID ('using' '(' configFiles=Files ')')? '{' block=TestBlock '}';

TestBlock returns xbase::XBlockExpression:
	expressions+=Action+;

Action returns xbase::XExpression:
      {Action} type=JvmTypeReference config=ActionConfiguration ";";

ActionConfiguration:
	{ActionConfiguration} targets+=(UIElement)* (":" data+=Datum+)?;

	def JvmOperation createTestMethod(TestDefinition test) {
		test.toMethod(test.name, typeRef(void)) [
			annotations += annotationRef("org.junit.Test");
			body = ''' 
			TEST BLOCK
			«test.block»
			'''
		]
	}

TestDefinition:
	"test" name=ValidID ('using' '(' configFiles=Files ')')? '{' block=TestBlock '}';
TestBlock returns xbase::XBlockExpression:
	{TestBlock} expressions+=Action+;
Action returns xbase::XExpression:
	{Action} type=JvmTypeReference config=ActionConfiguration ";";
ActionConfiguration:
	{ActionConfiguration} targets+=(UIElement)* (":" data+=Datum+)?;
UIElement:
	{UIElement} block=XExpression;

	def JvmOperation createTestMethod(TestDefinition test) {
		test.toMethod(test.name, typeRef(void)) [
			annotations += annotationRef("org.junit.Test");
			body = test.block
		]
	}

	override protected doInternalToJavaStatement(XExpression obj, ITreeAppendable appendable, boolean isReferenced) {

		if (obj instanceof TestBlock) {

			val block = obj as TestBlock;

			for (exp : block.expressions)
				doInternalToJavaStatement(exp, appendable, isReferenced);

			return;

		} else if (obj instanceof Action) {

			appendable.newLine

			val action = obj as Action;
			appendable.trace(action)
			appendable.append("(new ");
			appendable.append(action.type.qualifiedName + "(");
			for (target : action.config.targets) {
				internalToJavaExpression(target.block, appendable);
//				internalToJavaExpression(target.block, appendable);
				if (!action.config.targets.last.equals(target)) {
					appendable.append(",");
				}
			}
			appendable.append(").exec();")
			appendable.newLine
			println("Processed compiler expression")
			return
		} else {
			super.internalToConvertedExpression(obj, appendable)
		}
	}

		test myTestCaseSample using (some.xml ) {
			Click MyPage.element ;
			Fill MyPage.text : "How to use this" ;
			Fill ; /*What ever*/
			Click MyPage.getValues(3); // error: no viable alternative at input '3' ;
		}

  @Test
  public void myTestCaseSample() {
    (new actions.Click(/* name is null */./* name is null */).exec();
    (new actions.Fill(/* name is null */./* name is null */).exec();
    (new actions.Fill().exec();
    (new actions.Click(/* name is null */./* name is null */).exec();
  }

internalToJavaExpression(target.block, appendable); 

// i dont want all this before after whatever
SuiteDeclaration:
	'suite' name=ValidID ('using' '(' configFiles=Files ')')? '{' testCases+=TestDefinition* '}';

for (TestDefinition test : suite.testCases) {
				members += this.createTestMethod(test);
			}


....


	def JvmOperation createTestMethod(TestDefinition test) {
		test.toMethod(test.name, typeRef(void)) [
			annotations += annotationRef("org.junit.Test");
//			visibility = JvmVisibility.PRIVATE ;
			body = test.block
		]
		
	}

class MyDslRuntimeModule extends AbstractMyDslRuntimeModule {
//
    def Class<? extends ITypeComputer> bindITypeComputer() {
        return MyDslTypeComputer
    }
    def Class<? extends XbaseCompiler> bindXbaseCompiler() {
        return MyDslCompiler
    }
}

class MyDslTypeComputer extends XbaseTypeComputer {

	override computeTypes(XExpression expression, ITypeComputationState state) {
		if (expression instanceof Action) {
			_computeTypes(expression as Action, state);
		} else {
			super.computeTypes(expression, state)
		}
	}
	
		protected def void _computeTypes(Action object, ITypeComputationState state) {
			
			for (t : object.config.targets) {
				println("TODO better logic here ?!?")
				val iaction = state.getReferenceOwner().getServices().getTypeReferences().findDeclaredType("org.example.IAction", state.referenceOwner.contextResourceSet)
				state.withExpectation(
					state.referenceOwner.newParameterizedTypeReference(iaction)
				).computeTypes(t.block)
			}
			
		
		state.acceptActualType(getTypeForName(Void.TYPE, state), ConformanceFlags.CHECKED_SUCCESS)
	}

//	protected def void _computeTypes(UIElement object, ITypeComputationState state) {
//		state.withExpectation(getPrimitiveVoid(state)).computeTypes(object.comp)
//		state.acceptActualType(getTypeForName(Runnable, state), ConformanceFlags.CHECKED_SUCCESS)
//	}

}

	protected def void _computeTypes(Action action, ITypeComputationState state) {
		for (t : action.config.targets) {
			println("TODO better logic here ?!?")
			val iaction = state.getReferenceOwner().getServices().getTypeReferences().findDeclaredType(
				"org.example.ILocator", state.referenceOwner.contextResourceSet)
			state.withExpectation(
				state.referenceOwner.newParameterizedTypeReference(iaction)
			).computeTypes(t.block)
		}
		state.acceptActualType(getTypeForName(Void.TYPE, state), ConformanceFlags.CHECKED_SUCCESS)
	}

	public override dispatch void toJavaStatement(XAbstractFeatureCall expr, ITreeAppendable b, boolean isReferenced) {
		if (expr instanceof XMemberFeatureCall) {
			featureCalltoJavaExpression(expr, b, false);
		} else {
			toJavaStatement(expr as XAbstractFeatureCall, b, isReferenced);
		}
	}

test myTestCaseSample using (some.xml ) {
			Click MyOtherPage.element ;
			Fill MyPage.text : "How to use this" ;
			Fill ; /*What ever*/
			Click MyPage.getValues(3) : "Hello";

@Test
  public void myTestCaseSample() {
    (new actions.Click(MyOtherPage.element)).exec() ;
    (new actions.Fill(MyPage.text)).exec();
    (new actions.Fill()).exec();
    (new actions.Click(MyPage.getValues(3))).exec();
  }