/*

  * 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 javax.faces.webapp;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.Stack;

 import java.util.concurrent.atomic.AtomicInteger;

 import java.util.logging.Level;

 import javax.faces.component.NamingContainer;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UIOutput;

 import javax.faces.component.UIViewRoot;

 import javax.faces.context.FacesContext;

 import javax.faces.render.ResponseStateManager;

 import javax.servlet.jsp.JspException;

 import javax.servlet.jsp.JspWriter;

 import javax.servlet.jsp.PageContext;

 import javax.servlet.jsp.jstl.core.LoopTag;

 import javax.servlet.jsp.tagext.BodyContent;

 import javax.servlet.jsp.tagext.BodyTag;

 import javax.servlet.jsp.tagext.JspIdConsumer;

 import javax.servlet.jsp.tagext.Tag;

 /**

  * @since 1.2

  */

 public abstract class UIComponentClassicTagBase extends UIComponentTagBase implements BodyTag, JspIdConsumer

 {

     // do not change this w/out doing likewise in UIComponentTag

     private static final String COMPONENT_STACK_ATTR = "org.apache.myfaces.COMPONENT_STACK";

     private static final String REQUEST_FACES_CONTEXT = "org.apache.myfaces.REQUEST_FACES_CONTEXT";

     private static final String VIEW_IDS = "org.apache.myfaces.VIEW_IDS";

     private static final String FORMER_CHILD_IDS_SET_ATTR = "org.apache.myfaces.FORMER_CHILD_IDS";

     private static final String FORMER_FACET_NAMES_SET_ATTR = "org.apache.myfaces.FORMER_FACET_NAMES";

     private static final String PREVIOUS_JSP_IDS_SET = "org.apache.myfaces.PREVIOUS_JSP_IDS_SET";

     private static final String BOUND_VIEW_ROOT = "org.apache.myfaces.BOUND_VIEW_ROOT";

     private static final String LOGICAL_PAGE_ID = "org.apache.myfaces.LOGICAL_PAGE_ID";

     private static final String LOGICAL_PAGE_COUNTER = "org.apache.myfaces.LOGICAL_PAGE_COUNTER";

     protected static final String UNIQUE_ID_PREFIX = UIViewRoot.UNIQUE_ID_PREFIX + "_";

     protected PageContext pageContext = null;

     protected BodyContent bodyContent = null;

     private boolean _created = false;

     private String _jspId = null;

     private String _facesJspId = null;

     private List<String> _childrenAdded = null;

     private List<String> _facetsAdded = null;

     private UIComponent _componentInstance = null;

     private String _id = null;

     private boolean isInAnIterator;

     // the parent tag

     private Tag _parent = null;

     // the enclosing "classic" parent tag

     private UIComponentClassicTagBase _parentClassicTag = null;

     private FacesContext _facesContext = null;

     protected abstract void setProperties(UIComponent component);

     protected abstract UIComponent createComponent(FacesContext context, String newId) throws JspException;

     public void release()

     {

         internalRelease();

         // members, that must/need only be reset when there is no more risk, that the container

         // wants to reuse this tag

         pageContext = null;

         _parent = null;

         _jspId = null;

         _id = null;

         _facesJspId = null;

         bodyContent = null;

     }

     /**

      * Reset any members that apply to the according component instance and must not be reused if the container wants to

      * reuse this tag instance. This method is called when rendering for this tag is finished ( doEndTag() ) or when

      * released by the container.

      */

     private void internalRelease()

     {

         _facesContext = null;

         _componentInstance = null;

         _created = false;

         _childrenAdded = null;

         _facetsAdded = null;

     }

     /**

      * @see http://java.sun.com/javaee/5/docs/api/javax/faces/webapp/UIComponentClassicTagBase.html#getCreated()

      */

     @Override

     public boolean getCreated()

     {

         return _created;

     }

     protected List<String> getCreatedComponents()

     {

         return _childrenAdded;

     }

     /**

      * @see http://java.sun.com/javaee/5/docs/api/javax/faces/webapp/UIComponentClassicTagBase.html#

      *      getParentUIComponentClassicTagBase(javax.servlet.jsp.PageContext)

      * @param pageContext

      * @return

      */

     public static UIComponentClassicTagBase getParentUIComponentClassicTagBase(PageContext pageContext)

     {

         Stack<UIComponentClassicTagBase> stack = getStack(pageContext);

         int size = stack.size();

         return size > 0 ? stack.get(size - 1) : null;

     }

     /**

      * @see http://java.sun.com/javaee/5/docs/api/javax/faces/webapp/UIComponentClassicTagBase.html#getFacesJspId()

      * @return

      */

     public String getJspId()

     {

         return _jspId;

     }

     public void setJspId(String jspId)

     {

         // -= Leonardo Uribe =- The javadoc says the following about this method:

         //

         // 1. This method is called by the container before doStartTag(). 

         // 2. The argument is guaranteed to be unique within the page.

         //

         // Doing some tests it was found that the jspId generated in a

         // jsp:include are "reset", so if before call it it was id10

         // the tags inside jsp:include starts from id1 (really I suppose a

         // different counter is used), so if we assign this one

         // directly it is possible to cause duplicate id exceptions later.

         //

         // One problem is caused by f:view tag. This one is not included when

         // we check for duplicate id, so it is possible to assign to a component

         // in a jsp:include the id of the UIViewRoot instance and cause a 

         // duplicate id exception when the view is saved.

         //

         // Checking the javadoc it was found the following note:

         //

         // "... IMPLEMENTATION NOTE: This method will detect where we are in an 

         // include and assign a unique ID for each include in a particular 'logical page'. 

         // This allows us to avoid possible duplicate ID situations for included pages 

         // that have components without explicit IDs..."

         //

         // So we need to keep a counter per logical page or page context found. 

         // It is assumed the first one should not be suffixed. The others needs to be

         // suffixed, so all generated ids of those pages are different. The final result

         // is that jsp:include works correctly.

         //

         // Note this implementation detail takes precedence over c:forEach tag. If a

         // jsp:include is inside a c:forEach, jsp:include takes precedence and the 

         // iteration prefix is ignored. If a custom id is provided for a component, 

         // it will throw duplicate id exception, because this code is "override" 

         // by the custom id, and the iteration suffix only applies on generated ids.

         Integer logicalPageId = (Integer) pageContext.getAttribute(LOGICAL_PAGE_ID);

         if (logicalPageId != null)

         {

             if (logicalPageId.intValue() == 1)

             {

                 //Base case, just pass it unchanged

                 _jspId = jspId;

             }

             else

             {

                 // We are on a different page context, suffix it with the logicalPageId

                 _jspId = jspId + "pc" + logicalPageId;

             }

         }

         else

         {

             Map<Object, Object> attributeMap = getFacesContext().getAttributes();

             AtomicInteger logicalPageCounter = (AtomicInteger) attributeMap.get(LOGICAL_PAGE_COUNTER);

             if (logicalPageCounter == null)

             {

                 //We are processing the first component tag. 

                 logicalPageCounter = new AtomicInteger(1);

                 logicalPageId = 1;

                 attributeMap.put(LOGICAL_PAGE_COUNTER, logicalPageCounter);

                 pageContext.setAttribute(LOGICAL_PAGE_ID, logicalPageId);

             }

             else

             {

                 //We are on a different page context, so we need to assign and set.

                 logicalPageId = logicalPageCounter.incrementAndGet();

                 pageContext.setAttribute(LOGICAL_PAGE_ID, logicalPageId);

                 _jspId = jspId + "pc" + logicalPageId;

             }

         }

         _facesJspId = null;

         checkIfItIsInAnIterator(_jspId);

     }

     /**

      * @param child

      * @see http://java.sun.com/javaee/5/docs/api/javax/faces/webapp/UIComponentTagBase.html#addChild(javax.faces.

      *      _componentInstance.UIComponent)

      */

     @Override

     protected void addChild(UIComponent child)

     {

         if (_childrenAdded == null)

         {

             _childrenAdded = new ArrayList<String>();

         }

         _childrenAdded.add(child.getId());

     }

     /**

      * @param name

      * @see http://java.sun.com/javaee/5/docs/api/javax/faces/webapp/UIComponentTagBase.html#addFacet(java.lang.String)

      */

     @Override

     protected void addFacet(String name)

     {

         if (_facetsAdded == null)

         {

             _facetsAdded = new ArrayList<String>();

         }

         _facetsAdded.add(name);

     }

     /**

      * Return the UIComponent instance associated with this tag.

      * 

      * @return a UIComponent, never null.

      */

     @Override

     public UIComponent getComponentInstance()

     {

         return _componentInstance;

     }

     /**

      * @return

      * @see http://java.sun.com/javaee/5/docs/api/javax/faces/webapp/UIComponentTagBase.html#getFacesContext()

      */

     @Override

     protected FacesContext getFacesContext()

     {

         if (_facesContext != null)

         {

             return _facesContext;

         }

         _facesContext = pageContext == null ? null : (FacesContext)pageContext.getAttribute(REQUEST_FACES_CONTEXT);

         if (_facesContext != null)

         {

             return _facesContext;

         }

         _facesContext = FacesContext.getCurrentInstance();

         if (_facesContext != null)

         {

             if (pageContext != null)

             {

                 pageContext.setAttribute(REQUEST_FACES_CONTEXT, _facesContext);

             }

             return _facesContext;

         }

         // should never be reached

         throw new RuntimeException("FacesContext not found");

     }

     /**

      * @return

      * @see http://java.sun.com/javaee/5/docs/api/javax/faces/webapp/UIComponentTagBase.html#getIndexOfNextChildTag()

      */

     @Override

     protected int getIndexOfNextChildTag()

     {

         if (_childrenAdded == null)

         {

             return 0;

         }

         return _childrenAdded.size();

     }

     /**

      * @param id

      * @see http://java.sun.com/javaee/5/docs/api/javax/faces/webapp/UIComponentTagBase.html#setId(java.lang.String)

      */

     @Override

     public void setId(String id)

     {

         if (id != null && id.startsWith(UIViewRoot.UNIQUE_ID_PREFIX))

         {

             throw new IllegalArgumentException("Id is non-null and starts with UIViewRoot.UNIQUE_ID_PREFIX: " + id);

         }

         _id = id;

     }

     /**

      * Return the id (if any) specified as an xml attribute on this tag.

      */

     protected String getId()

     {

         return _id;

     }

     protected String getFacesJspId()

     {

         if (_facesJspId == null)

         {

             if (_jspId != null)

             {

                 _facesJspId = UNIQUE_ID_PREFIX + _jspId;

                 if (isIdDuplicated(_facesJspId))

                 {

                     _facesJspId = createNextId(_facesJspId);

                 }

             }

             else

             {

                 _facesJspId = _facesContext.getViewRoot().createUniqueId();

             }

         }

         return _facesJspId;

     }

     public void setBodyContent(BodyContent bodyContent)

     {

         this.bodyContent = bodyContent;

     }

     public void doInitBody() throws JspException

     {

         // nothing by default

     }

     @SuppressWarnings("unchecked")

     public int doAfterBody() throws JspException

     {

         UIComponentClassicTagBase parentTag = getParentUIComponentClassicTagBase(pageContext);

         if (isRootTag(parentTag) || isInRenderedChildrenComponent(parentTag))

         {

             UIComponent verbatimComp = createVerbatimComponentFromBodyContent();

             if (verbatimComp != null)

             {

                 List<String> childrenAddedIds =

                         (List<String>)_componentInstance.getAttributes().get(FORMER_CHILD_IDS_SET_ATTR);

                 if (childrenAddedIds == null)

                 {

                     _componentInstance.getChildren().add(verbatimComp);

                 }

                 else

                 {

                     int index = _componentInstance.getChildCount();

                     if (childrenAddedIds.size() == index)

                     {

                         // verbatim already present, replace it

                         _componentInstance.getChildren().add(index - 1, verbatimComp);

                     }

                     else

                     {

                         _componentInstance.getChildren().add(verbatimComp);

                     }

                 }

                 // also tell the parent-tag about the new component instance

                 if (parentTag != null)

                 {

                     parentTag.addChild(verbatimComp);

                 }

             }

         }

         return getDoAfterBodyValue();

     }

     /**

      * Standard method invoked by the JSP framework to inform this tag of the PageContext associated with the jsp page

      * currently being processed.

      */

     public void setPageContext(PageContext pageContext)

     {

         this.pageContext = pageContext;

     }

     /**

      * Returns the enclosing JSP tag object. Note that this is not necessarily a JSF tag.

      */

     public Tag getParent()

     {

         return _parent;

     }

     /**

      * Standard method invoked by the JSP framework to inform this tag of the enclosing JSP tag object.

      */

     public void setParent(Tag tag)

     {

         this._parent = tag;

     }

     public BodyContent getBodyContent()

     {

         return bodyContent;

     }

     public int doStartTag() throws JspException

     {

         this._facesContext = getFacesContext();

         if (_facesContext == null)

         {

             throw new JspException("FacesContext not found");

         }

         _childrenAdded = null;

         _facetsAdded = null;

         _parentClassicTag = getParentUIComponentClassicTagBase(pageContext);

         UIComponent verbatimComp = null;

         // create the verbatim component if not inside a facet (facets are rendered

         // by their parents) and in a component that renders children

         if (!isFacet())

         {

             Tag parent = getParent();

             // flush if in a loop tag and not in a jsp tag

             if (parent != null && parent instanceof LoopTag)

             {

                 JspWriter outWriter = pageContext.getOut();

                 boolean insideJspTag = (outWriter instanceof BodyContent);

                 if (!insideJspTag)

                 {

                     try

                     {

                         outWriter.flush();

                     }

                     catch (IOException e)

                     {

                         throw new JspException("Exception flushing when creating verbatim _componentInstance", e);

                     }

                 }

             }

             // create the transient _componentInstance

             if (_parentClassicTag != null)

             {

                 verbatimComp = _parentClassicTag.createVerbatimComponentFromBodyContent();

             }

         }

         // find the _componentInstance for this tag

         _componentInstance = findComponent(_facesContext);

         // add the verbatim component

         if (verbatimComp != null && _parentClassicTag != null)

         {

             addVerbatimBeforeComponent(_parentClassicTag, verbatimComp, _componentInstance);

         }

         Map<String, Object> viewComponentIds = getViewComponentIds();

         // check that the instance returned by the client ID for the viewComponentIds

         // is the same like this one, so we do not perform again the check for duplicated ids

         Object tagInstance = null;

         String clientId = null;

         if (_id != null)

         {

             clientId = _componentInstance.getClientId(_facesContext);

             tagInstance = (viewComponentIds.get(clientId) == this) ? this : null;

         }

         if (tagInstance == null)

         {

             // check for duplicated IDs

             if (_id != null)

             {

                 if (clientId != null)

                 {

                     if (viewComponentIds.containsKey(clientId))

                     {

                         throw new JspException("Duplicated component Id: '" + clientId + "' " + "for component: '"

                                 + getPathToComponent(_componentInstance) + "'.");

                     }

                     viewComponentIds.put(clientId, this);

                 }

             }

             // add to the component or facet to parent

             if (_parentClassicTag != null)

             {

                 if (isFacet())

                 {

                     _parentClassicTag.addFacet(getFacetName());

                 }

                 else

                 {

                     _parentClassicTag.addChild(_componentInstance);

                 }

             }

         }

         // push this tag on the stack

         pushTag();

         return getDoStartValue();

     }

     public int doEndTag() throws JspException

     {

         popTag();

         UIComponent component = getComponentInstance();

         removeFormerChildren(component);

         removeFormerFacets(component);

         try

         {

             UIComponentClassicTagBase parentTag = getParentUIComponentClassicTagBase(pageContext);

             UIComponent verbatimComp = createVerbatimComponentFromBodyContent();

             if (verbatimComp != null)

             {

                 component.getChildren().add(verbatimComp);

                 if (parentTag != null)

                 {

                     parentTag.addChild(verbatimComp);

                 }

             }

         }

         catch (Throwable e)

         {

             throw new JspException(e);

         }

         finally

         {

             component = null;

         }

         int retValue = getDoEndValue();

         internalRelease();

         return retValue;

     }

     /**

      * @throws JspException  

      */

     protected int getDoAfterBodyValue() throws JspException

     {

         return SKIP_BODY;

     }

     /**

      * Get the value to be returned by the doStartTag method to the JSP framework. Subclasses which wish to use the

      * inherited doStartTag but control whether the tag is permitted to contain nested tags or not can just override

      * this method to return Tag.SOME_CONSTANT.

      * 

      * @return BodyTag.EVAL_BODY_BUFFERED

      * @throws JspException 

      */

     protected int getDoStartValue() throws JspException

     {

         return BodyTag.EVAL_BODY_BUFFERED;

     }

     /**

      * Get the value to be returned by the doEndTag method to the JSP framework. Subclasses which wish to use the

      * inherited doEndTag but control whether the tag is permitted to contain nested tags or not can just override this

      * method to return Tag.SOME_CONSTANT.

      * 

      * @return Tag.EVAL_PAGE

      * @throws JspException 

      */

     protected int getDoEndValue() throws JspException

     {

         return Tag.EVAL_PAGE;

     }

     protected String getFacetName()

     {

         return isFacet() ? ((FacetTag)_parent).getName() : null;

     }

     /**

      * Creates a UIComponent from the BodyContent

      */

     protected UIComponent createVerbatimComponentFromBodyContent()

     {

         UIOutput verbatimComp = null;

         if (bodyContent != null)

         {

             String strContent = bodyContent.getString();

             if (strContent != null)

             {

                 String trimmedContent = strContent.trim();

                 if (trimmedContent.length() > 0 && !isComment(strContent))

                 {

                     verbatimComp = createVerbatimComponent();

                     verbatimComp.setValue(strContent);

                 }

             }

             bodyContent.clearBody();

         }

         return verbatimComp;

     }

     private static boolean isComment(String bodyContent)

     {

         return (bodyContent.startsWith("<!--") && bodyContent.endsWith("-->"));

     }

     /**

      * <p>

      * Creates a transient UIOutput using the Application, with the following characteristics:

      * </p>

      * <p/>

      * <p>

      * <code>componentType</code> is <code>javax.faces.HtmlOutputText</code>.

      * </p>

      * <p/>

      * <p>

      * <code>transient</code> is <code>true</code>.

      * </p>

      * <p/>

      * <p>

      * <code>escape</code> is <code>false</code>.

      * </p>

      * <p/>

      * <p>

      * <code>id</code> is <code>FacesContext.getViewRoot().createUniqueId()</code>

      * </p>

      */

     protected UIOutput createVerbatimComponent()

     {

         UIOutput verbatimComp =

                 (UIOutput)getFacesContext().getApplication().createComponent("javax.faces.HtmlOutputText");

         verbatimComp.setTransient(true);

         verbatimComp.getAttributes().put("escape", Boolean.FALSE);

         verbatimComp.setId(getFacesContext().getViewRoot().createUniqueId());

         return verbatimComp;

     }

     @SuppressWarnings("unchecked")

     protected void addVerbatimBeforeComponent(UIComponentClassicTagBase parentTag, UIComponent verbatimComp,

                                               UIComponent component)

     {

         UIComponent parent = component.getParent();

         if (parent == null)

         {

             return;

         }

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

         // EDGE CASE:

         // Consider CASE 1 or 2 where the _componentInstance is provided via a

         // _componentInstance binding in session or application scope.

         // The automatically created UIOuput instances for the template text

         // will already be present. Check the JSP_CREATED_COMPONENT_IDS attribute,

         // if present and the number of created components is the same

         // as the number of children replace at a -1 offset from the current

         // value of indexOfComponentInParent, otherwise, call add()

         List<String> childrenAddedIds = (List<String>)parent.getAttributes().get(FORMER_CHILD_IDS_SET_ATTR);

         int parentIndex = children.indexOf(component);

         if (childrenAddedIds != null)

         {

             if (parentIndex > 0 && childrenAddedIds.size() == parentIndex)

             {

                 UIComponent formerVerbatim = children.get(parentIndex - 1);

                 if (formerVerbatim instanceof UIOutput && formerVerbatim.isTransient())

                 {

                     children.set(parentIndex - 1, verbatimComp);

                 }

             }

         }

         children.add(parentIndex, verbatimComp);

         parentTag.addChild(verbatimComp);

     }

     /**

      * <p>

      * Add <i>verbatim</i> as a sibling of <i>_componentInstance</i> in <i>_componentInstance</i> in the parent's child

      * list. <i>verbatim</i> is added to the list at the position immediatly following <i>_componentInstance</i>.

      * </p>

      */

     protected void addVerbatimAfterComponent(UIComponentClassicTagBase parentTag, UIComponent verbatim,

                                              UIComponent component)

     {

         int indexOfComponentInParent = 0;

         UIComponent parent = component.getParent();

         // invert the order of this if and the assignment below. Since this line is

         // here, it appears an early return is acceptable/desired if parent is null,

         // and, if it is null, we should probably check for that before we try to

         // access it. 2006-03-15 jdl

         if (null == parent)

         {

             return;

         }

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

         indexOfComponentInParent = children.indexOf(component);

         if (children.size() - 1 == indexOfComponentInParent)

         {

             children.add(verbatim);

         }

         else

         {

             children.add(indexOfComponentInParent + 1, verbatim);

         }

         parentTag.addChild(verbatim);

     }

     /**

      * @deprecated the ResponseWriter is now set by {@link javax.faces.application.ViewHandler#renderView}

      */

     protected void setupResponseWriter()

     {

     }

     /**

      * Invoke encodeBegin on the associated UIComponent. Subclasses can override this method to perform custom

      * processing before or after the UIComponent method invocation.

      */

     protected void encodeBegin() throws IOException

     {

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Entered encodeBegin for client-Id: " + _componentInstance.getClientId(getFacesContext()));

         }

         _componentInstance.encodeBegin(getFacesContext());

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Exited encodeBegin");

         }

     }

     /**

      * Invoke encodeChildren on the associated UIComponent. Subclasses can override this method to perform custom

      * processing before or after the UIComponent method invocation. This is only invoked for components whose

      * getRendersChildren method returns true.

      */

     protected void encodeChildren() throws IOException

     {

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Entered encodeChildren for client-Id: " + _componentInstance.getClientId(getFacesContext()));

         }

         _componentInstance.encodeChildren(getFacesContext());

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Exited encodeChildren for client-Id: " + _componentInstance.getClientId(getFacesContext()));

         }

     }

     /**

      * Invoke encodeEnd on the associated UIComponent. Subclasses can override this method to perform custom processing

      * before or after the UIComponent method invocation.

      */

     protected void encodeEnd() throws IOException

     {

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Entered encodeEnd for client-Id: " + _componentInstance.getClientId(getFacesContext()));

         }

         _componentInstance.encodeEnd(getFacesContext());

         if (log.isLoggable(Level.FINE))

         {

             log.fine("Exited encodeEnd for client-Id: " + _componentInstance.getClientId(getFacesContext()));

         }

     }

     private boolean isRootTag(UIComponentClassicTagBase parentTag)

     {

         return (parentTag == this);

     }

     private boolean isInRenderedChildrenComponent(UIComponentClassicTagBase tag)

     {

         return (_parentClassicTag != null && tag.getComponentInstance().getRendersChildren());

     }

     private boolean isFacet()

     {

         return _parent != null && _parent instanceof FacetTag;

     }

     /** Map of <ID,Tag> in the view */

     @SuppressWarnings("unchecked")

     private Map<String, Object> getViewComponentIds()

     {

         Map<Object, Object> attributes = _facesContext.getAttributes();

         Map<String, Object> viewComponentIds;

         if (_parent == null)

         {

             // top level _componentInstance

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

             attributes.put(VIEW_IDS, viewComponentIds);

         }

         else

         {

             viewComponentIds = (Map<String, Object>) attributes.get(VIEW_IDS);

             // Check if null, this can happen if someone programatically tries to do an include of a 

             // JSP fragment. This code will prevent NullPointerException from happening in such cases.

             if (viewComponentIds == null)

             {

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

                 attributes.put(VIEW_IDS, viewComponentIds);

             }

         }

         return viewComponentIds;

     }

     @SuppressWarnings("unchecked")

     private static final Stack<UIComponentClassicTagBase> getStack(PageContext pageContext)

     {

         Stack<UIComponentClassicTagBase> stack =

                 (Stack<UIComponentClassicTagBase>)pageContext.getAttribute(COMPONENT_STACK_ATTR,

                     PageContext.REQUEST_SCOPE);

         if (stack == null)

         {

             stack = new Stack<UIComponentClassicTagBase>();

             pageContext.setAttribute(COMPONENT_STACK_ATTR, stack, PageContext.REQUEST_SCOPE);

         }

         return stack;

     }

     /**

      * The pageContext's request scope map is used to hold a stack of JSP tag objects seen so far, so that a new tag can

      * find the parent tag that encloses it. Access to the parent tag is used to find the parent UIComponent for the

      * component associated with this tag plus some other uses.

      */

     private void popTag()

     {

         Stack<UIComponentClassicTagBase> stack = getStack(pageContext);

         int size = stack.size();

         stack.remove(size - 1);

         if (size <= 1)

         {

             pageContext.removeAttribute(COMPONENT_STACK_ATTR, PageContext.REQUEST_SCOPE);

         }

     }

     private void pushTag()

     {

         getStack(pageContext).add(this);

     }

     //private boolean isIncludedOrForwarded() {

     //    return getFacesContext().getExternalContext().getRequestMap().

     //            containsKey("javax.servlet.include.request_uri");

     //}

     /** Generate diagnostic output. */

     private String getPathToComponent(UIComponent component)

     {

         StringBuffer buf = new StringBuffer();

         if (component == null)

         {

             buf.append("{Component-Path : ");

             buf.append("[null]}");

             return buf.toString();

         }

         getPathToComponent(component, buf);

         buf.insert(0, "{Component-Path : ");

         buf.append("}");

         return buf.toString();

     }

     /** Generate diagnostic output. */

     private static void getPathToComponent(UIComponent component, StringBuffer buf)

     {

         if (component == null)

         {

             return;

         }

         StringBuffer intBuf = new StringBuffer();

         intBuf.append("[Class: ");

         intBuf.append(component.getClass().getName());

         if (component instanceof UIViewRoot)

         {

             intBuf.append(",ViewId: ");

             intBuf.append(((UIViewRoot)component).getViewId());

         }

         else

         {

             intBuf.append(",Id: ");

             intBuf.append(component.getId());

         }

         intBuf.append("]");

         buf.insert(0, intBuf);

         getPathToComponent(component.getParent(), buf);

     }

     /**

      * Remove any child components of the associated components which do not have corresponding tags as children of this

      * tag. This only happens when a view is being re-rendered and there are components in the view tree which don't

      * have corresponding JSP tags. Wrapping JSF tags in JSTL "c:if" statements is one way this can happen. <br />

      * Attention: programmatically added components are are not affected by this: they will not be on the old list of

      * created components nor on the new list of created components, so nothing will happen to them.

      */

     @SuppressWarnings("unchecked")

     private void removeFormerChildren(UIComponent component)

     {

         List<String> formerChildIds = (List<String>)component.getAttributes().get(FORMER_CHILD_IDS_SET_ATTR);

         if (formerChildIds != null)

         {

             for (String childId : formerChildIds)

             {

                 if (_childrenAdded == null || !_childrenAdded.contains(childId))

                 {

                     UIComponent childToRemove = component.findComponent(childId);

                     if (childToRemove != null)

                     {

                         component.getChildren().remove(childToRemove);

                     }

                 }

             }

             if (_childrenAdded == null)

             {

                 component.getAttributes().remove(FORMER_CHILD_IDS_SET_ATTR);

             }

             else

             {

                 component.getAttributes().put(FORMER_CHILD_IDS_SET_ATTR, _childrenAdded);

             }

         }

         else

         {

             if (_childrenAdded != null)

             {

                 component.getAttributes().put(FORMER_CHILD_IDS_SET_ATTR, _childrenAdded);

             }

         }

     }

     /** See removeFormerChildren. */

     @SuppressWarnings("unchecked")

     private void removeFormerFacets(UIComponent component)

     {

         List<String> formerFacetNames = (List<String>)component.getAttributes().get(FORMER_FACET_NAMES_SET_ATTR);

         if (formerFacetNames != null)

         {

             for (String facetName : formerFacetNames)

             {

                 if (_facetsAdded == null || !_facetsAdded.contains(facetName))

                 {

                     component.getFacets().remove(facetName);

                 }

             }

             if (_facetsAdded == null)

             {

                 component.getAttributes().remove(FORMER_FACET_NAMES_SET_ATTR);

             }

             else

             {

                 component.getAttributes().put(FORMER_FACET_NAMES_SET_ATTR, _facetsAdded);

             }

         }

         else

         {

             if (_facetsAdded != null)

             {

                 component.getAttributes().put(FORMER_FACET_NAMES_SET_ATTR, _facetsAdded);

             }

         }

     }

     /**

      * Return the corresponding UIComponent for this tag, creating it if necessary.

      * <p>

      * If this is not the first time this method has been called, then return the cached _componentInstance instance

      * found last time.

      * <p>

      * If this is not the first time this view has been seen, then locate the existing _componentInstance using the id

      * attribute assigned to this tag and return it. Note that this is simple for components with user-assigned ids. For

      * components with generated ids, the "reattachment" relies on the fact that UIViewRoot will generate the same id

      * values for tags in this page as it did when first generating the view. For this reason all JSF tags within a JSTL

      * "c:if" are required to have explicitly-assigned ids.

      * <p>

      * Otherwise create the _componentInstance, populate its properties from the xml attributes on this JSP tag and

      * attach it to its parent.

      * <p>

      * When a _componentInstance is found or created the parent JSP tag is also told that the _componentInstance has

      * been "seen". When the parent tag ends it will delete any components which were in the view previously but have

      * not been seen this time; see doEndTag for more details.

      */

     protected UIComponent findComponent(FacesContext context) throws JspException

     {

         // 1. If we have previously located this component, return it.

         if (_componentInstance != null)

         {

             return _componentInstance;

         }

         // 2. Locate the parent component by looking for a parent UIComponentTag instance,

         // and ask it for its component. If there is no parent UIComponentTag instance,

         // this tag represents the root component, so get it from the current Tree and return it.

         UIComponentClassicTagBase parentTag = getParentUIComponentClassicTagBase(pageContext);

         if (parentTag == null)

         {

             // This is the root

             _componentInstance = context.getViewRoot();

             // check if the view root is already bound to the tag

             Object alreadyBoundViewRootFlag = _componentInstance.getAttributes().get(BOUND_VIEW_ROOT);

             if (alreadyBoundViewRootFlag == null)

             {

                 try

                 {

                     setProperties(_componentInstance);

                 }

                 catch (Throwable e)

                 {

                     throw new JspException(e);

                 }

                 if (_id != null)

                 {

                     _componentInstance.setId(_id);

                 }

                 else

                 {

                     _componentInstance.setId(getFacesJspId());

                 }

                 _componentInstance.getAttributes().put(BOUND_VIEW_ROOT, true);

                 _created = true;

             }

             else if (hasBinding())

             {

                 setProperties(_componentInstance);

             }

             return _componentInstance;

         }

         UIComponent parent = parentTag.getComponentInstance();

         if (parent == null)

         {

             throw new IllegalStateException("parent is null?");

         }

         String facetName = getFacetName();

         if (facetName != null)

         {

             // Facet

             String id = createUniqueId(context, parent);

             _componentInstance = parent.getFacet(facetName);

             if (_componentInstance == null)

             {

                 _componentInstance = createComponent(context, id);

                 _created = true;

                 parent.getFacets().put(facetName, _componentInstance);

             }

             else

             {

                 if (checkFacetNameOnParentExists(parentTag, facetName))

                 {

                     throw new IllegalStateException("facet '" + facetName

                             + "' already has a child associated. current associated _componentInstance id: "

                             + _componentInstance.getClientId(context) + " class: "

                             + _componentInstance.getClass().getName());

                 }

             }

             addFacetNameToParentTag(parentTag, facetName);

             return _componentInstance;

         }

         // Child

         //

         // Note that setProperties is called only when we create the

         // _componentInstance; on later passes, the attributes defined on the

         // JSP tag are set on this Tag object, but then completely

         // ignored.

         String id = createUniqueId(context, parent);

         // Warn users that this tag is about to find/steal the UIComponent

         // that has already been created for a sibling tag with the same id value .

         // _childrenAdded is a Set, and we will stomp over a past id when calling

         // addChildIdToParentTag.

         //

         // It would also be reasonable to throw an exception here rather than

         // just issue a warning as this is a pretty serious problem. However the

         // Sun RI just issues a warning...

         if (parentTag._childrenAdded != null && parentTag._childrenAdded.contains(id))

         {

             if (log.isLoggable(Level.WARNING))

             {

                 log.warning("There is more than one JSF tag with an id : " + id);

             }

         }

         _componentInstance = findComponent(parent, id);

         if (_componentInstance == null)

         {

             _componentInstance = createComponent(context, id);

             if (id.equals(_componentInstance.getId()) )

             {

             _created = true;

             int index = parentTag.getIndexOfNextChildTag();

             if (index > parent.getChildCount())

             {

                 index = parent.getChildCount();

             }

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

             children.add(index, _componentInstance);

         }

             // On weblogic portal using faces-adapter, the id set and the retrieved 

             // one for <netuix:namingContainer> is different. The reason is 

             // this custom solution for integrate jsf changes the id of the parent

             // component to allow the same native portlet to be allocated multiple

             // times in the same page

             else if (null == findComponent(parent,_componentInstance.getId()))

             {

                 _created = true;

                 int index = parentTag.getIndexOfNextChildTag();

                 if (index > parent.getChildCount())

                 {

                     index = parent.getChildCount();

                 }

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

                 children.add(index, _componentInstance);

             }

         }

         return _componentInstance;

     }

     private UIComponent findComponent(UIComponent parent, String id)

     {

         for (UIComponent child : parent.getChildren())

         {

             if (child.getId() != null && child.getId().equals(id))

             {

                 return child;

             }

         }

         return null;

     }

     private String createUniqueId(FacesContext context, UIComponent parent) throws JspException

     {

         String id = getId();

         if (id == null)

         {

             id = getFacesJspId();

         }

         else if (isIdDuplicated(id))

         {

             if (isInAnIterator)

             {

                 setId(createNextId(id));

                 id = getId();

             }

             else

             {

                 if (parent != null)

                 {

                     UIComponent namingContainer;

                     if (parent instanceof NamingContainer)

                     {

                         namingContainer = parent;

                     }

                     else

                     {

                         namingContainer = parent.getParent();

                     }

                     if (namingContainer != null)

                     {

                         UIComponent component = namingContainer.findComponent(id);

                         if (component == null || isPostBack(context))

                         {

                             return id;

                         }

                     }

                 }

                 throw new JspException("Duplicated Id found in the view: " + id);

             }

         }

         return id;

     }

     private String createNextId(String componentId)

     {

         Integer currentCounter = (Integer) getFacesContext().getAttributes().get(componentId);

         int iCurrentCounter = 1;

         if (currentCounter != null)

         {

             iCurrentCounter = currentCounter;

             iCurrentCounter++;

         }

         getFacesContext().getAttributes().put(componentId, iCurrentCounter);

         //if (isIncludedOrForwarded())