package org.simantics.interop.mapping.data;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.simantics.utils.datastructures.hints.HintContext;
import org.slf4j.Logger;


/**
 * 
 * 
 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
 *
 * @param <T>
 */
public class GraphNode<T> extends HintContext {
	
	private static final Logger LOGGER = org.slf4j.LoggerFactory.getLogger(GraphNode.class);
	
	protected T data;
	private List<Link<T>> nodes = new ArrayList<Link<T>>();

	private boolean disposed = false;
	
	public GraphNode(T data) {
		this.data = data;
	}
	
	/**
	 * Returns data.
	 * @return
	 */
	public T getData() {
		return data;
	}

	
	@Override
    public void setHint(Key key, Object value) {
		_checkDisposed();
		if (value == null)
			return;	
		super.setHint(key, value);
	}
	
	
	
	
	/**
	 * Adds link to the other node.
	 * @param relationName name of the link from this node to the other node.
	 * @param inverseRelationName nam,e of the link from the other node to this node.
	 * @param node the other node.
	 * @return the created link. Returns null if the link cannot be created.
	 */
	public Link<T> addLink(String relationName, String inverseRelationName,GraphNode<T> node) {
		_checkDisposed();
		LOGGER.info("Node link " + data + " " + node.data + " " + relationName + " " + inverseRelationName +"\n");
		if(containsLink(relationName, node) && node.containsLink(inverseRelationName, this)) {
			LOGGER.warn("Node " + getData() + " has already given child " +  node.getData() + " ,with name " + relationName + " / " + inverseRelationName);
			return null;
		}
		Link<T> rel = _addLink(relationName,node);
		Link<T> inv = node._addLink(inverseRelationName,this);
		rel.setInverseLink(inv);
		inv.setMainLink(rel);
		return rel;
	}
	
	/**
	 * Adds link to the other node, with <pre>null</pre> link name from the other node to this node.
	 * @param relationName
	 * @param node name of the link from this node to the other node
	 * @return the created link. Returns null if the link cannot be created.
	 */
	public Link<T> addLink(String relationName,GraphNode<T> node) {
		_checkDisposed();
		if(containsLink(relationName, node)) {
			LOGGER.warn("Node " + getData() + " has already given child " +  node.getData() + " ,with name " + relationName );
			return null;
		}
		Link<T> rel = _addLink(relationName,node);
		Link<T> inv = node._addLink(null,this);
		rel.setInverseLink(inv);
		inv.setMainLink(rel);
		return rel;
	}
	
	/**
	 * Adds link to the other node, with copying link properties from given link.
	 * @param link
	 * @param node name of the link from this node to the other node
	 * @return the created link. Returns null if the link cannot be created.
	 */
	public Link<T> addLink(Link<T> link ,GraphNode<T> node) {
		_checkDisposed();
		if(containsLink(link.getName(), node) && node.containsLink(link.getInverseName(), this)) {
			LOGGER.warn("Node " + getData() + " has already given child " +  node.getData() + " ,with name " + link.getName() + " / " + link.getInverseName());
			return null;
		}
		Link<T> rel = _addLink(link.getName(),node);
		Link<T> inv = node._addLink(link.getInverseName(),this);
		rel.setInverseLink(inv);
		inv.setMainLink(rel);
		rel.setHints(link.getHints());
		inv.setHints(link.getInverse().getHints());
		return rel;
	}
	
	protected Link<T> _addLink(String relation,  GraphNode<T> node) {
		Link<T> link = new Link<T>(this, relation,node);
		nodes.add(link);
		return link;
	}
	
	protected Link<T> _removeLink(String relation,String inverse, GraphNode<T> node) {
		for (int i = 0; i < nodes.size(); i++) {
			Link<T> link = nodes.get(i);
			if (node.equals(link.to()) && equals(relation,link.getName()) && equals(inverse,link.getInverseName())) {
				return nodes.remove(i);
			}
		}
		return null;
	}
	
