/*
    * Created on 08.03.2005
    *
    */
   package net.sf.crispy.util;
   
   import java.io.FileInputStream;
   import java.io.FileNotFoundException;
   import java.io.IOException;
  import java.io.InputStream;
  import java.net.InetAddress;
  import java.net.Socket;
  import java.util.Collection;
  import java.util.Date;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Properties;
  import java.util.TreeMap;
  import java.util.Map.Entry;
  import java.util.logging.LogManager;
  import java.util.logging.Logger;
  
  import javax.swing.JFrame;
  import javax.swing.JScrollPane;
  import javax.swing.JTree;
  import javax.swing.tree.DefaultMutableTreeNode;
  import javax.xml.namespace.QName;
  
  import net.sf.crispy.InvocationException;
  
  /**
   * Utility (helper) class.
   * 
   * @author Linke
   *
   */
  public class Util {
  	
  	/**
  	 * Find the deepest Exception by nested Exception.
  	 * Example:
  	 * 
  	 * <pre>
  	 * Exception e0 = new Exception ();
  	 * Exception e1 = new Exception (e0);
  	 * 
  	 * Exception eFind = findDeepestThrowable(e1);
  	 * The result: eFind == e0
  	 * </pre>
  	 * 
  	 * @param pvThrowable Root-Exception.
  	 * @return The deepest Exception.
  	 */
  	public static Throwable findDeepestThrowable(Throwable pvThrowable) {
  	 	if (pvThrowable.getCause() != null) {
  	 		Throwable lvThrowable = pvThrowable.getCause();
   			return findDeepestThrowable(lvThrowable);
  	 	} else {
  	 		return pvThrowable;
  	 	}
  	}
  
  	/**
  	 * Test to free port.
  	 * 
  	 * @param pvPort tested port
  	 * @return <code>true</code>, if the port is free, else <code>false</code>.
  	 */
  	public static boolean isPortFree (int pvPort) {
  		try {
  			InetAddress lvAddress = InetAddress.getLocalHost();
  			Socket lvSocket = new Socket(lvAddress, pvPort);
  			lvSocket.isBound(); 
  			return false;
  		} catch (Exception e) {
  			return true;
  		} 
  	}
  	
  	/**
  	 * Separate from url the url and the port: <code>localhost:8080 --> http://localhost and 8080</code>
  	 * @param pvUrlAndPort
  	 * @return String-Array with pos 0 = URL and pos 1 = the Port
  	 */
  	public static String[] separateHostAndPort (String pvUrlAndPort) {
  		if (pvUrlAndPort == null) {
  			return null;
  		} else {
  			String s[] = pvUrlAndPort.split(":");
  			if (s.length != 2) {
  				throw new IllegalArgumentException(pvUrlAndPort + " is a not separatable URL. Expected a String with two ':', how by http://localhost:8080.");
  			}
  			String lvUrl = s[0];
  			String lvPort = s[1];
  			// test whether port is a integer
  			Integer.parseInt(lvPort);
  			s = new String[] {lvUrl, lvPort};
  			return s;
 		}
 	}
 	
 	/**
 	 * Cut a String on the end of a input-String.
 	 * Example: Input-String <code>rmi://localhost:1099/</code>, Cutting-String <code>/</code>, New-String <code>rmi://localhost:1099</code>.
 	 * 
 	 * @param pvString Input-String
 	 * @param pvCuttingString Cutting-String
 	 * @return New String, without Cutting-String.
 	 */
 	public static String cutString(final String pvString, final String pvCuttingString) {
     	if ((pvString != null) && (pvCuttingString != null) && (pvString.endsWith(pvCuttingString))) {
     		return pvString.substring(0, (pvString.length() - pvCuttingString.length()));
     	} else {
     		return pvString;
     	}
 		
 	}
 	
 	/**
 	 * Create a object with the reflection API.
 	 * 
 	 * @param pvObjectString String from the object.
 	 * @return Created object.
 	 * @throws Exception
 	 */
 	public static Object createObject (String pvObjectString) throws Exception {
 		if (pvObjectString == null) {
 			return null;
 		} else {
 			Class clazz = Class.forName(pvObjectString);
 			return clazz.newInstance();
 		}
 	}
 	
 	/**
 	 * Test as search class is exist in the class array.
 	 * 
 	 * @param pvClassArray class array
 	 * @param pvSearchClass search class 
 	 * @return if the class is finding than <code>true</code>, else <code>false</code>
 	 */
 	public static boolean isClassInArray (Class[] pvClassArray, Class pvSearchClass) {
 		if ((pvClassArray == null) || (pvSearchClass == null)) { return false; }
 		for (int i = 0; i < pvClassArray.length; i++) {
 			boolean equals = pvClassArray[i].equals(pvSearchClass);
 			if (equals == true) { return true; }
 		}
 		return false;
 	}
 	
 	public static String printArray(Object[] pvArray) {
 		StringBuffer sb = new StringBuffer();
 		if (pvArray == null) {
 			return "Array is NULL";
 		} else {
 			for (int i = 0; i < pvArray.length; i++) {
 				sb.append(pvArray[i]).append(" -> ").append(pvArray[i].getClass().getName()).append("\n");
 			}
 			return sb.toString();
 		}
 	}
 	
 	public static String array2String (Object pvStrArray[]) {
 		if (pvStrArray == null) { return null; }
 		StringBuffer ret = new StringBuffer();
 		for (int i = 0; i < pvStrArray.length; i++) {
 			ret.append(pvStrArray[i]).append(" ; ");
 		}
 		return ret.toString();
 	}
 	
 	
 	public static void printMapInfo(Map pvMap) {
 		if (pvMap == null) {
 			System.out.println("Util.printMapInfo: Map ist null");
 		} else {
 			Iterator it = pvMap.entrySet().iterator();
 			while (it.hasNext()) {
 				Map.Entry lvMapEntry = (Entry) it.next();
 				System.out.println(lvMapEntry.getKey() + " = " + lvMapEntry.getValue() + " (" + lvMapEntry.getValue().getClass().getName() + ")");
 			}
 		}
 	}
 
 	public static String getClassNameWithOutPackage(final Class pvClass) {
 		if (pvClass == null) {
 			return null;
 		} else {
 			return getClassNameWithOutPackage(pvClass.getName());
 		}
 	}
 	
 	public static String getClassNameWithOutPackage(final String pvClassName) {
 		if (pvClassName == null) {
 			return null;
 		} else {
 			String lvNames[] = pvClassName.split("\\.");
 			return lvNames[(lvNames.length - 1)];
 		}
 	}
 	
 	/**
 	 * Reverse the package fro class. For example:
 	 * <code>test.crispy.example.model.Kunde</code> -> <code>model.example.crispy.test</code>.
 	 * By a class without a package, is the return value a empty String.
 	 *   
 	 * @param pvClass
 	 * @return reverse string.
 	 */
 	public static String reverse(Class pvClass) {
 		if (pvClass == null) { return null; }
 		String lvClassName = pvClass.getName();
 		String lvParts[] = lvClassName.split("\\.");
 		String lvRet = "";
 		int l = lvParts.length -1;
 		for (int i = l; i > 0; i--) {
 			lvRet = lvRet + lvParts[i-1] + ".";
 		}
 		lvRet = lvRet.substring(0, (lvRet.length() - 1)); 
 		return lvRet;
 	}
 	
 	/**
 	 * Create a <code>javax.xml.namespace.QName</code> by the class. For example
 	 * class: <code>test.crispy.example.model.Kunde</code> ->
 	 * LocalPart: <code>test.crispy.example.model.Kunde</code> and 
 	 * NamespaceURI: <code>model.example.crispy.test</code>.
 	 * 
 	 * @param pvClass The class for create a QName.
 	 * @return The created QName object.
 	 */
 	public static QName createQNameByClass(Class pvClass) {
 		if (pvClass == null) { return null; }
 		return new QName(Util.reverse(pvClass), pvClass.getName());
 	}
     
 	/**
 	 * Get from the properites all properties, that begins with the prefix and sorted this
 	 * properties to the property keys.
 	 * 
 	 * @param pvProperties all properties
 	 * @param pvPrefix filter = prefix from property key
 	 * @return sorted Map from all properties with correct prefix.
 	 */
 	public static Map getAllPropertiesByPrefixAndSort(Properties pvProperties, String pvPrefix) {
         Enumeration enumeration = pvProperties.keys();
         Map lvSorterMap = new TreeMap();
         while (enumeration.hasMoreElements()) {
         	Object lvPropertyObject = enumeration.nextElement();
         	if ( ! (lvPropertyObject.getClass().getName().equals(String.class.getName()))) {
         		throw new InvocationException("The property must be a String, but is: " 
         						+ lvPropertyObject.getClass().getName() 
         						+ " --> with value (key): " + lvPropertyObject);
         	}
         	String lvKey = (String) lvPropertyObject;
         	
         	if (lvKey.startsWith(pvPrefix)) {
         		String lvProxyInterceptorStr = pvProperties.getProperty(lvKey);
         		lvSorterMap.put(lvKey, lvProxyInterceptorStr);
         	}
         }
         return lvSorterMap;
 	}
 	
 	
     public static byte[] inputStream2ByteArray(InputStream is) throws IOException {
     	int BUFFER_SIZE = 8192;
         byte[] buffer = new byte[BUFFER_SIZE];
         byte[] content = new byte[0];
         int length;
         while ((length = is.read(buffer)) > 0) {
           byte[] tmp = content;
           content = new byte[tmp.length + length];
           System.arraycopy(tmp, 0, content, 0, tmp.length);
           System.arraycopy(buffer, 0, content, tmp.length, length);
         }
         return content;
       }
 
 
     public static void visualisationTree(Object pvObject) {
     	DefaultMutableTreeNode lvRoot = new DefaultMutableTreeNode("ROOT");
     	createTree(pvObject, lvRoot);
     	JFrame lvFrame = new JFrame("Crispy tree visualisation ...");
     	JTree lvTree = new JTree(lvRoot);
     	lvFrame.getContentPane().add(new JScrollPane(lvTree));
     	lvFrame.setVisible(true);
     	lvFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
     	lvFrame.show();
     	lvFrame.pack();
     	
     }
 
 
     public static void createTree (Object pvObject, DefaultMutableTreeNode pvRoot) {
         if (pvObject != null) {
             Class clazz = pvObject.getClass();
             if (pvObject instanceof Collection) {
                 createTreeByCollection((Collection) pvObject, pvRoot, null);
             }
             else if (pvObject instanceof Map) {
                 createTreeByMap((Map) pvObject, pvRoot, null);
             }
             else if ((clazz.equals(Integer.class))
                     || (clazz.equals(Double.class)) 
                     || (clazz.equals(Boolean.class)) 
                     || (clazz.equals(String.class)) 
                     || (clazz.equals(Date.class))) {  
                         pvRoot.add(new DefaultMutableTreeNode (pvObject));
                     }
             else {
                 pvRoot.add(new DefaultMutableTreeNode ("-- Ungueltiger Typ: " + clazz + ": " + pvObject));
             }
         }
     }
 
     public static String map2String (Map pvMap, String pvPropertyName) {
         if (pvMap == null) { return null; }
         StringBuffer sb = null;
         if (pvPropertyName != null) {
         	sb = new StringBuffer(pvPropertyName + ": ");
         } else {
         	sb = new StringBuffer();
         }
         StringBuffer sbClazz = new StringBuffer();
         
         Iterator it = pvMap.entrySet().iterator();
         while (it.hasNext()) {
         	Map.Entry lvMapEntry = (Entry) it.next();
             Object key = lvMapEntry.getKey();
             Object value = lvMapEntry.getValue();
 //            if ((value instanceof Collection) || (value instanceof Map)) {
             	
                 // mache nichts
 //            } else {
             // ???????????
             if (!(value instanceof Collection) && !(value instanceof Map)) {            	
                 if (key.toString().compareTo("class") == 0) {
                     sbClazz.append(" -> (").append(key).append(" = ").append(value).append(")");
                 } else {
                     sb.append("[").append(key).append(" = ").append(value).append("] ");
                 }
             }
         }
         return sb.append(sbClazz).toString();
     }
 
     public static void createTreeByMap (Map pvMap, DefaultMutableTreeNode pvRoot, String pvPropertyName) {
         if (pvMap != null) {
             DefaultMutableTreeNode child = new DefaultMutableTreeNode (map2String(pvMap, pvPropertyName));
             pvRoot.add(child);
             
             Iterator it = pvMap.entrySet().iterator();
             while (it.hasNext()) {
             	Map.Entry lvMapEntry = (Entry) it.next();
                 if (lvMapEntry.getValue() instanceof Collection) {
                     createTreeByCollection((Collection) lvMapEntry.getValue(), child, lvMapEntry.getKey().toString());
                 }
                 else if (lvMapEntry.getValue() instanceof Map) {
                     createTreeByMap((Map) lvMapEntry.getValue(), child, lvMapEntry.getKey().toString());
                 }
             }
         }        
     }
 
     public static void createTreeByCollection (Collection pvCollection, DefaultMutableTreeNode pvRoot, String pvPropertyName) {
         if ((pvCollection != null) && (pvCollection.size() > 0)) {
             Iterator it = pvCollection.iterator();
             while (it.hasNext()) {
                 Object value = it.next();
                 if (value instanceof Collection) {
                     createTreeByCollection((Collection) value, pvRoot, pvPropertyName);
                 }
                 else if (value instanceof Map) {
                     createTreeByMap((Map) value, pvRoot, pvPropertyName);
                 }
             }
         }
     }
 
         
 	public static boolean initJdkLogger () {
     	return initJdkLogger2 (Util.class.getResourceAsStream("jdk14-logging.properties"));
 	}
 
 	public static boolean initJdkLogger (String pvFileName) {
 		try {
 			return initJdkLogger2 (new FileInputStream(pvFileName));
 		} catch (FileNotFoundException e) {
 			e.printStackTrace();
 		}
     	return false;
 	}
 
 	public static boolean initJdkLogger2 (InputStream pvInputStream) {
 		try {
 			LogManager.getLogManager().readConfiguration(pvInputStream);
 			Logger logger = Logger.global;
 			LogManager.getLogManager().addLogger(logger);
 			logger.finest("Jdk14Logger initialisiert ...");
 			return true;
 		} catch (Exception e) {
 			e.printStackTrace();
 		}		
 		return false;
 	}
 }