-- @atlcompiler atl2006

module SF; 
create OUT : AMW from IN: AMW, left : MOF, right : MOF;


helper def: amwModel : AMW!MatchModel = OclUndefined;

helper def: listRef : Sequence(AMW!Element) = Sequence{};

helper def: methodName : String = 'Similarity flooding';


---------------------------------------------------------------------------------------------------
---------------------- generic helpers used for auxiliar tasks-----------------------------------------------------------------------------

helper context MOF!EModelElement def : isLeftME() : Boolean =
	MOF!EModelElement.allInstancesFrom('left')->exists(e | e = self);

helper context MOF!EClass def : isLeft() : Boolean =
	MOF!EClass.allInstancesFrom('left')->exists(e | e = self);

helper context MOF!EModelElement def : isRight() : Boolean =
	if self.oclIsTypeOf(MOF!EClass) then
		MOF!EClass.allInstancesFrom('right')->exists(e | e = self)		
	else
		if self.oclIsKindOf(MOF!EStructuralFeature) then
			self.isRightsf()
		else
			false
		endif
	endif;

helper context MOF!EStructuralFeature def : isLeftsf() : Boolean =
	self.eContainingClass.isLeft();

helper context MOF!EStructuralFeature def : isRightsf() : Boolean =
	self.eContainingClass.isRight();

helper def : maxSim : Real = 0.0;

helper def : targetRef : AMW!Element = OclUndefined;

helper context AMW!WElementRef def : getInstance (model : String): MOF!EModelElement =
	MOF!EModelElement.getInstanceById(model, self.ref);


----------------------------------------------------------------------------------------
------------------------------copied rules---------------------------------------------------

rule leftElement {
	from
		mmw : AMW!LeftElement
	to
		out : AMW!LeftElement (
			name <- mmw.name,
			element <- mmw.element
		)
}

rule rightElement {
	from
		mmw : AMW!RightElement
	to
		out : AMW!RightElement (
			name <- mmw.name,
			element <- mmw.element
		)
}

rule ElementRefs {
	from
		mmw : AMW!ElementRef 		
	to
		out : AMW!ElementRef (
			name <- mmw.name,
			ref <- mmw.ref,
			modelRef <- mmw.modelRef			
		)
}

rule matchmodel {
	from
		mmw: AMW!MatchModel 
	to
		model : AMW!MatchModel (
			name <- mmw.name,
			leftM <- mmw.leftM,
			rightM <- mmw.rightM,
			methods <- mmw.methods->union(Sequence{method})
		),
		method : AMW!Method (
			name <- thisModule.methodName
		)
}

rule method {
	from
		mmw : AMW!Method
	to 
		method : AMW!Method (
			name <- mmw.name			
		)
}

rule modelref {
	from
		mmw : AMW!ModelRef
	to
		out : AMW!ModelRef (
			name <- mmw.name,
			ref <- mmw.ref
		)
}


rule Edge {
	from
		mmw : AMW!PropagationEdge
	to 
		edge : AMW!PropagationEdge (
			name <- mmw.name,
			model <- mmw.model,			
			incomingLink <- mmw.incomingLink,
			outgoingLink <- mmw.outgoingLink,
			propagation <- mmw.propagation
		)
}

--------------------------------end copied rules-------------------------------------
----------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------

helper def: aTuple : TupleType(value : Real, count : Integer) = Tuple {value = 0, count = 0};


rule PropagationRule {
	from
		mmw : AMW!Equivalent
	to
		alink : AMW!Equivalent (			
			name <- mmw.name,
			model <- mmw.model,
			left <- mmw.left,
			right <- mmw.right
		)
	do {
		-- all the propagation of neighbors nodes
		thisModule.aTuple <- AMW!PropagationEdge.allInstancesFrom('IN')->		
		  select ( e | Set { e.incomingLink.left, e.incomingLink.right}  = 
			Set {mmw.left, mmw.right} )->
				iterate (e1; acc : TupleType(value : Real, count : Integer) = Tuple {value = 0, count = 0} |
					Tuple {
						value = acc.value + (e1.outgoingLink.similarity * e1.propagation),
						count = acc.count + 1
					}
				);		
		if (thisModule.aTuple.count = 0 ) {
			alink.similarity <- mmw.similarity;		
		}else {
			alink.similarity <- (mmw.similarity + thisModule.aTuple.value / thisModule.aTuple.count);		
		}
	}
}