	protected Link<T> _removeLink(String relation) {
		for (int i = 0; i < nodes.size(); i++) {
			Link<T> link = nodes.get(i);
			if (equals(relation,link.getName())) {
				return nodes.remove(i);
			}
		}
		return null;
	}
	
	protected Link<T> _removeLink(String relation, String inverse) {
		for (int i = 0; i < nodes.size(); i++) {
			Link<T> link = nodes.get(i);
			if (equals(relation,link.getName()) && equals(inverse,link.getInverseName())) {
				return nodes.remove(i);
			}
		}
		return null;
	}
	
	protected Link<T> _removeLink(String relation, GraphNode<T> node) {
		for (int i = 0; i < nodes.size(); i++) {
			Link<T> link = nodes.get(i);
			if (node.equals(link.to()) && equals(relation,link.getName())) {
				return nodes.remove(i);
			}
		}
		return null;
	}
	
	protected Link<T> _removeLink(GraphNode<T> node) {
		for (int i = 0; i < nodes.size(); i++ ) {
			Link<T> link = nodes.get(i);
			if (node.equals(link.to())) {
				return nodes.remove(i);
			}
		}
		return null;
	}
	
	protected boolean _removeLink(Link<T> link) {
		return nodes.remove(link);
	}
	
	/**
	 * Removes the given link.
	 * @param link
	 * @return true if the link was removed.
	 */
	public boolean removeLink(Link<T> link) {
		_checkDisposed();
		if (_removeLink(link)) {
			if (link.hasInverse()) {
				link.to()._removeLink(link.getInverse());
			}
			return true;
		}
		return false;
	}
	
	/**
	 * Removes a link (or multiple links).
	 * @param relation the name of the link from this node.
	 * @return true if a link was removed.
	 */
	public boolean removeLink(String relation) {
		_checkDisposed();
		boolean deleted = false;
		while (true) {
			Link<T> removed = _removeLink(relation);
			if (removed == null)
				break;
			if (removed.hasInverse()) {
				removed.to()._removeLink(removed.getInverse());
				deleted = true;
			}
		}
		return deleted;
	}
	
	/**
	 * Removes a link (or multiple links).
	 * @param relation the name of the link from this node.
	 * @return true if the link was removed.
	 */
	public boolean removeLink(String relation, String inverse) {
		_checkDisposed();
		boolean deleted = false;
		while (true) {
			Link<T> removed = _removeLink(relation, inverse);
			if (removed == null)
				break;
			if (removed.hasInverse()) {
				removed.to()._removeLink(removed.getInverse());
				deleted = true;
			}
		}
		return deleted;
	}

	/**
	 * Removes a link.
	 * @param relation the name of the link from this node to the other node.
	 * @param node the other node.
	 * @return true if the link was removed.
	 */
	public boolean removeLink(String relation, GraphNode<T> node) {
		_checkDisposed();
		
		boolean deleted = false;
		while (true) {
			Link<T> removed = _removeLink(relation, node);
			if (removed == null)
				break;
			if (removed.hasInverse()) {
				removed.to()._removeLink(removed.getInverse());
				deleted = true;
			}
		}
		return deleted;
	}
	
	/**
	 * Removes all links from this node to the other node.
	 * @param node the other node.
	 * @return
	 */
	public boolean removeLink(GraphNode<T> node) {
		_checkDisposed();
		boolean deleted = false;
		while (true) {
			Link<T> removed = _removeLink(node);
			if (removed == null)
				break;
			if (removed.hasInverse()) {
				removed.to()._removeLink(removed.getInverse());
				deleted = true;
			}
		}
		return deleted;
	}
	
	/**
	 * Removes a link.
	 * @param relation the name of the link from this node to the other node.
	 * @param inverse the name of the link from the other node to this node.
	 * @param node the other node.
	 * @return true if the link was removed.
	 */
	public boolean removeLink(String relation, String inverse, GraphNode<T> node) {
		_checkDisposed();
		Link<T> removed = _removeLink(relation, inverse, node);
		if (removed != null && removed.hasInverse()) {
			removed.to()._removeLink(removed.getInverse());
			return true;
		}
		return false;
	}
	
