/*

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

 import java.beans.BeanDescriptor;

 import java.beans.BeanInfo;

 import java.lang.reflect.Constructor;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Locale;

 import java.util.Map;

 import java.util.MissingResourceException;

 import java.util.TimeZone;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.concurrent.CopyOnWriteArrayList;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.el.CompositeELResolver;

 import javax.el.ELContext;

 import javax.el.ELContextListener;

 import javax.el.ELException;

 import javax.el.ELResolver;

 import javax.el.ExpressionFactory;

 import javax.el.MethodExpression;

 import javax.el.ValueExpression;

 import javax.faces.FacesException;

 import javax.faces.application.Application;

 import javax.faces.application.NavigationHandler;

 import javax.faces.application.ProjectStage;

 import javax.faces.application.Resource;

 import javax.faces.application.ResourceDependencies;

 import javax.faces.application.ResourceDependency;

 import javax.faces.application.ResourceHandler;

 import javax.faces.application.StateManager;

 import javax.faces.application.ViewHandler;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UIComponentBase;

 import javax.faces.component.UINamingContainer;

 import javax.faces.component.UIOutput;

 import javax.faces.component.UIViewRoot;

 import javax.faces.component.behavior.Behavior;

 import javax.faces.component.behavior.ClientBehaviorBase;

 import javax.faces.context.FacesContext;

 import javax.faces.convert.Converter;

 import javax.faces.convert.DateTimeConverter;

 import javax.faces.el.MethodBinding;

 import javax.faces.el.PropertyResolver;

 import javax.faces.el.ReferenceSyntaxException;

 import javax.faces.el.ValueBinding;

 import javax.faces.el.VariableResolver;

 import javax.faces.event.AbortProcessingException;

 import javax.faces.event.ActionListener;

 import javax.faces.event.ComponentSystemEventListener;

 import javax.faces.event.ListenerFor;

 import javax.faces.event.ListenersFor;

 import javax.faces.event.SystemEvent;

 import javax.faces.event.SystemEventListener;

 import javax.faces.event.SystemEventListenerHolder;

 import javax.faces.flow.FlowHandler;

 import javax.faces.render.ClientBehaviorRenderer;

 import javax.faces.render.RenderKit;

 import javax.faces.render.Renderer;

 import javax.faces.render.RendererWrapper;

 import javax.faces.validator.Validator;

 import javax.faces.view.ViewDeclarationLanguage;

 import javax.naming.Context;

 import javax.naming.InitialContext;

 import javax.naming.NamingException;

 import org.apache.commons.beanutils.BeanUtils;

 import org.apache.myfaces.application.cdi.ConverterWrapper;

 import org.apache.myfaces.cdi.util.ExternalArtifactResolver;

 import org.apache.myfaces.application.cdi.ValidatorWrapper;

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

 import org.apache.myfaces.config.RuntimeConfig;

 import org.apache.myfaces.config.element.Property;

 import org.apache.myfaces.config.element.ResourceBundle;

 import org.apache.myfaces.context.RequestViewContext;

 import org.apache.myfaces.context.RequestViewMetadata;

 import org.apache.myfaces.el.PropertyResolverImpl;

 import org.apache.myfaces.el.VariableResolverToApplicationELResolverAdapter;

 import org.apache.myfaces.el.convert.MethodExpressionToMethodBinding;

 import org.apache.myfaces.el.convert.ValueBindingToValueExpression;

 import org.apache.myfaces.el.convert.ValueExpressionToValueBinding;

 import org.apache.myfaces.el.unified.ELResolverBuilder;

 import org.apache.myfaces.el.unified.ResolverBuilderForFaces;

 import org.apache.myfaces.el.unified.resolver.FacesCompositeELResolver;

 import org.apache.myfaces.el.unified.resolver.FacesCompositeELResolver.Scope;

 import org.apache.myfaces.flow.FlowHandlerImpl;

 import org.apache.myfaces.lifecycle.LifecycleImpl;

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

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

 import org.apache.myfaces.util.ExternalSpecifications;

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

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

 /**

  * DOCUMENT ME!

  * 

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

  * @author Anton Koinov

  * @author Thomas Spiegl

  * @author Stan Silvert

  * @version $Revision$ $Date$

  */

 @SuppressWarnings("deprecation")

 public class ApplicationImpl extends Application

 {

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

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

     private final static VariableResolver VARIABLERESOLVER = new VariableResolverToApplicationELResolverAdapter();

     private final static PropertyResolver PROPERTYRESOLVER = new PropertyResolverImpl();

     // the name for the system property which specifies the current ProjectStage (see MYFACES-2545 for details)

     public final static String PROJECT_STAGE_SYSTEM_PROPERTY_NAME = "faces.PROJECT_STAGE";

     // MyFaces specific System Property to set the ProjectStage, if not present via the standard way

     @Deprecated

     public final static String MYFACES_PROJECT_STAGE_SYSTEM_PROPERTY_NAME = "org.apache.myfaces.PROJECT_STAGE";

     /**

      * Indicate the stage of the initialized application.

      */

     @JSFWebConfigParam(defaultValue="Production",

             expectedValues="Development, Production, SystemTest, UnitTest",

             since="2.0")

     private static final String PROJECT_STAGE_PARAM_NAME = "javax.faces.PROJECT_STAGE";

     /**

      * Indicate if the classes associated to components, converters, validators or behaviors

      * should be loaded as soon as they are added to the current application instance or instead

      * loaded in a lazy way.

      */

     @JSFWebConfigParam(defaultValue="true",since="2.0",tags="performance")

     private static final String LAZY_LOAD_CONFIG_OBJECTS_PARAM_NAME = "org.apache.myfaces.LAZY_LOAD_CONFIG_OBJECTS";

     private static final boolean LAZY_LOAD_CONFIG_OBJECTS_DEFAULT_VALUE = true;

     private Boolean _lazyLoadConfigObjects = null;

     /**

      * Key under UIViewRoot to generated unique ids for components added 

      * by @ResourceDependency effect.

      */

     private static final String RESOURCE_DEPENDENCY_UNIQUE_ID_KEY =

               "oam.view.resourceDependencyUniqueId";

     // ~ Instance fields

     // --------------------------------------------------------------------------

     // --

     private Collection<Locale> _supportedLocales = Collections.emptySet();

     private Locale _defaultLocale;

     private String _messageBundle;

     private ViewHandler _viewHandler;

     private NavigationHandler _navigationHandler;

     private ActionListener _actionListener;

     private String _defaultRenderKitId;

     private ResourceHandler _resourceHandler;

     private StateManager _stateManager;

     private FlowHandler _flowHandler;

     private ArrayList<ELContextListener> _elContextListeners;

     // components, converters, and validators can be added at runtime--must

     // synchronize, uses ConcurrentHashMap to allow concurrent read of map

     private final Map<String, Object> _converterIdToClassMap = new ConcurrentHashMap<String, Object>();

     private final Map<Class<?>, Object> _converterTargetClassToConverterClassMap

             = new ConcurrentHashMap<Class<?>, Object>();

     private final Map<String, Object> _componentClassMap = new ConcurrentHashMap<String, Object>();

     private final Map<String, Object> _validatorClassMap = new ConcurrentHashMap<String, Object>();

     private final Map<Class<? extends SystemEvent>, SystemListenerEntry> _systemEventListenerClassMap

             = new ConcurrentHashMap<Class<? extends SystemEvent>, SystemListenerEntry>();

     private final Map<String, String> _defaultValidatorsIds = new HashMap<String, String>();

     private volatile Map<String, String> _cachedDefaultValidatorsIds = null;

     private final Map<String, Object> _behaviorClassMap = new ConcurrentHashMap<String, Object>();

     private final RuntimeConfig _runtimeConfig;

     private ELResolver elResolver;

     private ELResolverBuilder resolverBuilderForFaces;

     private ProjectStage _projectStage;

     private volatile boolean _firstRequestProcessed = false;

     // MYFACES-3442 If HashMap or other non thread-safe structure is used, it is

     // possible to fall in a infinite loop under heavy load unless a synchronized block

     // is used to modify it or a ConcurrentHashMap.

     private final Map<Class<?>, List<ListenerFor>> _classToListenerForMap

             = new ConcurrentHashMap<Class<?>, List<ListenerFor>>() ;

     private final Map<Class<?>, List<ResourceDependency>> _classToResourceDependencyMap

             = new ConcurrentHashMap<Class<?>, List<ResourceDependency>>() ;

     private List<Class<? extends Converter>> _noArgConstructorConverterClasses 

             = new CopyOnWriteArrayList<Class<? extends Converter>>();

     /** Value of javax.faces.DATETIMECONVERTER_DEFAULT_TIMEZONE_IS_SYSTEM_TIMEZONE parameter */

     private boolean _dateTimeConverterDefaultTimeZoneIsSystemTimeZone = false; 

     private final ExternalArtifactResolver _externalArtifactResolver;

     /**

      * Represents semantic null in _componentClassMap. 

      */

     private static final UIComponent NOTHING = new UIComponentBase()

     {

         @Override

         public String getFamily()

         {

             return null;

         }

     };

     // ~ Constructors

     // --------------------------------------------------------------------------

     // -----

     public ApplicationImpl()

     {

         this(getRuntimeConfig());

     }

     private static RuntimeConfig getRuntimeConfig()

     {

         return RuntimeConfig.getCurrentInstance(

                 FacesContext.getCurrentInstance().getExternalContext());

     }

     ApplicationImpl(final RuntimeConfig runtimeConfig)

     {

         if (runtimeConfig == null)

         {

             throw new IllegalArgumentException("runtimeConfig must mot be null");

         }

         // set default implementation in constructor

         // pragmatic approach, no syncronizing will be needed in get methods

         _viewHandler = new ViewHandlerImpl();

         _navigationHandler = new NavigationHandlerImpl();

         _actionListener = new ActionListenerImpl();

         _defaultRenderKitId = "HTML_BASIC";

         _stateManager = new StateManagerImpl();

         _elContextListeners = new ArrayList<ELContextListener>();

         _resourceHandler = new ResourceHandlerImpl();

         _flowHandler = new FlowHandlerImpl();

         _runtimeConfig = runtimeConfig;

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("New Application instance created");

         }

         String configParam = getFaceContext().getExternalContext().

                 getInitParameter(Converter.DATETIMECONVERTER_DEFAULT_TIMEZONE_IS_SYSTEM_TIMEZONE_PARAM_NAME);

         if (configParam != null && configParam.toLowerCase().equals("true"))

         {

             _dateTimeConverterDefaultTimeZoneIsSystemTimeZone = true;

         }

         if (ExternalSpecifications.isCDIAvailable(getFaceContext().getExternalContext()))

         {

             _externalArtifactResolver = (ExternalArtifactResolver) 

                 ClassUtils.newInstance(

                     "org.apache.myfaces.cdi.util.CDIExternalArtifactResolver");

         }

         else

         {

             _externalArtifactResolver = null;

         }

     }

     // ~ Methods

     // --------------------------------------------------------------------------

     // ----------

     @Override

     public final void addELResolver(final ELResolver resolver)

     {

         if (isFirstRequestProcessed())

         {

             throw new IllegalStateException("It is illegal to add a resolver after the first request is processed");

         }

         if (resolver != null)

         {

             _runtimeConfig.addApplicationElResolver(resolver);

         }

     }

     @Override

     public void addDefaultValidatorId(String validatorId)

     {

         if (_validatorClassMap.containsKey(validatorId))

         {

             Class<? extends Validator> validatorClass =

                     getObjectFromClassMap(validatorId, _validatorClassMap);

             // Ensure atomicity between _defaultValidatorsIds and _cachedDefaultValidatorsIds

             synchronized(_defaultValidatorsIds)

             {

                 _defaultValidatorsIds.put(validatorId, validatorClass.getName());

                 _cachedDefaultValidatorsIds = null;

             }

         }

     }

     @Override

     public Map<String, String> getDefaultValidatorInfo()

     {

         // cachedMap ensures we will not return null if after the check for null

         // _cachedDefaultValidatorsIds is set to null. In theory the unmodifiable map

         // always has a reference to _defaultValidatorsIds, so any instance set

         // in _cachedDefaultValidatorsIds is always the same.

         Map<String, String> cachedMap = _cachedDefaultValidatorsIds;

         if (cachedMap == null)

         {

             synchronized(_defaultValidatorsIds)

             {

                 if (_cachedDefaultValidatorsIds == null)

                 {

                     _cachedDefaultValidatorsIds = Collections.unmodifiableMap(_defaultValidatorsIds);

                 }

                 cachedMap = _cachedDefaultValidatorsIds;

             }

         }

         return cachedMap;

     }

     @Override

     public final ELResolver getELResolver()

     {

         // we don't need synchronization here since it is ok to have multiple

         // instances of the elresolver

         if (elResolver == null)

         {

             elResolver = createFacesResolver();

         }

         return elResolver;

     }

     private ELResolver createFacesResolver()

     {

         boolean supportJSPAndFacesEL = MyfacesConfig.getCurrentInstance(

                                 getFaceContext().getExternalContext()).isSupportJSPAndFacesEL();

         CompositeELResolver resolver;

         if (supportJSPAndFacesEL)

         {

             resolver = new FacesCompositeELResolver(Scope.Faces);

         }

         else

         {

             resolver = new CompositeELResolver();

         }

         getResolverBuilderForFaces().build(resolver);

         return resolver;

     }

     protected final ELResolverBuilder getResolverBuilderForFaces()

     {

         if (resolverBuilderForFaces == null)

         {

             resolverBuilderForFaces = new ResolverBuilderForFaces(_runtimeConfig);

         }

         return resolverBuilderForFaces;

     }

     public final void setResolverBuilderForFaces(final ELResolverBuilder factory)

     {

         resolverBuilderForFaces = factory;

     }

     @Override

     public final java.util.ResourceBundle getResourceBundle(final FacesContext facesContext, final String name)

             throws FacesException, NullPointerException

     {

         checkNull(facesContext, "facesContext");

         checkNull(name, "name");

         final String bundleName = getBundleName(facesContext, name);

         if (bundleName == null)

         {

             return null;

         }

         Locale locale = Locale.getDefault();

         final UIViewRoot viewRoot = facesContext.getViewRoot();

         if (viewRoot != null && viewRoot.getLocale() != null)

         {

             locale = viewRoot.getLocale();

         }

         try

         {

             return getResourceBundle(bundleName, locale, getClassLoader());

         }

         catch (MissingResourceException e)

         {

             try

             {

                 return getResourceBundle(bundleName, locale, this.getClass().getClassLoader());

             }

             catch (MissingResourceException e1)

             {            

                 throw new FacesException("Could not load resource bundle for name '"

                                          + name + "': " + e.getMessage(), e1);

             }

         }

     }

     private ClassLoader getClassLoader()

     {

         return ClassUtils.getContextClassLoader();

     }

     String getBundleName(final FacesContext facesContext, final String name)

     {

         ResourceBundle bundle = getRuntimeConfig(facesContext).getResourceBundle(name);

         return bundle != null ? bundle.getBaseName() : null;

     }

     java.util.ResourceBundle getResourceBundle(final String name, final Locale locale, final ClassLoader loader)

             throws MissingResourceException

     {

         return java.util.ResourceBundle.getBundle(name, locale, loader);

     }

     final RuntimeConfig getRuntimeConfig(final FacesContext facesContext)

     {

         return RuntimeConfig.getCurrentInstance(facesContext.getExternalContext());

     }

     final FacesContext getFaceContext()

     {

         return FacesContext.getCurrentInstance();

     }

     @Override

     public final UIComponent createComponent(final ValueExpression componentExpression,

                                              final FacesContext facesContext, final String componentType)

             throws FacesException, NullPointerException

     {

         /*

          * Before the component instance is returned, it must be inspected for the presence of a ListenerFor (or

          * ListenersFor) or ResourceDependency (or ResourceDependencies) annotation. If any of these annotations are

          * present, the action listed in ListenerFor or ResourceDependency must be taken on the component, 

          * before it is

          * returned from this method. This variant of createComponent must not inspect the Renderer for the 

          * component to

          * be returned for any of the afore mentioned annotations. Such inspection is the province of

          */

         checkNull(componentExpression, "componentExpression");

         checkNull(facesContext, "facesContext");

         checkNull(componentType, "componentType");

         ELContext elContext = facesContext.getELContext();

         try

         {

             Object retVal = componentExpression.getValue(elContext);

             UIComponent createdComponent;

             if (retVal instanceof UIComponent)

             {

                 createdComponent = (UIComponent) retVal;

                 _handleAnnotations(facesContext, createdComponent, createdComponent);

             }

             else

             {

                 createdComponent = createComponent(facesContext, componentType);

                 componentExpression.setValue(elContext, createdComponent);

             }

             return createdComponent;

         }

         catch (FacesException e)

         {

             throw e;

         }

         catch (Exception e)

         {

             throw new FacesException(e);

         }

     }

     @Override

     public UIComponent createComponent(ValueExpression componentExpression, FacesContext context, 

                                        String componentType, String rendererType)

     {

         // Like createComponent(ValueExpression, FacesContext, String)

         UIComponent component = createComponent(componentExpression, context, componentType);

         if (rendererType != null)

         {

             _inspectRenderer(context, component, componentType, rendererType);

         }

         return component;

     }

     @Override

     public final ExpressionFactory getExpressionFactory()

     {

         return _runtimeConfig.getExpressionFactory();

     }

     @SuppressWarnings("unchecked")

     @Override

     public final <T> T evaluateExpressionGet(final FacesContext context, final String expression,

                                              final Class<? extends T> expectedType) throws ELException

     {

         ELContext elContext = context.getELContext();

         ExpressionFactory factory = getExpressionFactory();

         return (T) factory.createValueExpression(elContext, expression, expectedType).getValue(elContext);

     }

     @Override

     public final void addELContextListener(final ELContextListener listener)

     {

         synchronized (_elContextListeners)

         {

             _elContextListeners.add(listener);

         }

     }

     @Override

     public void publishEvent(FacesContext facesContext, Class<? extends SystemEvent> systemEventClass,

                              Class<?> sourceBaseType, Object source)

     {

         checkNull(systemEventClass, "systemEventClass");

         checkNull(source, "source");

         //Call events only if event processing is enabled.

         if (!facesContext.isProcessingEvents())

         {

             return;

         }

         // spec: If this argument is null the return from source.getClass() must be used as the sourceBaseType. 

         if (sourceBaseType == null)

         {

             sourceBaseType = source.getClass();

         }

         try

         {

             SystemEvent event = null;

             if (source instanceof SystemEventListenerHolder)

             {

                 SystemEventListenerHolder holder = (SystemEventListenerHolder) source;

                 // If the source argument implements SystemEventListenerHolder, call

                 // SystemEventListenerHolder.getListenersForEventClass(java.lang.Class) on it, passing the

                 // systemEventClass

                 // argument. If the list is not empty, perform algorithm traverseListenerList on the list.

                 event = _traverseListenerList(holder.getListenersForEventClass(systemEventClass), systemEventClass,

                                               source, event);

             }

             UIViewRoot uiViewRoot = facesContext.getViewRoot();

             if (uiViewRoot != null)

             {

                 //Call listeners on view level

                 event = _traverseListenerListWithCopy(uiViewRoot.getViewListenersForEventClass(systemEventClass), 

                         systemEventClass, source, event);

             }

             SystemListenerEntry systemListenerEntry = _systemEventListenerClassMap.get(systemEventClass);

             if (systemListenerEntry != null)

             {

                 systemListenerEntry.publish(systemEventClass, sourceBaseType, source, event);

             }

         }

         catch (AbortProcessingException e)

         {

             // If the act of invoking the processListener method causes an AbortProcessingException to be thrown,

             // processing of the listeners must be aborted, no further processing of the listeners for this event must

             // take place, and the exception must be logged with Level.SEVERE.

             log.log(Level.SEVERE, "Event processing was aborted", e);

         }

     }

     @Override

     public void publishEvent(FacesContext facesContext, Class<? extends SystemEvent> systemEventClass, Object source)

     {

         publishEvent(facesContext, systemEventClass, source.getClass(), source);

     }

     @Override

     public final void removeELContextListener(final ELContextListener listener)

     {

         synchronized (_elContextListeners)

         {

             _elContextListeners.remove(listener);

         }

     }

     @Override

     public final ELContextListener[] getELContextListeners()

     {

         // this gets called on every request, so I can't afford to synchronize

         // I just have to trust that toArray() with do the right thing if the

         // list is changing (not likely)

         return _elContextListeners.toArray(new ELContextListener[_elContextListeners.size()]);

     }

     @Override

     public final void setActionListener(final ActionListener actionListener)

     {

         checkNull(actionListener, "actionListener");

         _actionListener = actionListener;

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("set actionListener = " + actionListener.getClass().getName());

         }

     }

     @Override

     public final ActionListener getActionListener()

     {

         return _actionListener;

     }

     @Override

     public Iterator<String> getBehaviorIds()

     {

         return _behaviorClassMap.keySet().iterator();

     }

     @Override

     public final Iterator<String> getComponentTypes()

     {

         return _componentClassMap.keySet().iterator();

     }

     @Override

     public final Iterator<String> getConverterIds()

     {

         return _converterIdToClassMap.keySet().iterator();

     }

     @Override

     public final Iterator<Class<?>> getConverterTypes()

     {

         return _converterTargetClassToConverterClassMap.keySet().iterator();

     }

     @Override

     public final void setDefaultLocale(final Locale locale)

     {

         checkNull(locale, "locale");

         _defaultLocale = locale;

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("set defaultLocale = " + locale.getCountry() + " " + locale.getLanguage());

         }

     }

     @Override

     public final Locale getDefaultLocale()

     {

         return _defaultLocale;

     }

     @Override

     public final void setMessageBundle(final String messageBundle)

     {

         checkNull(messageBundle, "messageBundle");

         _messageBundle = messageBundle;

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("set MessageBundle = " + messageBundle);

         }

     }

     @Override

     public final String getMessageBundle()

     {

         return _messageBundle;

     }

     @Override

     public final void setNavigationHandler(final NavigationHandler navigationHandler)

     {

         checkNull(navigationHandler, "navigationHandler");

         _navigationHandler = navigationHandler;

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("set NavigationHandler = " + navigationHandler.getClass().getName());

         }

     }

     @Override

     public final NavigationHandler getNavigationHandler()

     {

         return _navigationHandler;

     }

     /**

      * @deprecated

      */

     @Deprecated

     @Override

     public final void setPropertyResolver(final PropertyResolver propertyResolver)

     {

         checkNull(propertyResolver, "propertyResolver");

         if (getFaceContext() != null)

         {

             throw new IllegalStateException("propertyResolver must be defined before request processing");

         }

         _runtimeConfig.setPropertyResolver(propertyResolver);

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("set PropertyResolver = " + propertyResolver.getClass().getName());

         }

     }

     @Override

     public ProjectStage getProjectStage()

     {

         // If the value has already been determined by a previous call to this

         // method, simply return that value.

         if (_projectStage == null)

         {

             String stageName = null;

             // try to obtain the ProjectStage from the system property

             // faces.PROJECT_STAGE as proposed by Ed Burns

             stageName = System.getProperty(PROJECT_STAGE_SYSTEM_PROPERTY_NAME);

             if (stageName == null)

             {

                 // if not found check for the "old" System Property

                 // and print a warning message to the log (just to be 

                 // sure that everyone recognizes the change in the name).

                 stageName = System.getProperty(MYFACES_PROJECT_STAGE_SYSTEM_PROPERTY_NAME);

                 if (stageName != null)

                 {

                     log.log(Level.WARNING, "The system property " + MYFACES_PROJECT_STAGE_SYSTEM_PROPERTY_NAME

                             + " has been replaced by " + PROJECT_STAGE_SYSTEM_PROPERTY_NAME + "!"

                             + " Please change your settings.");

                 }

             }

             if (stageName == null)

             {

                 // Look for a JNDI environment entry under the key given by the

                 // value of ProjectStage.PROJECT_STAGE_JNDI_NAME (return type of

                 // java.lang.String).

                 try

                 {

                     Context ctx = new InitialContext();

                     Object temp = ctx.lookup(ProjectStage.PROJECT_STAGE_JNDI_NAME);

                     if (temp != null)

                     {

                         if (temp instanceof String)

                         {

                             stageName = (String) temp;

                         }

                         else

                         {

                             log.severe("JNDI lookup for key " + ProjectStage.PROJECT_STAGE_JNDI_NAME

                                     + " should return a java.lang.String value");

                         }

                     }

                 }

                 catch (NamingException e)

                 {

                     // no-op

                 }

                 catch (NoClassDefFoundError er)

                 {

                     //On Google App Engine, javax.naming.Context is a restricted class.

                     //In that case, NoClassDefFoundError is thrown. stageName needs to be configured

                     //below by context parameter.

                     //It can be done with changing the order to look first at

                     // context param, but it is defined in the spec.

                     //http://java.sun.com/javaee/6/docs/api/javax/faces/application/Application.html#getProjectStage()

                     //no-op

                 }

             }

             /*

              * If found, continue with the algorithm below, otherwise, look for an entry in the initParamMap of the

              * ExternalContext from the current FacesContext with the key ProjectStage.PROJECT_STAGE_PARAM_NAME

              */

             if (stageName == null)

             {

                 FacesContext context = FacesContext.getCurrentInstance();

                 stageName = context.getExternalContext().getInitParameter(ProjectStage.PROJECT_STAGE_PARAM_NAME);

             }

             // If a value is found

             if (stageName != null)

             {

                 /*

                  * see if an enum constant can be obtained by calling ProjectStage.valueOf(), passing 

                  * the value from the initParamMap. If this succeeds without exception, save the value 

                  * and return it.

                  */

                 try

                 {

                     _projectStage = ProjectStage.valueOf(stageName);

                     return _projectStage;

                 }

                 catch (IllegalArgumentException e)

                 {

                     log.log(Level.INFO, "Couldn't discover the current project stage: "+stageName);

                 }

             }

             else

             {

                 if (log.isLoggable(Level.INFO))

                 {

                     log.info("Couldn't discover the current project stage, using " + ProjectStage.Production);

                 }

             }

             /*

              * If not found, or any of the previous attempts to discover the enum constant value have failed, log a

              * descriptive error message, assign the value as ProjectStage.Production and return it.

              */

             _projectStage = ProjectStage.Production;

         }

         return _projectStage;

     }

     /**

      * @deprecated

      */

     @Deprecated

     @Override

     public final PropertyResolver getPropertyResolver()

     {

         return PROPERTYRESOLVER;

     }

     @Override

     public final void setResourceHandler(ResourceHandler resourceHandler)

     {

         checkNull(resourceHandler, "resourceHandler");

         if(isFirstRequestProcessed())

         {

             throw new IllegalStateException(

                     "setResourceHandler may not be executed after a lifecycle request has been completed");

         }

         _resourceHandler = resourceHandler;

     }

     @Override

     public final ResourceHandler getResourceHandler()

     {

         return _resourceHandler;

     }

     @Override

     public final void setSupportedLocales(final Collection<Locale> locales)

     {

         checkNull(locales, "locales");

         _supportedLocales = locales;

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("set SupportedLocales");

         }

     }

     @Override

     public final Iterator<Locale> getSupportedLocales()

     {

         return _supportedLocales.iterator();

     }

     @Override

     public final Iterator<String> getValidatorIds()

     {

         return _validatorClassMap.keySet().iterator();

     }

     /**

      * @deprecated

      */

     @Deprecated

     @Override

     public final void setVariableResolver(final VariableResolver variableResolver)

     {

         checkNull(variableResolver, "variableResolver");

         if (isFirstRequestProcessed())

         {

             throw new IllegalStateException("variableResolver must be defined before request processing");

         }

         _runtimeConfig.setVariableResolver(variableResolver);

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("set VariableResolver = " + variableResolver.getClass().getName());

         }

     }

     /**

      * @deprecated

      */

     @Deprecated

     @Override

     public final VariableResolver getVariableResolver()

     {

         return VARIABLERESOLVER;

     }

     @Override

     public final void setViewHandler(final ViewHandler viewHandler)

     {

         checkNull(viewHandler, "viewHandler");

         if(isFirstRequestProcessed())

         {

             throw new IllegalStateException(

                     "setViewHandler may not be executed after a lifecycle request has been completed");

         }

         _viewHandler = viewHandler;

         if (log.isLoggable(Level.FINEST))

         {

             log.finest("set ViewHandler = " + viewHandler.getClass().getName());

         }

     }

     @Override

     public void subscribeToEvent(Class<? extends SystemEvent> systemEventClass, SystemEventListener listener)

     {

         subscribeToEvent(systemEventClass, null, listener);

     }

     @Override

     public void subscribeToEvent(Class<? extends SystemEvent> systemEventClass, Class<?> sourceClass,

                                  SystemEventListener listener)

     {

         checkNull(systemEventClass, "systemEventClass");

         checkNull(listener, "listener");

         SystemListenerEntry systemListenerEntry;

         synchronized (_systemEventListenerClassMap)

         {

             systemListenerEntry = _systemEventListenerClassMap.get(systemEventClass);

             if (systemListenerEntry == null)

             {

                 systemListenerEntry = new SystemListenerEntry();

                 _systemEventListenerClassMap.put(systemEventClass, systemListenerEntry);

             }

         }

         systemListenerEntry.addListener(listener, sourceClass);

     }

     @Override

     public void unsubscribeFromEvent(Class<? extends SystemEvent> systemEventClass, SystemEventListener listener)

     {

         unsubscribeFromEvent(systemEventClass, null, listener);

     }

     @Override

     public void unsubscribeFromEvent(Class<? extends SystemEvent> systemEventClass, Class<?> sourceClass,

                                      SystemEventListener listener)

     {

         checkNull(systemEventClass, "systemEventClass");

         checkNull(listener, "listener");

         SystemListenerEntry systemListenerEntry = _systemEventListenerClassMap.get(systemEventClass);

         if (systemListenerEntry != null)

         {

             systemListenerEntry.removeListener(listener, sourceClass);

         }

     }

     @Override

     public final ViewHandler getViewHandler()

     {

         return _viewHandler;

     }

     @Override

     public void addBehavior(String behaviorId, String behaviorClass)

     {

         checkNull(behaviorId, "behaviorId");

         checkEmpty(behaviorId, "behaviorId");

         checkNull(behaviorClass, "behaviorClass");

         checkEmpty(behaviorClass, "behaviorClass");

         try

         {

             if(isLazyLoadConfigObjects())

             {

                 _behaviorClassMap.put(behaviorId, behaviorClass);

             }

             else

             {

                 _behaviorClassMap.put(behaviorId, ClassUtils.simpleClassForName(behaviorClass));

             }

             if (log.isLoggable(Level.FINEST))

             {

                 log.finest("add Behavior class = " + behaviorClass + " for id = " + behaviorId);

             }

         }

         catch (Exception e)

         {

             log.log(Level.SEVERE, "Behavior class " + behaviorClass + " not found", e);

         }

     }

     @Override

     public final void addComponent(final String componentType, final String componentClassName)

     {

         checkNull(componentType, "componentType");

         checkEmpty(componentType, "componentType");

         checkNull(componentClassName, "componentClassName");

         checkEmpty(componentClassName, "componentClassName");

         try

         {

             if(isLazyLoadConfigObjects())

             {

                 _componentClassMap.put(componentType, componentClassName);

             }

             else

             {

                 _componentClassMap.put(componentType, ClassUtils.simpleClassForName(componentClassName));

             }

             if (log.isLoggable(Level.FINEST))

             {

                 log.finest("add Component class = " + componentClassName + " for type = " + componentType);

             }

         }

         catch (Exception e)

         {

             log.log(Level.SEVERE, "Component class " + componentClassName + " not found", e);

         }

     }

     @Override

     public final void addConverter(final String converterId, final String converterClass)

     {

         checkNull(converterId, "converterId");

         checkEmpty(converterId, "converterId");

         checkNull(converterClass, "converterClass");

         checkEmpty(converterClass, "converterClass");

         try

         {

             if(isLazyLoadConfigObjects())

             {

                 _converterIdToClassMap.put(converterId, converterClass);

             }

             else

             {

                 _converterIdToClassMap.put(converterId, ClassUtils.simpleClassForName(converterClass));

             }

             if (log.isLoggable(Level.FINEST))

             {

                 log.finest("add Converter id = " + converterId + " converterClass = " + converterClass);

             }

         }

         catch (Exception e)

         {

             log.log(Level.SEVERE, "Converter class " + converterClass + " not found", e);

         }

     }

     @Override

     public final void addConverter(final Class<?> targetClass, final String converterClass)

     {

         checkNull(targetClass, "targetClass");

         checkNull(converterClass, "converterClass");

         checkEmpty(converterClass, "converterClass");

         try

         {

             if(isLazyLoadConfigObjects())

             {

                 _converterTargetClassToConverterClassMap.put(targetClass, converterClass);

             }

             else

             {

                 _converterTargetClassToConverterClassMap.put(targetClass,

                                                              ClassUtils.simpleClassForName(converterClass));

             }

             if (log.isLoggable(Level.FINEST))

             {

                 log.finest("add Converter for class = " + targetClass + " converterClass = " + converterClass);

             }

         }

         catch (Exception e)

         {

             log.log(Level.SEVERE, "Converter class " + converterClass + " not found", e);

         }

     }

     @Override

     public final void addValidator(final String validatorId, final String validatorClass)

     {

         checkNull(validatorId, "validatorId");

         checkEmpty(validatorId, "validatorId");

         checkNull(validatorClass, "validatorClass");

         checkEmpty(validatorClass, "validatorClass");

         try

         {

             if(isLazyLoadConfigObjects())

             {

                 _validatorClassMap.put(validatorId, validatorClass);

             }

             else

             {

                 _validatorClassMap.put(validatorId, ClassUtils.simpleClassForName(validatorClass));

             }

             if (log.isLoggable(Level.FINEST))

             {

                 log.finest("add Validator id = " + validatorId + " class = " + validatorClass);

             }

         }

         catch (Exception e)

         {

             log.log(Level.SEVERE, "Validator class " + validatorClass + " not found", e);

         }

     }

     @Override

     public Behavior createBehavior(String behaviorId) throws FacesException

     {

         checkNull(behaviorId, "behaviorId");

         checkEmpty(behaviorId, "behaviorId");

         final Class<? extends Behavior> behaviorClass =

                 getObjectFromClassMap(behaviorId, _behaviorClassMap);

         if (behaviorClass == null)

         {

             throw new FacesException("Could not find any registered behavior-class for behaviorId : " + behaviorId);

         }

         try

         {

             Behavior behavior = behaviorClass.newInstance();

             FacesContext facesContext = FacesContext.getCurrentInstance();

             _handleAttachedResourceDependencyAnnotations(facesContext, behavior);

             if (behavior instanceof ClientBehaviorBase)

             {

               ClientBehaviorBase clientBehavior = (ClientBehaviorBase) behavior;

               String renderType = clientBehavior.getRendererType();

               if (renderType != null)

               {

                 ClientBehaviorRenderer cbr = facesContext.getRenderKit().getClientBehaviorRenderer(renderType);

                 _handleAttachedResourceDependencyAnnotations(facesContext, cbr);

               }

             }

             return behavior;

         }

         catch (Exception e)

         {

             log.log(Level.SEVERE, "Could not instantiate behavior " + behaviorClass, e);

             throw new FacesException("Could not instantiate behavior: " + behaviorClass, e);

         }

     }

     @Override

     public UIComponent createComponent(FacesContext context, Resource componentResource)

     {

         checkNull(context, "context");

         checkNull(componentResource, "componentResource");

         UIComponent component = null;

         Resource resource;

         String fqcn;

         Class<? extends UIComponent> componentClass = null;

         /*

          * Obtain a reference to the ViewDeclarationLanguage for this Application instance by calling

          * ViewHandler.getViewDeclarationLanguage(javax.faces.context.FacesContext, java.lang.String), passing the

          * viewId found by calling UIViewRoot.getViewId() on the UIViewRoot in the argument FacesContext.

          */

         UIViewRoot view = context.getViewRoot();

         Application application = context.getApplication();

         ViewDeclarationLanguage vdl

                 = application.getViewHandler().getViewDeclarationLanguage(context, view.getViewId());

         /*

          * Obtain a reference to the composite component metadata for this composite component by calling

          * ViewDeclarationLanguage.getComponentMetadata(javax.faces.context.FacesContext,

          * javax.faces.application.Resource), passing the facesContext and componentResource arguments to this method.

          * This version of JSF specification uses JavaBeans as the API to the component metadata.

          */

         BeanInfo metadata = vdl.getComponentMetadata(context, componentResource);

         if (metadata == null)

         {

             throw new FacesException("Could not get component metadata for " 

                     + componentResource.getResourceName()

                     + ". Did you forget to specify <composite:interface>?");

         }

         /*

          * Determine if the component author declared a component-type for this component instance by obtaining the

          * BeanDescriptor from the component metadata and calling its getValue() method, passing

          * UIComponent.COMPOSITE_COMPONENT_TYPE_KEY as the argument. If non-null, the result must be a ValueExpression

          * whose value is the component-type of the UIComponent to be created for this Resource component. Call through

          * to createComponent(java.lang.String) to create the component.

          */

         BeanDescriptor descriptor = metadata.getBeanDescriptor();

         ValueExpression componentType = (ValueExpression) descriptor.getValue(

                 UIComponent.COMPOSITE_COMPONENT_TYPE_KEY);

         boolean annotationsApplied = false;

         if (componentType != null)

         {

             component = application.createComponent((String) componentType.getValue(context.getELContext()));

             annotationsApplied = true;

         }

         else

         {

             /*

              * Otherwise, determine if a script based component for this Resource can be found by calling

              * ViewDeclarationLanguage.getScriptComponentResource(javax.faces.context.FacesContext,

              * javax.faces.application.Resource). If the result is non-null, and is a script written in one of the

              * languages listed in JSF 4.3 of the specification prose document, create a UIComponent instance from the

              * script resource.

              */

             resource = vdl.getScriptComponentResource(context, componentResource);

             if (resource != null)

             {

                 String name = resource.getResourceName();

                 String className = name.substring(0, name.lastIndexOf('.'));

                 component = (UIComponent)ClassUtils.newInstance(className);

             }

             else

             {

                 /*

                  * Otherwise, let library-name be the return from calling Resource.getLibraryName() on the argument

                  * componentResource and resource-name be the return from calling Resource.getResourceName() on the

                  * argument componentResource. Create a fully qualified Java class name by removing any file extension

                  * from resource-name and let fqcn be library-name + "." + resource-name. If a class with the name of

                  * fqcn cannot be found, take no action and continue to the next step. If any of 

                  * InstantiationException,

                  * IllegalAccessException, or ClassCastException are thrown, wrap the exception in a FacesException and

                  * re-throw it. If any other exception is thrown, log the exception and continue to the next step.

                  */

                 boolean isProduction = FacesContext.getCurrentInstance().isProjectStage(ProjectStage.Production);

                 String name = componentResource.getResourceName();

                 String className = name.substring(0, name.lastIndexOf('.'));

                 fqcn = componentResource.getLibraryName() + "." + className;