/*

  * 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.tag.jsf;

 import java.io.IOException;

 import java.util.Collections;

 import java.util.EnumSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.el.ValueExpression;

 import javax.faces.FacesWrapper;

 import javax.faces.application.Application;

 import javax.faces.application.ProjectStage;

 import javax.faces.component.ActionSource;

 import javax.faces.component.EditableValueHolder;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UIOutput;

 import javax.faces.component.UniqueIdVendor;

 import javax.faces.component.ValueHolder;

 import javax.faces.component.behavior.ClientBehaviorHolder;

 import javax.faces.component.visit.VisitCallback;

 import javax.faces.component.visit.VisitContext;

 import javax.faces.component.visit.VisitHint;

 import javax.faces.component.visit.VisitResult;

 import javax.faces.context.FacesContext;

 import javax.faces.event.PhaseId;

 import javax.faces.validator.BeanValidator;

 import javax.faces.validator.Validator;

 import javax.faces.view.EditableValueHolderAttachedObjectHandler;

 import javax.faces.view.facelets.ComponentConfig;

 import javax.faces.view.facelets.ComponentHandler;

 import javax.faces.view.facelets.FaceletContext;

 import javax.faces.view.facelets.MetaRuleset;

 import javax.faces.view.facelets.TagAttribute;

 import javax.faces.view.facelets.TagException;

 import javax.faces.view.facelets.TagHandlerDelegate;

 import javax.faces.view.facelets.ValidatorHandler;

 import org.apache.myfaces.util.ExternalSpecifications;

 import org.apache.myfaces.view.facelets.AbstractFaceletContext;

 import org.apache.myfaces.view.facelets.ComponentState;

 import org.apache.myfaces.view.facelets.DefaultFaceletsStateManagementStrategy;

 import org.apache.myfaces.view.facelets.FaceletCompositionContext;

 import org.apache.myfaces.view.facelets.FaceletDynamicComponentRefreshTransientBuildEvent;

 import org.apache.myfaces.view.facelets.FaceletViewDeclarationLanguage;

 import org.apache.myfaces.view.facelets.FaceletViewDeclarationLanguageBase;

 import org.apache.myfaces.view.facelets.el.CompositeComponentELUtils;

 import org.apache.myfaces.view.facelets.tag.MetaRulesetImpl;

 import org.apache.myfaces.view.facelets.tag.jsf.core.AjaxHandler;

 import org.apache.myfaces.view.facelets.tag.jsf.core.FacetHandler;

 /**

  *  

  * Implementation of the tag logic used in the JSF specification. 

  * 

  * @see org.apache.myfaces.view.facelets.tag.jsf.ComponentHandler

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

  * @version $Revision$ $Date$

  *

  * @since 2.0

  */

 public class ComponentTagHandlerDelegate extends TagHandlerDelegate

 {

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

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

             EnumSet.of(VisitHint.SKIP_ITERATION));

     private final ComponentHandler _delegate;

     private final String _componentType;

     private final TagAttribute _id;

     private final String _rendererType;

     private final ComponentBuilderHandler _componentBuilderHandlerDelegate;

     private final RelocatableResourceHandler _relocatableResourceHandler;

     @SuppressWarnings("unchecked")

     public ComponentTagHandlerDelegate(ComponentHandler delegate)

     {

         _delegate = delegate;

         ComponentConfig delegateComponentConfig = delegate.getComponentConfig();

         _componentType = delegateComponentConfig.getComponentType();

         _rendererType = delegateComponentConfig.getRendererType();

         _id = delegate.getTagAttribute("id");      

         ComponentHandler handler = _delegate;

         boolean found = false;

         while(handler != null && !found)

         {

             if (handler instanceof ComponentBuilderHandler)

             {

                 found = true;

             }

             else if (handler instanceof FacesWrapper)

             {

                 handler = ((FacesWrapper<? extends ComponentHandler>)handler).getWrapped();

             }

             else

             {

                 handler = null;

             }

         }

         if (found)

         {

             _componentBuilderHandlerDelegate = (ComponentBuilderHandler) handler;

         }

         else

         {

             _componentBuilderHandlerDelegate = null;

         }

         //Check if this component is instance of RelocatableResourceHandler

         handler = _delegate;

         found = false;

         while(handler != null && !found)

         {

             if (handler instanceof RelocatableResourceHandler)

             {

                 found = true;

             }

             else if (handler instanceof FacesWrapper)

             {

                 handler = ((FacesWrapper<? extends ComponentHandler>)handler).getWrapped();

             }

             else

             {

                 handler = null;

             }

         }

         if (found)

         {

             _relocatableResourceHandler = (RelocatableResourceHandler) handler;

         }

         else

         {

             // Check if the component is a relocatable component done overriding the tag handler

             if (_componentType != null && _rendererType != null &&

                 (_rendererType.equals("javax.faces.resource.Script") ||

                  _rendererType.equals("javax.faces.resource.Stylesheet")) &&

                 _componentType.equals(UIOutput.COMPONENT_TYPE))

             {

                 _relocatableResourceHandler = ComponentRelocatableResourceHandler.INSTANCE;

             }   

             else

             {

                 _relocatableResourceHandler = null;

             }

         }

     }

     /**

      * Method handles UIComponent tree creation in accordance with the JSF 1.2 spec.

      * <ol>

      * <li>First determines this UIComponent's id by calling {@link #getId(FaceletContext) getId(FaceletContext)}.</li>

      * <li>Search the parent for an existing UIComponent of the id we just grabbed</li>

      * <li>If found, {@link FaceletCompositionContext#markForDeletion(UIComponent) mark} its children for deletion.</li>

      * <li>If <i>not</i> found, call {@link #createComponent(FaceletContext) createComponent}.

      * <ol>

      * <li>Only here do we apply

      * {@link javax.faces.view.facelets.TagHandler#setAttributes(FaceletCompositionContext, Object) attributes}</li>

      * <li>Set the UIComponent's id</li>

      * <li>Set the RendererType of this instance</li>

      * </ol>

      * </li>

      * <li>Now apply the nextHandler, passing the UIComponent we've created/found.</li>

      * <li>Now add the UIComponent to the passed parent</li>

      * <li>Lastly, if the UIComponent already existed (found),

      * then {@link #finalizeForDeletion(FaceletCompositionContext, UIComponent) finalize}

      * for deletion.</li>

      * </ol>

      * 

      * @see javax.faces.view.facelets.FaceletHandler#apply(javax.faces.view.facelets.FaceletContext,

      * javax.faces.component.UIComponent)

      * 

      * @throws TagException

      *             if the UIComponent parent is null

      */

     @SuppressWarnings("unchecked")

     @Override

     public void apply(FaceletContext ctx, UIComponent parent) throws IOException

     {

         // make sure our parent is not null

         if (parent == null)

         {

             throw new TagException(_delegate.getTag(), "Parent UIComponent was null");

         }

         FacesContext facesContext = ctx.getFacesContext();

         // possible facet scoped

         String facetName = this.getFacetName(ctx, parent);

         // our id

         String id = ctx.generateUniqueId(_delegate.getTagId());

         // Cast to use UniqueIdVendor stuff

         FaceletCompositionContext mctx = (FaceletCompositionContext) FaceletCompositionContext.getCurrentInstance(ctx);

         // grab our component

         UIComponent c = null;

         //boolean componentFoundInserted = false;

         //Used to preserve the original parent. Note when the view is being refreshed, the real parent could be

         //another component.

         UIComponent oldParent = parent;

         if (mctx.isRefreshingSection())

         {

             if (_relocatableResourceHandler != null)

             {

                 c = _relocatableResourceHandler.findChildByTagId(ctx, parent, id);

             }

             else

             {

                 if (facetName != null)

                 {

                     c = ComponentSupport.findChildInFacetByTagId(parent, id, facetName);

                 }

                 else

                 {

                     c = ComponentSupport.findChildInChildrenByTagId(parent, id);

                 }

             }

         }

         boolean componentFound = false;

         if (c != null)

         {

             componentFound = true;

             // Check if the binding needs dynamic refresh and if that so, invoke the refresh from this location, to

             // preserve the same context

             if (_delegate.getBinding() != null &&

                 c.getAttributes().containsKey(

                     FaceletDynamicComponentRefreshTransientBuildEvent.DYNAMIC_COMPONENT_BINDING_NEEDS_REFRESH))

             {

                 VisitContext visitContext = (VisitContext) mctx.getVisitContextFactory().

                     getVisitContext(facesContext, null, VISIT_HINTS_DYN_REFRESH);

                 c.visitTree(visitContext, new PublishFaceletDynamicComponentRefreshTransientBuildCallback());

             }

             mctx.incrementUniqueComponentId();

             // mark all children for cleaning

             if (log.isLoggable(Level.FINE))

             {

                 log.fine(_delegate.getTag() + " Component[" + id + "] Found, marking children for cleanup");

             }

             // The call for mctx.markForDeletion(c) is always necessary, because

             // component resource relocation occur as an effect of PostAddToViewEvent,

             // so at this point it is unknown if the component was relocated or not.

             mctx.markForDeletion(c);

             if (_relocatableResourceHandler != null)

             {

                 mctx.markRelocatableResourceForDeletion(c);

             }

         }

         else

         {

             c = this.createComponent(ctx);

             if (log.isLoggable(Level.FINE))

             {

                 log.fine(_delegate.getTag() + " Component[" + id + "] Created: " + c.getClass().getName());

             }

             _delegate.setAttributes(ctx, c);

             // mark it owned by a facelet instance

             c.getAttributes().put(ComponentSupport.MARK_CREATED, id);

             if (facesContext.isProjectStage(ProjectStage.Development))

             {

                 c.getAttributes().put(UIComponent.VIEW_LOCATION_KEY,

                         _delegate.getTag().getLocation());

             }

             // assign our unique id

             if (this._id != null)

             {

                 mctx.incrementUniqueComponentId();

                 c.setId(this._id.getValue(ctx));

             }

             else

             {

                 String componentId = mctx.generateUniqueComponentId();

                 UniqueIdVendor uniqueIdVendor = mctx.getUniqueIdVendorFromStack();

                 if (uniqueIdVendor == null)

                 {

                     uniqueIdVendor = facesContext.getViewRoot();

                     if (uniqueIdVendor == null)

                     {

                         // facesContext.getViewRoot() returns null here if we are in

                         // phase restore view, so we have to try to get the view root

                         // via the method in ComponentSupport and our parent

                         uniqueIdVendor = ComponentSupport.getViewRoot(ctx, parent);

                     }

                 }

                 if (uniqueIdVendor != null)

                 {

                     // UIViewRoot implements UniqueIdVendor, so there is no need to cast to UIViewRoot

                     // and call createUniqueId()

                     String uid = uniqueIdVendor.createUniqueId(facesContext, componentId);

                     c.setId(uid);

                 }

             }

             if (this._rendererType != null)

             {

                 c.setRendererType(this._rendererType);

             }

             // hook method

             _delegate.onComponentCreated(ctx, c, parent);

             if (_relocatableResourceHandler != null && 

                 _relocatableResourceHandler instanceof ComponentRelocatableResourceHandler)

             {

                 UIComponent parentCompositeComponent

                         = mctx.getCompositeComponentFromStack();

                 if (parentCompositeComponent != null)

                 {

                     c.getAttributes().put(CompositeComponentELUtils.LOCATION_KEY,

                             parentCompositeComponent.getAttributes().get(CompositeComponentELUtils.LOCATION_KEY));

                 }

             }

             if (mctx.isRefreshingTransientBuild() && _relocatableResourceHandler != null)

             {

                 mctx.markRelocatableResourceForDeletion(c);

             }

         }

         c.pushComponentToEL(facesContext, c);

         if (c instanceof UniqueIdVendor)

         {

             mctx.pushUniqueIdVendorToStack((UniqueIdVendor)c);

         }

         if (mctx.isDynamicComponentTopLevel())

         {

             mctx.setDynamicComponentTopLevel(false);

             _delegate.applyNextHandler(ctx, c);

             mctx.setDynamicComponentTopLevel(true);

         }

         else

         {

             // first allow c to get populated

             _delegate.applyNextHandler(ctx, c);

         }

         boolean oldProcessingEvents = facesContext.isProcessingEvents();

         // finish cleaning up orphaned children

         if (componentFound && !mctx.isDynamicComponentTopLevel())

         {

             mctx.finalizeForDeletion(c);

             //if (!componentFoundInserted)

             //{

                 if (mctx.isRefreshingSection())

                 {

                     facesContext.setProcessingEvents(false);

                     if (_relocatableResourceHandler != null &&

                         parent != null && !parent.equals(c.getParent()))

                     {

                         // Replace parent with the relocated parent.

                         parent = c.getParent();

                         // Since we changed the parent, the facetName becomes invalid, because it points

                         // to the component before relocation. We need to find the right facetName (if any) so we can

                         // refresh the component properly.

                         UIComponent c1 = ComponentSupport.findChildInChildrenByTagId(parent, id);

                         if (c1 == null)

                         {

                             facetName = ComponentSupport.findChildInFacetsByTagId(parent, id);

                         }

                         else

                         {

                             facetName = null;

                         }

                     }

                     ComponentSupport.setCachedFacesContext(c, facesContext);

                 }

                 if (facetName == null)

                 {

                     parent.getChildren().remove(c);

                 }

                 else

                 {

                     ComponentSupport.removeFacet(ctx, parent, c, facetName);

                 }

                 if (mctx.isRefreshingSection())

                 {

                     ComponentSupport.setCachedFacesContext(c, null);

                     facesContext.setProcessingEvents(oldProcessingEvents);

                 }

             //}

         }

         if (!componentFound)

         {

             if (c instanceof ClientBehaviorHolder && !UIComponent.isCompositeComponent(c))

             {

                 Iterator<AjaxHandler> it = ((AbstractFaceletContext) ctx).getAjaxHandlers();

                 if (it != null)

                 {

                     while(it.hasNext())

                     {

                         it.next().applyAttachedObject(facesContext, c);

                     }

                 }

             }

             if (c instanceof EditableValueHolder)

             {

                 // add default validators here, because this feature 

                 // is only available in facelets (see MYFACES-2362 for details)

                 addEnclosingAndDefaultValidators(ctx, mctx, facesContext, (EditableValueHolder) c);

             }

         }

         _delegate.onComponentPopulated(ctx, c, oldParent);

         if (!mctx.isDynamicComponentTopLevel() || !componentFound)

         {

             if (componentFound && mctx.isRefreshingSection())

             {

                 facesContext.setProcessingEvents(false);

                 ComponentSupport.setCachedFacesContext(c, facesContext);

             }

             if (facetName == null)

             {

                 parent.getChildren().add(c);

             }

             else

             {

                 ComponentSupport.addFacet(ctx, parent, c, facetName);

             }

             if (componentFound && mctx.isRefreshingSection())

             {

                 ComponentSupport.setCachedFacesContext(c, null);

                 facesContext.setProcessingEvents(oldProcessingEvents);

             }

         }

         if (c instanceof UniqueIdVendor)

         {

             mctx.popUniqueIdVendorToStack();

         }

         c.popComponentFromEL(facesContext);

         if (mctx.isMarkInitialState())

         {

             //Call it only if we are using partial state saving

             c.markInitialState();

         }

     }

     /**

      * Return the Facet name we are scoped in, otherwise null

      * 

      * @param ctx

      * @return

      */

     protected final String getFacetName(FaceletContext ctx, UIComponent parent)

     {

         return (String) parent.getAttributes().get(FacetHandler.KEY);

     }

     /**

      * If the binding attribute was specified, use that in conjuction with our componentType String variable to call

      * createComponent on the Application, otherwise just pass the componentType String. <p /> If the binding was used,

      * then set the ValueExpression "binding" on the created UIComponent.

      * 

      * @see Application#createComponent(javax.faces.el.ValueBinding, javax.faces.context.FacesContext, java.lang.String)

      * @see Application#createComponent(java.lang.String)

      * @param ctx

      *            FaceletContext to use in creating a component

      * @return

      */

     protected UIComponent createComponent(FaceletContext ctx)

     {

         if (_componentBuilderHandlerDelegate != null)

         {

             // the call to Application.createComponent(FacesContext, Resource)

             // is delegated because we don't have here the required Resource instance

             return _componentBuilderHandlerDelegate.createComponent(ctx);

         }

         UIComponent c = null;

         FacesContext faces = ctx.getFacesContext();

         Application app = faces.getApplication();

         if (_delegate.getBinding() != null)

         {

             ValueExpression ve = _delegate.getBinding().getValueExpression(ctx, Object.class);

             if (PhaseId.RESTORE_VIEW.equals(faces.getCurrentPhaseId()))

             {

                 if (!ve.isReadOnly(faces.getELContext()))

                 {

                     try

                     {

                         // force reset it is an easy and cheap way to allow "binding" attribute to work on 

                         // view scope beans or flow scope beans (using a transient variable)

                         ve.setValue(faces.getELContext(), null);

                     }

                     catch (Exception e)

                     {

                         // ignore

                     }

                 }

             }

             if (this._rendererType == null)

             {

                 c = app.createComponent(ve, faces, this._componentType);

             }

             else

             {

                 c = app.createComponent(ve, faces, this._componentType, this._rendererType);

             }

             if (c != null)

             {

                 c.setValueExpression("binding", ve);

                 if (!ve.isReadOnly(faces.getELContext()))

                 {

                     ComponentSupport.getViewRoot(ctx, c).getAttributes().put("oam.CALL_PRE_DISPOSE_VIEW", Boolean.TRUE);

                     c.subscribeToEvent(PreDisposeViewEvent.class, new ClearBindingValueExpressionListener());

                 }

                 if (c.getChildCount() > 0 || c.getFacetCount() > 0)

                 {

                     // In this case, this component is used to hold a subtree that is generated

                     // dynamically. In this case, the best is mark this component to be restored

                     // fully, because this ensures the state is correctly preserved. Note this

                     // is only necessary when the component has additional children or facets,

                     // because those components requires an unique id provided by createUniqueId(),

                     // and this ensures stability of the generated ids.

                     c.getAttributes().put(DefaultFaceletsStateManagementStrategy.COMPONENT_ADDED_AFTER_BUILD_VIEW,

                                           ComponentState.REMOVE_ADD);

                     if (FaceletViewDeclarationLanguageBase.isDynamicComponentNeedsRefresh(ctx.getFacesContext()))

                     {

                         FaceletViewDeclarationLanguageBase.resetDynamicComponentNeedsRefreshFlag(

                                 ctx.getFacesContext());

                         FaceletCompositionContext mctx = FaceletCompositionContext.getCurrentInstance(ctx);

                         if (mctx.isUsingPSSOnThisView())

                         {

                             FaceletViewDeclarationLanguage.cleanTransientBuildOnRestore(faces);

                         }

                         else

                         {

                             FaceletViewDeclarationLanguageBase.activateDynamicComponentRefreshTransientBuild(faces);

                         }

                         //

                         // Mark top binding component to be dynamically refreshed. In that way, facelets algorithm

                         // will be able to decide if the component children requires to be refreshed dynamically 

                         // or not.

                         c.getAttributes().put(

                                 FaceletDynamicComponentRefreshTransientBuildEvent.

                                     DYNAMIC_COMPONENT_BINDING_NEEDS_REFRESH,

                                 Boolean.TRUE);

                     }

                 }

             }

         }

         else

         {

             // According to the, spec call the second alternative with null rendererType gives

             // the same result, but without the unnecesary call for FacesContext.getCurrentInstance().

             // Saves 1 call per component without rendererType (f:viewParam, h:column, f:selectItem, ...)

             // and it does not have any side effects (the spec javadoc mentions in a explicit way

             // that rendererType can be null!).

             /*

             if (this._rendererType == null)

             {

                 c = app.createComponent(this._componentType);

             }

             else

             {*/

                 c = app.createComponent(faces, this._componentType, this._rendererType);

             //}

         }

         return c;

     }

     /**

      * If the id TagAttribute was specified, get it's value, otherwise generate a unique id from our tagId.

      * 

      * @see TagAttribute#getValue(FaceletContext)

      * @param ctx

      *            FaceletContext to use

      * @return what should be a unique Id

      */

     protected String getId(FaceletContext ctx)

     {

         if (this._id != null)

         {

             return this._id.getValue(ctx);

         }

         return ctx.generateUniqueId(_delegate.getTagId());

     }

     @Override

     public MetaRuleset createMetaRuleset(Class type)

     {

         MetaRuleset m = new MetaRulesetImpl(_delegate.getTag(), type);

         // ignore standard component attributes

         m.ignore("binding").ignore("id");

         // add auto wiring for attributes

         m.addRule(ComponentRule.INSTANCE);

         // add special rule for passthrough attributes

         m.addRule(PassthroughRuleImpl.INSTANCE);

         // if it's an ActionSource

         if (ActionSource.class.isAssignableFrom(type))

         {

             m.addRule(ActionSourceRule.INSTANCE);

         }

         // if it's a ValueHolder

         if (ValueHolder.class.isAssignableFrom(type))

         {

             m.addRule(ValueHolderRule.INSTANCE);

             // if it's an EditableValueHolder

             if (EditableValueHolder.class.isAssignableFrom(type))

             {

                 m.ignore("submittedValue");

                 m.ignore("valid");

                 m.addRule(EditableValueHolderRule.INSTANCE);

             }

         }

         // allow components to specify the "class" attribute 

         m.alias("class", "styleClass");

         return m;

     }

     /**

      * Add the default Validators to the component.

      * Also adds all validators specified by enclosing <f:validateBean> tags

      * (e.g. the BeanValidator if it is not a default validator).

      *

      * @param context The FacesContext.

      * @param mctx the AbstractFaceletContext

      * @param component The EditableValueHolder to which the validators should be added

      */

     private void addEnclosingAndDefaultValidators(FaceletContext ctx, 

                                       FaceletCompositionContext mctx, 

                                       FacesContext context, 

                                       EditableValueHolder component)

     {

         // add all enclosing validators, because they have precedence over default validators.

         Iterator<Map.Entry<String, EditableValueHolderAttachedObjectHandler>> enclosingValidatorIds =

             mctx.getEnclosingValidatorIdsAndHandlers();

         if (enclosingValidatorIds != null)

         {

             while (enclosingValidatorIds.hasNext())

             {

                 Map.Entry<String, EditableValueHolderAttachedObjectHandler> entry = enclosingValidatorIds.next();

                 addEnclosingValidator(context, component, entry.getKey(), entry.getValue());

             }

         }

         // add all defaultValidators

         Map<String, String> defaultValidators = context.getApplication().getDefaultValidatorInfo();

         if (defaultValidators != null && defaultValidators.size() != 0)

         {

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

             {

                 if (!mctx.containsEnclosingValidatorId(entry.getKey()))

                 {

                     addDefaultValidator(ctx, mctx, context, component, entry.getKey(), entry.getValue());

                 }

             }

         }

     }

     private void addDefaultValidator(FaceletContext ctx, FaceletCompositionContext mctx, FacesContext context, 

             EditableValueHolder component, String validatorId, String validatorClassName)

     {

         Validator enclosingValidator = null;

         if (validatorClassName == null)

         {

             // we have no class name for validators of enclosing <f:validateBean> tags

             // --> we have to create it to get the class name

             // note that normally we can use this instance later anyway!

             enclosingValidator = context.getApplication().createValidator(validatorId);

             validatorClassName = enclosingValidator.getClass().getName();

         }

         // check if the validator is already registered for the given component

         // this happens if <f:validateBean /> is nested inside the component on the view

         Validator validator = null;

         for (Validator v : component.getValidators())

         {

             if (v.getClass().getName().equals(validatorClassName))

             {

                 // found

                 validator = v;

                 break;

             }

         }

         if (validator == null)

         {

             if (shouldAddDefaultValidator(ctx, mctx, component, validatorId))

             {

                 if (enclosingValidator != null)

                 {

                     // we can use the instance from before

                     validator = enclosingValidator;

                 }

                 else

                 {

                     // create it

                     validator = context.getApplication().createValidator(validatorId);

                 }

                 // add the validator to the component

                 component.addValidator(validator);

             }

             else

             {

                 // we should not add the validator

                 return;

             }

         }

         // special things to configure for a BeanValidator

         if (validator instanceof BeanValidator)

         {

             BeanValidator beanValidator = (BeanValidator) validator;

             // check the validationGroups

             String validationGroups =  beanValidator.getValidationGroups();

             if (validationGroups == null 

                     || validationGroups.matches(BeanValidator.EMPTY_VALIDATION_GROUPS_PATTERN))

             {

                 // no validationGroups available

                 // --> get the validationGroups from the stack

                 //String stackGroup = mctx.getFirstValidationGroupFromStack();

                 //if (stackGroup != null)

                 //{

                 //    validationGroups = stackGroup;

                 //}

                 //else

                 //{

                     // no validationGroups on the stack

                     // --> set the default validationGroup

                     validationGroups = javax.validation.groups.Default.class.getName();

                 //}

                 beanValidator.setValidationGroups(validationGroups);

             }

         }

     }

     /**

      * Determine if the validator with the given validatorId should be added.

      *

      * @param validatorId The validatorId.

      * @param facesContext The FacesContext.

      * @param mctx the AbstractFaceletContext

      * @param component The EditableValueHolder to which the validator should be added.

      * @return true if the Validator should be added, false otherwise.

      */

     @SuppressWarnings("unchecked")

     private boolean shouldAddDefaultValidator(FaceletContext ctx, FaceletCompositionContext mctx,

                                               EditableValueHolder component, 

                                               String validatorId)

     {

         // check if the validatorId is on the exclusion list on the component

         List<String> exclusionList 

                 = (List<String>) ((UIComponent) component).getAttributes()

                         .get(ValidatorTagHandlerDelegate.VALIDATOR_ID_EXCLUSION_LIST_KEY);

         if (exclusionList != null)

         {

             for (String excludedId : exclusionList)

             {

                 if (excludedId.equals(validatorId))

                 {

                     return false;

                 }

             }

         }

         // check if the validatorId is on the exclusion list on the stack

         /*

         Iterator<String> it = mctx.getExcludedValidatorIds();

         if (it != null)

         {            

             while (it.hasNext())

             {

                 String excludedId = it.next();

                 if (excludedId.equals(validatorId))

                 {

                     return false;

                 }

             }

         }*/

         Iterator<Map.Entry<String, EditableValueHolderAttachedObjectHandler>> enclosingValidatorIds =

             mctx.getEnclosingValidatorIdsAndHandlers();

         if (enclosingValidatorIds != null)

         {

             while (enclosingValidatorIds.hasNext())

             {

                 Map.Entry<String, EditableValueHolderAttachedObjectHandler> entry = enclosingValidatorIds.next();

                 boolean validatorIdAvailable = entry.getKey() != null && !"".equals(entry.getKey());

                 if (validatorIdAvailable && entry.getKey().equals(validatorId))

                 {

                     if (((ValidatorHandler)((FacesWrapper<ValidatorHandler>)entry.getValue()).getWrapped())

                             .isDisabled(ctx))

                     {

                         return false;

                     }

                 }

             }

         }

         // Some extra rules are required for Bean Validation.

         if (validatorId.equals(BeanValidator.VALIDATOR_ID))

         {

             if (!ExternalSpecifications.isBeanValidationAvailable())

             {

                 // the BeanValidator was added as a default-validator, but

                 // bean validation is not available on the classpath.

                 // --> log a warning about this scenario.

                 log.log(Level.WARNING, "Bean validation is not available on the " +

                         "classpath, thus the BeanValidator will not be added for " +

                         "the component " + component);

                 return false;

             }

         }

         // By default, all default validators should be added

         return true;

     }

     private void addEnclosingValidator(FacesContext context, 

             EditableValueHolder component, String validatorId, 

             EditableValueHolderAttachedObjectHandler attachedObjectHandler)

     {

         if (shouldAddEnclosingValidator(component, validatorId))

         {

             if (attachedObjectHandler != null)

             {

                 attachedObjectHandler.applyAttachedObject(context, (UIComponent) component);

             }

             else

             {

                 Validator validator = null;

                 // create it

                 validator = context.getApplication().createValidator(validatorId);

                 // special things to configure for a BeanValidator

                 if (validator instanceof BeanValidator)

                 {

                     BeanValidator beanValidator = (BeanValidator) validator;

                     // check the validationGroups

                     String validationGroups =  beanValidator.getValidationGroups();

                     if (validationGroups == null 

                             || validationGroups.matches(BeanValidator.EMPTY_VALIDATION_GROUPS_PATTERN))

                     {

                         // no validationGroups available

                         // --> get the validationGroups from the stack

                         //String stackGroup = mctx.getFirstValidationGroupFromStack();

                         //if (stackGroup != null)

                         //{

                         //    validationGroups = stackGroup;

                         //}

                         //else

                         //{

                             // no validationGroups on the stack

                             // --> set the default validationGroup

                             validationGroups = javax.validation.groups.Default.class.getName();

                         //}

                         beanValidator.setValidationGroups(validationGroups);

                     }

                 }

                 // add the validator to the component

                 component.addValidator(validator);

             }

         }

     }

     /**

      * Determine if the validator with the given validatorId should be added.

      * 

      * The difference here with shouldAddEnclosingValidator is the inner one has

      * precedence over the outer one, so a disable="true" over the same outer 

      * validator, the inner one should ignore this condition. 

      * 

      * @param mctx

      * @param facesContext

      * @param component

      * @param validatorId

      * @return

      */

     @SuppressWarnings("unchecked")

     private boolean shouldAddEnclosingValidator(

             EditableValueHolder component, 

             String validatorId)

     {

         // check if the validatorId is on the exclusion list on the component

         List<String> exclusionList = (List<String>) ((UIComponent) component)

                 .getAttributes()

                 .get(ValidatorTagHandlerDelegate.VALIDATOR_ID_EXCLUSION_LIST_KEY);

         if (exclusionList != null)

         {

             for (String excludedId : exclusionList)

             {

                 if (excludedId.equals(validatorId))

                 {

                     return false;

                 }

             }

         }

         // Some extra rules are required for Bean Validation.

         if (validatorId.equals(BeanValidator.VALIDATOR_ID) &&

             !ExternalSpecifications.isBeanValidationAvailable())

         {

             // the BeanValidator was added as a default-validator, but

             // bean validation is not available on the classpath.

             // --> log a warning about this scenario.

             log.log(Level.WARNING,

                     "Bean validation is not available on the "

                             + "classpath, thus the BeanValidator will not be added for "

                             + "the component " + component);

             return false;

         }

         // By default, all default validators should be added

         return true;

     }

     private static class PublishFaceletDynamicComponentRefreshTransientBuildCallback implements VisitCallback

     {

         public VisitResult visit(VisitContext context, UIComponent target)

         {

             context.getFacesContext().getApplication().publishEvent(

                     context.getFacesContext(), FaceletDynamicComponentRefreshTransientBuildEvent.class, 

                     target.getClass(), target);

             return VisitResult.ACCEPT;

         }

     }

 }