	public boolean containsLink(GraphNode<T> node) {
		_checkDisposed();
		for (Link<T> link : nodes) {
			if (node.equals(link.to()))
				return true;
		}
		return false;
	}
	
	public boolean containsLink(String relationName, GraphNode<T> node) {
		_checkDisposed();
		if (relationName == null)
			return false;
		for (Link<T> link : nodes) {
			if (node.equals(link.to()) && equals(relationName,link.getName()))
				return true;
		}
		return false;
	}
	
	public boolean containsLink(String relationName, String inverseName, GraphNode<T> node) {
		_checkDisposed();
		for (Link<T> link : nodes) {
			if (node.equals(link.to()) && equals(relationName,link.getName()) && equals(inverseName,link.getInverseName()))
				return true;
		}
		return false;
	}

	public Collection<Link<T>> getLinks() {
		_checkDisposed();
		Collection<Link<T>> coll = new ArrayList<Link<T>>(nodes);
		return coll;
	}
	
	public Collection<GraphNode<T>> getNodes(String rel) {
		_checkDisposed();
		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();

		for (Link<T> link : nodes) {
			if (equals(rel,link.getName()))
				result.add(link.to());
		}
		
		return result;
	}
	
	public Collection<Link<T>> getLinks(String rel) {
		_checkDisposed();
		Collection<Link<T>> result = new ArrayList<Link<T>>();

		for (Link<T> link : nodes) {
			if (equals(rel,link.getName()))
				result.add(link);
		}
		
		return result;
	}
	
	public Collection<Link<T>> getLinks(String rel, GraphNode<T> node) {
		_checkDisposed();
		Collection<Link<T>> result = new ArrayList<Link<T>>();

		for (Link<T> link : nodes) {
			if (equals(rel,link.getName()) && link.to().equals(node))
				result.add(link);
		}
		
		return result;
	}
	
	public Collection<Link<T>> getLinks(String rel, String inverse) {
		_checkDisposed();
		Collection<Link<T>> result = new ArrayList<Link<T>>();

		for (Link<T> link : nodes) {
			if (equals(rel,link.getName()) && equals(inverse, link.getInverseName()))
				result.add(link);
		}
		
		return result;
	}
	
	public Collection<Link<T>> getLinks(String rel, String inverse, GraphNode<T> node) {
		_checkDisposed();
		Collection<Link<T>> result = new ArrayList<Link<T>>();

		for (Link<T> link : nodes) {
			if (equals(rel,link.getName()) && equals(inverse, link.getInverseName()) && link.to().equals(node))
				result.add(link);
		}
		
		return result;
	}
	
	public Collection<GraphNode<T>> getNodesWithInv(String inv) {
		_checkDisposed();
		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();

		for (Link<T> link : nodes) {
			if (equals(inv,link.getInverseName()))
				result.add(link.to());
		}
		
		return result;
	}
	
	public Collection<GraphNode<T>> getNodes(String rel, String inv) {
		_checkDisposed();
		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();

		for (Link<T> link : nodes) {
			if (equals(rel,link.getName()) && equals(inv,link.getInverseName()))
				result.add(link.to());
		}

		return result;
	}
	
	public static boolean equals(String s1, String s2) {
		if (s1 != null)
			return s1.equals(s2);
		if (s2 != null)
			return s2.equals(s1);
		return true; // both null
	}
	
	
	/**
	 * Returns links from this node to the given node.
	 * @param node
	 * @return
	 */
	public Collection<Link<T>> getLinks(GraphNode<T> node) {
		_checkDisposed();
		Collection<Link<T>> result = new ArrayList<Link<T>>();
		for (Link<T> link : nodes) {
			if (link.to().equals(node))
				result.add(link);
		}
		return result;
	}
	
