/**
 * <copyright>
 * Copyright (c) 2010-2014 Henshin developers. All rights reserved. 
 * This program and the accompanying materials are made available 
 * under the terms of the Eclipse Public License v1.0 which 
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * </copyright>
 */
package org.eclipse.emf.henshin.interpreter.info;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.henshin.interpreter.impl.EngineImpl;
import org.eclipse.emf.henshin.interpreter.matching.constraints.AttributeConstraint;
import org.eclipse.emf.henshin.interpreter.matching.constraints.BinaryConstraint;
import org.eclipse.emf.henshin.interpreter.matching.constraints.ContainmentConstraint;
import org.eclipse.emf.henshin.interpreter.matching.constraints.DanglingConstraint;
import org.eclipse.emf.henshin.interpreter.matching.constraints.PathConstraint;
import org.eclipse.emf.henshin.interpreter.matching.constraints.ReferenceConstraint;
import org.eclipse.emf.henshin.interpreter.matching.constraints.UnaryConstraint;
import org.eclipse.emf.henshin.interpreter.matching.constraints.Variable;
import org.eclipse.emf.henshin.model.Attribute;
import org.eclipse.emf.henshin.model.BinaryFormula;
import org.eclipse.emf.henshin.model.Edge;
import org.eclipse.emf.henshin.model.Formula;
import org.eclipse.emf.henshin.model.Graph;
import org.eclipse.emf.henshin.model.Mapping;
import org.eclipse.emf.henshin.model.NestedCondition;
import org.eclipse.emf.henshin.model.Node;
import org.eclipse.emf.henshin.model.Rule;
import org.eclipse.emf.henshin.model.UnaryFormula;
import org.eclipse.emf.henshin.model.staticanalysis.PathFinder;

public class VariableInfo {
	
	// variables which represent nodes when they are first introduced, e.g. if a
	// mapped node occurs in the LHS and in one condition, only the variable
	// representing the LHS node will be in this collection
	private Collection<Variable> mainVariables;
	
	// node-variable pair
	private Map<Node, Variable> node2variable;
	
	// variable-node pair
	private Map<Variable, Node> variable2node;
	
	// map between a graph and all variables corresponding to nodes of that
	// graph
	private Map<Graph, List<Variable>> graph2variables;
	
	// map between a key variable and its main variable, e.g. there is a mapping
	// chain from the node belonging to the main variable to the key variable
	private Map<Variable, Variable> variable2mainVariable;
	
	private Rule rule;
	private EngineImpl engine;
	
	public VariableInfo(RuleInfo ruleInfo, EngineImpl engine) {
		this.rule = ruleInfo.getRule();
		this.engine = engine;
		
		this.node2variable = new HashMap<Node, Variable>();
		this.variable2node = new HashMap<Variable, Node>();
		
		this.graph2variables = new HashMap<Graph, List<Variable>>();
		this.variable2mainVariable = new HashMap<Variable, Variable>();
		
		createVariables(rule.getLhs(), null);
		
		for (Node node : rule.getLhs().getNodes()) {
			if (rule.getMappings().getImage(node,rule.getRhs())==null)
				createDanglingConstraints(node);
		}
		
		mainVariables = variable2mainVariable.values();
	}
	
	private void createVariables(Graph g, Collection<Mapping> mappings) {
		List<Variable> variables = new ArrayList<Variable>();
		
		for (Node node : g.getNodes()) {
			EClass type = node.getType();
			Variable var = new Variable(type);
			variables.add(var);
			node2variable.put(node, var);
			variable2node.put(var, node);
			
			Variable mainVariable = var;
			if (mappings != null) {
				for (Mapping mapping : mappings) {
					if (node == mapping.getImage()) {
						mainVariable = variable2mainVariable.get(node2variable.get(mapping
								.getOrigin()));
					}
				}
			}
			
			variable2mainVariable.put(var, mainVariable);
		}
		
		for (Node node : g.getNodes()) {
			createConstraints(node);
		}
		
		graph2variables.put(g, variables);
		
		createVariables(g.getFormula());
	}
	
	private void createVariables(Formula formula) {
		if (formula instanceof BinaryFormula) {
			createVariables(((BinaryFormula) formula).getLeft());
			createVariables(((BinaryFormula) formula).getRight());
		} else if (formula instanceof UnaryFormula)
			createVariables(((UnaryFormula) formula).getChild());
		else if (formula instanceof NestedCondition) {
			NestedCondition nc = (NestedCondition) formula;
			createVariables(nc.getConclusion(), nc.getMappings());
		}
	}
	
