The fridge SHALL detect and communicate information with AS MANY food packages AS POSSIBLE.

SHALL (AS MANY AS POSSIBLE p)
p: The fridge detects and communicates information with food packages

//list of all requirements
Requirements:
	requirements+=Requirement+;

//each requirement is finalized with ";"
Requirement:
	(root+=General)+ ';';
//undefined types
terminal BOOLEAN returns ecore::EBoolean:'true'|'false';

terminal FREESTRING:  (('\\')?('a'..'z'|'A'..'Z'|'_'|'0'..'9'|','|'.'))*  ;

//Natural Language
NL hidden(WS): FREESTRING ( FREESTRING)*;

General:
	rest = Rest =>({UntilOperator.left=current}('UNTIL'|'until') right=General)*;

//aqui se encontram as demais regras da gramatica
Rest:
	Primitive|ShallOperator|MayOperator|EventuallyOperator|BeforeOperator|AfterOperator|InOperator|AsCloseOperator|AsOperator
;

Primitive:
	BooleanValue | StringValue
;
//primitives
BooleanValue:value=BOOLEAN;
StringValue:value=NL;

ShallOperator:
	('SHALL'|'shall') elements=General;

MayOperator:
	("MAY"|'may') action1=General ('OR'|'or') action2=General;

EventuallyOperator:
	('EVENTUALLY'|'eventually') element=General;

BeforeOperator:
	('BEFORE'|'before') event=NL other=General;

AfterOperator:
	('AFTER'|'after') event=NL other=General;

InOperator:
	('IN'|'in') t=NL other=General;
	
AsCloseOperator:
	('AS' 'CLOSE' 'AS' 'POSSIBLE' 'TO'|'as' 'close' 'as' 'possible' 'to') ForQ=NL;

AsOperator:
	AsEarlyOperator|AsLateOperator|AsManyOperator|AsFewOperator;

AsEarlyOperator:
	('AS' 'EARLY' 'AS' 'POSSIBLE'|'as' 'early' 'as' 'possible') value=General;
AsLateOperator:
	('AS' 'LATE' 'AS' 'POSSIBLE'|'as' 'late' 'as' 'possible') value=General;
AsManyOperator:
	('AS' 'MANY'|'as' 'many') (element=NL)? ('AS' 'POSSIBLE'|'as' 'possible') value=General;
AsFewOperator:
	('AS' 'FEW'|'as' 'few') (element=NL)? ('AS' 'POSSIBLE'|'as' 'possible') value=General;

override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) {
		// criamos um arquivo em separado para cada requisito
		var counter = 1
		for (e : resource.allContents.toIterable.filter(Requirement)) {
			fsa.generateFile("relaxExpressions" + counter + ".exp", e.compile)
			counter++
		}
	}

	def compile(Requirement r) '''
		«FOR f : r.root»
			«f.compileGeneral»
		«ENDFOR»
	'''

	def compileGeneral(General g) '''
		«IF g.rest != null»
			«g.rest.compileRest »
		«ENDIF»
	'''
	
	def compileRest(Rest r) '''
		«IF r.eContainer.class.equals(Primitive) »
			aa
		«ENDIF»
	'''

Rest
  - AsOperator
  - ...
  - Primitive
    - StringValue
    - BooleanValue

General
 - UntilOperator

	def dipatch compileGeneral(General g) '''
		//TODO
	'''
	def dipatch compileGeneral(UntilOperator g) '''
		//TODO
	'''
	
	def dipatch compileRest(Rest r) '''
		// TODO
	'''
	def dipatch compileRest(BooleanValue r) '''
		// TODO
	'''
	def dipatch xompileRest(StringValue r) '''
		// TODO
	'''
	def dipatch compileRest(AsOperator r) '''
		// TODO
	'''

	def dispatch compileRest(Rest r) '''
		// TODO
	'''
	def dispatch compileRest(BooleanValue r) '''
		// TODO
	'''
	def dispatch compileRest(StringValue r) '''
		// TODO
	'''
	def dispatch compileRest(AsOperator r) '''
		// TODO
	'''

def compileGeneral(General g) '''
		«IF g.rest != null»
			«g.rest.compileRestRule »
		«ENDIF»
	'''
	
	def compileRestRule(Rest r) '''
		«r.rule.compileRest»
	'''
	//sobreposicao das regras contidas em Rest
	def dispatch compileRest(Primitive p)'''
		«p.compilePrimitive»
	'''
	
	def dispatch compileRest(ShallOperator s)'''
		SHALL
		«s.elements.compileGeneral»
	'''
	
	//compilar primitivos
	def dispatch compilePrimitive(BooleanValue b)'''
		«b.value»
	'''
	
	def dispatch compilePrimitive(StringValue s)'''
		«s.value.trim»
	'''