/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  package com.gridsystems.innergrid.kernel;
  
  import java.io.PrintStream;
  import java.io.PrintWriter;
  import java.rmi.RemoteException;
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.Vector;
  import java.util.regex.Pattern;
  
  import javax.xml.namespace.QName;
  
  import org.apache.axis.AxisFault;
  import org.apache.axis.Constants;
  import org.apache.axis.encoding.SerializationContext;
  import org.apache.axis.utils.JavaUtils;
  import org.apache.axis.utils.XMLUtils;
  import org.w3c.dom.DOMException;
  import org.w3c.dom.Element;
  import org.w3c.dom.Node;
  
  /**
   * Exception type for all published APIs.
   * <p>
   * All exceptions should be converted into a KernelException before being thrown
   * in a public API method. Internal methods can also throw a KernelException if
   * an error is considered to be of interest for a public API calling them.
   * <p>
   * Subclassing is highly encouraged for improving code readability and maintainability.
   * For those cases where another base exception class is mandatory, see the
   * {@link com.gridsystems.innergrid.kernel.Kernelizable Kernelizable} interface.
   * <p>
   * <b>IMPORTANT</b>: The parameter list is transferred to the client side as a string
   * list. Methods for parsing those strings will be convenient if there is a need of
   * obtaining the original values in the client.
   *
   * @author Rodrigo Ruiz
   * @see com.gridsystems.innergrid.kernel.Kernelizable
   */
  public class KernelException extends AxisFault implements Kernelizable {
  
    /**
     * Serial Version UID.
     */
    private static final long serialVersionUID = 1876438763487634L;
  
    /**
     * The message for this exception.
     */
    protected String msg;
  
    /**
     * The pattern used to generate the message.
     */
    protected String pattern;
  
    /**
     * The list of error message parameters.
     */
    protected Object[] params;
  
    /**
     * Creates an instance with a fixed message (no I18N).
     *
     * @param code    The error code
     * @param pattern The message pattern (without parameter replacement)
     * @param params  The error message parameters
     * @param cause   The root cause
     * @deprecated
     */
    public KernelException(String code, String pattern, Object[] params, Throwable cause) {
      this(cause, new QName("Kernel", code), pattern, params);
    }
  
    /**
     * Creates an instance with a fixed message (no I18N).
     *
     * @param code    The fully qualified error code
     * @param pattern The message pattern (without parameter replacement)
     * @param params  The error message parameters
     * @param cause   The root cause
     * @deprecated
     */
   public KernelException(QName code, String pattern, Object[] params, Throwable cause) {
     super(null, cause);
     super.setFaultCode(code);
     this.pattern = pattern;
     this.params = params;
     if (pattern == null) {
       msg = ""; // The fault string should never be null
     } else {
       if (params == null) {
         msg = pattern;
       } else {
         msg = MessageFormat.format(pattern, params);
       }
     }
     super.setFaultString(msg);
     super.setFaultReason(msg);
   }
 
   /**
    * Creates an instance with a fixed message (no I18N).
    *
    * @param cause   Root cause
    * @param code    Error code
    * @param pattern Message pattern (without parameter replacement)
    * @param params  Message parameters
    */
   public KernelException(Throwable cause, String code, String pattern, Object... params) {
     this(cause, new QName("Kernel", code), pattern, params);
   }
 
   /**
    * Creates an instance with a fixed message (no I18N).
    *
    * @param cause   Root cause
    * @param code    Fully qualified error code
    * @param pattern Message pattern (without parameter replacement)
    * @param params  Message parameters
    */
   public KernelException(Throwable cause, QName code, String pattern, Object... params) {
     super(null, cause);
     super.setFaultCode(code);
     this.pattern = pattern;
     this.params = params;
     if (pattern == null) {
       msg = ""; // The fault string should never be null
     } else {
       if (params == null) {
         msg = pattern;
       } else {
         msg = MessageFormat.format(pattern, params);
       }
     }
     super.setFaultString(msg);
     super.setFaultReason(msg);
   }
 
   /**
    * Gets this instance error code.
    *
    * @return The error code of this exception
    */
   public String getCode() {
     QName code = super.getFaultCode();
     String local = code.getLocalPart();
     int pos = local.indexOf('}');
 
     return local.substring(pos + 1);
   }
 
   /**
    * Compares this instance error code with the specified one and returns true if they
    * are equals.
    *
    * @param code The code to compare to
    * @return true if the specified code is equals to this instance one
    */
   public boolean hasCode(String code) {
     QName qcode = super.getFaultCode();
     return qcode.getLocalPart().equals(code);
   }
 
   /**
    * Gets this fault code namespace.
    *
    * @return The faul code namespace
    */
   public String getNamespace() {
     QName code = super.getFaultCode();
     return code.getNamespaceURI();
   }
 
   /**
    * Gets the list of parameters for this exception message.
    *
    * @return The message parameters list
    */
   public Object[] getParams() {
     return this.params;
   }
 
   /**
    * Gets this exception message.
    * <p>
    * The message is obtained from the pattern and the list of parameters.
    *
    * @return the message for this exception
    */
   @Override public String getMessage() {
     return this.msg;
   }
 
   /**
    * Gets this exception pattern.
    *
    * @return This exception pattern.
    */
   public String getPattern() {
     return this.pattern;
   }
 
   /**
    * Overrides the default implementation, returning the concatenation of
    * this exception code and message.
    *
    * @return a human-readable description of this instance
    */
   @Override public String toString() {
     return getCode() + ": " + getMessage();
   }
 
   /**
    * Parses a RemoteException instance, and if it contains a KernelException, returns
    * a properly initialized one. Otherwise, it wraps the Exception into a
    * KernelException with UNK000 code
    *
    * @param e The source remote exception
    * @return  A properly initialized KernelException instance
    */
   public static KernelException fromRemoteException(RemoteException e) {
     if (e instanceof KernelException) {
       return (KernelException)e;
     }
 
     if (e instanceof AxisFault) {
       AxisFault fault = (AxisFault)e;
       Element[] details = fault.getFaultDetails();
 
       QName code = null;
       String pattern = fault.getFaultString();
       Throwable cause = fault.getCause();
       Object[] params = null;
       ArrayList<String> list = new ArrayList<String>();
 
       // Parses the details array
       int count = details == null ? 0 : details.length;
       for (int i = 0; i < count; i++) {
         String nodeName  = details[i].getLocalName();
         String nodeText  = getTextContent(details[i]);
 
         if ("KernelException".equals(nodeName) && "true".equals(nodeText)) {
           // Is a KernelException, parses it
           code = fault.getFaultCode();
         }
         if ("parameter".equals(nodeName)) {
           list.add(nodeText);
         }
         if ("pattern".equals(nodeName)) {
           pattern = nodeText;
         }
       }
 
       // If it is not a KernelException, uses a generic UNK000 code
       if (code == null) {
         log.debug("The exception " + e.getMessage()
           + " has been wrapped in a UNK000 exception", e);
         return new KernelException("UNK000", pattern, null, fault);
       }
 
       // Put the parsed parameters into an array
       params = new String[list.size()];
       list.toArray(params);
 
       return new KernelException(code, pattern, params, cause);
     }
 
     // It is an unknown RemoteException subclass, simply wraps it
     return new KernelException("UNK000", e.getMessage(), null, e);
   }
 
   /**
    * {@inheritDoc}
    */
   public KernelException toKernelException() {
     return this;
   }
 
   /**
    * Gets the text content of the specified node.
    *
    * @param node  The node to retrieve the text from
    * @return      The node text
    * @throws DOMException If an error occurs
    */
   private static String getTextContent(Node node) throws DOMException {
     StringBuffer sb = new StringBuffer();
     getTextContent(node, sb);
     return sb.toString();
   }
 
   /**
    * Gets the text content of the specified node.
    * <p>
    * If the node is of Text type, its value is returned. Otherwise, text content from
    * all its children nodes is concatenated into a single string.
    *
    * @param node  The node whose contents we must retrieve.
    * @param buf   The string buffer to write the result to
    * @throws DOMException If an error occurs
    */
   private static void getTextContent(Node node, StringBuffer buf) throws DOMException {
     if (node.getNodeType() == Node.TEXT_NODE) {
       buf.append(node.getNodeValue());
     }
 
     Node child = node.getFirstChild();
     while (child != null) {
       if (child.getNodeType() == Node.TEXT_NODE) {
         buf.append(child.getNodeValue());
       }
       child = child.getNextSibling();
     }
   }
 
   /**
    * Fixes the internal AxisFault detail list with the extensions of
    * KernelException.
    *
    * @param context The serialization context passed from the Axis servlet
    * @throws Exception if an error occurs while serializing the exception
    */
   @Override
   public void output(SerializationContext context) throws Exception {
     prepare();
     super.output(context);
   }
 
   /**
    * Inserts all non-standard field values as XML elements into the details
    * section of the SOAP exception.
    */
   @SuppressWarnings("unchecked")
   protected void prepare() {
     faultDetails = new Vector();
 
     setFaultString(getMessage());
 
     Element el;
 
     // Mark this exception as a KernelException instance
     el = XMLUtils.StringToElement(Constants.NS_URI_AXIS, "KernelException", "true");
     faultDetails.add(el);
 
     // Adds the list of parameters as standard Details elements
     int count = (params == null) ? 0 : params.length;
     for (int i = 0; i < count; i++) {
       el = XMLUtils.StringToElement(Constants.NS_URI_AXIS, "parameter",
                                     params[i] == null ? "null" : params[i].toString());
       faultDetails.add(el);
     }
 
     // Adds the pattern as a standard detail element
     el =  XMLUtils.StringToElement(Constants.NS_URI_AXIS, "pattern", getPattern());
     faultDetails.add(el);
 
     Throwable cause = getCause();
     if (cause != null) {
       // Put the exception class into the "exceptionName" element in the details.
       // This allows us to get back a correct Java Exception class on the other side
       // (assuming they have it available).
       el = XMLUtils.StringToElement(Constants.NS_URI_AXIS, "exceptionName",
                                             cause.getClass().getName());
 
       faultDetails.add(el);
 
       el =  XMLUtils.StringToElement(Constants.NS_URI_AXIS, "stackTrace",
                                      JavaUtils.stackToString(cause));
 
       faultDetails.add(el);
     }
   }
 
   /**
    * Stripped stacktrace.
    *
    * {@inheritDoc}
    */
   @Override public void printStackTrace(PrintWriter out) {
     synchronized (out) {
       out.println(this.getCode() + ": " + this.getMessage());
 
       Throwable cause = this.getCause();
       if (cause != null) {
         out.println("Caused By:");
         out.println(cause.toString());
       } else {
         cause = this;
       }
       StackTraceElement[] trace = cause.getStackTrace();
       int count = trace == null ? 0 : trace.length;
       int max = traceLength(trace);
       for (int i = 0; i < max; i++) {
         out.println("\tat " + trace[i]);
       }
       if (max < count) {
         out.println("\tat " + trace[max]);
         out.println("\t... [" + (count - max - 1) + " elements omitted]");
       }
     }
   }
 
   /**
    * Stripped stacktrace.
    *
    * {@inheritDoc}
    */
   @Override public void printStackTrace(PrintStream out) {
     synchronized (out) {
       out.println(this.getCode() + ": " + this.getMessage());
 
       Throwable cause = this.getCause();
       if (cause != null) {
         out.println("Caused By:");
         out.println(cause.toString());
       } else {
         cause = this;
       }
       StackTraceElement[] trace = cause.getStackTrace();
       int count = trace == null ? 0 : trace.length;
       int max = traceLength(trace);
       for (int i = 0; i < max; i++) {
         out.println("\tat " + trace[i]);
       }
       if (max < count) {
         out.println("\tat " + trace[max]);
         out.println("\t... [" + (count - max - 1) + " elements omitted]");
       }
     }
   }
 
   /**
    * Gets the number of elements of the specified stack trace to print.
    *
    * @param trace The elements to check
    * @return The number of elements to print
    */
   private static int traceLength(StackTraceElement[] trace) {
     int count = trace == null ? 0 : trace.length;
     boolean skip = false;
 
     for (int i = 0; i < count; i++) {
       String s = trace[i].getClassName() + '.' + trace[i].getMethodName();
 
       boolean match = excludePattern.matcher(s).matches();
       if (skip && match) {
         return i;
       } else if (!skip) {
         skip = !match;
       }
     }
 
     return count;
   }
 
   /**
    * Class exclussion pattern for stack traces.
    */
   private static Pattern excludePattern
     = Pattern.compile("(^(java\\.|javax\\.|sun\\.reflect\\.).+)"
                       + "|^(.+(\\.ApiProvider\\.invokeMethod))");
 
 }