package com.explosion.utilities.exception;
   
   /*
    * =============================================================================
    * 
    * Copyright 2004 Stephen Cowx
    * 
    * Licensed under the Apache License, Version 2.0 (the "License"); you may not
    * use this file except in compliance with the License. You may obtain a copy of
   * the License at
   * 
   * http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
   * License for the specific language governing permissions and limitations under
   * the License.
   * 
   * =============================================================================
   */
  
  import java.io.CharArrayWriter;
  import java.io.PrintStream;
  import java.io.PrintWriter;
  
  import org.apache.log4j.LogManager;
  import org.apache.log4j.Logger;
  
  import com.explosion.utilities.GeneralConstants;
  
  /***
   * This is a generic wrapper exception which can be used for multiple purposes
   * There is an ability to specify a code if need be
   */
  
  public class EnhancedException extends Exception
  {
  
      private static Logger log = LogManager.getLogger(EnhancedException.class);
  
      private Exception originalException;
  
      private String originalStackTrace = "";
  
      private int exceptionSeverity;
  
      private int exceptionCode;
  
      private String message;
  
      private Object params[];
  
      public EnhancedException()
      {}
  
      public EnhancedException(String message, Exception originalException)
      {
          this.message = message;
          setOriginalException(originalException);
      }
      
      public EnhancedException(String message)
      {
          this.message = message;
      }
      
      public String getMessage()
      {
          return message;
      }
  
      public void setMessage(String message)
      {
          this.message = message;
      }
  
      public int getExceptionSeverity()
      {
          return exceptionSeverity;
      }
  
      public void setExceptionSeverity(int exceptionSeverity)
      {
          this.exceptionSeverity = exceptionSeverity;
      }
  
      public int getExceptionCode()
      {
          return exceptionCode;
      }
  
      public void setExceptionCode(int exceptionCode)
      {
          this.exceptionCode = exceptionCode;
      }
  
      public void setOriginalException(Exception originalException)
      {
         this.originalStackTrace = getStackTrace(originalException);
         this.originalException = originalException;
 
         if (message == null) message = "";
 
         setMessage(message + originalException.getMessage());
     }
 
     public Exception getOriginalException()
     {
         return originalException;
     }
 
     /***
      * This method returns the message and the first line of the stack trace.
      */
     public String toString()
     {
         String message = "";
         if (originalException == null)
         {
             message = getMessage();
         } else
         {
             int i = originalStackTrace.indexOf(GeneralConstants.LS);
 
             if (i > 0)
                 message = originalStackTrace.substring(0, i);
             else
                 message = originalStackTrace;
 
             if (getMessage() != null) message = getMessage() + GeneralConstants.LS + message;
 
         }
 
         return message;
     }
 
     /***
      * This method returns the stack trace of the original exception combined
      * with the message used when the CodedException was created.
      */
     private String getCombinedStackTrace() throws Exception
     {
         if (originalException == null)
         {
             return getStackTrace(this);
         } else
         {
             if (getMessage() != null)
                 return getMessage() + GeneralConstants.LS + originalStackTrace;
             else
                 return originalStackTrace;
         }
     }
 
     /***
      * Handy method which returns the Stack trace of an exception
      */
     public static String getStackTrace(Throwable ex)
     {
         try
         {
             CharArrayWriter charWriter = new CharArrayWriter();
             PrintWriter writer = new PrintWriter(charWriter);
             ex.printStackTrace(writer);
             writer.flush();
 
             String value = new String(charWriter.toCharArray());
             writer.close();
 
             return value;
         } catch (Exception e)
         {
             return "Error occurred while parsing stack trace !";
         }
     }
 
     /***
      * Override of superclass
      */
     public void printStackTrace(PrintStream s)
     {
         if (originalException == null)
             super.printStackTrace(s);
         else
             try
             {
                 s.println(getCombinedStackTrace());
             } catch (Exception e)
             {}
     }
 
     /***
      * Override of superclass
      */
     public void printStackTrace(PrintWriter s)
     {
         if (originalException == null)
             super.printStackTrace(s);
         else
             try
             {
                 s.println(getCombinedStackTrace());
             } catch (Exception e)
             {}
     }
 
     /***
      * Override of superclass
      */
     public void printStackTrace()
     {
         if (originalException == null)
             super.printStackTrace();
         else
             try
             {
                 log.debug(getCombinedStackTrace());
             } catch (Exception e)
             {}
     }
 
 }