/**
 * Copyright 2010 The Kuali Foundation Licensed under the
 * Educational Community 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.osedu.org/licenses/ECL-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.
 */

package org.kuali.student.common.util;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Constructor;
import java.util.Map;

import org.apache.log4j.Logger;
import org.springframework.aop.ThrowsAdvice;
import org.springframework.core.Ordered;

/**
 * @author Daniel Epstein
 *         <p>
 *         Use this Advice to map one exception to another for use when other
 *         advice eats your runtime exceptions outside of your code. This happens in
 *         Transactions when commit is not called until outside of your DAO
 *         layer.
 *         </p>
 * 
 * <p>
 * Set the property "exceptionMapping" as a map that maps an exception class to
 * your own exception class
 * </p>
 * 
 * <p>
 * Remember that aspect order is important and that this bean will always be
 * order "500"
 * </p>
 * 
 * Example:
 * 
 * <pre>
 * &lt;tx:annotation-driven transaction-manager=&quot;JtaTxManager&quot; order=&quot;1000&quot;/&gt;
 * lt;bean id=&quot;mapExceptionAdvisor&quot;
 * class=&quot;org.myfoo.ExceptionMappingAdvice&quot;&gt;
 * &lt;property name=&quot;exceptionMapping&quot;&gt;
 *      &lt;map&gt;
 *              &lt;entry key=&quot;javax.persistence.EntityExistsException&quot;
 *                      value=&quot;org.myfoo.exceptions.AlreadyExistsException&quot; /&gt;
 *      &lt;/map&gt;
 * &lt;/property&gt;
 * lt;/bean&gt;
 * lt;aop:config&gt;
 * &lt;aop:aspect id=&quot;dataAccessToBusinessException&quot;
 *      ref=&quot;mapExceptionAdvisor&quot;&gt;
 *      &lt;aop:after-throwing
 *              pointcut=&quot;execution(* org.myfoo.service.*.*(..))&quot;
 *              method=&quot;afterThrowing&quot; throwing=&quot;ex&quot; /&gt;
 * &lt;/aop:aspect&gt;
 * lt;/aop:config&gt;
 * </pre>
 */
public class ExceptionMappingAdvice implements ThrowsAdvice, Ordered {
        private int order = 500;
        private static final long serialVersionUID = 1L;
        private Map<Class<? extends Exception>, Class<? extends Exception>> exceptionMapping;
        private Class<? extends Exception> defaultException;
        final Logger logger = Logger.getLogger(ExceptionMappingAdvice.class);

        /**
         * This method will use the real exception thrown and look up the exception
         * that should be thrown
         * 
         * @param ex
         * @throws Exception
         */
        public void afterThrowing(Exception ex) throws Exception {
                Class<? extends Exception> mappedExceptionClass = exceptionMapping
                                .get(ex.getClass());

                if (mappedExceptionClass != null) {
            if (logger.isDebugEnabled()) {
                logger.debug(String.format("Mapping exception %s to %s", ex.getClass(), mappedExceptionClass));
            }
            Constructor<? extends Exception> c = mappedExceptionClass
                                        .getConstructor(String.class);
            throw c.newInstance(ex.getMessage());
                }
                
                //Throw a default exception if this is a runtime exception
                if(ex instanceof RuntimeException){
                        logger.trace("No mapping available, throwing default exception "+defaultException);
                        if (defaultException != null) {
                                //Log the error
                                StringWriter traceWriter = new StringWriter();
                                PrintWriter printWriter = new PrintWriter(traceWriter, false);
                                logger.error(printWriter, ex);
                                printWriter.close();
                                String faultMessage = traceWriter.getBuffer().toString();
                                logger.error(faultMessage);
                                //Throw the default exception
                                try{
                                        Constructor<? extends Exception> c = defaultException
                                                        .getConstructor(String.class, Throwable.class);
                                        throw c.newInstance(ex.getMessage(), ex);
                                }catch(NoSuchMethodException e){
                                        Constructor<? extends Exception> c = defaultException
                                                        .getConstructor(String.class);
                                        throw c.newInstance(ex.getMessage());
                                }
                        }
                        //Check if no default was defined
            if (logger.isDebugEnabled()) {
                logger.debug(String.format("No mapping or default exception available. Exception %s", ex.getClass()));
            }
            throw new RuntimeException("Could Not Map Exception: " + ex.toString());
                }
        }

        @Override
        public int getOrder() {
                return order;
        }

        /**
         * @param order
         *            the order to set
         */
        public void setOrder(int order) {
                this.order = order;
        }

        /**
         * @return the exceptionMapping
         */
        public Map<Class<? extends Exception>, Class<? extends Exception>> getExceptionMapping() {
                return exceptionMapping;
        }

        /**
         * @param exceptionMapping
         *            the exceptionMapping to set
         */
        public void setExceptionMapping(
                        Map<Class<? extends Exception>, Class<? extends Exception>> exceptionMapping) {
                this.exceptionMapping = exceptionMapping;
        }

        /**
         * @return the defaultException
         */
        public Class<? extends Exception> getDefaultException() {
                return defaultException;
        }

        /**
         * @param defaultException
         *            the defaultException to set
         */
        public void setDefaultException(Class<? extends Exception> defaultException) {
                this.defaultException = defaultException;
        }

}