/*

  * 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.lifecycle;

 import java.util.List;

 import java.util.concurrent.CopyOnWriteArrayList;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.faces.FacesException;

 import javax.faces.FactoryFinder;

 import javax.faces.application.ProjectStage;

 import javax.faces.context.FacesContext;

 import javax.faces.context.Flash;

 import javax.faces.event.ExceptionQueuedEvent;

 import javax.faces.event.ExceptionQueuedEventContext;

 import javax.faces.event.PhaseId;

 import javax.faces.event.PhaseListener;

 import javax.faces.lifecycle.ClientWindow;

 import javax.faces.lifecycle.ClientWindowFactory;

 import javax.faces.lifecycle.Lifecycle;

 import org.apache.myfaces.config.FacesConfigurator;

 import org.apache.myfaces.shared_impl.webapp.webxml.WebXml;

 import org.apache.myfaces.util.DebugUtils;

 /**

  * Implements the lifecycle as described in Spec. 1.0 PFD Chapter 2

  * 

  * @author Manfred Geiler (latest modification by $Author$)

  * @author Nikolay Petrov

  * @version $Revision$ $Date$

  */

 public class LifecycleImpl extends Lifecycle

 {

     //private static final Log log = LogFactory.getLog(LifecycleImpl.class);

     private static final Logger log = Logger.getLogger(LifecycleImpl.class.getName());

     /**

      * Boolean.TRUE is stored under this key in the application map if

      * the first request has been processed.

      */

     public static final String FIRST_REQUEST_PROCESSED_PARAM = "org.apache.myfaces.lifecycle.first.request.processed";

     private final PhaseExecutor[] lifecycleExecutors;

     private final PhaseExecutor renderExecutor;

     /**

      * Initially, for ensure thread safety we used synchronization blocks and a cached 

      * _phaseListenerArray and that works. The intention is ensure atomicity between

      * _phaseListenerList and _phaseListenerArray, but thinking more about it use

      * CopyOnWriteArrayList and do not use _phaseListenerArray is a lot better. 

      * 

      * Most times, we have few instances of PhaseListener registered, so the advantage of 

      * use _phaseListenerArray is overcome by do not have a synchronization block on getPhaseListeners().

      * Additionally, it is more often to perform traversals than insertions/removals and 

      * we can expect only 2 calls for getPhaseListeners() per request (so only two copy 

      * operations of a very small list).

      */

     private final List<PhaseListener> _phaseListenerList

             = new CopyOnWriteArrayList<PhaseListener>(); // new ArrayList();

     /**

      * This variable should be marked as volatile to ensure all threads can see it

      * after the first request is processed. Note that LifecycleImpl instance could be

      * shared by multiple requests at the same time, so this is relevant to prevent

      * multiple updates to FIRST_REQUEST_PROCESSED_PARAM. Really since the value

      * only changes from false to true, have a racy single check here does not harm, but

      * note in this case the semantic of the variable must be preserved.

      */

     private volatile boolean _firstRequestProcessed = false;

     /**

      * Lazy cache for returning _phaseListenerList as an Array.

      * 

      * Replaced by _phaseListenerList CopyOnWriteArrayList

      */

     //private PhaseListener[] _phaseListenerArray = null;

     private ClientWindowFactory clientWindowFactory;

     public LifecycleImpl()

     {

         // hide from public access

         lifecycleExecutors = new PhaseExecutor[] { new RestoreViewExecutor(), new ApplyRequestValuesExecutor(),

                 new ProcessValidationsExecutor(), new UpdateModelValuesExecutor(), new InvokeApplicationExecutor() };

         renderExecutor = new RenderResponseExecutor();

         clientWindowFactory = (ClientWindowFactory) FactoryFinder.getFactory(FactoryFinder.CLIENT_WINDOW_FACTORY);

     }

     @Override

     public void attachWindow(FacesContext facesContext)

     {

         ClientWindow clientWindow = facesContext.getExternalContext().getClientWindow();

         if (clientWindow == null)

         {

             clientWindow = getClientWindowFactory().getClientWindow(facesContext);

         }

         if (clientWindow != null)

         {

             clientWindow.decode(facesContext);

             facesContext.getExternalContext().setClientWindow(clientWindow);

         }

     }

     protected ClientWindowFactory getClientWindowFactory()

     {

         return clientWindowFactory;

     }

     @Override

     public void execute(FacesContext facesContext) throws FacesException

     {

         //try

         //{

             // check for updates of web.xml and faces-config descriptors 

             // only if project state is not production

             if(!facesContext.isProjectStage(ProjectStage.Production))

             {

                 WebXml.update(facesContext.getExternalContext());

                 new FacesConfigurator(facesContext.getExternalContext()).update();

             }

             PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, facesContext, getPhaseListeners());

             for (PhaseExecutor executor : lifecycleExecutors)

             {

                 if (executePhase(facesContext, executor, phaseListenerMgr))

                 {

                     return;

                 }

             }

         //}

         //catch (Throwable ex)

         //{

             // handle the Throwable accordingly. Maybe generate an error page.

             //ErrorPageWriter.handleThrowable(facesContext, ex);

         //}

     }

     private boolean executePhase(FacesContext context, PhaseExecutor executor, PhaseListenerManager phaseListenerMgr)

         throws FacesException

     {

         boolean skipFurtherProcessing = false;

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("entering " + executor.getPhase() + " in " + LifecycleImpl.class.getName());

         }

         PhaseId currentPhaseId = executor.getPhase();

         Flash flash = context.getExternalContext().getFlash();

         try

         {

             /* 

              * Specification, section 2.2

              * The default request lifecycle processing implementation must ensure that the currentPhaseId property 

              * of the FacesContext instance for this request is set with the proper PhaseId constant for the current 

              * phase as the first instruction at the beginning of each phase

              */

             context.setCurrentPhaseId(currentPhaseId);

             flash.doPrePhaseActions(context);

             // let the PhaseExecutor do some pre-phase actions

             executor.doPrePhaseActions(context);

             phaseListenerMgr.informPhaseListenersBefore(currentPhaseId);

             if (isResponseComplete(context, currentPhaseId, true))

             {

                 // have to return right away

                 return true;

             }

             if (shouldRenderResponse(context, currentPhaseId, true))

             {

                 skipFurtherProcessing = true;

             }

             if (executor.execute(context))

             {

                 return true;

             }

         }

         catch (Throwable e)

         {

             // JSF 2.0: publish the executor's exception (if any).

             publishException (e, currentPhaseId, context);

         }

         finally

         {

             phaseListenerMgr.informPhaseListenersAfter(currentPhaseId);

             flash.doPostPhaseActions(context);

         }

         context.getExceptionHandler().handle();

         if (isResponseComplete(context, currentPhaseId, false) || shouldRenderResponse(context, currentPhaseId, false))

         {

             // since this phase is completed we don't need to return right away even if the response is completed

             skipFurtherProcessing = true;

         }

         if (!skipFurtherProcessing && log.isLoggable(Level.FINEST))

         {

             log.finest("exiting " + executor.getPhase() + " in " + LifecycleImpl.class.getName());

         }

         return skipFurtherProcessing;

     }

     @Override

     public void render(FacesContext facesContext) throws FacesException

     {

         //try

         //{

             // if the response is complete we should not be invoking the phase listeners

             if (isResponseComplete(facesContext, renderExecutor.getPhase(), true))

             {

                 return;

             }

             if (log.isLoggable(Level.FINEST))

             {

                 log.finest("entering " + renderExecutor.getPhase() + " in " + LifecycleImpl.class.getName());

             }

             PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, facesContext, getPhaseListeners());

             Flash flash = facesContext.getExternalContext().getFlash();

             try

             {

                 facesContext.setCurrentPhaseId(renderExecutor.getPhase());

                 flash.doPrePhaseActions(facesContext);

                 // let the PhaseExecutor do some pre-phase actions

                 renderExecutor.doPrePhaseActions(facesContext);

                 phaseListenerMgr.informPhaseListenersBefore(renderExecutor.getPhase());

                 // also possible that one of the listeners completed the response

                 if (isResponseComplete(facesContext, renderExecutor.getPhase(), true))

                 {

                     return;

                 }

                 renderExecutor.execute(facesContext);

             }

             catch (Throwable e)

             {

                 // JSF 2.0: publish the executor's exception (if any).

                 publishException (e, renderExecutor.getPhase(), facesContext);

             }

             finally

             {

                 phaseListenerMgr.informPhaseListenersAfter(renderExecutor.getPhase());

                 flash.doPostPhaseActions(facesContext);

                 // publish a field in the application map to indicate

                 // that the first request has been processed

                 requestProcessed(facesContext);

             }

             facesContext.getExceptionHandler().handle();

             if (log.isLoggable(Level.FINEST))

             {

                 // Note: DebugUtils Logger must also be in trace level

                 DebugUtils.traceView("View after rendering");

             }

             if (log.isLoggable(Level.FINEST))

             {

                 log.finest("exiting " + renderExecutor.getPhase() + " in " + LifecycleImpl.class.getName());

             }

         //}

         //catch (Throwable ex)

         //{

             // handle the Throwable accordingly. Maybe generate an error page.

             //ErrorPageWriter.handleThrowable(facesContext, ex);

         //}

     }

     private boolean isResponseComplete(FacesContext facesContext, PhaseId phase, boolean before)

     {

         boolean flag = false;

         if (facesContext.getResponseComplete())

         {

             if (log.isLoggable(Level.FINE))

             {

                 log.fine("exiting from lifecycle.execute in " + phase

                         + " because getResponseComplete is true from one of the " + (before ? "before" : "after")

                         + " listeners");

             }

             flag = true;

         }

         return flag;

     }

     private boolean shouldRenderResponse(FacesContext facesContext, PhaseId phase, boolean before)

     {

         boolean flag = false;

         if (facesContext.getRenderResponse())

         {

             if (log.isLoggable(Level.FINE))

             {

                 log.fine("exiting from lifecycle.execute in " + phase

                         + " because getRenderResponse is true from one of the " + (before ? "before" : "after")

                         + " listeners");

             }

             flag = true;

         }

         return flag;

     }

     @Override

     public void addPhaseListener(PhaseListener phaseListener)

     {

         if (phaseListener == null)

         {

             throw new NullPointerException("PhaseListener must not be null.");

         }

         //synchronized (_phaseListenerList)

         //{

             _phaseListenerList.add(phaseListener);

             //_phaseListenerArray = null; // reset lazy cache array

         //}

     }

     @Override

     public void removePhaseListener(PhaseListener phaseListener)

     {

         if (phaseListener == null)

         {

             throw new NullPointerException("PhaseListener must not be null.");

         }

         //synchronized (_phaseListenerList)

         //{

             _phaseListenerList.remove(phaseListener);

             //_phaseListenerArray = null; // reset lazy cache array

         //}

     }

     @Override

     public PhaseListener[] getPhaseListeners()

     {

         //synchronized (_phaseListenerList)

         //{

             // (re)build lazy cache array if necessary

             //if (_phaseListenerArray == null)

             //{

             //    _phaseListenerArray = _phaseListenerList.toArray(new PhaseListener[_phaseListenerList.size()]);

             //}

             //return _phaseListenerArray;

         //}

         return _phaseListenerList.toArray(new PhaseListener[_phaseListenerList.size()]);

     }

     private void publishException (Throwable e, PhaseId phaseId, FacesContext facesContext)

     {

         ExceptionQueuedEventContext context = new ExceptionQueuedEventContext (facesContext, e, null, phaseId);

         facesContext.getApplication().publishEvent (facesContext, ExceptionQueuedEvent.class, context);

     }

     /**

      * This method places an attribute on the application map to 

      * indicate that the first request has been processed. This

      * attribute is used by several methods in ApplicationImpl 

      * to determine whether or not to throw an IllegalStateException

      * @param facesContext

      */

     private void requestProcessed(FacesContext facesContext)

     {

         if(!_firstRequestProcessed)

         {

             // The order here is important. First it is necessary to put

             // the value on application map before change the value here.

             // If multiple threads reach this point concurrently, the

             // variable will be written on the application map at the same

             // time but always with the same value.

             facesContext.getExternalContext().getApplicationMap()

                 .put(FIRST_REQUEST_PROCESSED_PARAM, Boolean.TRUE);

             _firstRequestProcessed = true;

         }        

     }

 }