pattern policy(policy: Policy) {
    Policy(policy);
}

pattern roleName(role: Role, name : java String) {
    Role.name(role,name);
}

pattern userShouldHaveARole(user: User) {
    neg User.UR(user, _);
}

pattern accessRelation(user: User, permission: Permission) {
    User.UR(user,role);
    Role.RD(role, demarcation);
   	Demarcation.DP(demarcation, permission);
}

package validator;

import java.util.function.Consumer;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.equinox.app.IApplication;
import org.eclipse.equinox.app.IApplicationContext;
import org.eclipse.viatra.query.runtime.api.AdvancedViatraQueryEngine;
import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
import org.eclipse.viatra.query.runtime.emf.EMFScope;
import org.eclipse.viatra.transformation.runtime.emf.modelmanipulation.IModelManipulations;
import org.eclipse.viatra.transformation.runtime.emf.modelmanipulation.SimpleModelManipulations;
import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRuleFactory;
import org.eclipse.viatra.transformation.runtime.emf.transformation.batch.BatchTransformation;
import org.eclipse.viatra.transformation.runtime.emf.transformation.batch.BatchTransformationStatements;
import org.eclipse.xtext.xbase.lib.Extension;

import com.google.common.base.Objects;

import queries.AccessRelation;
import queries.Policy;
import queries.RoleName;
//import queries.SameRoleName;
import queries.TestQueries;
import queries.UserShouldHaveARole;

public class Validator implements IApplication {

	@Extension
	private BatchTransformation transformation;
	@Extension
	private BatchTransformationStatements statements;
	@Extension
	private BatchTransformationRuleFactory factory = new BatchTransformationRuleFactory();
	@Extension
	private IModelManipulations manipulation;

	@Override
	public Object start(IApplicationContext context) throws Exception {
		
		System.out.println("Validator Called!");
		System.out.print("Initialize model scope and preparing engine... ");
		EMFScope scope = initializeModelScope();
		AdvancedViatraQueryEngine engine = prepareAdvancedQueryEngine(scope);
		System.out.println(" Done!");
		
		Thread.sleep(5000);
		
		System.out.println("\nAdding Change Listeners... ");
		addChangeListeners(engine);
		System.out.println("Done!");
		
		Thread.sleep(5000);
		
		System.out.println("\nSearching for Access Relation Matches... ");
		//printAllAccessRelationMatches(engine);
		System.out.println("Done!");
		
		System.out.println("\nSearching for Users without a role... ");
		printAllUserShouldHaveARoleMatches(engine);
		System.out.println("Done!");
		
		Thread.sleep(5000);
		
		System.out.println("\nCreate and Execute Model Transformation");
		//createTransformation(engine);
		//execute();
		System.out.println("Done!");
		
		return 0; 
	}

	@Override
	public void stop() {
		// Headless applications do not require specific stop steps
	}

	private EMFScope initializeModelScope() {
		ResourceSet rs = new ResourceSetImpl();
		rs.getResource(URI.createPlatformPluginURI("rbacviatratest/trebla.rbac", true), true);

		return new EMFScope(rs);
	}

	private AdvancedViatraQueryEngine prepareAdvancedQueryEngine(EMFScope scope) {
		AdvancedViatraQueryEngine engine = AdvancedViatraQueryEngine.createUnmanagedEngine(scope);

		// Initialize all queries on engine
		TestQueries.instance().prepare(engine);

		return engine;
	}

	private void addChangeListeners(AdvancedViatraQueryEngine engine) {
		// fireNow = true parameter means all current matches are sent to the listener
		
		engine.addMatchUpdateListener(UserShouldHaveARole.Matcher.on(engine), ListenerFactory.getUserShouldHaveARoleUpdateListener(), true);
		engine.addMatchUpdateListener(AccessRelation.Matcher.on(engine), ListenerFactory.getAccessRelationUpdateListener(), true);
		engine.addMatchUpdateListener(RoleName.Matcher.on(engine), ListenerFactory.getRoleNameMatchUpdateListener(), true);
	}
	
