package fr.ifremer.quadrige2.ui.swing.common;
   
   /*-
    * #%L
    * Quadrige2 Core :: Quadrige2 UI Common
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2017 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * 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 Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  
  import fr.ifremer.quadrige2.ui.swing.common.action.AbstractAction;
  import jaxx.runtime.swing.JAXXRuntimeException;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.nuiton.jaxx.application.ApplicationTechnicalException;
  import org.nuiton.jaxx.application.swing.action.ApplicationActionException;
  import org.springframework.security.access.AccessDeniedException;
  import org.springframework.security.core.AuthenticationException;
  
  import java.lang.reflect.InvocationTargetException;
  
  /**
   * <p>ExceptionHandler class.</p>
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   */
  public class ExceptionHandler implements Thread.UncaughtExceptionHandler {
  
      private static final Log LOG = LogFactory.getLog(ExceptionHandler.class);
  
      /** {@inheritDoc} */
      @Override
      public void uncaughtException(Thread t, Throwable ex) {
          handleException(t.getName(), ex);
      }
  
      /**
       * <p>handle.</p>
       *
       * @param thrown a {@link java.lang.Throwable} object.
       */
      public void handle(Throwable thrown) {
          // for EDT exceptions
          handleException(Thread.currentThread().getName(), thrown);
      }
  
      /**
       * <p>handleException.</p>
       *
       * @param tname a {@link java.lang.String} object.
       * @param ex a {@link java.lang.Throwable} object.
       */
      protected void handleException(String tname, Throwable ex) {
          Throwable cause = ex;
  
          // if exception coming from reflection, try to get the target exception
          while (cause.getCause() instanceof InvocationTargetException) {
              // try to get inner comprehensive cause
              cause = cause.getCause();
          }
          if (cause instanceof InvocationTargetException) {
              cause = ((InvocationTargetException) cause).getTargetException();
          }
  
          // threat ApplicationActionException inner exception
          if (cause instanceof ApplicationActionException) {
              ApplicationActionException actionException = (ApplicationActionException) cause;
              Throwable innerException = actionException.getCause();
  
              // if inner exception is already managed by the action, avoid it
              if (actionException.getAction() instanceof AbstractAction
                  && (innerException instanceof AuthenticationException
                  || innerException instanceof AccessDeniedException)) {
                  return;
              }
  
              // try to get next exception
              cause = innerException;
          } else {
              // ApplicationActionException already logged, but log all others
              if (LOG.isErrorEnabled()) {
                  LOG.error("Global application exception [" + tname + "]", cause);
              }
 
         }
         // default exception message
         String message = cause.getMessage();
 
         if (cause instanceof ApplicationTechnicalException) {
             cause = cause.getCause();
         }
 
         if (cause instanceof JAXXRuntimeException) {
             cause = cause.getCause();
             message = cause.getMessage();
         }
 
         // TODO à tester
         ApplicationUIContext.getInstance().getErrorHelper().showErrorDialog(message, cause);
 //        JOptionPane.showMessageDialog(null, message, "Global application exception", JOptionPane.ERROR_MESSAGE);
 
     }
 }