package Sequenic.T2ext.Selection;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

interface PathSelector {
	
	public boolean select(int[] path);
	public int[] synthesize(int[] path);
	
	public static final PathSelector ALWAYS = new PathSelector() {
		
		public int[] synthesize(int[] path){
			return null;
		}
		
		public boolean select(int[] path){
			return true;
		}
		
		@Override public String toString() { 
			return "PathSelector.ALWAYS";}
	};
	
	public static final PathSelector NEVER = new PathSelector() {
		
		public int[] synthesize(int[] path){
			return path;
		}
		
		public boolean select(int[] path){
			return false;
		}
		
		@Override public String toString() { 
			return "PathSelector.NEVER";}
	};
			
	/** A class to incrementally build a PathSelector
	 * 
	 * @author Jeiel Schalkwijk
	 *
	 */
	final static class Factory
	{
		private Map<HashEqualsEdge,Integer> relabel = new HashMap<HashEqualsEdge, Integer>();
		private Set<HashEqualsEdge> dangerousEdges = new HashSet<HashEqualsEdge>();
				
		void markDangerous(int srcId, int targetId)
		{
			HashEqualsEdge edge = HashEqualsEdge.weakCache.make(srcId, targetId);
			if(dangerousEdges.add(edge))
				//dangerous edges are never relabeled
				relabel.remove(edge);
		}
		
		void relabelIfNeeded(int origId, int origChildId, int modChildId)
		{
			if(origChildId!=modChildId) 
			{
				HashEqualsEdge key = HashEqualsEdge.weakCache.make(origId, origChildId);
				
				if(dangerousEdges.contains(key))
					//dangerous edges are never relabeled
					return;
				
				//Can not relabel the same edge to two different modChilds
				//In this case retesting is needed, even if the path is not modification-traversing
				if(relabel.containsKey(key) && relabel.get(key).intValue()!=modChildId) {
					modChildId = -1;
				}
				relabel.put(key, modChildId);
			}			
		}
		
		void relabelStartNodeIfNeeded(int origStartId, int modStartId)
		{
			if(origStartId != modStartId)
				relabel.put(null, modStartId);
		}
		
		PathSelector resetAndReturn() 
		{			
			PathSelector ret;
			switch (dangerousEdges.size()) {
			case 0:
				ret = PathSelector.NEVER;				
				break;
			case 1:
				ret = new DangerousEdgesSelector(
						Collections.singleton(dangerousEdges.iterator().next())
						);
				dangerousEdges.clear();
				break;
			default:
				ret = new DangerousEdgesSelector(dangerousEdges);
				dangerousEdges = new HashSet<HashEqualsEdge>();
			}
			
			if(!relabel.isEmpty())
			{
				ret = new Relabeller(relabel, ret);
				relabel = new HashMap<HashEqualsEdge, Integer>();
			}
			return ret;			
		}
	}
	
	static final class DangerousEdgesSelector extends HashEqualsEdge implements PathSelector
	{
		private final Set<HashEqualsEdge> dangerousEdges;
		public DangerousEdgesSelector(final Set<HashEqualsEdge> dangerousEdges) {
			this.dangerousEdges = dangerousEdges;
		}
		
		public boolean select(int[] path)
		{
			if(path.length>1) 
			{
				edge = path[0];
				for(int i = 1; i<path.length; i++) 
				{
					edge = (edge << 16) | path[i];
					if(dangerousEdges.contains(this))
						return true;
				}
			}
			
			//if path.length <2 or none of the edges was dangerous
			return false;
		}

		public int[] synthesize(int[] path){
			return select(path) ? null : path;
		}
		
		@Override
		public String toString()
		{
			return "Dangerous Edges: " + dangerousEdges.toString();
		}
	}
	
	static final class Relabeller extends HashEqualsEdge implements PathSelector 
	{
		private final Map<HashEqualsEdge,Integer> mappings;
		private final PathSelector dangerousSelector;
		
		public Relabeller(final Map<HashEqualsEdge,Integer> mappings, final PathSelector dangerousSelector) {
			this.mappings = mappings;
			this.dangerousSelector = dangerousSelector;
		}
		
		public boolean select(int[] path)
		{
			return dangerousSelector.select(path);
		}
		
		private int[] copyPath(int[] path) {
			int[] newPath = new int[path.length];
			System.arraycopy(path, 0, newPath, 0, path.length);
			if(mappings.containsKey(null))
				newPath[0] = mappings.get(null);
			return newPath;
		}	
		
		public int[] synthesize(final int[] path)
		{
			if(dangerousSelector.select(path))
				return null;
			if(path.length==0)
				return path;
			
			int[] newPath = null;
			edge = path[0];
			for(int i = 1; i<path.length; i++) 
			{
				edge = (edge << 16) | path[i];
				if(mappings.containsKey(this)) 
				{
					if(newPath==null)
						newPath = copyPath(path);
					
					//relabel to destination node. If id is -1 then relabeling is not possible and null is returned.
					if(-1==(newPath[i] = mappings.get(this)))
						return null;
				}
			}
			
			if(newPath!=null)
				return newPath;
			else if(mappings.containsKey(null))
				return copyPath(path);
			else
				return path;
		}
		
		@Override
		public String toString()
		{
			
			return (dangerousSelector==null? "Just relabel:" : dangerousSelector.toString() + "\nAnd Relabel: ") + mappings.toString();
		}
				
	}
	
}