	/**
	 * Returns names of links from this node to the given node. Does not return null names.
	 * @param node
	 * @return
	 */
	public Collection<String> getRelations(GraphNode<T> node) {
		_checkDisposed();
		Collection<String> result = new ArrayList<String>();
		for (Link<T> link : nodes) {
			if (link.to().equals(node) && link.getName() != null)
				result.add(link.getName());
		}
		return result;
	}
	
	/**
	 * Returns links from given node to this node.
	 * @param node
	 * @return
	 */
	public Collection<Link<T>> getInverseLinks(GraphNode<T> node) {
		_checkDisposed();
		Collection<Link<T>> result = new ArrayList<Link<T>>();
		for (Link<T> link : nodes) {
			if (link.to().equals(node))
				result.add(link.getInverse());
		}
		return result;
	}
	
	/**
	 * Returns names of links from given node to this node. Does not return null names.
	 * @param node
	 * @return
	 */
	public Collection<String> getInverses(GraphNode<T> node) {
		_checkDisposed();
		Collection<String> result = new ArrayList<String>();
		for (Link<T> link : nodes) {
			if (link.to().equals(node) && link.getInverseName() != null)
				result.add(link.getInverseName());
		}
		return result;
	}
	
	
	
	@Override
	public int hashCode() {
		return data.hashCode();
	}
	
	@Override
	public boolean equals(Object arg0) {
		if (!arg0.getClass().equals(getClass()))
			return false;
		GraphNode<?> other = (GraphNode<?>)arg0;
		if (this == other)
			return true;
		if (this.data == null || other.data == null)
			return false;
		if (!data.equals(other.data))
			return false;

		return true;
	}
	
	/**
	 * Merges given nodes to new node. 
	 * Does not copy hints!
	 * @param other
	 */
	public GraphNode<T> merge(GraphNode<T> other, T mergedData) {
		_checkDisposed();
		GraphNode<T> mergedNode = new GraphNode<T>(mergedData);
		copyLinks(this, mergedNode);
		copyLinks(other, mergedNode);
		
		//mergedNode.setHints(other.getHints());
		//mergedNode.setHints(this.getHints());
		
		this.destroy();
		other.destroy();
		
		return mergedNode;
	}
	
	
	
	
	
	/**
	 * Copies a link to other node.
	 * @param from the node containing original link
	 * @param to the node where link is copied to
	 * @param l the link that is copied.
	 * @return created link, if copy is successful. Otherwise returns null.
	 */
	public static <T> Link<T> copyLink(GraphNode<T> from, GraphNode<T> to, Link<T> l) {
		if (l.from() != from)
			throw new IllegalArgumentException("Link is not starting from " + from + " node.");
		if (l.to() == to)
			return null;
		if (to.containsLink(l.getName(), l.getInverseName(),l.to()))
			return null;
		if (l.isMain()) {
			Link<T> newLink = to.addLink(l.getName(),l.getInverseName(),l.to());
			if (newLink != null) {
				newLink.setHints(l.getHints());
				newLink.getInverse().setHints(l.getInverse().getHints());
				return newLink;
			} else {
				return null;
			}
		} else {
			Link<T> newLink = l.to().addLink(l.getInverseName(), l.getName(),to);
			if (newLink != null) {
				newLink.setHints(l.getInverse().getHints());
				newLink.getInverse().setHints(l.getHints());
				return newLink.getInverse();
			} else {
				return null;
			}
		}	
		
	}
	