	private void createConstraints(Node node) {
		Variable var = node2variable.get(node);
		
		// User-defined node constraints:
		UnaryConstraint userConstraint = engine.createUserConstraints(node);
		if (userConstraint != null){
			var.userConstraints.add(userConstraint);
		}
		
		// Outgoing edges:
		for (Edge edge : node.getOutgoing()) {
			Variable target = node2variable.get(edge.getTarget());
			ReferenceConstraint constraint;
			String index = edge.getIndex();
			if (index!=null && index.length()>0) {
				if (rule.getParameter(index)!=null) {
					constraint = new ReferenceConstraint(target, edge.getType(), index, false);
					var.requiresFinalCheck = true;
				} else {
					try {
						Number constant = (Number) engine.getScriptEngine().eval(index);
						constraint = new ReferenceConstraint(target, edge.getType(), constant, true);
					} catch (Exception e) {
						throw new RuntimeException("Error evaluating index expression: " + index);
					}
				}
			} else {
				constraint = new ReferenceConstraint(target, edge.getType(), null, true);
			}
			var.referenceConstraints.add(constraint);
			BinaryConstraint binaryUserConstraint = engine.createUserConstraints(edge);
			if (binaryUserConstraint != null){
				var.binaryUserConstraints.put(constraint, binaryUserConstraint);
			}
			
		}
		
		// Incoming edges:
		for (Edge edge : node.getIncoming()) {
			if (edge.getType().isContainment()) {
				Variable target = node2variable.get(edge.getSource());
				ContainmentConstraint constraint = new ContainmentConstraint(target);
				var.containmentConstraints.add(constraint);
			} else if (edge.getType().getEOpposite() != null) {
				Variable target = node2variable.get(edge.getSource());
				ReferenceConstraint constraint = new ReferenceConstraint(target, edge.getType().getEOpposite(), null, true);
				var.referenceConstraints.add(constraint);
			}
		}
		
		// Attributes:
		for (Attribute attribute : node.getAttributes()) {
			String value = attribute.getValue();
			AttributeConstraint constraint;
			if (rule.getParameter(value)!=null) {
				constraint = new AttributeConstraint(attribute.getType(), value, false);
			} else {
				Object constant = engine.evalAttributeExpression(attribute, rule);
				constraint = new AttributeConstraint(attribute.getType(), constant, true);
			}
			var.attributeConstraints.add(constraint);
			UnaryConstraint unaryUserConstraint = engine.createUserConstraints(attribute);
			if (unaryUserConstraint != null){
				var.attributeUserConstraints.put(constraint, unaryUserConstraint);
			}
		}
		
		// Path constraints:
		if (!rule.getLhs().getPACs().isEmpty()) {
			for (Node target : node.getGraph().getNodes()) {
				if (node==target) continue;
				for (Entry<List<EReference>,Integer> entry : PathFinder.findReferencePaths(node, target, true, true).entrySet()) {
					if (entry.getKey().size() > 1) { // only paths of length > 1
						Variable targetVar = node2variable.get(target);
						PathConstraint constraint = new PathConstraint(targetVar, entry.getKey(), entry.getValue());
						var.pathConstraints.add(constraint);
					}
				}
			}
		}
		
	}
	
	private void createDanglingConstraints(Node node) {
		Variable var = node2variable.get(node);
		DanglingConstraint constraint = 
				new DanglingConstraint(getEdgeCounts(node, false), getEdgeCounts(node, true));
		var.danglingConstraints.add(constraint);
	}
	
	private Map<EReference, Integer> getEdgeCounts(Node node, boolean incoming) {
		Collection<Edge> edges = incoming ? node.getIncoming() : node.getOutgoing();
		Collection<Edge> oppositeEdges = incoming ? node.getOutgoing() : node.getIncoming();
		
		if (edges.size() == 0)
			return null;
		
		Map<EReference, Integer> edgeCount = new HashMap<EReference, Integer>();
		for (Edge edge : edges) {
			EReference type = edge.getType();
			Integer count = edgeCount.get(type);
			if (count == null) {
				count = ONE;
			} else {
				count = count + 1;
			}
			edgeCount.put(type, count);
		}
		
		for (Edge edge : oppositeEdges) {
			if (edge.getType().getEOpposite() == null)
				continue;
			
			EReference oppType = edge.getType().getEOpposite();
			
			if (incoming) {
				// opposite edges are outgoing from the PoV of the node
				Node remoteNode = edge.getTarget();
				if (remoteNode.getOutgoing(oppType, node) == null) {
					Integer count = edgeCount.get(oppType);
					if (count == null) {
						count = ONE;
					} else {
						count = count + 1;
					}
					edgeCount.put(oppType, count);
				}
			} else {
				// opposite edges are incoming from the PoV of the node
				Node remoteNode = edge.getSource();
				if (node.getOutgoing(oppType, remoteNode) == null) {
					Integer count = edgeCount.get(oppType);
					if (count == null) {
						count = ONE;
					} else {
						count = count + 1;
					}
					edgeCount.put(oppType, count);
				}
			}
		}
		
		return edgeCount;
	}
	
	public Node getVariableForNode(Variable variable) {
		return variable2node.get(variable);
	}
	
	public Collection<Variable> getDependendVariables(Variable mainVariable) {
		Collection<Variable> dependendVariables = new HashSet<Variable>();
		for (Variable var : variable2mainVariable.keySet()) {
			if (variable2mainVariable.get(var) == mainVariable)
				dependendVariables.add(var);
		}
		
		return dependendVariables;
	}
	
	public Collection<Variable> getMainVariables() {
		return mainVariables;
	}
	
	/**
	 * @return the graph2variables
	 */
	public Map<Graph, List<Variable>> getGraph2variables() {
		return graph2variables;
	}
	
	/**
	 * @return the node2variable
	 */
	public Map<Node, Variable> getNode2variable() {
		// TODO: change Solution to get rid of this method
		return node2variable;
	}
		
	private static final Integer ONE = new Integer(1);
	
}