	private void printAllAccessRelationMatches(ViatraQueryEngine engine) {
		AccessRelation.Matcher matcher = AccessRelation.Matcher.on(engine);
		for (AccessRelation.Match match : matcher.getAllMatches()) {
			System.out.println("Found Access Relation:" + match.prettyPrint());
		}
	}
	
	private void printAllUserShouldHaveARoleMatches(ViatraQueryEngine engine) {
		UserShouldHaveARole.Matcher matcher = UserShouldHaveARole.Matcher.on(engine);
		for (UserShouldHaveARole.Match match : matcher.getAllMatches()) {
			System.out.println("Found user without role:" + match.prettyPrint());
		}
	}
	
	public void execute() {
		System.out.println("Execute Called!");
		this.statements.<Policy.Match>fireOne(this.getExampleRule());
	}

	private BatchTransformationStatements createTransformation(AdvancedViatraQueryEngine engine) {
		BatchTransformationStatements _xblockexpression = null;
		{
			SimpleModelManipulations _simpleModelManipulations = new SimpleModelManipulations(engine);
			this.manipulation = _simpleModelManipulations;
			this.transformation = BatchTransformation.forEngine(engine).build();
			_xblockexpression = this.statements = this.transformation.getTransformationStatements();
		}
		return _xblockexpression;
	}

	  private BatchTransformationRule<Policy.Match, Policy.Matcher> getExampleRule() {
		    final Consumer<Policy.Match> _function = (Policy.Match it) -> {
		    	it.getPolicy().getRoles().get(0).setName("R2");
		    };
		    final BatchTransformationRule<Policy.Match, Policy.Matcher> exampleRule = this.factory.<Policy.Match, Policy.Matcher>createRule(Policy.instance()).action(_function).build();
		    return exampleRule;
	  }

	public void dispose() {
		boolean _notEquals = (!Objects.equal(this.transformation, null));
		if (_notEquals) {
			this.transformation.getRuleEngine().dispose();
		}
		this.transformation = null;
		return;
	}

}

	public static IMatchUpdateListener<RoleName.Match> getRoleNameMatchUpdateListener() {
		return new IMatchUpdateListener<RoleName.Match>() {
			@Override
			public void notifyAppearance(RoleName.Match match) {
				System.out.printf("[ADD RoleName Match] %s %n", match.prettyPrint());
			}
	
			@Override
			public void notifyDisappearance(RoleName.Match match) {
				System.out.printf("[REM RoleName Match] %s %n", match.prettyPrint());
	
			}
		};
	}
	
	public static IMatchUpdateListener<UserShouldHaveARole.Match> getUserShouldHaveARoleUpdateListener() {
		return new IMatchUpdateListener<UserShouldHaveARole.Match>() {
			@Override
			public void notifyAppearance(UserShouldHaveARole.Match match) {
				System.out.printf("[ADD UserShouldHaveARole Match] %s %n", match.prettyPrint());
			}
	
			@Override
			public void notifyDisappearance(UserShouldHaveARole.Match match) {
				System.out.printf("[REM UserShouldHaveARole Match] %s %n", match.prettyPrint());
	
			}
		};
	}
	public static IMatchUpdateListener<AccessRelation.Match> getAccessRelationUpdateListener() {
		return new IMatchUpdateListener<AccessRelation.Match>() {
			@Override
			public void notifyAppearance(AccessRelation.Match match) {
				System.out.printf("[ADD AccessRelation Match] %s %n", match.prettyPrint());
			}
	
			@Override
			public void notifyDisappearance(AccessRelation.Match match) {
				System.out.printf("[REM AccessRelation Match] %s %n", match.prettyPrint());
	
			}
		};
	}
	

Validator Called!
Initialize model scope and preparing engine...  Done!

Adding Change Listeners... 
[ADD UserShouldHaveARole Match] "user"=Kevin Alberts 
[ADD AccessRelation Match] "user"=Isaac, "permission"=Workshop 
[...]
[ADD AccessRelation Match] "user"=Isaac, "permission"=Office2 
Done!

Searching for Users without a role... 
[ADD RoleName Match] "role"=Director, "name"=Director 
[...]
[ADD RoleName Match] "role"=Guard, "name"=Guard 
Found user without role:"user"=Kevin Alberts
Done!