	/**
	 * Copies a link to other node, but inverts its direction.
	 * @param from the node containing original link
	 * @param to the node where link is copied to
	 * @param l the link that is copied.
	 * @return created link, if copy is successful. Otherwise returns null.
	 */
	public static <T> Link<T> copyLinkInverse(GraphNode<T> from, GraphNode<T> to, Link<T> l) {
		if (l.from() != from)
			throw new IllegalArgumentException("Link is not starting from " + from + " node.");
		if (l.to() == to)
			return null;
		if (to.containsLink(l.getInverseName(), l.getName(),l.to()))
			return null;
		if (l.isMain()) {
			Link<T> newLink = l.to().addLink(l.getName(),l.getInverseName(),to);
			if (newLink != null) {
				newLink.setHints(l.getHints());
				newLink.getInverse().setHints(l.getInverse().getHints());
				return newLink;
			} else {
				return null;
			}
		} else {
			Link<T> newLink = to.addLink(l.getInverseName(), l.getName(),l.to());
			if (newLink != null) {
				newLink.setHints(l.getInverse().getHints());
				newLink.getInverse().setHints(l.getHints());
				return newLink.getInverse();
			} else {
				return null;
			}
		}	
		
	}

	public static <T> void copyLinks(GraphNode<T> from, GraphNode<T> to, Collection<Link<T>> links) {
		for (Link<T> l : links) {
			copyLink(from, to, l);
		}
	}

	
	public static <T> void copyLinks(GraphNode<T> from, GraphNode<T> to) {
		for (Link<T> l : from.getLinks()) {
			copyLink(from, to, l);
		}
	}
	
	/**
	 * Copies a link to other node and removes the original link. If move is not successful, the original link is not removed.
	 * @param from the node containing original link
	 * @param to the node where link is copied to
	 * @param l the link that is moved.
	 * @return created link, if move is successful. Otherwise returns null. 
	 */
	public static <T> Link<T> moveLink(GraphNode<T> from, GraphNode<T> to, Link<T> l) {
		Link<T> newLink = copyLink(from, to, l);
		if (newLink != null) {
			from.removeLink(l);
			return newLink;
		}
		return null;
	}
	
	public static <T> void moveLinks(GraphNode<T> from, GraphNode<T> to, Collection<Link<T>> links) {
		for (Link<T> l : links) {
			Link<T> newLink = copyLink(from, to, l);
			if (newLink != null) {
				from.removeLink(l);
			}	
		}
	}
	
	public static <T> void moveLinkInverses(GraphNode<T> from, GraphNode<T> to, Collection<Link<T>> links) {
		for (Link<T> l : links) {
			Link<T> newLink = copyLinkInverse(from, to, l);
			if (newLink != null) {
				from.removeLink(l);
			}	
		}
	}
	
	public static <T> void moveLinks(GraphNode<T> from, GraphNode<T> to) {
		for (Link<T> l : from.getLinks()) {
			Link<T> newLink = copyLink(from, to, l);
			if (newLink != null) {
				from.removeLink(l);
			}	
		}
	}
	
	/**
	 * Replaces a link with a link going first to given node, and the to the original destination.
	 * The link names and hints are copied to the created links.
	 * 
	 * Example: link is 'a' -> 'b'. With insert attribute 'c', the result is 'a' -> 'c' -> 'b'.
	 *   
	 * @param link
	 * @param insert
	 * @return Array containing created links (2).
	 */
	@SuppressWarnings("unchecked")
	public static <T> Link<T>[] insert(Link<T> link, GraphNode<T> insert) {
		GraphNode<T> a = link.from();
		Link<T> c_b = moveLink(a, insert, link);
		Link<T> a_c = a.addLink(c_b, insert);
		return new Link[]{a_c,c_b};
	}

	
	
	/**
	 * Finds all nodes that have the same relations to the same nodes as this node. 
	 * @return
	 */
	public Collection<GraphNode<T>> getFullSimilars() {
		_checkDisposed();
		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();
		Set<GraphNode<T>> potential = new HashSet<GraphNode<T>>();
		for (Link<T> link : nodes) {
			for (Link<T> link2 : link.to().nodes) {
				if (!link2.to().equals(this))
					potential.add(link2.to());
			}
		}
		for (GraphNode<T> node : potential) {
			if (node.nodes.containsAll(nodes))
				result.add(node);
		}
		
		return result;
	}
	
