package com.randomnoun.common;
   
   /* (c) 2013 randomnoun. All Rights Reserved. This work is licensed under a
    * BSD Simplified License. (http://www.randomnoun.com/bsd-simplified.html)
    */
   
   import java.io.*;
   import java.lang.reflect.*;
   import java.net.URLDecoder;
  import java.nio.charset.Charset;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipInputStream;
  
  import org.apache.log4j.Logger;
  
  /**
   * Exception utilities class.
   *
   * <p>This class contains static utility methods for handling and manipulating exceptions;
   * the only one you're likely to call being 
   * {@link #getStackTraceWithRevisions(Throwable, ClassLoader, int, String)},
   * which extracts CVS revision information from classes to produce an annotated (and highlighted)
   * stack trace.
   * 
   * <p>When passing in {@link java.lang.ClassLoader}s to these methods, you may want to try one of 
   * <ul>
   * <li>this.getClass().getClassLoader()
   * <li>Thread.currentThread().getContextClassLoader()
   * </ul>
   * 
   * @see <a href="http://www.randomnoun.com/wp/2012/12/17/marginally-better-stack-traces/">http://www.randomnoun.com/wp/2012/12/17/marginally-better-stack-traces/</a>
   * @author knoxg
   */
  public class ExceptionUtil {
      
  
      /** Perform no stack trace element highlighting */
      public static final int HIGHLIGHT_NONE = 0;
      
      /** Allow stack trace elements to be highlighted, as text */
      public static final int HIGHLIGHT_TEXT = 1;
      
      /** Allow stack trace elements to be highlighted, as bold HTML */
      public static final int HIGHLIGHT_HTML = 2;
  
      /** Allow stack trace elements to be highlighted, with span'ed CSS elements */
      public static final int HIGHLIGHT_HTML_WITH_CSS = 3;
  
      /** The number of characters of the git revision to include in non-CSS stack traces (from the left side of the String) */
      public static final int NUM_CHARACTERS_GIT_REVISION = 8;
      
      static Logger logger = Logger.getLogger(ExceptionUtil.class);
      
      /**
       * Private constructor to prevent instantiation of this class
       */
      private ExceptionUtil() {
      }
  
      /**
       * Converts an exception's stack trace to a string. If the exception passed
       * to this function is null, returns the empty string.
       *
       * @param e exception
       * 
       * @return string representation of the exception's stack trace
       */
      public static String getStackTrace(Throwable e) {
          if (e == null) {
              return "";
          }
          StringWriter writer = new StringWriter();
          e.printStackTrace(new PrintWriter(writer));
          return writer.toString();
      }
  
      /**
       * Converts an exception's stack trace to a string. Each stack trace element
       * is annotated to include the CVS revision Id, if it contains a public static
       * String element containing this information. 
       * 
       * <p>Stack trace elements whose classes begin with the specified highlightPrefix
       * are also marked, to allow easier debugging. Highlights used can be text
       * (which will insert the string "=&gt;" before relevent stack trace elements), or 
       * HTML (which will render the stack trace element between &lt;b&gt; and &lt;/b&gt; tags.
       * 
       * <p>If HTML highlighting is enabled, then the exception message is also HTML-escaped.
       *
       * @param e exception
       * @param loader ClassLoader used to read stack trace element revision information
       * @param highlight One of the HIGHLIGHT_* constants in this class
       * @param highlightPrefix A prefix used to determine which stack trace elements are
       *   rendered as being 'important'. (e.g. "<code>com.randomnoun.common.</code>"). Multiple
       *   prefixes can be specified, if separated by commas.   
      * 
      * @return string representation of the exception's stack trace
      */
     public static String getStackTraceWithRevisions(Throwable e, ClassLoader loader, int highlight, String highlightPrefix) {
         if (e == null) {
             return "(null)";
         }
         StringBuffer sb = new StringBuffer();
         String additionalMessageSource = null;
         String additionalMessage = null; // because some Exceptions are <strike>retarded</strike> of questionable quality
 
         // was replacing 'e' here with e.getTarget() if e was a bsh.TargetError, 
         // but should probably just tack this onto the .getCause() chain stead
 		
         try {
 	        if (e.getClass().getName().equals("com.spotify.docker.client.exceptions.DockerRequestException")) {
 	        	Method m;
 				m = e.getClass().getMethod("message");
 				additionalMessageSource = "DockerRequestException.message()=";
 				additionalMessage = (String) m.invoke(e);
 				if (additionalMessage!=null) { additionalMessage = additionalMessage.trim(); }
 	        }
 		} catch (SecurityException e1) {
 			// ignore - just use original exception
 		} catch (NoSuchMethodException e1) {
 			// ignore - just use original exception
 		} catch (IllegalArgumentException e1) {
 			// ignore - just use original exception
 		} catch (IllegalAccessException e1) {
 			// ignore - just use original exception
 		} catch (InvocationTargetException e1) {
 			// ignore - just use original exception
 		}
         
         String s = e.getClass().getName();
         String message = e.getLocalizedMessage();
         if (highlight==HIGHLIGHT_HTML || highlight==HIGHLIGHT_HTML_WITH_CSS) {
         	sb.append(escapeHtml((message != null) ? (s + ": " + message) : s ));
         } else {
         	sb.append((message != null) ? (s + ": " + message) : s );
         }
         
         if (additionalMessage!=null) {
         	sb.append('\n');
             if (highlight==HIGHLIGHT_HTML || highlight==HIGHLIGHT_HTML_WITH_CSS) {
             	sb.append(escapeHtml(additionalMessageSource));
             	sb.append(escapeHtml(additionalMessage));
             } else {
             	sb.append(additionalMessageSource);
             	sb.append(additionalMessage);
             }
         }
         sb.append('\n');
         
         // dump the stack trace for the top-level exception
         StackTraceElement[] trace = null;
         trace = e.getStackTrace();
         
         Map<String, JarMetadata> jarMetadataCache = new HashMap<String, JarMetadata>();
         
         for (int i=0; i < trace.length; i++) {
             sb.append(getStackTraceElementWithRevision(jarMetadataCache, trace[i], loader, highlight, highlightPrefix) + "\n");
         }
         Throwable cause = getCause(e);
         if (cause != null) {
             sb.append(getStackTraceWithRevisionsAsCause(jarMetadataCache, cause, trace, loader, highlight, highlightPrefix));
         }
         return sb.toString();
     }
 
     /** Returns the 'Caused by...' exception text for a chained exception, performing the
      * same stack trace element reduction as performed by the built-in {@link java.lang.Throwable#printStackTrace()}
      * class.
      * 
      * <p>Note that the notion of 'Suppressed' exceptions introduced in Java 7 is not 
      * supported by this implementation.
      *  
      * @param e the cause of the original exception
      * @param causedTrace the original exception trace
      * @param loader ClassLoader used to read stack trace element revision information
      * @param highlight One of the HIGHLIGHT_* constants in this class
      * @param highlightPrefix A prefix used to determine which stack trace elements are
      *   rendered as being 'important'. (e.g. "<tt>com.randomnoun.common.</tt>"). Multiple
      *   prefixes can be specified, if separated by commas.
      *   
      * @return the 'caused by' component of a stack trace
      */
     private static String getStackTraceWithRevisionsAsCause(Map<String, JarMetadata> jarMetadataCache, Throwable e, StackTraceElement[] causedTrace, ClassLoader loader, int highlight, String highlightPrefix) {
         
         StringBuffer sb = new StringBuffer();
         
         // Compute number of frames in common between this and caused
         StackTraceElement[] trace = e.getStackTrace();
         int m = trace.length-1;
         int n = causedTrace.length-1;
         while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) {
             m--; n--;
         }
         int framesInCommon = trace.length - 1 - m;
 
         String s = e.getClass().getName();
         String message = e.getLocalizedMessage();
         if (message==null) {  // org.json.simple.parser.ParseException doesn't set message 
         	message = e.toString(); 
         	if (s.equals(message)) { message = null; }
         } 
         sb.append("Caused by: ");
         if (highlight==HIGHLIGHT_HTML || highlight==HIGHLIGHT_HTML_WITH_CSS) {
         	sb.append(escapeHtml((message != null) ? (s + ": " + message) : s ));
         } else {
         	sb.append((message != null) ? (s + ": " + message) : s );
         }
         sb.append("\n");
         
         for (int i=0; i <= m; i++) {
             sb.append(getStackTraceElementWithRevision(jarMetadataCache, trace[i], loader, highlight, highlightPrefix) + "\n");
         }
         if (framesInCommon != 0)
             sb.append("\t... " + framesInCommon + " more\n");
 
         // Recurse if we have a cause
         Throwable ourCause = getCause(e);
         if (ourCause != null) {
             sb.append(getStackTraceWithRevisionsAsCause(jarMetadataCache, ourCause, trace, loader, highlight, highlightPrefix));
         }
         return sb.toString();
     }
     
     /** Returns a single stack trace element as a String, with highlighting
      * 
      * @param jarMetadataCache jar-level metadata cached during the traversal of the stackTraceElements.
      * @param ste the StackTraceElement
      * @param loader ClassLoader used to read stack trace element revision information
      * @param highlight One of the HIGHLIGHT_* constants in this class
      * @param highlightPrefix A prefix used to determine which stack trace elements are
      *   rendered as being 'important'. (e.g. "<tt>com.randomnoun.common.</tt>"). Multiple
      *   prefixes can be specified, separated by commas.
      *   
      * @return the stack trace element as a String, with highlighting
      */
     private static String getStackTraceElementWithRevision(Map<String, JarMetadata> jarMetadataCache, 
     	StackTraceElement ste, ClassLoader loader,
         int highlight, String highlightPrefix) 
     {
         // s should be something like:
         // jakarta.servlet.http.HttpServlet.service(HttpServlet.java:740) or
     	// java.net.Socket.<init>(Socket.java:425), which should be HTML escaped
         String s;
         if (highlightPrefix==null || highlight==HIGHLIGHT_NONE) {
         	s = "    at " + ste.toString();
         } else {
 	        boolean isHighlighted = (highlight!=HIGHLIGHT_NONE && isHighlighted(ste.getClassName(), highlightPrefix));
 	        if (isHighlighted) {
 	        	if (highlight==HIGHLIGHT_HTML) {
 		            s = "    at <b>" + escapeHtml(ste.toString()) + "</b>";  
 		        } else if (isHighlighted && highlight==HIGHLIGHT_HTML_WITH_CSS) {
 			        s = "    at <span class=\"stackTrace-highlight\">" + escapeHtml(ste.toString()) + "</span>";
 		        } else if (isHighlighted && highlight==HIGHLIGHT_TEXT) {
 		            s = " => at " + ste.toString();
 		        } else { 
 		            throw new IllegalArgumentException("Unknown highlight " + highlight);
 		        }
 	        } else { // !isHighlighted
 	        	if (highlight==HIGHLIGHT_HTML || highlight==HIGHLIGHT_HTML_WITH_CSS) {
 	        		s = "    at " + escapeHtml(ste.toString());
 	        	} else {
 	        		s = "    at " + ste.toString();
 	        	}
 	        } 
         }
         
         int openBracketPos = s.lastIndexOf("(");
         int closeBracketPos = s.lastIndexOf(")");
         if (openBracketPos!=-1 && closeBracketPos!=-1) {
             try {
                 // add maven, git and cvs revision info
                 String className = ste.getClassName();
                 JarMetadata jarMetadata = getJarMetadata(jarMetadataCache, loader, className);
                 String revision = getClassRevision(loader, className);
                 if (revision != null) {
                 	if (highlight==HIGHLIGHT_HTML_WITH_CSS) {
                 		s = s.substring(0, closeBracketPos) + "<span class=\"stackTrace-revision\">" + revision + "</span> " + s.substring(closeBracketPos);
                 	} else {
                 		s = s.substring(0, closeBracketPos) + ", " + revision + s.substring(closeBracketPos);
                 	}
                 }
                 if (jarMetadata != null) {
                 	if (jarMetadata.groupId!=null && jarMetadata.artifactId!=null) {
                 		if (highlight==HIGHLIGHT_HTML_WITH_CSS) {
                 			s = s.substring(0, openBracketPos + 1) + "<span class=\"stackTrace-maven\">" + jarMetadata.groupId + ":" + jarMetadata.artifactId + ":" + jarMetadata.version + "</span> " + s.substring(openBracketPos + 1);
                 		} else {
                 			s = s.substring(0, openBracketPos + 1) + jarMetadata.groupId + ":" + jarMetadata.artifactId + ":" + jarMetadata.version + ", " + s.substring(openBracketPos + 1);
                 		}
                 	}
                 	if (jarMetadata.gitRevision!=null) {
                 		if (highlight==HIGHLIGHT_HTML_WITH_CSS) {
                 			s = s.substring(0, openBracketPos + 1) + "<span class=\"stackTrace-git\">" + jarMetadata.gitRevision + "</span> " + s.substring(openBracketPos + 1);
                 		} else {
                 			s = s.substring(0, openBracketPos + 1) + jarMetadata.gitRevision.substring(0, NUM_CHARACTERS_GIT_REVISION) + ", " + s.substring(openBracketPos + 1);
                 		}
                 	}
                 }
             } catch (Exception e2) {
             	// logger.error(e2);
             } catch (NoClassDefFoundError ncdfe) {
             }
         }
         return s;
     }
     
     /** Returns true if the provided className matches the highlightPrefix pattern supplied, 
      * false otherwise
      *  
      * @param className The name of a class (i.e. the class contained in a stack trace element)
      * @param highlightPrefix A prefix used to determine which stack trace elements are
      *   rendered as being 'important'. (e.g. "<tt>com.randomnoun.common.</tt>"). Multiple
      *   prefixes can be specified, separated by commas.
      *   
      * @return true if the provided className matches the highlightPrefix pattern supplied, 
      *   false otherwise
      */
     private static boolean isHighlighted(String className, String highlightPrefix) {
     	if (highlightPrefix.contains(",")) {
     		String[] prefixes = highlightPrefix.split(",");
     		boolean highlighted = false; 
     		for (int i=0; i<prefixes.length && !highlighted; i++) {
     			highlighted = className.startsWith(prefixes[i]);
     		}
     		return highlighted;
     	} else {
     		return className.startsWith(highlightPrefix);
     	}
     }
 
     /** Return the number of elements in the current thread's stack trace (i.e. the height
      * of the call stack). 
      * 
      * @return the height of the call stack 
      */
     public static int getStackDepth() {
         Throwable t = new Throwable();
         return t.getStackTrace().length;
     }
     
     /** Jar-level metadata is cached for the duration of a single ExceptionUtils method call */
     private static class JarMetadata {
     	String gitRevision;
     	String groupId;
     	String artifactId;
     	String version;
     }
     
     
     /** Returns the JAR metadata (including the git revision and mvn groupId:artifactId co-ordinates) of the JAR containing a class. 
      * 
      * @param loader The classLoader to use
      * @param className The class we wish to retrieve
      * 
      * @return A JarMetadata class, or null
      * 
      * @throws ClassNotFoundException
      * @throws SecurityException
      * @throws NoSuchFieldException
      * @throws IllegalArgumentException
      * @throws IllegalAccessException
      */    
     private static JarMetadata getJarMetadata(Map<String, JarMetadata> jarMetadataCache, ClassLoader loader, String className) 
         	throws ClassNotFoundException, SecurityException, NoSuchFieldException, 
         	IllegalArgumentException, IllegalAccessException 
     {
         if (className.indexOf('$')!=-1) {
             className = className.substring(0, className.indexOf('$'));
         }
         // this can also throw java.lang.Errors e.g. 
         // "Caused by: java.lang.Error: Trampoline must not be defined by the bootstrap classloader
         // at java.base/sun.reflect.misc.Trampoline.<clinit>(MethodUtil.java:43)"
         Class<?> clazz;
         try {
         	clazz = Class.forName(className, true, loader);
         } catch (Throwable t) {
         	return null;
         }
         
         // this is stored in the build.properties file, which we'll have to get from the JAR containing the class
         // see http://stackoverflow.com/questions/1983839/determine-which-jar-file-a-class-is-from
         int revisionMethod = 0;
         
         String uri = clazz.getResource('/' + clazz.getName().replace('.', '/') + ".class").toString();
         if (uri.startsWith("file:")) {
         	// this happens in eclipse; e.g. 
         	//   uri=file:/C:/Users/knoxg/workspace-4.4.1-sts-3.6.2/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/wtpwebapps/jacobi-web/WEB-INF/classes/com/jacobistrategies/web/struts/Struts1Shim.class
         	// use the current class loader's build.properties if available
         	revisionMethod = 1;
         } else if (uri.startsWith("jar:file:")) {
         	revisionMethod = 2;
         } else {
             // int idx = uri.indexOf(':');
             // String protocol = idx == -1 ? "(unknown)" : uri.substring(0, idx);
             // logger.warn("unknown protocol " + protocol + " in classpath uri '" + uri + "'");
             revisionMethod = -1;
         }
 
         JarMetadata md = null;
         if (revisionMethod == 1) {
         	// get the revision from the supplied class loader's build.properties, if there is one
         	md = new JarMetadata();
         	InputStream is = loader.getResourceAsStream("/build.properties");
         	if (is==null) {
         		// logger.warn("missing build.properties");
         		return null;
         	} else {
         		Properties props = new Properties();
         		try {
         			props.load(is);
         			md.gitRevision = props.getProperty("git.buildNumber");
         			if ("${buildNumber}".equals(md.gitRevision)) { md.gitRevision = null; }
 	        	} catch (IOException ioe) {
 	 	        	// ignore;
 	 	        }
         	}
         	
         } else if (revisionMethod == 2) {
         	// get the revision from the containing JAR
         	
 	        int idx = uri.indexOf('!');
 	        //As far as I know, the if statement below can't ever trigger, so it's more of a sanity check thing.
 	        if (idx == -1) {
 	        	// logger.warn("unparseable classpath uri '" + uri + "'");
 	        	return null;
 	        }
 	        String fileName;
 	        try {
 	            fileName = URLDecoder.decode(uri.substring("jar:file:".length(), idx), Charset.defaultCharset().name());
 	        } catch (UnsupportedEncodingException e) {
 	            throw new IllegalStateException("default charset doesn't exist. Your VM is borked.");
 	        }
 	        
         	// use the cache if it exists
         	if (jarMetadataCache!=null) {
         		md = jarMetadataCache.get(fileName);
         	}
         	if (md==null) {
         		md = new JarMetadata();
         		jarMetadataCache.put(fileName, md);
         		File f = new File(fileName); // .getAbsolutePath();
 		        
 		        // get the build.properties from this JAR
 		        // logger.debug("Getting build.properties for " + className + " from " + f.getPath());
 		        try {
 			        ZipInputStream zis = new ZipInputStream(new FileInputStream(f));
 			        try {
 				        ZipEntry ze = zis.getNextEntry();
 				        while (ze!=null && (md.gitRevision==null || md.version==null)) {
 				        	// logger.debug(ze.getName());
 				        	if (ze.getName().equals("build.properties") || ze.getName().equals("/build.properties")) {
 				        		// logger.debug(ze.getName());
 				        		Properties props = new Properties();
 				        		props.load(zis);
 				        		md.gitRevision = props.getProperty("git.buildNumber");
 				        	}
 				        	if (ze.getName().endsWith("/pom.properties")) { 
 				        		// e.g. META-INF/maven/edu.ucla.cs.compilers/jtb/pom.xml, pom.properties
 				        		// should probably check full path to prevent false positives
 				        		Properties props = new Properties();
 				        		props.load(zis);
 				        		md.groupId = props.getProperty("groupId");
 				        		md.artifactId = props.getProperty("artifactId");
 				        		md.version = props.getProperty("version");
 				        	}
 				        	ze = zis.getNextEntry();
 				        }
 			        } finally {
 			        	zis.close();
 			        }
 		        } catch (IOException ioe) {
 		        	// ignore;
 		        }
         	}
         }
         return md;
     }
     
     /** Returns a string describing the CVS revision number of a class. 
      * 
      * <p>The class is initialised as part of this process, which may cause a number of 
      * exceptions to be thrown. 
      * 
      * @param loader The classLoader to use
      * @param className The class we wish to retrieve
      * 
      * @return The CVS revision string, in the form "ver 1.234"
      * 
      * @throws ClassNotFoundException
      * @throws SecurityException
      * @throws NoSuchFieldException
      * @throws IllegalArgumentException
      * @throws IllegalAccessException
      */    
     private static String getClassRevision(ClassLoader loader, String className) 
         	throws ClassNotFoundException, SecurityException, NoSuchFieldException, 
         	IllegalArgumentException, IllegalAccessException 
     {
         if (className.indexOf('$')!=-1) {
             className = className.substring(0, className.indexOf('$'));
         }
         
         // if this is in a CVS repository, each class has it's own _revision public final static String variable
         Class<?> clazz = Class.forName(className, true, loader);
         Field field = null;
         try {
         	field = clazz.getField("_revision");
         } catch (NoSuchFieldException nsfe) {
         	
         }
         String classRevision = null;
         if (field!=null) {
 	        classRevision = (String) field.get(null);
 	    
 	        // remove rest of $Id$ text 
 	        int pos = classRevision.indexOf(",v ");
 	        if (pos != -1) {
 	            classRevision = classRevision.substring(pos + 3);
 	            pos = classRevision.indexOf(' ');
 	            classRevision = "ver " + classRevision.substring(0, pos);
 	        }
         }
         return classRevision;
     }
 
 
     /** An alternate implementation of {@link #getClassRevision(ClassLoader, String)},
      * which searches the raw bytecode of the class, rather than using Java reflection.
      * May be a bit more robust.
      * 
      * @param loader Classloader to use
      * @param className Class to load
      * 
      * @return The CVS revision string, in the form "ver 1.234".
      * 
      * @throws ClassNotFoundException
      * @throws SecurityException
      * @throws NoSuchFieldException
      * @throws IllegalArgumentException
      * @throws IllegalAccessException
      */
     /* TODO implement */
     public static String getClassRevision2(ClassLoader loader, String className) 
     	throws ClassNotFoundException, SecurityException, NoSuchFieldException, 
     	IllegalArgumentException, IllegalAccessException 
     {
         if (className.indexOf('$')!=-1) {
             className = className.substring(0, className.indexOf('$'));
         }
         // String file = className.replace('.',  '/') + ".class";
         // InputStream is = loader.getResourceAsStream(file);
         
         // read up to '$Id:' text
         
         throw new UnsupportedOperationException("Not implemented");
     }
     
     
     
     /** Returns a list of all the messages contained within a exception (following the causal
      * chain of the supplied exception). This may be more useful to and end-user, since it
      * should not contain any references to Java class names.
      * 
      * @param throwable an exception
      * 
      * @return a List of Strings
      */
     public static List<String> getStackTraceSummary(Throwable throwable) {
     	List<String> result = new ArrayList<String>();
     	while (throwable!=null) {
     		result.add(throwable.getMessage());
     		throwable = getCause(throwable);
     		// I think some RemoteExceptions have non-standard caused-by chains as well...
     		if (throwable==null) {
     			if (throwable instanceof java.sql.SQLException) {
     				throwable = ((java.sql.SQLException) throwable).getNextException();
     			} 
     		}
     	}
     	return result;
     }
 
     /** Returns the cause of an exception, or null if not known.
      * If the exception is a a <code>bsh.TargetError</code>, then the cause is determined
      * by calling the <code>getTarget()</code> method, otherwise this method will
      * return the same value returned by the standard Exception 
      * <code>getCause()</code> method.
      * 
      * @param e the cause of an exception, or null if not known.
      * 
      * @return the cause of an exception, or null if not known.
      */
     private static Throwable getCause(Throwable e) {
     	Throwable cause = null;
     	if (e.getClass().getName().equals("bsh.TargetError")) {
             try {
     	        if (e.getClass().getName().equals("bsh.TargetError")) {
     	        	Method m;
     				m = e.getClass().getMethod("getTarget");
     				cause = (Throwable) m.invoke(e);
     	        }
     		} catch (SecurityException e1) {
     			// ignore - just use original exception
     		} catch (NoSuchMethodException e1) {
     			// ignore - just use original exception
     		} catch (IllegalArgumentException e1) {
     			// ignore - just use original exception
     		} catch (IllegalAccessException e1) {
     			// ignore - just use original exception
     		} catch (InvocationTargetException e1) {
     			// ignore - just use original exception
     		}
     	} else {
     		cause = e.getCause();
     	}
     	return cause;
     }
 
     /**
      * Returns the HTML-escaped form of a string. Any <code>&amp;</code>,
      * <code>&lt;</code>, <code>&gt;</code>, and <code>"</code> characters are converted to
      * <code>&amp;amp;</code>, <code>&amp;lt;</code>, <code>&amp;gt;</code>, and
      * <code>&amp;quot;</code> respectively.
      *
      * @param string the string to convert
      *
      * @return the HTML-escaped form of the string
      */
     static public String escapeHtml(String string) {
         if (string == null) {
             return "";
         }
 
         char c;
         StringBuffer sb = new StringBuffer(string.length());
 
         for (int i = 0; i < string.length(); i++) {
             c = string.charAt(i);
 
             switch (c) {
                 case '&':
                     sb.append("&amp;");
                     break;
                 case '<':
                     sb.append("&lt;");
                     break;
                 case '>':
                     sb.append("&gt;");
                     break;
                 case '\"':
                     sb.append("&quot;");
                     break;
                 default:
                     sb.append(c);
             }
         }
 
         return sb.toString();
     }
     
 }