package org.eclipse.emf.henshin.sam.invcheck.filter;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import org.eclipse.emf.henshin.sam.invcheck.InvariantCheckerUtil;
import org.eclipse.emf.henshin.sam.invcheck.SubgraphIterator;
import org.eclipse.emf.henshin.sam.invcheck.algorithm.IsomorphicPartMatcher;
import org.eclipse.emf.henshin.sam.invcheck.filter.CombinationProducer.Pair;
import org.eclipse.emf.henshin.sam.model.samannotation.AnnotatedElem;
import org.eclipse.emf.henshin.sam.model.samgraph.Edge;
import org.eclipse.emf.henshin.sam.model.samgraph.Graph;
import org.eclipse.emf.henshin.sam.model.samgraph.Node;
import org.eclipse.emf.henshin.sam.model.samrules.GraphRule;
import org.eclipse.emf.henshin.sam.model.samrules.SamrulesPackage;
import org.eclipse.emf.henshin.sam.model.samtrace.Match;

public class ContainsGraphRuleHelper {

	//@SuppressWarnings("restriction")
	//private static transient final Logger log = Logger.getLogger(ContainsGraphRuleHelper.class);

	private GraphRule[] allRules;

	private boolean printDebug;
	
	public ContainsGraphRuleHelper(GraphRule[] rules) {
		if ( rules == null ) {
			throw new NullPointerException(
			        "null is not an allowed value for constructor parameter!");
		}
		this.allRules = rules;
	}


	/**
	 * Looks in the given <code>Graph</code> which of the
	 * <code>GraphRules</code> known by this
	 * <code>ContainsGraphRuleHelper</code> instance are contained within it.
	 * <br/> This method returns for each urgent <code>GraphRule</code> (i.e.
	 * <code>GraphRule.isUrgent() == true</code>) all mappings of the
	 * <code>GraphRule</code> within the given <code>Graph</code>.
	 * 
	 * @param graph
	 *            the graph to check for contained urgen transitions
	 * @return a collection of <code>GraphRules</code> and mappings to the
	 *         given <code>Graph</code>
	 */
	public Collection<Pair<GraphRule, Collection<Match>>> getUrgentTransitions(
	        Graph graph) {
		IsomorphicPartMatcher ipm = new IsomorphicPartMatcher();
		ipm.setHostGraph(graph);
		Collection<Pair<GraphRule, Collection<Match>>> result =
		        new HashSet<Pair<GraphRule, Collection<Match>>>();
		for ( int index = 0; index < this.allRules.length; index++ ) {
			GraphRule currentRule = this.allRules[index];
			if ( currentRule.isUrgent() ) {
				Graph tmpGraph = currentRule.getLeft();
				
				Set<AnnotatedElem> subGraph = SubgraphIterator.graphToSubGraph(tmpGraph);
				        
				ipm.setPattern(tmpGraph);
				ipm.setCurrentSubGraph(subGraph);
				
				Collection<Match> tmp = ipm.findAllMatchings();
				Vector<Match> col = new Vector<Match>();
				for (Match m : tmp) {
					if (checkRuleMatchingApplicability(m)) {
						col.add(m);
					}
				}				
				
				if ( col != null && !col.isEmpty() ) {
					Pair<GraphRule, Collection<Match>> pair =
					        new Pair<GraphRule, Collection<Match>>(
					                currentRule, col);
					result.add(pair);
				}
			}
		}
		return result;
	}
	
	public Map<GraphRule,Collection<Match>> findAllMatchingRules(final int priority, Graph graph) {
		IsomorphicPartMatcher ipm = new IsomorphicPartMatcher();
		ipm.setHostGraph(graph);
		Map<GraphRule,Collection<Match>> result = new HashMap<GraphRule, Collection<Match>>();
		for (int index = 0; index < this.allRules.length; index++) {
			ipm.reset();
			GraphRule currentRule = allRules[index];
			if (currentRule.getPriority() > priority) {
				Graph tmpGraph = currentRule.getLeft();
				ipm.setCurrentSubGraph(SubgraphIterator.graphToSubGraph(tmpGraph));
				ipm.setPattern(tmpGraph);
				
				Collection<Match> tmp = ipm.findAllMatchings();
				Vector<Match> col = new Vector<Match>();
				for (Match m : tmp) {
					if (checkRuleMatchingApplicability(m)) {
						col.add(m);
					}
				}				
				
				if (col != null && col.size() > 0) {
					result.put(currentRule, col);
				}
			}
		}
		return result;
	}
	
	/**
	 * Unfortunately, the gluing condition needs to hold for the pattern, i.e. all graphs satisfying the pattern.
	 * Therefore we cannot just check the condition for nodes from the pattern.
	 * At the moment, rules are only considered applicable if they do not contain deleted nodes.
	 * In the future, this check can be extended by searching for nacs enforcing the gluing condition
	 * and by including information from the type graph.
	 * 
	 * @param matching
	 * @return
	 */
	public boolean checkRuleMatchingApplicability(Match matching) {
		for (Node ruleN : matching.getNodeMatching().keySet()) {
			if (ruleN.eClass() == SamrulesPackage.eINSTANCE.getDeletedNode()) {
				return false;
				/*
				Node hostGraphNode = matching.getNodeMatching().get(ruleN);
				for (Edge e : hostGraphNode.getIncoming()) {
					if (!InvariantCheckingUtil.isNegated(e) && !matching.getEdgeMatching().containsValue(e)) {
						return false;
					}
				}
				for (Edge e : hostGraphNode.getOutgoing()) {
					if (!InvariantCheckingUtil.isNegated(e) && !matching.getEdgeMatching().containsValue(e)) {
						return false;
					}
				}*/
			}
		}
		return true;
	}
	
	public boolean findMatchingRule(final int priority, Graph graph) {
		IsomorphicPartMatcher ipm = new IsomorphicPartMatcher();
		ipm.setHostGraph(graph);		
		for (int index = 0; index < this.allRules.length; index++) {
			ipm.reset();
			GraphRule currentRule = allRules[index];
			if (currentRule.getPriority() > priority) {
				Graph tmpGraph = currentRule.getLeft();
				ipm.setCurrentSubGraph(SubgraphIterator.graphToSubGraph(tmpGraph));
				ipm.setPattern(tmpGraph);
				Match currentMatch = ipm.getNextMatching();
				while (currentMatch != null) {
					if (checkRuleMatchingApplicability(currentMatch)) {
						return true;
					} else {
						currentMatch = ipm.getNextMatching();
					}
				}				
			}
		}
		return false;
	}

}