	/**
	 * Finds all nodes that have at least one similar relation to the same nodes as this node. 
	 * @return
	 */
	public Collection<GraphNode<T>> getSemiSimilars() {
		_checkDisposed();
		Collection<GraphNode<T>> result = new ArrayList<GraphNode<T>>();
		Set<GraphNode<T>> potential = new HashSet<GraphNode<T>>();
		for (Link<T> link : nodes) {
			for (Link<T> link2 : link.to().nodes) {
				if (!link2.to().equals(this))
					potential.add(link2.to());
			}
		}
		for (GraphNode<T> node : potential) {
			for (Link<T> link : nodes) {
				if (node.nodes.contains(link))
					result.add(node);
			}
		}
		
		return result;
	}
	

	/**
	 * Disposes this node. Removes all the links that connect to this node.
	 */
	public void destroy() {
		if (disposed)
			return;
		LOGGER.info("Node destroy " + data + " " + this);
		Collection<Link<T>> coll = new ArrayList<Link<T>>();
		coll.addAll(nodes);
		nodes.clear();
		for (Link<T> link : coll) {
			link.to()._removeLink(this);
		}
		nodes = null;
		disposed = true;
	}
	
	/**
	 * Removes this node from the graph, and reconnects parents and children of this node.
	 */
	public void remove() {
		if (disposed)
			return;
		// FIXME: link.to may be *this.
		LOGGER.info("Node remove " + data + " " + this);
		if (nodes.size() == 1) {
			Link<T> link = nodes.get(0);
			link.to().removeLink(link.getInverseName(), link.getName(), this);
		} else {
			for (int i = 0; i < nodes.size() -1 ; i++) {
				Link<T> link1 = nodes.get(i);
				link1.to()._removeLink(link1.getInverseName(), link1.getName(), this);
				for (int j = i+1; j < nodes.size(); j++) {
					Link<T> link2 = nodes.get(j);
					link2.to()._removeLink(link2.getInverseName(), link2.getName(), this);
					if (link1.to().equals(link2.to()))
						continue;
					link1.to().addLink(link1.getInverseName(),link2.getInverseName(),link2.to());
				}
				
			}
		}
		
		nodes.clear();
		nodes = null;
		disposed = true;

	}
	
	/**
	 * 
	 * @return true if the node has been disposed and cannot be used anymore.
	 */
	public boolean isDisposed() {
		return disposed;
	}
	
	/**
	 * Dispose the node and all nodes that are in the same graph.
	 */
	public void dispose() {
		if (disposed)
			return;
		Collection<Link<T>> links = new ArrayList<Link<T>>();
		links.addAll(nodes);
		nodes.clear();
		for (Link<T> l : links)
			l.to().dispose();
		links.clear();
		nodes = null;
		disposed = true;
	}
	

	protected void _checkDisposed() {
		if (disposed) {
			LOGGER.error("Remove Node, disposed " + this);
			throw new RuntimeException("Node " + this + " is disposed.");
		}
	}
	
	
	public int distanceTo(GraphNode<T> node, String rel, String inv) {
		if (node.equals(this))
			return 0;
		int count = 0;
		Set<GraphNode<T>> processed = new HashSet<GraphNode<T>>();
		Set<GraphNode<T>> next = new HashSet<GraphNode<T>>();
		next.add(this);
		while (true) {
			if (next.size() == 0)
				return -1;
			count++;
			processed.addAll(next);
			Set<GraphNode<T>> nextNext = new HashSet<GraphNode<T>>();
			for (GraphNode<T> n : next) {
				for (GraphNode<T> nn : n.getNodes(rel, inv))
					if (!processed.contains(nn))
						nextNext.add(nn);
			}
			next = nextNext;
			if (next.contains(node))
				return count;
		}
	}
	
	public String toString() {
		return "Node : " + data;
	}
}