/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  package org.apache.myfaces.context;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Queue;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.faces.FacesException;
  import javax.faces.application.ProjectStage;
  import javax.faces.component.UIComponent;
  import javax.faces.context.ExceptionHandler;
  import javax.faces.context.ExceptionHandlerWrapper;
  import javax.faces.context.FacesContext;
  import javax.faces.event.AbortProcessingException;
  import javax.faces.event.ExceptionQueuedEvent;
  import javax.faces.event.ExceptionQueuedEventContext;
  import javax.faces.event.SystemEvent;
  import javax.servlet.http.HttpServletResponse;
  
  import org.apache.myfaces.lifecycle.ViewNotFoundException;
  import org.apache.myfaces.renderkit.ErrorPageWriter;
  import org.apache.myfaces.shared.util.WebConfigParamUtils;
  import org.apache.myfaces.spi.WebConfigProvider;
  import org.apache.myfaces.spi.WebConfigProviderFactory;
  
  /**
   * Extended MyFaces-specific ExceptionHandler implementation. 
   * 
   * @author Leonardo Uribe
   *
   */
  public class MyFacesExceptionHandlerWrapperImpl extends ExceptionHandlerWrapper
  {
      private static final Logger log = Logger.getLogger(MyFacesExceptionHandlerWrapperImpl.class.getName());
      
      private Queue<ExceptionQueuedEvent> handled;
      private Queue<ExceptionQueuedEvent> unhandled;
      private ExceptionQueuedEvent handledAndThrown;
  
      
      private ExceptionHandler _delegate;
      private boolean _isErrorPagePresent;
      private boolean _useMyFacesErrorHandling;
      private boolean _inited;
  
      public MyFacesExceptionHandlerWrapperImpl(ExceptionHandler delegate)
      {
          this._delegate = delegate;
          this._inited = false;
      }
      
      protected void init()
      {
          if (!_inited)
          {
              FacesContext facesContext = FacesContext.getCurrentInstance();
              WebConfigProvider webConfigProvider = WebConfigProviderFactory.getWebConfigProviderFactory(
                      facesContext.getExternalContext()).getWebConfigProvider(facesContext.getExternalContext());
      
              _isErrorPagePresent = webConfigProvider.isErrorPagePresent(facesContext.getExternalContext());
              _useMyFacesErrorHandling = WebConfigParamUtils.getBooleanInitParameter(facesContext.getExternalContext(),
                      ErrorPageWriter.ERROR_HANDLING_PARAMETER, facesContext.isProjectStage(ProjectStage.Development));
              _inited = true;
          }
      }
      
      protected void init(FacesContext facesContext)
      {
          if (!_inited)
          {
              if (facesContext == null)
              {
                  facesContext = FacesContext.getCurrentInstance();
              }
              WebConfigProvider webConfigProvider = WebConfigProviderFactory.getWebConfigProviderFactory(
                      facesContext.getExternalContext()).getWebConfigProvider(facesContext.getExternalContext());
      
              _isErrorPagePresent = webConfigProvider.isErrorPagePresent(facesContext.getExternalContext());
             _useMyFacesErrorHandling = WebConfigParamUtils.getBooleanInitParameter(facesContext.getExternalContext(),
                     ErrorPageWriter.ERROR_HANDLING_PARAMETER, facesContext.isProjectStage(ProjectStage.Development));
             _inited = true;
         }
     }
     
     protected void init(SystemEvent exceptionQueuedEvent)
     {
         if (!_inited)
         {
             if (exceptionQueuedEvent instanceof ExceptionQueuedEvent)
             {
                 ExceptionQueuedEvent eqe = (ExceptionQueuedEvent)exceptionQueuedEvent;
                 ExceptionQueuedEventContext eqec = eqe.getContext();
                 if (eqec != null)
                 {
                     FacesContext facesContext = eqec.getContext();
                     if (facesContext != null)
                     {
                         init(facesContext);
                         return;
                     }
                 }
             }
             init(FacesContext.getCurrentInstance());
         }
     }
     
     protected boolean isUseMyFacesErrorHandling()
     {
         return _useMyFacesErrorHandling;
     }
     
     protected boolean isErrorPagePresent()
     {
         return _isErrorPagePresent;
     }
     
     /**
      * {@inheritDoc}
      */
     @Override
     public ExceptionQueuedEvent getHandledExceptionQueuedEvent()
     {
         init();
         if (!isUseMyFacesErrorHandling())
         {
             return super.getHandledExceptionQueuedEvent();
         }
         else
         {
             return handledAndThrown;
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Iterable<ExceptionQueuedEvent> getHandledExceptionQueuedEvents()
     {
         init();
         if (!isUseMyFacesErrorHandling())
         {
             return super.getHandledExceptionQueuedEvents();
         }
         else
         {
             return handled == null ? Collections.<ExceptionQueuedEvent>emptyList() : handled;
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Iterable<ExceptionQueuedEvent> getUnhandledExceptionQueuedEvents()
     {
         init();
         if (!isUseMyFacesErrorHandling())
         {
             return super.getUnhandledExceptionQueuedEvents();
         }
         else
         {
             return unhandled == null ? Collections.<ExceptionQueuedEvent>emptyList() : unhandled;
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void handle() throws FacesException
     {
         init();
         if (!isUseMyFacesErrorHandling())
         {
             if (isErrorPagePresent())
             {
                 FacesContext facesContext = FacesContext.getCurrentInstance();
                 // save current view in the request map to access it on the error page
                 facesContext.getExternalContext().getRequestMap().put(ErrorPageWriter.VIEW_KEY,
                                                                       facesContext.getViewRoot());
             }
             try
             {
                 super.handle();
             }
             catch (FacesException e)
             {
                 FacesContext facesContext = FacesContext.getCurrentInstance();
                 if (e.getCause() instanceof ViewNotFoundException)
                 {
                     facesContext.getExternalContext().setResponseStatus(HttpServletResponse.SC_NOT_FOUND);
                 }
                 else
                 {
                     facesContext.getExternalContext().setResponseStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                 }
                 throw e;
             }
             return;
         }
         else
         {
             if (unhandled != null && !unhandled.isEmpty())
             {
                 if (handled == null)
                 {
                     handled = new LinkedList<ExceptionQueuedEvent>();
                 }
                 
                 List<Throwable> throwableList = new ArrayList<Throwable>();
                 List<UIComponent> components = new ArrayList<UIComponent>();
                 FacesContext facesContext = null;
                 
                 do
                 {
                     // For each ExceptionEvent in the list
                     
                     // get the event to handle
                     ExceptionQueuedEvent event = unhandled.peek();
                     try
                     {
                         // call its getContext() method
                         ExceptionQueuedEventContext context = event.getContext();
     
                         if (facesContext == null)
                         {
                             facesContext = event.getContext().getContext();
                         }
                         
                         // and call getException() on the returned result
                         Throwable exception = context.getException();
                         
                         // Upon encountering the first such Exception that is not an instance of
                         // javax.faces.event.AbortProcessingException
                         if (!shouldSkip(exception))
                         {
                             // set handledAndThrown so that getHandledExceptionQueuedEvent() returns this event
                             handledAndThrown = event;
                             
                             Throwable rootCause = getRootCause(exception);
                             
                             throwableList.add(rootCause == null ? exception : rootCause);
                             components.add(event.getContext().getComponent());
                             
                             //break;
                         }
                         else
                         {
                             // Testing mojarra it logs a message and the exception
                             // however, this behaviour is not mentioned in the spec
                             log.log(Level.SEVERE, exception.getClass().getName() + " occured while processing " +
                                     (context.inBeforePhase() ? "beforePhase() of " : 
                                             (context.inAfterPhase() ? "afterPhase() of " : "")) + 
                                     "phase " + context.getPhaseId() + ": " +
                                     "UIComponent-ClientId=" + 
                                     (context.getComponent() != null ? 
                                             context.getComponent().getClientId(context.getContext()) : "") + ", " +
                                     "Message=" + exception.getMessage());
                             
                             log.log(Level.SEVERE, exception.getMessage(), exception);
                         }
                     }
                     finally
                     {
                         // if we will throw the Exception or if we just logged it,
                         // we handled it in either way --> add to handled
                         handled.add(event);
                         unhandled.remove(event);
                     }
                 } while (!unhandled.isEmpty());
 
                 if (facesContext == null)
                 {
                     facesContext = FacesContext.getCurrentInstance();
                 }
                 if (throwableList.size() == 1)
                 {
                     ErrorPageWriter.handle(facesContext, components, throwableList.get(0));
                 }
                 else if (throwableList.size() > 1)
                 {
                     ErrorPageWriter.handle(facesContext, components,
                                            throwableList.toArray(new Throwable[throwableList.size()]));
                 }
             }
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void processEvent(SystemEvent exceptionQueuedEvent) throws AbortProcessingException
     {
         init(exceptionQueuedEvent);
         
         if (!isUseMyFacesErrorHandling())
         {
             super.processEvent(exceptionQueuedEvent);
         }
         else
         {
             if (unhandled == null)
             {
                 unhandled = new LinkedList<ExceptionQueuedEvent>();
             }
             
             unhandled.add((ExceptionQueuedEvent)exceptionQueuedEvent);
         }
     }
 
     protected Throwable getRethrownException(Throwable exception)
     {
         // Let toRethrow be either the result of calling getRootCause() on the Exception, 
         // or the Exception itself, whichever is non-null
         Throwable toRethrow = getRootCause(exception);
         if (toRethrow == null)
         {
             toRethrow = exception;
         }
         
         return toRethrow;
     }
     
     protected FacesException wrap(Throwable exception)
     {
         if (exception instanceof FacesException)
         {
             return (FacesException) exception;
         }
         return new FacesException(exception);
     }
     
     protected boolean shouldSkip(Throwable exception)
     {
         return exception instanceof AbortProcessingException;
     }
     
     @Override
     public ExceptionHandler getWrapped()
     {
         return _delegate;
     }
 }