/*
    * 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.view.facelets;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  import javax.faces.application.Application;
  import javax.faces.application.NavigationHandler;
  import javax.faces.application.ProjectStage;
  import javax.faces.application.ResourceDependency;
  import javax.faces.application.ViewHandler;
  import javax.faces.component.UIComponent;
  import javax.faces.component.UIViewRoot;
  import javax.faces.context.FacesContext;
  import javax.faces.event.PhaseId;
  import javax.faces.view.StateManagementStrategy;
  import javax.faces.view.ViewDeclarationLanguage;
  import org.apache.myfaces.application.StateManagerImpl;
  import org.apache.myfaces.component.ComponentResourceContainer;
  import org.apache.myfaces.context.RequestViewContext;
  import org.apache.myfaces.context.RequestViewMetadata;
  import org.apache.myfaces.lifecycle.DefaultRestoreViewSupport;
  import org.apache.myfaces.lifecycle.RestoreViewSupport;
  import org.apache.myfaces.shared.config.MyfacesConfig;
  import org.apache.myfaces.shared.util.WebConfigParamUtils;
  import org.apache.myfaces.view.facelets.impl.FaceletCompositionContextImpl;
  import org.apache.myfaces.view.facelets.pool.ViewPool;
  import org.apache.myfaces.view.facelets.pool.ViewPoolFactory;
  import org.apache.myfaces.view.facelets.pool.ViewEntry;
  import org.apache.myfaces.view.facelets.pool.ViewStructureMetadata;
  import org.apache.myfaces.view.facelets.pool.impl.ViewPoolFactoryImpl;
  import org.apache.myfaces.view.facelets.tag.jsf.ComponentSupport;
  import org.apache.myfaces.view.facelets.tag.jsf.FaceletState;
  
  /**
   * This class is reponsible for all processing tasks related to the view pool.
   * 
   * For enable the pool only for a subset of your views, you can
   * add an entry inside faces-config.xml file like this:
   * <pre>
   * {@code 
   * <faces-config-extension>
   *   <view-pool-mapping>
   *      <url-pattern>/*</url-pattern>
   *      <parameter>
   *          <name>org.apache.myfaces.VIEW_POOL_MAX_POOL_SIZE</name>
   *          <value>5</value>
   *      </parameter>
   *  </view-pool-mapping>
   * </faces-config-extension>
   * }
   * </pre>
   * 
   * @author Leonardo Uribe
   */
  public class ViewPoolProcessor
  {
      /**
       * Used to hold the view pool processor instance on the application map. 
       * A ViewPoolProcessor is only accessible if the view pool has been
       * enabled for the whole application (using a web config parameter) or 
       * partially (an &lt;view-pool-mapping&gt; entry inside &lt;faces-config-extension&gt;).
       */
      private final static String INSTANCE = "oam.ViewPoolProcessor";
      
      /**
       * UIViewRoot attribute to enable/disable the view for use pooling.
       */
      public final static String ENABLE_VIEW_POOL = "oamEnableViewPool";
      
      /**
       * Flag that indicates to the StateManagementStrategy that no state needs 
       * to be stored and we are using saveState() to dispose the view and store it
       * into the pool directly.
       */
      public final static String FORCE_HARD_RESET = "oam.ViewPool.forceHardReset";
      
      /**
       * Flag to indicate that dispose this view on navigation is valid.
      */
     public final static String DISPOSE_VIEW_NAVIGATION = "oam.ViewPool.disposeViewOnNavigation";
     
     /**
      * Attribute of UIViewRoot that indicates if a soft (1) or hard(2) 
      * (reset and check) reset is required in the call to saveState().
      */
     public final static String RESET_SAVE_STATE_MODE_KEY ="oam.view.resetSaveStateMode";
     
     /**
      * Indicates no reset should be done on this state saving
      */
     public static final int RESET_MODE_OFF = 0;
     
     /**
      * Indicates a soft reset should be done when saveState(...) is performed,
      * which means all transient state should be cleared but the delta state 
      * should not be destroyed in the process.
      */
     public static final int RESET_MODE_SOFT = 1;
     
     /**
      * Indicates a hard reset should be done when saveState(...) is performed,
      * which means all transient and delta state should be cleared, destroying
      * all existing state in the process. If something cannot be reseted, the 
      * state should return non null, so the algorithm can remove the component
      * from the tree and mark the tree as partial (requires refresh before
      * reuse).
      */
     public static final int RESET_MODE_HARD = 2;
     
     /**
      * Param used to indicate a "deferred navigation" needs to be done. To allow the view pool to
      * dispose the view properly (and reuse it later), it is necessary to ensure the view is not
      * being used at the moment. If the navigation call occur inside an action listener, the current
      * view is being used and cannot be disposed (because it conflicts with hard/soft reset). This
      * extension allows to call handleNavigation() before end invoke application phase, but after
      * traverse the component tree. 
      */
     public static final String INVOKE_DEFERRED_NAVIGATION = "oam.invoke.navigation";
 
     private ViewPoolFactory viewPoolFactory;
     private RestoreViewSupport restoreViewSupport;
     
     public ViewPoolProcessor(FacesContext context)
     {
         viewPoolFactory = new ViewPoolFactoryImpl(context);
         restoreViewSupport = new DefaultRestoreViewSupport(context);
     }
     
     public static ViewPoolProcessor getInstance(FacesContext context)
     {
         return (ViewPoolProcessor) context.getExternalContext().
                 getApplicationMap().get(INSTANCE);
     }
     
     /**
      * This method should be called at startup to decide if a view processor should be
      * provided or not to the runtime.
      * 
      * @param context 
      */
     public static void initialize(FacesContext context)
     {
         if (context.isProjectStage(ProjectStage.Production))
         {
             boolean initialize = true;
             String elMode = WebConfigParamUtils.getStringInitParameter(
                         context.getExternalContext(),
                         FaceletCompositionContextImpl.INIT_PARAM_CACHE_EL_EXPRESSIONS, 
                             ELExpressionCacheMode.noCache.name());
             if (!elMode.equals(ELExpressionCacheMode.alwaysRecompile.name()))
             {
                 Logger.getLogger(ViewPoolProcessor.class.getName()).log(
                     Level.INFO, FaceletCompositionContextImpl.INIT_PARAM_CACHE_EL_EXPRESSIONS +
                     " web config parameter is set to \"" + ( (elMode == null) ? "none" : elMode) +
                     "\". To enable view pooling this param"+
                     " must be set to \"alwaysRecompile\". View Pooling disabled.");
                 initialize = false;
             }
             
             long refreshPeriod = WebConfigParamUtils.getLongInitParameter(context.getExternalContext(),
                     FaceletViewDeclarationLanguage.PARAMS_REFRESH_PERIOD,
                     FaceletViewDeclarationLanguage.DEFAULT_REFRESH_PERIOD_PRODUCTION);
 
             if (refreshPeriod != -1)
             {
                 Logger.getLogger(ViewPoolProcessor.class.getName()).log(
                     Level.INFO, ViewHandler.FACELETS_REFRESH_PERIOD_PARAM_NAME +
                     " web config parameter is set to \"" + Long.toString(refreshPeriod) +
                     "\". To enable view pooling this param"+
                     " must be set to \"-1\". View Pooling disabled.");
                 initialize = false;
             }
             
             if (MyfacesConfig.getCurrentInstance(context.getExternalContext()).isStrictJsf2FaceletsCompatibility())
             {
                 Logger.getLogger(ViewPoolProcessor.class.getName()).log(
                     Level.INFO, MyfacesConfig.INIT_PARAM_STRICT_JSF_2_FACELETS_COMPATIBILITY +
                     " web config parameter is set to \"" + "true" +
                     "\". To enable view pooling this param "+
                     " must be set to \"false\". View Pooling disabled.");
                 initialize = false;
             }
             
             if (initialize)
             {
                 ViewPoolProcessor processor = new ViewPoolProcessor(context);
                 context.getExternalContext().
                     getApplicationMap().put(INSTANCE, processor);
             }
         }
     }
 
     public ViewPool getViewPool(FacesContext context, UIViewRoot root)
     {
         if (root.isTransient())
         {
             // Stateless views cannot be pooled, because we are reusing
             // state saving algorithm for that.
             return null;
         }
         Boolean enableViewPool = (Boolean) root.getAttributes().get(ViewPoolProcessor.ENABLE_VIEW_POOL);
         if (enableViewPool != null && !Boolean.TRUE.equals(enableViewPool))
         {
             // view pool not enabled for this view.
             return null;
         }
         else
         {
             return viewPoolFactory.getViewPool(context, root);
         }
     }
     
     public boolean isViewPoolEnabledForThisView(FacesContext context, UIViewRoot root)
     {
         if (root.isTransient())
         {
             // Stateless views cannot be pooled, because we are reusing
             // state saving algorithm for that.
             return false;
         }
         Boolean enableViewPool = (Boolean) root.getAttributes().get(ViewPoolProcessor.ENABLE_VIEW_POOL);
         if (enableViewPool != null)
         {
             if (Boolean.TRUE.equals(enableViewPool))
             {
                 return true;
             }
             else
             {
                 return false;
             }
         }
         else
         {
             ViewPool viewPool = getViewPool(context, root);
             if (viewPool != null)
             {
                 return true;
             }
         }
         return false;
     }
 
     public boolean isViewPoolStrategyAllowedForThisView(FacesContext context, UIViewRoot root)
     {
         // Check if the viewId is not null.
         if (root.getViewId() == null)
         {
             return false;
         }
         if (root.isTransient())
         {
             // Stateless views cannot be pooled, because we are reusing
             // state saving algorithm for that.
             return false;
         }
         
         // Check if the view is enabled or not for use pooling
         if (!isViewPoolEnabledForThisView(context, root))
         {
             return false;
         }
 
         // Check if the vdl is using PSS on this view (has a vdl and that vdl is facelets)
         ViewDeclarationLanguage vdl = context.getApplication().getViewHandler().
             getViewDeclarationLanguage(context, root.getViewId());
         if (vdl == null)
         {
             return false;
         }
         else if (!ViewDeclarationLanguage.FACELETS_VIEW_DECLARATION_LANGUAGE_ID.equals(vdl.getId()))
         {
             return false;
         }
         
         if (vdl.getStateManagementStrategy(context, root.getViewId()) == null)
         {
             return false;
         }
         return true;
     }
 
     public void setViewPoolDisabledOnThisView(FacesContext context, UIViewRoot root, boolean value)
     {
         root.getAttributes().put(ViewPoolProcessor.ENABLE_VIEW_POOL, !value);
     }
     
     /**
      * Takes the newView and restore the state taken as base the provided ViewEntry,
      * and then move all child components from oldView to newView, to finally obtain
      * a clean component tree.
      * 
      * @param context
      * @param newView
      * @param entry 
      */
     public void cloneAndRestoreView(FacesContext context, UIViewRoot newView, 
             ViewEntry entry, ViewStructureMetadata metadata)
     {
         UIViewRoot oldView = entry.getViewRoot();
         // retrieveViewRootInitialState(context, oldView)
         Object viewState = metadata.getViewRootState();
         Object newViewState;
         UIComponent metadataFacet = newView.getFacet(UIViewRoot.METADATA_FACET_NAME);
         if (viewState == null)
         {
             // (Optional, it should be always metadata)
             oldView.clearInitialState();
             viewState = oldView.saveState(context);
         }
         Map<String, Object> viewScopeMap = newView.getViewMap(false);
         if (viewScopeMap != null && !viewScopeMap.isEmpty())
         {
             newViewState = newView.saveState(context);
         }
         else
         {
             newViewState = null;
         }
         
         boolean oldProcessingEvents = context.isProcessingEvents();
         context.setProcessingEvents(false);
         try
         {
             if (oldView.getFacetCount() > 0)
             {
                 List<String> facetKeys = new ArrayList<String>();
                 facetKeys.addAll(oldView.getFacets().keySet());
                 for (String facetKey : facetKeys)
                 {
                     //context.setProcessingEvents(false);
                     if (metadataFacet != null && UIViewRoot.METADATA_FACET_NAME.equals(facetKey) &&
                         !PhaseId.RESTORE_VIEW.equals(context.getCurrentPhaseId()))
                     {
                         // Metadata facet is special, it is created when ViewHandler.createView(...) is
                         // called, so it shouldn't be taken from the oldView, otherwise the state
                         // will be lost. Instead reuse it and discard the one in oldView.
                         // But on restore view phase, use the old one, because the new one does not
                         // have initial state marked.
                         newView.getFacets().put(facetKey, metadataFacet);
                     }
                     else
                     {
                         UIComponent facet = oldView.getFacets().remove(facetKey);
                         //context.setProcessingEvents(true);
                         newView.getFacets().put(facetKey, facet);
                     }
                 }
             }
             if (oldView.getChildCount() > 0)
             {
                 for (Iterator<UIComponent> it = oldView.getChildren().iterator(); it.hasNext();)
                 {
                     //context.setProcessingEvents(false);
                     UIComponent c = it.next();
                     it.remove();
                     //context.setProcessingEvents(true);
                     newView.getChildren().add(c);
                 }
             }
             
             // Restore the newView as saved just before markInitialState() call
             newView.restoreState(context, viewState);
             newView.markInitialState();
             
             if (!PhaseId.RESTORE_VIEW.equals(context.getCurrentPhaseId()))
             {
                 // Restore bindings like in restore view phase, because in this case,
                 // bindings needs to be set (Application.createComponent is not called!).
                 restoreViewSupport.processComponentBinding(context, newView);
                 
                 // Restore view scope map if necessary
                 if (viewScopeMap != null && !viewScopeMap.isEmpty())
                 {
                     Map<String, Object> newViewScopeMap = newView.getViewMap(false);
                     if (newViewScopeMap == null)
                     {
                         newView.restoreViewScopeState(context, newViewState);
                     }
                     else
                     {
                         // Should theoretically not happen, because when a pooled static view 
                         // is saved, the view scope map is skipped, otherwise it could be a
                         // leak. Anyway, we let this code here that overrides the values from
                         // the original map.
                         for (Map.Entry<String, Object> entry2 : viewScopeMap.entrySet())
                         {
                             newViewScopeMap.put(entry2.getKey(), entry2.getValue());
                         }
                     }
                 }
             }
             
             // Update request view metadata to ensure resource list is restored as when the
             // view was built on the first time. This ensures correct calculation of added 
             // resources by dynamic behavior. 
             RequestViewContext rcv = RequestViewContext.getCurrentInstance(context, newView, false);
             if (rcv != null)
             {
                 rcv.setRequestViewMetadata(metadata.getRequestViewMetadata().cloneInstance());
             }
             else
             {
                 RequestViewContext.setCurrentInstance(context, newView,
                         RequestViewContext.newInstance(metadata.getRequestViewMetadata().cloneInstance()));
             }
         }
         finally
         {
             context.setProcessingEvents(oldProcessingEvents);
         }
     }
     
     public void storeViewStructureMetadata(FacesContext context, UIViewRoot root)
     {
         ViewPool viewPool = getViewPool(context, root);
         if (viewPool != null)
         {
             FaceletState faceletState = (FaceletState) root.getAttributes().get(
                     ComponentSupport.FACELET_STATE_INSTANCE);
             boolean isDynamic = faceletState != null ? faceletState.isDynamic() : false;
             if (!isDynamic)
             {
                 viewPool.storeStaticViewStructureMetadata(context, root, faceletState);            
             }
             else
             {
                 viewPool.storeDynamicViewStructureMetadata(context, root, faceletState);
             }
         }
     }
     
     public ViewStructureMetadata retrieveViewStructureMetadata(FacesContext context,
             UIViewRoot root)
     {
         ViewPool viewPool = getViewPool(context, root);
         if (viewPool != null)
         {
             FaceletState faceletState = (FaceletState) root.getAttributes().get(
                     ComponentSupport.FACELET_STATE_INSTANCE);
             boolean isDynamic = faceletState != null ? faceletState.isDynamic() : false;
             if (!isDynamic)
             {
                 return viewPool.retrieveStaticViewStructureMetadata(context, root);
             }
             else
             {
                 return viewPool.retrieveDynamicViewStructureMetadata(context, root, faceletState);
             }
         }
         return null;
     }
     
     public void pushResetableView(FacesContext context, UIViewRoot view, FaceletState faceletViewState)
     {
         ViewPool viewPool = getViewPool(context, view);
         if (viewPool != null)
         {
             boolean isDynamic = faceletViewState != null ? faceletViewState.isDynamic() : false;
             if (!isDynamic)
             {
                 clearTransientAndNonFaceletComponentsForStaticView(context, view);
                 viewPool.pushStaticStructureView(context, view);
             }
             else
             {
                 ViewStructureMetadata viewStructureMetadata = viewPool.retrieveDynamicViewStructureMetadata(
                     context, view, faceletViewState);
                 if (viewStructureMetadata != null)
                 {
                     clearTransientAndNonFaceletComponentsForDynamicView(context, view, viewStructureMetadata);
                     viewPool.pushDynamicStructureView(context, view, faceletViewState);
                 }
             }
         }
     }
     
     public void pushPartialView(FacesContext context, UIViewRoot view, FaceletState faceletViewState, int count)
     {
         ViewPool viewPool = getViewPool(context, view);
         
         if (viewPool != null && viewPool.isWorthToRecycleThisView(context, view))
         {
             ViewStructureMetadata viewStructureMetadata = null;
             if (faceletViewState == null)
             {
                 viewStructureMetadata = viewPool.retrieveStaticViewStructureMetadata(context, view);
             }
             else
             {
                 viewStructureMetadata = viewPool.retrieveDynamicViewStructureMetadata(
                     context, view, faceletViewState);
             }
             if (viewStructureMetadata != null)
             {
                 ClearPartialTreeContext ptc = new ClearPartialTreeContext();
                 // add partial structure view to the map.
                 clearTransientAndRemoveNonResetableComponents(context, ptc, view, viewStructureMetadata);
                 int reusableCount = ptc.getCount();
                 float factor = ((float)reusableCount) / ((float)count);
                 if (factor > 0.3f)
                 {
                     viewPool.pushPartialStructureView(context, view);
                 }
             }
         }        
     }
     
     protected void clearTransientAndNonFaceletComponentsForStaticView(final FacesContext context, 
             final UIViewRoot root)
     {
         // In a static view, clear components that are both transient and non bound to any facelet tag handler
         // is quite simple. Since the structure of the view is static, there is no need to check component resources.
         clearTransientAndNonFaceletComponents(context, root);
     }
     
     public void clearTransientAndNonFaceletComponentsForDynamicView(final FacesContext context, 
             final UIViewRoot root, final ViewStructureMetadata viewStructureMetadata)
     {
         //Scan children
         int childCount = root.getChildCount();
         if (childCount > 0)
         {
             for (int i = 0; i < childCount; i++)
             {
                 UIComponent child = root.getChildren().get(i);
                 if (child != null && child.isTransient() &&
                     child.getAttributes().get(ComponentSupport.MARK_CREATED) == null)
                 {
                     root.getChildren().remove(i);
                     i--;
                     childCount--;
                 }
                 else
                 {
                     if (child.getChildCount() > 0 || !child.getFacets().isEmpty())
                     {
                         clearTransientAndNonFaceletComponents(context, child);
                     }
                 }
             }
         }
 
         clearTransientAndNonFaceletComponentsForDynamicViewUIViewRootFacets(
             context, root, viewStructureMetadata);
     }
     
     private void clearTransientAndNonFaceletComponentsForDynamicViewUIViewRootFacets(final FacesContext context, 
             final UIViewRoot root, ViewStructureMetadata viewStructureMetadata)
     {
         
         //Scan facets
         if (root.getFacetCount() > 0)
         {
             Map<String, UIComponent> facets = root.getFacets();
             for (Iterator<UIComponent> itr = facets.values().iterator(); itr.hasNext();)
             {
                 UIComponent fc = itr.next();
                 if (fc != null && !(fc instanceof ComponentResourceContainer))
                 {
                     if ( fc.isTransient() &&
                         fc.getAttributes().get(ComponentSupport.MARK_CREATED) == null)
                     {
                         itr.remove();
                     }
                     else
                     {
                         if (fc.getChildCount() > 0 || !fc.getFacets().isEmpty())
                         {
                             clearTransientAndNonFaceletComponents(context, fc);
                         }
                     }
                 }
                 else if (fc != null)
                 {
                     // In a facet which is a ComponentResourceContainer instance,
                     // we need to check these two cases:
                     // 1. Resources relocated by facelets
                     // 2. Resources created by effect of a @ResourceDependency annotation
                     if (fc.getId() != null && fc.getId().startsWith("javax_faces_location_"))
                     {
                         String target = fc.getId().substring("javax_faces_location_".length());
                         Map<String, List<ResourceDependency>> addedResources = 
                             viewStructureMetadata.getRequestViewMetadata().
                                 getResourceDependencyAnnotations(context);
                         List<ResourceDependency> resourceDependencyList = (addedResources != null) ?
                             addedResources.get(target) : null;
 
                         clearComponentResourceContainer(context, fc, resourceDependencyList);
                     }
                 }
             }
         }
     }
     
     private void clearComponentResourceContainer(final FacesContext context, UIComponent component,
         List<ResourceDependency> resourceDependencyList)
     {
         //Scan children
         int childCount = component.getChildCount();
         if (childCount > 0)
         {
             for (int i = 0; i < childCount; i++)
             {
                 UIComponent child = component.getChildren().get(i);
                 String id = (String) child.getAttributes().get(ComponentSupport.MARK_CREATED);
                 if (child != null && child.isTransient() &&
                     id == null)
                 {
                     //Remove both transient not facelets bound components
                     component.getChildren().remove(i);
                     i--;
                     childCount--;
                 }
                 else if (id != null)
                 {
                     // If it has an id set, it is a facelet component resource.
                     // The refresh algorithm take care of the cleanup.
                 }
                 /*
                 else if (!child.isTransient() && id != null && !faceletResources.contains(id))
                 {
                     // check if the resource has a facelet tag in this "dynamic state", if not
                     // remove it. Really leave a component resource does not harm, but 
                     // the objective is make this view as close as when if it is built as new.
                     component.getChildren().remove(i);
                     i--;
                     childCount--;
                 }*/
                 else
                 {
                     // Check if the component instance was created using a @ResourceDependency annotation
                     Object[] rdk = (Object[]) child.getAttributes().get(
                                 RequestViewMetadata.RESOURCE_DEPENDENCY_KEY);
                     if (rdk != null)
                     {
                         boolean found = false;
                         String library = (String) rdk[0];
                         String name = (String) rdk[1];
                         if (resourceDependencyList != null)
                         {
                             for (ResourceDependency resource : resourceDependencyList)
                             {
                                 if (library == null && resource.library() == null)
                                 {
                                     if (name != null && name.equals(resource.name()))
                                     {
                                         found = true;
                                         break;
                                     }
                                 }
                                 else
                                 {
                                     if (library != null && library.equals(resource.library()) &&
                                         name != null && name.equals(resource.name()) )
                                     {
                                         found = true;
                                         break;
                                     }
                                 }
                             }
                         }
                         if (!found)
                         {
                             //Remove it, because for this dynamic state it it does not exists.
                             component.getChildren().remove(i);
                             i--;
                             childCount--;
                         }
                         // If found just leave it.
                     }
                     else
                     {
                         if (child.getChildCount() > 0 || !child.getFacets().isEmpty())
                         {
                             clearTransientAndNonFaceletComponents(context, child);
                         }
                     }
                 }
             }
         }
     }
 
     /**
      * Clear all transient components not created by facelets algorithm. In this way,
      * we ensure the component tree does not have any changes done after markInitialState.
      * 
      * @param context
      * @param component 
      */
     private void clearTransientAndNonFaceletComponents(final FacesContext context, final UIComponent component)
     {
         //Scan children
         int childCount = component.getChildCount();
         if (childCount > 0)
         {
             for (int i = 0; i < childCount; i++)
             {
                 UIComponent child = component.getChildren().get(i);
                 if (child != null && child.isTransient() &&
                     child.getAttributes().get(ComponentSupport.MARK_CREATED) == null)
                 {
                     component.getChildren().remove(i);
                     i--;
                     childCount--;
                 }
                 else
                 {
                     if (child.getChildCount() > 0 || !child.getFacets().isEmpty())
                     {
                         clearTransientAndNonFaceletComponents(context, child);
                     }
                 }
             }
         }
 
         //Scan facets
         if (component.getFacetCount() > 0)
         {
             Map<String, UIComponent> facets = component.getFacets();
             for (Iterator<UIComponent> itr = facets.values().iterator(); itr.hasNext();)
             {
                 UIComponent fc = itr.next();
                 if (fc != null && fc.isTransient() &&
                     fc.getAttributes().get(ComponentSupport.MARK_CREATED) == null)
                 {
                     itr.remove();
                 }
                 else
                 {
                     if (fc.getChildCount() > 0 || !fc.getFacets().isEmpty())
                     {
                         clearTransientAndNonFaceletComponents(context, fc);
                     }
                 }
             }
         }
     }
 
     private void clearTransientAndRemoveNonResetableComponents(final FacesContext context, 
         final ClearPartialTreeContext ptc, final UIViewRoot root, 
         ViewStructureMetadata viewStructureMetadata)
     {
         //Scan children
         int childCount = root.getChildCount();
 
         try
         {
             root.getAttributes().put(ViewPoolProcessor.RESET_SAVE_STATE_MODE_KEY, 
                         ViewPoolProcessor.RESET_MODE_HARD);
             if (childCount > 0)
             {
                 for (int i = 0; i < childCount; i++)
                 {
                     UIComponent child = root.getChildren().get(i);
                     boolean containsFaceletId = child.getAttributes().containsKey(ComponentSupport.MARK_CREATED);
                     if (child != null && child.isTransient() && !containsFaceletId)
                     {
                         //Transient and not bound to facelets tag, remove it!.
                         root.getChildren().remove(i);
                         i--;
                         childCount--;
                     }
                     else
                     {
                         if (child.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER))
                         {
                             //Dynamically added or moved, remove it!
                             root.getChildren().remove(i);
                             i--;
                             childCount--;
 
                         }
                         else if (containsFaceletId ||
                             child.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER))
                         {
                             // Bound to a facelet tag or created by facelets, we have two options:
                             // 1. If is not transient, check its state and try to clear it, if fails remove it
                             // 2. If is transient, assume stateless, continue.
                             if (!child.isTransient())
                             {
                                 // Remember that hard reset is already enabled.
                                 Object state = child.saveState(context);
                                 if (state == null)
                                 {
                                     if (child.getChildCount() > 0 || !child.getFacets().isEmpty())
                                     {
                                         clearTransientAndRemoveNonResetableComponents(context, ptc, child);
                                     }
                                     ptc.incrementCount();
                                 }
                                 else
                                 {
                                     root.getChildren().remove(i);
                                     i--;
                                     childCount--;
                                 }
                             }
                             else
                             {
                                 ptc.incrementCount();
                             }
                         }
                         else
                         {
                             // Non facelets component, remove it!.
                             root.getChildren().remove(i);
                             i--;
                             childCount--;
                         }
                     }
                 }
             }
 
             clearTransientAndNonFaceletComponentsForDynamicViewUIViewRootFacets(
                 context, root, viewStructureMetadata);
         }
         finally
         {
             root.getAttributes().put(ViewPoolProcessor.RESET_SAVE_STATE_MODE_KEY, 
                         ViewPoolProcessor.RESET_MODE_OFF);
         }
     }
     
     private void clearTransientAndRemoveNonResetableComponents(final FacesContext context,
         final ClearPartialTreeContext ptc, final UIComponent component)
     {
         //Scan children
         int childCount = component.getChildCount();
         if (childCount > 0)
         {
             for (int i = 0; i < childCount; i++)
             {
                 UIComponent child = component.getChildren().get(i);
                 boolean containsFaceletId = child.getAttributes().containsKey(ComponentSupport.MARK_CREATED);
                 if (child != null && child.isTransient() && !containsFaceletId)
                 {
                     //Transient and not bound to facelets tag, remove it!.
                     component.getChildren().remove(i);
                     i--;
                     childCount--;
                 }
                 else
                 {
                     if (child.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER))
                     {
                         //Dynamically added or moved, remove it!
                         component.getChildren().remove(i);
                         i--;
                         childCount--;
 
                     }
                     else if (containsFaceletId ||
                         child.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER))
                     {
                         // Bound to a facelet tag or created by facelets, we have two options:
                         // 1. If is not transient, check its state and try to clear it, if fails remove it
                         // 2. If is transient, assume stateless, continue.
                         if (!child.isTransient())
                         {
                             // Remember that hard reset is already enabled.
                             Object state = child.saveState(context);
                             if (state == null)
                             {
                                 if (child.getChildCount() > 0 || !child.getFacets().isEmpty())
                                 {
                                     clearTransientAndRemoveNonResetableComponents(context, ptc, child);
                                 }
                                 ptc.incrementCount();
                             }
                             else
                             {
                                 component.getChildren().remove(i);
                                 i--;
                                 childCount--;
                             }
                         }
                         else
                         {
                             ptc.incrementCount();
                         }
                     }
                     else
                     {
                         // Non facelets component, remove it!.
                         component.getChildren().remove(i);
                         i--;
                         childCount--;
                     }
                 }
             }
         }
 
         //Scan facets
         if (component.getFacetCount() > 0)
         {
             Map<String, UIComponent> facets = component.getFacets();
             for (Iterator<UIComponent> itr = facets.values().iterator(); itr.hasNext();)
             {
                 UIComponent fc = itr.next();
                 boolean containsFaceletId = fc.getAttributes().containsKey(ComponentSupport.MARK_CREATED);
                 if (fc != null && fc.isTransient() && !containsFaceletId)
                 {
                     //Transient and not bound to facelets tag, remove it!.
                     itr.remove();
                 }
                 else
                 {
                     if (fc.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER))
                     {
                         //Dynamically added or moved, remove it!
                         itr.remove();
 
                     }
                     else if (containsFaceletId ||
                         fc.getAttributes().containsKey(ComponentSupport.COMPONENT_ADDED_BY_HANDLER_MARKER))
                     {
                         // Bound to a facelet tag or created by facelets, we have two options:
                         // 1. If is not transient, check its state and try to clear it, if fails remove it
                         // 2. If is transient, assume stateless, continue.
                         if (!fc.isTransient())
                         {
                             // Remember that hard reset is already enabled.
                             Object state = fc.saveState(context);
                             if (state == null)
                             {
                                 if (fc.getChildCount() > 0 || !fc.getFacets().isEmpty())
                                 {
                                     clearTransientAndRemoveNonResetableComponents(context, ptc, fc);
                                 }
                                 ptc.incrementCount();
                             }
                             else
                             {
                                 itr.remove();
                             }
                         }
                         else
                         {
                             ptc.incrementCount();
                         }
                     }
                     else
                     {
                         // Non facelets component, remove it!.
                         itr.remove();
                     }
                 }
             }
         }
     }
     
     public void processDeferredNavigation(FacesContext facesContext)
     {
             Object[] command = (Object[]) facesContext.getAttributes().get(
                 ViewPoolProcessor.INVOKE_DEFERRED_NAVIGATION);
         if (command != null)
         {
             try
             {
                 facesContext.getAttributes().put(ViewPoolProcessor.DISPOSE_VIEW_NAVIGATION, Boolean.TRUE);
                 NavigationHandler navigationHandler = facesContext.getApplication().getNavigationHandler();
                 if (command.length == 3)
                 {
                     navigationHandler.handleNavigation(facesContext, (String) command[0], (String) command[1], 
                         (String) command[2]);
                 }
                 else
                 {
                     navigationHandler.handleNavigation(facesContext, (String) command[0], (String) command[1]);
                 }
                 //Render Response if needed
                 facesContext.renderResponse();
                 facesContext.getAttributes().remove(ViewPoolProcessor.INVOKE_DEFERRED_NAVIGATION);
             }
             finally
             {
                 facesContext.getAttributes().remove(ViewPoolProcessor.DISPOSE_VIEW_NAVIGATION);
             }
         }
     }
     
     private static final String SERIALIZED_VIEW_REQUEST_ATTR = 
         StateManagerImpl.class.getName() + ".SERIALIZED_VIEW";
 
     public void disposeView(FacesContext facesContext, UIViewRoot root)
     {
         if (root == null)
         {
             return;
         }
 
         String viewId = root.getViewId();
         if (viewId == null)
         {
             return;
         }
         Application app = facesContext.getApplication();
         if (app == null)
         {
             return;
         }
         ViewHandler viewHandler = app.getViewHandler();
         if (viewHandler == null)
         {
             return;
         }
 
         if (Boolean.TRUE.equals(facesContext.getAttributes().get(ViewPoolProcessor.DISPOSE_VIEW_NAVIGATION)))
         {
             ViewDeclarationLanguage vdl = facesContext.getApplication().
                     getViewHandler().getViewDeclarationLanguage(
                         facesContext, root.getViewId());
 
             if (vdl != null && ViewDeclarationLanguage.FACELETS_VIEW_DECLARATION_LANGUAGE_ID.equals(vdl.getId()))
             {
                 StateManagementStrategy sms = vdl.getStateManagementStrategy(facesContext, root.getId());
                 if (sms != null)
                 {
                     // Force indirectly to store the map in the pool
                     facesContext.getAttributes().put(ViewPoolProcessor.FORCE_HARD_RESET, Boolean.TRUE);
 
                     try
                     {
                         Object state = sms.saveView(facesContext);
                     }
                     finally
                     {
                         facesContext.getAttributes().remove(ViewPoolProcessor.FORCE_HARD_RESET);
                     }
 
                     // Clear the calculated value from the application map
                     facesContext.getAttributes().remove(SERIALIZED_VIEW_REQUEST_ATTR);
                 }
             }
         }
     }
     
     private static class ClearPartialTreeContext 
     {
         private int count;
         
         public ClearPartialTreeContext()
         {
             count = 0;
         }
 
         /**
          * @return the count
          */
         public int getCount()
         {
             return count;
         }
 
         public int incrementCount()
         {
             return count++;
         }
         /**
          * @param count the count to set
          */
         public void setCount(int count)
         {
             this.count = count;
         }
     }
 }