package test.at.gv.egovernment.moa.id.proxy.builder;

import java.io.PrintStream;
import java.util.ArrayList;

import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

import at.gv.egovernment.moa.util.Base64Utils;

/**
 * @author Administrator
 *
 * To change this generated comment edit the template variable "typecomment":
 * Window>Preferences>Java>Templates.
 * To enable and disable the creation of type comments go to
 * Window>Preferences>Java>Code Generation.
 */
public class DOMTreeCompare {

	boolean debug = true;	
	
	private static PrintStream Log = null;
	
	static
	{
		Log = System.out;
	}
	
	public boolean compareElements(Element root1, Element root2)
	{
		//Log.println("----- Compare Elements:"+root1.getNodeName()+" "+root2.getNodeName());
		filterTree(root1);
		filterTree(root2);
		return compareNodes(root1,root2,0,"root/",false);		
	}
	
	private boolean compareNodes(Node n1, Node n2, int level,String path,boolean attribute)
	{
		/*try {
			Log.println(DOMUtils.serializeNode(n1));
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}*/
		boolean equal = false;
		//Log.println("----- Compare Node "+level+":"+n1+" "+n2);
		//Log.println("----- Compare Node "+level+":"+n1.getNodeName()+" "+n2.getNodeName());
		//Log.println("----- Checking:"+path+getPathString(n1));
		NodeList nl1 = n1.getChildNodes();
		NodeList nl2 = n2.getChildNodes();
		
		int size1 = nl1.getLength();
		int size2 = nl2.getLength();
		
		if(debug)display_one(n1);
		if(debug)display_one(n2);
		
		
		if(debug)
		if(n1.getNodeName().equals("Base64Content") && n2.getNodeName().equals("Base64Content"))
		{
			try {
				Log.println("CONT:"+new String(Base64Utils.decode(strip(n1.getChildNodes().item(0).getNodeValue()),false)));
				Log.println("CONT:"+new String(Base64Utils.decode(strip(n2.getChildNodes().item(0).getNodeValue()),false)));
			}
			catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		
		if(size1 != size2) 
		{
			Log.println("----- Anzahl der Kinder nicht gleich:"+path+getPathString(n1)+":"+getPathString(n2));
			return false;
		}
		
		equal = compareNodeExact(n1,n2,level,path+getPathString(n1)+"/");
		if(!equal)
		{
			Log.println("----- Knoten sind nicht identisch:"+path+getPathString(n1));
			return false;
		}
		
		if(n1.hasAttributes() || n2.hasAttributes())
		{
			equal = compareNodeAttriubtes(n1,n2,level+1,path+getPathString(n1)+"/(a)");
			if(!equal)
			{
				Log.println("----- Attribute stimmen nicht überein:"+path+getPathString(n1));		
				return false;
			}
		}
		if(size1==0)
		{
			return true;
		}
		
		for(int counter=0;counter<size1;counter++)
		{
			boolean found = false;
			Node comp_n1 = nl1.item(counter);

			//if(comp_n1==null) return false;

			Node comp_n2 = null;
			size2 = nl2.getLength();
			for(int counter2=0;counter2<size2;counter2++)
			{
				comp_n2 = nl2.item(counter2);
				
				/*equal = compareNodeExact(comp_n1,comp_n2,level+1);
				if(equal) return false;*/
				//Log.println("COMP_N1:"+comp_n1);
				//Log.println("COMP_N2:"+comp_n2);
				equal = compareNodes(comp_n1,comp_n2,level+1,path+getPathString(comp_n1)+"/",false);
				if(equal)
				{
					n2.removeChild(comp_n2);
					counter2=size2;
					nl2 = n2.getChildNodes();
					size2 = nl2.getLength();
				}

			}
			
			if(!equal) 
			{
			   	Log.println("----- Keine Übereinstimmung gefunden:"+path+getPathString(comp_n1));
				return false;
			}
		}
		return true;
	}
	
	private boolean compareNodeExact(Node n1,Node n2,int level,String path)
	{
		if(n1.getNodeType() == Node.TEXT_NODE)
		{
			Text textnode = (Text)n1;
			/*Log.println("----- *****"+textnode.getNodeName());
			Log.println("----- *****"+textnode.getParentNode().getNodeName());
			Log.println("----- *****"+textnode.getNodeValue());*/
		}
		
		//Log.println("----- Checking:"+path);
		String n1_name = n1.getNodeName();
		String n2_name = n2.getNodeName();
		/*Log.println("----- !!!!!"+n1.getNodeName());
		Log.println("----- !!!!!"+n1.getNodeValue());
		Log.println("----- !!!!!"+n1.getLocalName());
		Log.println("----- !!!!!"+n1.getPrefix());
		Log.println("----- !!!!!"+n1.getNextSibling());
		Log.println("----- !!!!!"+n1.getPreviousSibling());*/
		
		//Log.println("----- Compare Node "+level+":"+n1_name+" "+n2_name);
		if(!((n1_name==null && n2_name==null) ||
		   (n1_name!=null && n2_name!=null &&  n1_name.equals(n2_name))))
		   {
			   	Log.println("----- Name stimmt nicht überein:"+path);
		   		return false;
		   }

		//Log.println("----- Compare Node "+level+":"+n1.getNodeType()+" "+n2.getNodeType());
		if(n1.getNodeType() != n2.getNodeType())
		{
			   	Log.println("----- Knotentyp stimmt nicht überein:"+path);
		   		return false;
		}
		
		String n1_ns = n1.getPrefix();
		String n2_ns = n2.getPrefix();
		//Log.println("----- Compare Node "+level+":"+n1_ns+" "+n2_ns);
		if(!((n1_ns==null && n2_ns==null) ||
		   (n1_ns!=null && n2_ns!=null &&  n1_ns.equals(n2_ns))))
		   {
			   	Log.println("----- NameSpace stimmt nicht überein:"+path);
		   		return false;
		   }
		
		String n1_value = n1.getNodeValue();
		String n2_value = n2.getNodeValue();	
		
		boolean special = false;
		special = specialValues(n1_value,n2_value,path);
		if(special) return true;
				
		//Log.println("----- Compare Node "+level+":"+n1_value+" "+n2_value);
		if(!((n1_value==null && n2_value==null) ||
		   (n1_value!=null && n2_value!=null &&  n1_value.equals(n2_value)))) 
		   {
			   	Log.println("----- Wert stimmt nicht überein:"+path);
			   	Log.println("----- Value1:\n"+n1_value);
			   	Log.println("----- Value2:\n"+n2_value);
		   		return false;
		   }
		

		return true;
	}
	
	private boolean compareNodeAttriubtesWithoutSize(Node n1, Node n2, int level,String path)
	{
		return true;
	}
	
	private boolean compareNodeAttriubtes(Node n1, Node n2, int level,String path)
	{
		//Log.println("----- Compare NodeAttributes "+level+":"+n1.getNodeName()+" "+n2.getNodeName());
		Element n1elem = (Element)n1;
		Element n2elem = (Element)n2;
		
		NamedNodeMap nnm1 = n1.getAttributes();
		NamedNodeMap nnm2 = n2.getAttributes();
		
		int size1 = 0;
		int size2 = 0;
		
		boolean specialattrs = specialAttributesSize(path);
		
		if(!specialattrs)
		{
		
			if(nnm1==null && nnm2==null) return true;
			if(nnm1==null || nnm2==null) 
			{
				Log.println("----- Anzahl der Attribute nicht gleich:"+path+":"+getPathString(n1));
				return false;
			}
			size1 = nnm1.getLength();
			size2 = nnm2.getLength();
			
			if(size1 != size2) 
			{
				Log.println("----- Anzahl der Attribute nicht gleich:"+path+":"+getPathString(n1));
				return false;
			}
		
		}
		else
		{
			return compareNodeAttriubtesWithoutSize(n1,n2,level,path);
		}
		
		for(int counter=0;counter<size1;counter++)
		{
			Node attribute_node1 = nnm1.item(counter);
			Node attribute_node2 = nnm2.item(counter);
			
			String attr1_name = attribute_node1.getNodeName();
			String attr2_name = attribute_node2.getNodeName();
			
			String value1 = n1elem.getAttribute(attr1_name);
			String value2 = n2elem.getAttribute(attr2_name);
			
			boolean special = false;
			
			special = specialAttributes(path,attr1_name,value1,attr2_name,value2);
			if(special)
			{
				return special;
			}
			
			if(!value1.equals(value2))
			{
				Log.println("----- Keine Übereinstimmung gefunden:"+path+getPathString(n1));
				return false;
			}
		}
		
		return true;
	}
	
	private boolean checkNode(Node base,String name)
	{
		if(base.getNodeName().equals(name))
		{
			return true;
		}		
		
		NodeList children = base.getChildNodes();
		int size = children.getLength();
		for(int counter=0;counter<size;counter++)
		{
			boolean found = checkNode(children.item(counter),name);
			if(found) return true;
		}
		return false;
	}
	
	private void display_one(Node base)
	{
		int att_size=0;	
		if(base.getAttributes()!=null)
		{
			att_size=base.getAttributes().getLength();
		}
		if(base.getNodeName().equals("#text"))
			Log.println(base.getNodeName()+base.getChildNodes().getLength()+":"+att_size+" ("+base.getNodeValue()+")");
		else
			Log.println(base.getNodeName()+base.getChildNodes().getLength()+":"+att_size);
	}
	
	private void display(Node base)
	{
		display(base,1);
	}
	
	private void display(Node base,int level)
	{
		String spacer = "";
		for(int counter=0;counter<level;counter++)
		{
			spacer+="  ";
		}		
	
		int att_size=0;	
		if(base.getAttributes()!=null)
		{
			att_size=base.getAttributes().getLength();
		}
		if(base.getNodeName().equals("#text"))
			Log.println(spacer+base.getNodeName()+base.getChildNodes().getLength()+":"+att_size+" ("+base.getNodeValue()+")");
		else
			Log.println(spacer+base.getNodeName()+base.getChildNodes().getLength()+":"+att_size);
		
		NodeList children = base.getChildNodes();
		int size = children.getLength();
		for(int counter=0;counter<size;counter++)
		{
			display(children.item(counter),level+1);
		}
	}
	
	private void filterTree(Node base)
	{
		ArrayList removeList = new ArrayList();
		
		NodeList children = base.getChildNodes();
		int size = children.getLength();
		for(int counter=0;counter<size;counter++)
		{
			Node child1 = children.item(counter);
			if(child1.getNodeType() == Node.TEXT_NODE && child1.getNodeValue().trim().equals(""))
			{
				removeList.add(child1);
			}
		}
		
		size = removeList.size();
		for(int counter=0;counter<size;counter++)
		{
			base.removeChild((Node)removeList.get(counter));
		}
		
		children = base.getChildNodes();
		size = children.getLength();
		for(int counter=0;counter<size;counter++)
		{
			filterTree(children.item(counter));
		}
		
	}
	
	private String getPathString(Node n)
	{
		if(n.getNodeType()==Node.TEXT_NODE)
		{
			return n.getParentNode().getNodeName()+"(text)";
		}
		else
		{
			return n.getNodeName();	
		}
		
	}
	
	public boolean specialAttributes(String path,String attr1_name,String value1,String attr2_name,String value2)
	{
		//if(value1.startsWith("reference-") && value2.startsWith("reference-")) return true;
		//if(value1.startsWith("signature-") && value2.startsWith("signature-")) return true;
		
		return false;
	}
	
	public boolean specialAttributesSize(String path)
	{
		//if(path.endsWith("/xsl:template/(a)")) return true;
		return false;
	}
	
	public boolean specialValues(String value1,String value2,String path)
	{
		
		//Log.println(path);
		/*if(ignoreSignatureValue)
		{
			if(path.endsWith("/dsig:SignatureValue(text)/"))
			{
				return true;
			}
		}
		else
		{
			if(path.endsWith("/dsig:SignatureValue(text)/"))
			{
				String stripped_1 = strip(value1);
				String stripped_2 = strip(value2);
				return stripped_1.equals(stripped_2);
			}
		}*/
		
		return false;
	}
	
	private String strip(String input)
	{
		String output = replaceStringAll(input," ","");
		output = replaceStringAll(output,"\n","");
		output = replaceStringAll(output,"\r","");
		return output;
	}
	
	private static String replaceStringAll(
		String input,
		String oldPart,
		String newPart)
		{

		String erg = null;
		
		int pos = input.indexOf(oldPart);
		if(pos==-1) return input;

		while(true)
		{
	
			//First Part
			pos = input.indexOf(oldPart);
			if(pos==-1) break;
			erg = input.substring(0, pos);
			
			//Insert new Part
			erg += newPart;
	
			//insert REST
			erg
				+= input.substring(
					input.indexOf(oldPart) + oldPart.length(),
					input.length());
			
			input = erg;
		}
		return erg;
	}
	
}