import datatypes;
import DSM.coremetamodel.Editor;
import DSM.metamodel.PetriNet.PetriNetEditor.PetriNet;

@incremental
machine petriNetQuickFix{
	
/*	@goal
	pattern validNet() = {
		DSM.metamodel.PetriNet.PetriNetEditor.PetriNet(Net);
		
		find selfArc(Arc);
		find invalidArc(Arc);
		
	}*/
	
	@Random
	shareable pattern arcRelation(Arc,N1,N2) = {
		Node(N1);
		Node(N2);
		Node.Edge(Arc,N1,N2);
	}
	
	@orderby('col'='1', 'type'='name')
	pattern connectedNodes(N1,N2) = {
		Node(N1);
		Node(N2);
		Node.Edge(Arc,N1,N2);
	}
	
	@orderby('col'='0', 'type'='name')
	pattern place(P) = { Place(P);}
	
	@orderby('col'='0', 'type'='name')
	pattern transition(T) = { Transition(T);}
	
	@Random
	pattern notConnectedNodes(N1, N2) = {
		Node(N1);
		Node(N2);
		neg pattern arcbetween(N1,N2) = {
			Node(N1);
			Node(N2);
			Node.Edge(Arc,N1,N2);
		}
	}
	
	@labelingliteral(priority = '2')
	gtrule deleteArc(in Arc) = {
		precondition find arcRelation(Arc,From,To)
		
		action{
			delete(Arc);
		} 
	}
	
	@labelingliteral(priority = '1')
	gtrule createInArc(in TransFrom, in PlaceTo) = {
		precondition @Random pattern transNotConnToNode(TransFrom, PlaceTo) = {
			Transition(TransFrom);
			Place(PlaceTo);
			find notConnectedNodes(TransFrom, PlaceTo);
		}
		action{
			let R = undef in new(Transition.InArc(R,TransFrom,PlaceTo));
		}
	}
	
	@labelingliteral(priority = '1')
	gtrule createOutArc(in PlaceFrom, in TransTo) = {
		precondition @Random pattern transNotConnToNode(PlaceFrom, TransTo) = {
			Place(PlaceFrom);
			Transition(TransTo);
			find notConnectedNodes(PlaceFrom, TransTo);
		}
		
		action{
			let R = undef in new(Place.OutArc(R,PlaceFrom,TransTo));
		}
	}
	
	@Random
	shareable pattern arcRerouteToPlace(Arc,Trans,Place) = {
		Transition(Trans);
		Node(P);
		Node.Edge(Arc,Trans,P);
		Place(Place);
		Place =/= P;
		find notConnectedNodes(Trans,Place);
	}
	
	@labelingliteral(priority = '0')
	gtrule rerouteInArc(in Arc) = {
		precondition find arcRerouteToPlace(Arc,Trans,Place)
		
		action{
			setTo(Arc,Place);
		}
	}

	@Random
	shareable pattern arcRerouteToTrans(Arc,Place,Tr) = {
		Node(Trans);
		Place(Place);
		Node.Edge(Arc,Place,Trans);
		Transition(Tr);
		Trans =/= Tr;
		find notConnectedNodes(Place,Tr);
	}
	
	@labelingliteral(priority = '0')
	gtrule rerouteOutArc(in Arc) = {
		precondition find arcRerouteToTrans(Arc,Place,Tr)
		
		action{
			setTo(Arc,Tr);
		}
	}
	
	
	@goal
	pattern selfArc(Arc) = {
		Node(N);
		Node.Edge(Arc,N,N);
	}
	
	@goal
	pattern invalidArc(Arc) = {
		Node(N1);
		Node(N2);
		Node.Edge(Arc,N1,N2);
		
		find sameType(N1,N2);
	}
	
	pattern sameType(N1,N2) = {	
		Place(N1);
		Place(N2);
	} or {
		Transition(N1);
		Transition(N2);
	}

	@goal
	pattern duplicateArc(Arc) = {
		Node(N1);
		Node(N2);
		Node.Edge(Arc,N1,N2);
		Node.Edge(Arc2,N1,N2);
		
		neg pattern inhibitorAndInArc(Arc,Arc2) = {
			Place(P);
			Transition(T);
			Place.InhibitorArc(Arc,P,T);
			Place.OutArc(Arc2,P,T);
		} or {
			Place(P);
			Transition(T);
			Place.InhibitorArc(Arc2,P,T);
			Place.OutArc(Arc,P,T);
		}
	}
	
	//@goal
	pattern lonelyNode(Node) = {
		Node(Node);
		
		neg pattern toNode(Node,From) = {
			Node(Node);
			Node(From);
			Node.Edge(R,From,Node); }
		neg pattern fromNode(Node,To) = {
			Node(Node);
			Node(To);
			Node.Edge(R,Node,To); }
	}
	
	@goal
	pattern lonelyToken(Token) = {
		Place.Token(Token);
		
		neg pattern place(Token,P) = {
			Place.Token(Token);
			Place(P);
			Place.tokens(R,P,Token); }
	}
	
	@goal
	pattern lonelyPlace(Place) = {
		Place(Place);
		
		neg pattern toTransition(Place,Transition) = {
			Place(Place);
			Transition(Transition);
			Node.Edge(R,Place,Transition); }
		neg pattern fromTransition(Place,Transition) = {
			Place(Place);
			Transition(Transition);
			Node.Edge(R,Transition,Place); }
	}
	
	@goal
	pattern lonelyTransition(Transition) = {
		Transition(Transition);
		
		neg pattern fromPlace(Place,Transition) = {
			Place(Place);
			Transition(Transition);
			Node.Edge(R,Place,Transition); }
		neg pattern toPlace(Place,Transition) = {
			Place(Place);
			Transition(Transition);
			Node.Edge(R,Transition,Place); }
	}
	
	@goal
	pattern stateMachineViolatingArc(T) = {
		Transition(T);
		find MoreThanOneOutPlace(T);
	} or {
		Transition(T);
		find MoreThanOneInPlace(T);
	} or {
		Transition(T);
		find LessThanOneInPlace(T);
	} or {
		Transition(T);
		find LessThanOneOutPlace(T);
	}
	
	pattern MoreThanOneOutPlace(T) = {
		Place(P1);
		Place(P2);
		Transition(T);
		Transition.InArc(R1,T,P1);
		Transition.InArc(R2,T,P2);
	}
	
	pattern MoreThanOneInPlace(T) = {
		Place(P1);
		Place(P2);
		Transition(T);
		Place.OutArc(R1,P1,T);
		Place.OutArc(R2,P2,T);
	}
	
	pattern LessThanOneOutPlace(T) = {
		Transition(T);
		neg pattern noOutPlace(T) = {
			Transition(T);
			Place(P1);
			Transition.InArc(R1,T,P1);
		}
	}
	
	pattern LessThanOneInPlace(T) = {
		Transition(T);
		neg pattern noInPlace(T) = {
			Transition(T);
			Place(P1);
			Place.OutArc(R1,P1,T);
		}
	}
	
	//@goal
	pattern markedGraphViolatingPlace(P) = {
		Place(P);
		find MoreThanOneInTransition(P);
	} or {
		Place(P);
		find MoreThanOneOutTransition(P);
	} or {
		Place(P);
		find LessThanOneInTransition(P);
	} or {
		Place(P);
		find LessThanOneOutTransition(P);
	}
	
	pattern MoreThanOneInTransition(P) = {
		Transition(T1);
		Transition(T2);
		Place(P);
		Transition.InArc(R1,T1,P);
		Transition.InArc(R2,T2,P);
	}
		
	pattern MoreThanOneOutTransition(P) = {
		Transition(T1);
		Transition(T2);
		Place(P);
		Place.OutArc(R1,P,T1);
		Place.OutArc(R2,P,T2);
	}
	
	pattern LessThanOneInTransition(P) = {
		Place(P);
		neg pattern noInTransition(P) = {
			Transition(T);
			Place(P);
			Transition.InArc(R,T,P);
		}
	}
	
	pattern LessThanOneOutTransition(P) = {
		Place(P);
		neg pattern noOutTransition(P) = {
			Transition(T);
			Place(P);
			Place.OutArc(R,P,T);
		}
	}
	
	//@goal
	//pattern freeChoiceViolatingPlace(Place)
	
	//@goal
	//pattern assimetricChoiceViolatingPlaces(Place1, Place2)
	
	/*@labelingliteral
	gtrule X(inout , inout ) = {
		precondition pattern (, ) = {
			
		}
		
		action {
	  		
	  	}
	}*/
	
	
}