/*

  * 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.io.Serializable;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.EnumSet;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import javax.el.ValueExpression;

 import javax.faces.FacesException;

 import javax.faces.FactoryFinder;

 import javax.faces.application.ProjectStage;

 import javax.faces.application.StateManager;

 import javax.faces.component.ContextCallback;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UIComponentBase;

 import javax.faces.component.UIViewRoot;

 import javax.faces.component.visit.VisitCallback;

 import javax.faces.component.visit.VisitContext;

 import javax.faces.component.visit.VisitContextFactory;

 import javax.faces.component.visit.VisitHint;

 import javax.faces.component.visit.VisitResult;

 import javax.faces.context.FacesContext;

 import javax.faces.event.PostAddToViewEvent;

 import javax.faces.event.PreRemoveFromViewEvent;

 import javax.faces.event.SystemEvent;

 import javax.faces.event.SystemEventListener;

 import javax.faces.render.RenderKitFactory;

 import javax.faces.render.ResponseStateManager;

 import javax.faces.view.StateManagementStrategy;

 import javax.faces.view.ViewDeclarationLanguage;

 import javax.faces.view.ViewDeclarationLanguageFactory;

 import javax.faces.view.ViewMetadata;

 import org.apache.myfaces.application.StateManagerImpl;

 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFWebConfigParam;

 import org.apache.myfaces.context.RequestViewContext;

 import org.apache.myfaces.shared.config.MyfacesConfig;

 import org.apache.myfaces.shared.util.ClassUtils;

 import org.apache.myfaces.shared.util.HashMapUtils;

 import org.apache.myfaces.shared.util.WebConfigParamUtils;

 import org.apache.myfaces.view.facelets.compiler.CheckDuplicateIdFaceletUtils;

 import org.apache.myfaces.view.facelets.pool.ViewEntry;

 import org.apache.myfaces.view.facelets.pool.ViewPool;

 import org.apache.myfaces.view.facelets.pool.ViewStructureMetadata;

 import org.apache.myfaces.view.facelets.tag.jsf.ComponentSupport;

 import org.apache.myfaces.view.facelets.tag.jsf.FaceletState;

 /**

  * This class implements partial state saving feature when facelets

  * is used to render pages. (Theorically it could be applied on jsp case too,

  * but all considerations below should be true before apply it).

  * 

  * The following considerations apply for this class:

  * 

  * 1. This StateManagementStrategy should only be active if javax.faces.PARTIAL_STATE_SAVING

  *    config param is active(true). See javadoc on StateManager for details.

  * 2. A map using component clientId as keys are used to hold the state.

  * 3. Each component has a valid id after ViewDeclarationLanguage.buildView().

  *    This implies that somewhere, every TagHandler that create an UIComponent 

  *    instance should call setId and assign it.

  * 4. Every TagHandler that create an UIComponent instance should call markInitialState

  *    after the component is populated. Otherwise, full state is always saved.

  * 5. A SystemEventListener is used to keep track for added and removed components, listen

  *    PostAddToViewEvent and PreRemoveFromViewEvent event triggered by UIComponent.setParent()

  *    method.

  * 6. It is not possible to use javax.faces.component.visit API to traverse the component

  *    tree during save/restore, because UIData.visitTree traverse all rows and we only need

  *    to restore state per component (not per row).

  * 7. It is necessary to preserve the order of the children added/removed between requests.

  * 8. Added and removed components could be seen as subtrees. This imply that we need to save

  *    the structure of the added components subtree and remove one component could be remove

  *    all its children and facets from view inclusive.

  * 9. It is necessary to save and restore the list of added/removed components between several

  *    requests.

  * 10.All components ids removed in any moment of time must be preserved.

  * 11.Each component must be restored only once.

  * 11.The order is important for ids added when it is traversed the tree, otherwise the algorithm 

  *    could change the order in which components will be restored.  

  * 

  * @author Leonardo Uribe (latest modification by $Author$)

  * @version $Revision$ $Date$

  * @since 2.0

  *

  */

 public class DefaultFaceletsStateManagementStrategy extends StateManagementStrategy

 {

     public static final String CLIENTIDS_ADDED = "oam.CLIENTIDS_ADDED";

     public static final String CLIENTIDS_REMOVED = "oam.CLIENTIDS_REMOVED";

     /**

      * Key used on component attribute map to indicate if a component was added

      * after build view, so itself and all descendants should not use partial

      * state saving. There are two possible values:

      * 

      * Key not present: The component uses pss.

      * ComponentState.ADD: The component was added to the view after build view.

      * ComponentState.REMOVE_ADD: The component was removed/added to the view. Itself and all

      * descendants should be saved and restored, but we have to unregister/register

      * from CLIENTIDS_ADDED and CLIENTIDS_REMOVED lists. See ComponentSupport.markComponentToRestoreFully

      * for details.

      * ComponentState.ADDED: The component has been added or removed/added, but it has

      * been already processed.

      */

     public  static final String COMPONENT_ADDED_AFTER_BUILD_VIEW = "oam.COMPONENT_ADDED_AFTER_BUILD_VIEW"; 

     /**

      * If this param is set to true (by default), when pss algorithm is executed to save state, a visit tree

      * traversal is done, instead a plain traversal like previous versions (2.0.7/2.1.1 and earlier) of MyFaces Core.

      * 

      * This param is just provided to preserve backwards behavior. 

      * @deprecated JSF 2.2 change enforces tree visiting as the preferred way. Performance tests shows that plain

      * visit is faster but the difference is negligible.

      */

     @Deprecated

     @JSFWebConfigParam(since="2.0.8, 2.1.2", defaultValue="true", expectedValues="true, false",

                        group="state", tags="performance", deprecated=true)

     public static final String SAVE_STATE_WITH_VISIT_TREE_ON_PSS

             = "org.apache.myfaces.SAVE_STATE_WITH_VISIT_TREE_ON_PSS";

     /**

      * Define how duplicate ids are checked when ProjectStage is Production, by default (auto) it only check ids of

      * components that does not encapsulate markup (like facelets UILeaf).

      *  

      * <ul>

      * <li>true: check all ids, including ids for components that are transient and encapsulate markup.</li>

      * <li>auto: (default) check ids of components that does not encapsulate markup (like facelets UILeaf). 

      * Note ids of UILeaf instances are generated by facelets vdl, start with "j_id", are never rendered 

      * into the response and UILeaf instances are never used as a target for listeners, so in practice 

      * there is no need to check such ids. This reduce the overhead associated with generate client ids.</li>

      * <li>false: do not do any check when ProjectStage is Production</li>

      * </ul>

      * <p> According to specification, identifiers must be unique within the scope of the nearest ancestor to 

      * the component that is a naming container.</p>

      */

     @JSFWebConfigParam(since="2.0.12, 2.1.6", defaultValue="auto", expectedValues="true, auto, false",

                        group="state", tags="performance")

     public static final String CHECK_ID_PRODUCTION_MODE

             = "org.apache.myfaces.CHECK_ID_PRODUCTION_MODE";

     private static final String CHECK_ID_PRODUCTION_MODE_DEFAULT = "auto";

     private static final String CHECK_ID_PRODUCTION_MODE_TRUE = "true";

     private static final String CHECK_ID_PRODUCTION_MODE_AUTO = "auto";

     private static final String SKIP_ITERATION_HINT = "javax.faces.visit.SKIP_ITERATION";

     private static final String SERIALIZED_VIEW_REQUEST_ATTR = 

         StateManagerImpl.class.getName() + ".SERIALIZED_VIEW";

     private static final Object[] EMPTY_STATES = new Object[]{null, null};

     private static final Set<VisitHint> VISIT_HINTS = Collections.unmodifiableSet( 

             EnumSet.of(VisitHint.SKIP_ITERATION));

     private static final String UNIQUE_ID_COUNTER_KEY =

               "oam.view.uniqueIdCounter";

     private ViewDeclarationLanguageFactory _vdlFactory;

     private RenderKitFactory _renderKitFactory = null;

     private VisitContextFactory _visitContextFactory = null;

     private String _checkIdsProductionMode;

     private MyfacesConfig _config;

     private ViewPoolProcessor _viewPoolProcessor;

     public DefaultFaceletsStateManagementStrategy ()

     {

         this(FacesContext.getCurrentInstance());

     }

     public DefaultFaceletsStateManagementStrategy (FacesContext context)

     {

         _vdlFactory = (ViewDeclarationLanguageFactory)

                 FactoryFinder.getFactory(FactoryFinder.VIEW_DECLARATION_LANGUAGE_FACTORY);

         _config = MyfacesConfig.getCurrentInstance(context.getExternalContext());

         _viewPoolProcessor = ViewPoolProcessor.getInstance(context);

     }

     @SuppressWarnings("unchecked")

     @Override

     public UIViewRoot restoreView (FacesContext context, String viewId, String renderKitId)

     {

         ResponseStateManager manager;

         Object state[];

         Map<String, Object> states;

         UIViewRoot view = null;

         // The value returned here is expected to be false (set by RestoreViewExecutor), but

         //we don't know if some ViewHandler wrapper could change it, so it is better to save the value.

         final boolean oldContextEventState = context.isProcessingEvents();

         // Get previous state from ResponseStateManager.

         manager = getRenderKitFactory().getRenderKit(context, renderKitId).getResponseStateManager();

         state = (Object[]) manager.getState(context, viewId);

         if (state == null)

         {

             //No state could be restored, return null causing ViewExpiredException

             return null;

         }

         if (state[1] instanceof Object[])

         {

             Object[] fullState = (Object[]) state[1]; 

             view = (UIViewRoot) internalRestoreTreeStructure((TreeStructComponent)fullState[0]);

             if (view != null)

             {

                 context.setViewRoot (view);

                 view.processRestoreState(context, fullState[1]);

                 // If the view is restored fully, it is necessary to refresh RequestViewContext, otherwise at

                 // each ajax request new components associated with @ResourceDependency annotation will be added

                 // to the tree, making the state bigger without real need.

                 RequestViewContext.getCurrentInstance(context).

                         refreshRequestViewContext(context, view);

                 if (fullState.length == 3 && fullState[2] != null)

                 {

                     context.setResourceLibraryContracts((List) UIComponentBase.

                         restoreAttachedState(context, fullState[2]));

                 }

             }

         }

         else

         {

             // Per the spec: build the view.

             ViewDeclarationLanguage vdl = _vdlFactory.getViewDeclarationLanguage(viewId);

             Object faceletViewState = null;

             try

             {

                 ViewMetadata metadata = vdl.getViewMetadata (context, viewId);

                 if (metadata != null)

                 {

                     view = metadata.createMetadataView(context);

                     // If no view and response complete there is no need to continue

                     if (view == null && context.getResponseComplete())

                     {

                         return null;

                     }

                 }

                 if (view == null)

                 {

                     view = context.getApplication().getViewHandler().createView(context, viewId);

                 }

                 context.setViewRoot (view); 

                 boolean skipBuildView = false;

                 if (state != null && state[1] != null)

                 {

                     // Since JSF 2.2, UIViewRoot.restoreViewScopeState() must be called, but

                     // to get the state of the root, it is necessary to force calculate the

                     // id from this location. Remember in this point, PSS is enabled, so the

                     // code match with the assigment done in 

                     // FaceletViewDeclarationLanguage.buildView()

                     states = (Map<String, Object>) state[1];

                     faceletViewState = UIComponentBase.restoreAttachedState(

                             context,states.get(ComponentSupport.FACELET_STATE_INSTANCE));

                     if (faceletViewState != null && _viewPoolProcessor != null)

                     {

                         ViewPool viewPool = _viewPoolProcessor.getViewPool(context, view);

                         if (viewPool != null)

                         {

                             ViewStructureMetadata viewMetadata = viewPool.retrieveDynamicViewStructureMetadata(

                                 context, view, (FaceletState) faceletViewState);

                             if (viewMetadata != null)

                             {

                                 ViewEntry entry = viewPool.popDynamicStructureView(context, view,

                                         (FaceletState) faceletViewState);

                                 if (entry != null)

                                 {

                                     skipBuildView = true;

                                     _viewPoolProcessor.cloneAndRestoreView(context, view, entry, viewMetadata);

                                 }

                             }

                         }

                     }

                     if (view.getId() == null)

                     {

                         view.setId(view.createUniqueId(context, null));

                     }

                     if (faceletViewState != null)

                     {

                         //if (skipBuildView)

                         //{

                             FaceletState newFaceletState = (FaceletState) view.getAttributes().get(

                                     ComponentSupport.FACELET_STATE_INSTANCE);

                             if (newFaceletState != null)

                             {

                                 newFaceletState.restoreState(context, 

                                         ((FaceletState)faceletViewState).saveState(context));

                                 faceletViewState = newFaceletState;

                             }

                             else

                             {

                                 view.getAttributes().put(ComponentSupport.FACELET_STATE_INSTANCE,  faceletViewState);

                             }

                         //}

                         //else

                         //{

                         //    view.getAttributes().put(ComponentSupport.FACELET_STATE_INSTANCE,  faceletViewState);

                         //}

                     }

                     if (state.length == 3)

                     {

                         //Jump to where the count is

                         view.getAttributes().put(UNIQUE_ID_COUNTER_KEY, state[2]);

                     }

                     Object viewRootState = states.get(view.getClientId(context));

                     if (viewRootState != null)

                     {

                         try

                         {

                             view.pushComponentToEL(context, view);

                             view.restoreViewScopeState(context, viewRootState);

                         }

                         finally

                         {

                             view.popComponentFromEL(context);

                         }

                     }

                 }

                 // On RestoreViewExecutor, setProcessingEvents is called first to false

                 // and then to true when postback. Since we need listeners registered to PostAddToViewEvent

                 // event to be handled, we should enable it again. For partial state saving we need this listeners

                 // be called from here and relocate components properly.

                 if (!skipBuildView)

                 {

                     try 

                     {

                         context.setProcessingEvents (true);

                         vdl.buildView (context, view);

                         // In the latest code related to PostAddToView, it is

                         // triggered no matter if it is applied on postback. It seems that MYFACES-2389, 

                         // TRINIDAD-1670 and TRINIDAD-1671 are related.

                         suscribeListeners(view);

                     }

                     finally

                     {

                         context.setProcessingEvents (oldContextEventState);

                     }

                 }

             }

             catch (Throwable e)

             {

                 throw new FacesException ("unable to create view \"" + viewId + "\"", e);

             }

             // Stateless mode only for transient views and non stateless mode for

             // stateful views. This check avoid apply state over a stateless view.

             boolean statelessMode = manager.isStateless(context, viewId);

             if (statelessMode && !view.isTransient())

             {

                 throw new IllegalStateException("View is not transient");

             }

             if (!statelessMode && view.isTransient())

             {

                 throw new IllegalStateException("Cannot apply state over stateless view");

             }

             if (state != null && state[1] != null)

             {

                 states = (Map<String, Object>) state[1];

                 //Save the last unique id counter key in UIViewRoot

                 Integer lastUniqueIdCounter = (Integer) view.getAttributes().get(UNIQUE_ID_COUNTER_KEY);

                 // Retrieve the facelet state before restore anything. The reason is

                 // it could be necessary to restore the bindings map from here.

                 FaceletState oldFaceletState = (FaceletState) view.getAttributes().get(

                         ComponentSupport.FACELET_STATE_INSTANCE);

                 // Visit the children and restore their state.

                 boolean emptyState = false;

                 boolean containsFaceletState = states.containsKey(

                         ComponentSupport.FACELET_STATE_INSTANCE);

                 if (states.isEmpty())

                 {

                     emptyState = true; 

                 }

                 else if (states.size() == 1 && 

                         containsFaceletState)

                 {

                     emptyState = true; 

                 }

                 //Restore state of current components

                 if (!emptyState)

                 {

                     // Check if there is only one component state

                     // and that state is UIViewRoot instance (for example

                     // when using ViewScope)

                     if ((states.size() == 1 && !containsFaceletState) || 

                         (states.size() == 2 && containsFaceletState))

                     {

                         Object viewState = states.get(view.getClientId(context));

                         if (viewState != null)

                         {

                             restoreViewRootOnlyFromMap(context,viewState, view);

                         }

                         else

                         {

                             //The component is not viewRoot, restore as usual.

                             restoreStateFromMap(context, states, view);

                         }

                     }

                     else

                     {

                         restoreStateFromMap(context, states, view);

                     }

                 }

                 if (faceletViewState != null)

                 {

                     // Make sure binding map

                     if (oldFaceletState != null && oldFaceletState.getBindings() != null && 

                             !oldFaceletState.getBindings().isEmpty())

                     {

                         // Be sure the new facelet state has the binding map filled from the old one.

                         // When vdl.buildView() is called by restoreView, FaceletState.bindings map is filled, but

                         // when view pool is enabled, vdl.buildView() could restore the view, but create an alternate

                         // FaceletState instance, different from the one restored. In this case, the restored instance

                         // has precedence, but we need to fill bindings map using the entries from the instance that

                         // comes from the view pool.

                         FaceletState newFaceletState = (FaceletState) faceletViewState;

                         for (Map.Entry<String, Map<String, ValueExpression> > entry : 

                                 oldFaceletState.getBindings().entrySet())

                         {

                             for (Map.Entry<String, ValueExpression> entry2 : entry.getValue().entrySet())

                             {

                                 ValueExpression expr = newFaceletState.getBinding(entry.getKey(), entry2.getKey());

                                 if (expr == null)

                                 {

                                     newFaceletState.putBinding(entry.getKey(), entry2.getKey(), entry2.getValue());

                                 }

                             }

                         }

                         view.getAttributes().put(ComponentSupport.FACELET_STATE_INSTANCE,  newFaceletState);

                     }

                     else

                     {

                         //restore bindings

                         view.getAttributes().put(ComponentSupport.FACELET_STATE_INSTANCE,  faceletViewState);

                     }

                 }

                 if (lastUniqueIdCounter != null)

                 {

                     Integer newUniqueIdCounter = (Integer) view.getAttributes().get(UNIQUE_ID_COUNTER_KEY);

                     if (newUniqueIdCounter != null && 

                         lastUniqueIdCounter.intValue() > newUniqueIdCounter.intValue())

                     {

                         // The unique counter was restored by a side effect of 

                         // restoreState() over UIViewRoot with a lower count,

                         // to avoid a component duplicate id exception we need to fix the count.

                         view.getAttributes().put(UNIQUE_ID_COUNTER_KEY, lastUniqueIdCounter);

                     }

                 }

                 handleDynamicAddedRemovedComponents(context, view, states);

             }

         }

         return view;

     }

     public void handleDynamicAddedRemovedComponents(FacesContext context, UIViewRoot view, Map<String, Object> states)

     {

         List<String> clientIdsRemoved = getClientIdsRemoved(view);

         if (clientIdsRemoved != null)

         {

             Set<String> idsRemovedSet = new HashSet<String>(HashMapUtils.calcCapacity(clientIdsRemoved.size()));

             context.getAttributes().put(FaceletViewDeclarationLanguage.REMOVING_COMPONENTS_BUILD, Boolean.TRUE);

             try

             {

                 // perf: clientIds are ArrayList: see method registerOnAddRemoveList(String)

                 for (int i = 0, size = clientIdsRemoved.size(); i < size; i++)

                 {

                     String clientId = clientIdsRemoved.get(i);

                     if (!idsRemovedSet.contains(clientId))

                     {

                         RemoveComponentCallback callback = new RemoveComponentCallback();

                         view.invokeOnComponent(context, clientId, callback);

                         if (callback.isComponentFound())

                         {

                             //Add only if component found

                             idsRemovedSet.add(clientId);

                         }

                     }

                 }

                 clientIdsRemoved.clear();

                 clientIdsRemoved.addAll(idsRemovedSet);

             }

             finally

             {

                 context.getAttributes().remove(FaceletViewDeclarationLanguage.REMOVING_COMPONENTS_BUILD);

             }

         }

         List<String> clientIdsAdded = getClientIdsAdded(view);

         if (clientIdsAdded != null)

         {

             Set<String> idsAddedSet = new HashSet<String>(HashMapUtils.calcCapacity(clientIdsAdded.size()));

             // perf: clientIds are ArrayList: see method setClientsIdsAdded(String)

             for (int i = 0, size = clientIdsAdded.size(); i < size; i++)

             {

                 String clientId = clientIdsAdded.get(i);

                 if (!idsAddedSet.contains(clientId))

                 {

                     final AttachedFullStateWrapper wrapper = (AttachedFullStateWrapper) states.get(clientId);

                     if (wrapper != null)

                     {

                         final Object[] addedState = (Object[]) wrapper.getWrappedStateObject(); 

                         if (addedState != null)

                         {

                             if (addedState.length == 2)

                             {

                                 view = (UIViewRoot)

                                         internalRestoreTreeStructure((TreeStructComponent) addedState[0]);

                                 view.processRestoreState(context, addedState[1]);

                                 break;

                             }

                             else

                             {

                                 final String parentClientId = (String) addedState[0];

                                 view.invokeOnComponent(context, parentClientId, 

                                     new AddComponentCallback(addedState));

                             }

                         }

                     }

                     idsAddedSet.add(clientId);

                 }

             }

             // Reset this list, because it will be calculated later when the view is being saved

             // in the right order, preventing duplicates (see COMPONENT_ADDED_AFTER_BUILD_VIEW for details).

             clientIdsAdded.clear();

             // This call only has sense when components has been added programatically, because if facelets has control

             // over all components in the component tree, build the initial state and apply the state will have the

             // same effect.

             RequestViewContext.getCurrentInstance(context).

                     refreshRequestViewContext(context, view);

         }

     }

     public static class RemoveComponentCallback implements ContextCallback

     {

         private boolean componentFound;

         public RemoveComponentCallback()

         {

             this.componentFound = false;

         }

         public void invokeContextCallback(FacesContext context,

                 UIComponent target)

         {

             if (target.getParent() != null && 

                 !target.getParent().getChildren().remove(target))

             {

                 String key = null;

                 if (target.getParent().getFacetCount() > 0)

                 {

                     for (Map.Entry<String, UIComponent> entry :

                             target.getParent().getFacets().entrySet())

                     {

                         if (entry.getValue()==target)

                         {

                             key = entry.getKey();

                             break;

                         }

                     }

                 }

                 if (key != null)

                 {

                     UIComponent removedTarget = target.getParent().getFacets().remove(key);

                     if (removedTarget != null)

                     {

                         this.componentFound = true;

                     }

                 }

             }

             else

             {

                 this.componentFound = true;

             }

         }

         public boolean isComponentFound()

         {

             return this.componentFound;

         }

     }

     public static class AddComponentCallback implements ContextCallback

     {

         private final Object[] addedState;

         public AddComponentCallback(Object[] addedState)

         {

             this.addedState = addedState;

         }

         public void invokeContextCallback(FacesContext context,

                 UIComponent target)

         {

             if (addedState[1] != null)

             {

                 String facetName = (String) addedState[1];

                 UIComponent child

                         = internalRestoreTreeStructure((TreeStructComponent)

                                                        addedState[3]);

                 child.processRestoreState(context, addedState[4]);

                 target.getFacets().put(facetName,child);

             }

             else

             {

                 Integer childIndex = (Integer) addedState[2];

                 UIComponent child

                         = internalRestoreTreeStructure((TreeStructComponent)

                                                        addedState[3]);

                 child.processRestoreState(context, addedState[4]);

                 boolean done = false;

                 // Is the child a facelet controlled component?

                 if (child.getAttributes().containsKey(ComponentSupport.MARK_CREATED))

                 {

                     // By effect of c:forEach it is possible that the component can be duplicated

                     // in the component tree, so what we need to do as a fallback is replace the

                     // component in the spot with the restored version.

                     UIComponent parent = target;

                     if (parent.getChildCount() > 0)

                     {

                         String tagId = (String) child.getAttributes().get(ComponentSupport.MARK_CREATED);

                         if (childIndex < parent.getChildCount())

                         {

                             // Try to find the component quickly 

                             UIComponent dup = parent.getChildren().get(childIndex);

                             if (tagId.equals(dup.getAttributes().get(ComponentSupport.MARK_CREATED)))

                             {

                                 // Replace

                                 parent.getChildren().remove(childIndex.intValue());

                                 parent.getChildren().add(childIndex, child);

                                 done = true;

                             }

                         }

                         if (!done)

                         {

                             // Fallback to iteration

                             for (int i = 0, childCount = parent.getChildCount(); i < childCount; i ++)

                             {

                                 UIComponent dup = parent.getChildren().get(i);

                                 if (tagId.equals(dup.getAttributes().get(ComponentSupport.MARK_CREATED)))

                                 {

                                     // Replace

                                     parent.getChildren().remove(i);

                                     parent.getChildren().add(i, child);

                                     done = true;

                                     break;

                                 }

                             }

                         }

                     }

                 }

                 if (!done)

                 {

                     try

                     {

                         target.getChildren().add(childIndex, child);

                     }

                     catch (IndexOutOfBoundsException e)

                     {

                         // We can't be sure about where should be this 

                         // item, so just add it. 

                         target.getChildren().add(child);

                     }

                 }

             }

         }

     }

     @Override

     public Object saveView (FacesContext context)

     {

         UIViewRoot view = context.getViewRoot();

         Object states;

         if (view == null)

         {

             // Not much that can be done.

             return null;

         }

         Object serializedView = context.getAttributes()

             .get(SERIALIZED_VIEW_REQUEST_ATTR);

         //Note on ajax case the method saveState could be called twice: once before start

         //document rendering and the other one when it is called StateManager.getViewState method.

         if (serializedView == null)

         {

             // Make sure the client IDs are unique per the spec.

             if (context.isProjectStage(ProjectStage.Production))

             {

                 if (CHECK_ID_PRODUCTION_MODE_AUTO.equals(getCheckIdProductionMode(context)))

                 {

                     CheckDuplicateIdFaceletUtils.checkIdsStatefulComponents(context, view);

                 }

                 else if (CHECK_ID_PRODUCTION_MODE_TRUE.equals(getCheckIdProductionMode(context)))

                 {

                     CheckDuplicateIdFaceletUtils.checkIds(context, view);

                 }

             }

             else

             {

                 CheckDuplicateIdFaceletUtils.checkIds(context, view);

             }

             // Create save state objects for every component.

             boolean viewResetable = false;

             int count = 0;

             Object faceletViewState = null;

             boolean saveViewFully = view.getAttributes().containsKey(COMPONENT_ADDED_AFTER_BUILD_VIEW);

             if (saveViewFully)

             {

                 ensureClearInitialState(view);

                 Object rlcStates = !context.getResourceLibraryContracts().isEmpty() ? 

                     UIComponentBase.saveAttachedState(context, 

                                 new ArrayList<String>(context.getResourceLibraryContracts())) : null;

                 states = new Object[]{

                             internalBuildTreeStructureToSave(view),

                             view.processSaveState(context), rlcStates};

             }

             else

             {

                 states = new HashMap<String, Object>();

                 faceletViewState = view.getAttributes().get(ComponentSupport.FACELET_STATE_INSTANCE);

                 if (faceletViewState != null)

                 {

                     ((Map<String, Object>)states).put(ComponentSupport.FACELET_STATE_INSTANCE,

                             UIComponentBase.saveAttachedState(context, faceletViewState));

                     //Do not save on UIViewRoot

                     view.getAttributes().remove(ComponentSupport.FACELET_STATE_INSTANCE);

                     view.getTransientStateHelper().putTransient(

                             ComponentSupport.FACELET_STATE_INSTANCE, faceletViewState);

                 }

                 if (_viewPoolProcessor != null && 

                     _viewPoolProcessor.isViewPoolEnabledForThisView(context, view))

                 {

                     SaveStateAndResetViewCallback cb = saveStateOnMapVisitTreeAndReset(

                             context,(Map<String,Object>) states, view,

                             Boolean.TRUE.equals(

                         context.getAttributes().get(ViewPoolProcessor.FORCE_HARD_RESET)));

                     viewResetable = cb.isViewResetable();

                     count = cb.getCount();

                 }

                 else

                 {

                     saveStateOnMapVisitTree(context,(Map<String,Object>) states, view);

                 }

                 if ( ((Map<String,Object>)states).isEmpty())

                 {

                     states = null;

                 }

             }

             Integer uniqueIdCount = (Integer) view.getAttributes().get(UNIQUE_ID_COUNTER_KEY);

             if (uniqueIdCount != null && !uniqueIdCount.equals(1))

             {

                 serializedView = new Object[] { null, states, uniqueIdCount };

             }

             else if (states == null)

             {

                 serializedView = EMPTY_STATES;

             }

             else

             {

                 serializedView = new Object[] { null, states };

             }

             //If view cache enabled store the view state into the pool

             if (!saveViewFully && _viewPoolProcessor != null)

             {

                 if (viewResetable)

                 {

                     _viewPoolProcessor.pushResetableView(

                         context, view, (FaceletState) faceletViewState);

                 }

                 else

                 {

                     _viewPoolProcessor.pushPartialView(

                         context, view, (FaceletState) faceletViewState, count);

                 }

             }

             context.getAttributes().put(SERIALIZED_VIEW_REQUEST_ATTR, serializedView);

         }

         return serializedView;

     }

     private void restoreViewRootOnlyFromMap(

             final FacesContext context, final Object viewState,

             final UIComponent view)

     {

         // Only viewState found, process it but skip tree

         // traversal, saving some time.

         try

         {

             //Restore view

             view.pushComponentToEL(context, view);

             if (viewState != null && !(viewState instanceof AttachedFullStateWrapper))

             {

                 try

                 {

                     view.restoreState(context, viewState);

                 }

                 catch(Exception e)

                 {

                     throw new IllegalStateException(

                             "Error restoring component: "+

                             view.getClientId(context), e);

                 }

             }

         }

         finally

         {

              view.popComponentFromEL(context);

         }

     }

     private void restoreStateFromMap(final FacesContext context, final Map<String,Object> states,

             final UIComponent component)

     {

         if (states == null)

         {

             return;

         }

         try

         {

             //Restore view

             component.pushComponentToEL(context, component);

             Object state = states.get(component.getClientId(context));

             if (state != null)

             {

                 if (state instanceof AttachedFullStateWrapper)

                 {

                     //Don't restore this one! It will be restored when the algorithm remove and add it.

                     return;

                 }

                 try

                 {

                     component.restoreState(context, state);

                 }

                 catch(Exception e)

                 {

                     throw new IllegalStateException("Error restoring component: "+component.getClientId(context), e);

                 }

             }

             //Scan children

             if (component.getChildCount() > 0)

             {

                 //String currentClientId = component.getClientId();

                 List<UIComponent> children  = component.getChildren();

                 for (int i = 0; i < children.size(); i++)

                 {

                     UIComponent child = children.get(i);

                     if (child != null && !child.isTransient())

                     {

                         restoreStateFromMap( context, states, child);

                     }

                 }

             }

             //Scan facets

             if (component.getFacetCount() > 0)

             {

                 Map<String, UIComponent> facetMap = component.getFacets();

                 for (Map.Entry<String, UIComponent> entry : facetMap.entrySet())

                 {

                     UIComponent child = entry.getValue();

                     if (child != null && !child.isTransient())

                     {

                         //String facetName = entry.getKey();

                         restoreStateFromMap( context, states, child);

                     }

                 }

             }

         }

         finally

         {

             component.popComponentFromEL(context);

         }

     }

     static List<String> getClientIdsAdded(UIViewRoot root)

     {

         return (List<String>) root.getAttributes().get(CLIENTIDS_ADDED);

     }

     static void setClientsIdsAdded(UIViewRoot root, List<String> clientIdsList)

     {

         root.getAttributes().put(CLIENTIDS_ADDED, clientIdsList);

     }

     static List<String> getClientIdsRemoved(UIViewRoot root)

     {

         return (List<String>) root.getAttributes().get(CLIENTIDS_REMOVED);

     }

     static void setClientsIdsRemoved(UIViewRoot root, List<String> clientIdsList)

     {

         root.getAttributes().put(CLIENTIDS_REMOVED, clientIdsList);

     }

     @SuppressWarnings("unchecked")

     private void registerOnAddRemoveList(FacesContext facesContext, String clientId)

     {

         UIViewRoot uiViewRoot = facesContext.getViewRoot();

         List<String> clientIdsAdded = (List<String>) getClientIdsAdded(uiViewRoot);

         if (clientIdsAdded == null)

         {

             //Create a set that preserve insertion order

             clientIdsAdded = new ArrayList<String>();

         }

         clientIdsAdded.add(clientId);

         setClientsIdsAdded(uiViewRoot, clientIdsAdded);

         List<String> clientIdsRemoved = (List<String>) getClientIdsRemoved(uiViewRoot);

         if (clientIdsRemoved == null)

         {

             //Create a set that preserve insertion order

             clientIdsRemoved = new ArrayList<String>();

         }

         clientIdsRemoved.add(clientId);

         setClientsIdsRemoved(uiViewRoot, clientIdsRemoved);

     }

     @SuppressWarnings("unchecked")

     private void registerOnAddList(FacesContext facesContext, String clientId)

     {

         UIViewRoot uiViewRoot = facesContext.getViewRoot();

         List<String> clientIdsAdded = (List<String>) getClientIdsAdded(uiViewRoot);

         if (clientIdsAdded == null)

         {

             //Create a set that preserve insertion order

             clientIdsAdded = new ArrayList<String>();

         }

         clientIdsAdded.add(clientId);

         setClientsIdsAdded(uiViewRoot, clientIdsAdded);

     }

     private void saveStateOnMapVisitTree(final FacesContext facesContext, final Map<String,Object> states,

             final UIViewRoot uiViewRoot)

     {

         facesContext.getAttributes().put(SKIP_ITERATION_HINT, Boolean.TRUE);

         try

         {

             uiViewRoot.visitTree( getVisitContextFactory().getVisitContext(

                     facesContext, null, VISIT_HINTS), new VisitCallback()

             {

                 public VisitResult visit(VisitContext context, UIComponent target)

                 {

                     FacesContext facesContext = context.getFacesContext();

                     Object state;

                     if ((target == null) || target.isTransient())

                     {

                         // No need to bother with these components or their children.

                         return VisitResult.REJECT;

                     }

                     ComponentState componentAddedAfterBuildView

                             = (ComponentState) target.getAttributes().get(COMPONENT_ADDED_AFTER_BUILD_VIEW);

                     //Note if UIViewRoot has this marker, JSF 1.2 like state saving is used.

                     if (componentAddedAfterBuildView != null && (target.getParent() != null))

                     {

                         if (ComponentState.REMOVE_ADD.equals(componentAddedAfterBuildView))

                         {

                             registerOnAddRemoveList(facesContext, target.getClientId(facesContext));

                             target.getAttributes().put(COMPONENT_ADDED_AFTER_BUILD_VIEW, ComponentState.ADDED);

                         }

                         else if (ComponentState.ADD.equals(componentAddedAfterBuildView))

                         {

                             registerOnAddList(facesContext, target.getClientId(facesContext));

                             target.getAttributes().put(COMPONENT_ADDED_AFTER_BUILD_VIEW, ComponentState.ADDED);

                         }

                         else if (ComponentState.ADDED.equals(componentAddedAfterBuildView))

                         {

                             registerOnAddList(facesContext, target.getClientId(facesContext));

                         }

                         ensureClearInitialState(target);

                         //Save all required info to restore the subtree.

                         //This includes position, structure and state of subtree

                         int childIndex = target.getParent().getChildren().indexOf(target);

                         if (childIndex >= 0)

                         {

                             states.put(target.getClientId(facesContext), new AttachedFullStateWrapper( 

                                     new Object[]{

                                         target.getParent().getClientId(facesContext),

                                         null,

                                         childIndex,

                                         internalBuildTreeStructureToSave(target),

                                         target.processSaveState(facesContext)}));

                         }

                         else

                         {

                             String facetName = null;

                             if (target.getParent().getFacetCount() > 0)

                             {

                                 for (Map.Entry<String, UIComponent> entry : target.getParent().getFacets().entrySet()) 

                                 {

                                     if (target.equals(entry.getValue()))

                                     {

                                         facetName = entry.getKey();

                                         break;

                                     }

                                 }

                             }

                             states.put(target.getClientId(facesContext),new AttachedFullStateWrapper(new Object[]{

                                     target.getParent().getClientId(facesContext),

                                     facetName,

                                     null,

                                     internalBuildTreeStructureToSave(target),

                                     target.processSaveState(facesContext)}));

                         }

                         return VisitResult.REJECT;

                     }

                     else if (target.getParent() != null)

                     {

                         state = target.saveState (facesContext);

                         if (state != null)

                         {

                             // Save by client ID into our map.

                             states.put (target.getClientId (facesContext), state);

                         }

                         return VisitResult.ACCEPT;

                     }

                     else

                     {

                         //Only UIViewRoot has no parent in a component tree.

                         return VisitResult.ACCEPT;

                     }

                 }

             });

         }

         finally

         {

             facesContext.getAttributes().remove(SKIP_ITERATION_HINT);

         }

         if (!uiViewRoot.isTransient())

         {

             Object state = uiViewRoot.saveState (facesContext);

             if (state != null)

             {

                 // Save by client ID into our map.

                 states.put (uiViewRoot.getClientId (facesContext), state);

             }

         }

     }

     private SaveStateAndResetViewCallback saveStateOnMapVisitTreeAndReset(final FacesContext facesContext,

             final Map<String,Object> states, final UIViewRoot uiViewRoot, boolean forceHardReset)

     {

         facesContext.getAttributes().put(SKIP_ITERATION_HINT, Boolean.TRUE);

         SaveStateAndResetViewCallback callback = new SaveStateAndResetViewCallback(

                 facesContext.getViewRoot(), states, forceHardReset);

         if (forceHardReset)

         {

             uiViewRoot.getAttributes().put(ViewPoolProcessor.RESET_SAVE_STATE_MODE_KEY, 

                     ViewPoolProcessor.RESET_MODE_HARD);

         }

         else

         {

             uiViewRoot.getAttributes().put(ViewPoolProcessor.RESET_SAVE_STATE_MODE_KEY, 

                     ViewPoolProcessor.RESET_MODE_SOFT);

         }

         try

         {

             if (_viewPoolProcessor != null && 

                 !_viewPoolProcessor.isViewPoolEnabledForThisView(facesContext, uiViewRoot))

             {

                 callback.setViewResetable(false);

             }

             // Check if the view has removed components. If that so, it

             // means there is some manipulation over the component tree that

             // can be rollback, so it is ok to set the view as resetable.

             if (callback.isViewResetable())

             {

                 List<String> removedIds = getClientIdsRemoved(uiViewRoot);

                 if (removedIds != null && !removedIds.isEmpty())

                 {

                     callback.setViewResetable(false);

                 }

             }

             try

             {

                 uiViewRoot.visitTree( getVisitContextFactory().getVisitContext(

                         facesContext, null, VISIT_HINTS), callback);

             }

             finally

             {

                 facesContext.getAttributes().remove(SKIP_ITERATION_HINT);

             }

             if (callback.isViewResetable() && callback.isRemoveAddedComponents())

             {

                 List<String> clientIdsToRemove = getClientIdsAdded(uiViewRoot);

                 if (clientIdsToRemove != null)

                 {

                     // perf: clientIds are ArrayList: see method registerOnAddRemoveList(String)

                     for (int i = 0, size = clientIdsToRemove.size(); i < size; i++)

                     {

                         String clientId = clientIdsToRemove.get(i);

                         uiViewRoot.invokeOnComponent(facesContext, clientId, new RemoveComponentCallback());

                     }

                 }

             }

             Object state = uiViewRoot.saveState (facesContext);

             if (state != null)

             {

                 // Save by client ID into our map.

                 states.put (uiViewRoot.getClientId (facesContext), state);

                 //Hard reset (or reset and check state again)

                 Integer oldResetMode = (Integer) uiViewRoot.getAttributes().put(

                         ViewPoolProcessor.RESET_SAVE_STATE_MODE_KEY, ViewPoolProcessor.RESET_MODE_HARD);

                 state = uiViewRoot.saveState (facesContext);

                 uiViewRoot.getAttributes().put(ViewPoolProcessor.RESET_SAVE_STATE_MODE_KEY, oldResetMode);

                 if (state != null)

                 {

                     callback.setViewResetable(false);

                 }

             }

         }

         finally

         {

             uiViewRoot.getAttributes().put(ViewPoolProcessor.RESET_SAVE_STATE_MODE_KEY, 

                     ViewPoolProcessor.RESET_MODE_OFF);

         }

         return callback;

     }

     private class SaveStateAndResetViewCallback implements VisitCallback

     {

         private final Map<String, Object> states;

         private final UIViewRoot view;

         private boolean viewResetable;

         private boolean skipRoot;

         private int count;

         private boolean forceHardReset;

         private boolean removeAddedComponents;

         public SaveStateAndResetViewCallback(UIViewRoot view, Map<String, Object> states,

                 boolean forceHardReset)

         {

             this.states = states;

             this.view = view;

             this.viewResetable = true;

             this.skipRoot = true;

             this.count = 0;

             this.forceHardReset = forceHardReset;

             this.removeAddedComponents = false;

         }

         public VisitResult visit(VisitContext context, UIComponent target)

         {

             FacesContext facesContext = context.getFacesContext();

             Object state;

             this.count++;

             if ((target == null) || target.isTransient())

             {

                 // No need to bother with these components or their children.

                 return VisitResult.REJECT;

             }

             if (skipRoot && target instanceof UIViewRoot)

             {

                 //UIViewRoot should be scanned at last.

                 skipRoot = false;

                 return VisitResult.ACCEPT;

             }

             ComponentState componentAddedAfterBuildView

                     = (ComponentState) target.getAttributes().get(COMPONENT_ADDED_AFTER_BUILD_VIEW);

             //Note if UIViewRoot has this marker, JSF 1.2 like state saving is used.

             if (componentAddedAfterBuildView != null && (target.getParent() != null))

             {

                 //Set this view as not resetable.

                 //setViewResetable(false);

                 // Enable flag to remove added components later

                 setRemoveAddedComponents(true);

                 if (forceHardReset)

                 {

                     // The ideal is remove the added component here but visitTree does not support that

                     // kind of tree manipulation.

                     if (isViewResetable() &&

                         ComponentState.REMOVE_ADD.equals(componentAddedAfterBuildView))

                     {

                         setViewResetable(false);

                     }

                     // it is not important to save anything, skip

                     return VisitResult.REJECT;

                 }

                 if (ComponentState.REMOVE_ADD.equals(componentAddedAfterBuildView))

                 {

                     //If the view has removed components, set the view as non resetable

                     setViewResetable(false);

                     registerOnAddRemoveList(facesContext, target.getClientId(facesContext));

                     target.getAttributes().put(COMPONENT_ADDED_AFTER_BUILD_VIEW, ComponentState.ADDED);

                 }

                 else if (ComponentState.ADD.equals(componentAddedAfterBuildView))

                 {

                     registerOnAddList(facesContext, target.getClientId(facesContext));

                     target.getAttributes().put(COMPONENT_ADDED_AFTER_BUILD_VIEW, ComponentState.ADDED);

                 }

                 else if (ComponentState.ADDED.equals(componentAddedAfterBuildView))

                 {

                     // Later on the check of removed components we'll see if the view

                     // is resetable or not.

                     registerOnAddList(facesContext, target.getClientId(facesContext));

                 }

                 ensureClearInitialState(target);