/*
    * 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;
  
  import javax.faces.application.ApplicationFactory;
  import javax.faces.component.visit.VisitContextFactory;
  import javax.faces.context.ExceptionHandlerFactory;
  import javax.faces.context.ExternalContextFactory;
  import javax.faces.context.FacesContext;
  import javax.faces.context.FacesContextFactory;
  import javax.faces.context.FlashFactory;
  import javax.faces.context.PartialViewContextFactory;
  import javax.faces.flow.FlowHandlerFactory;
  import javax.faces.lifecycle.ClientWindowFactory;
  import javax.faces.lifecycle.LifecycleFactory;
  import javax.faces.render.RenderKitFactory;
  import javax.faces.view.ViewDeclarationLanguageFactory;
  import javax.faces.view.facelets.FaceletCacheFactory;
  import javax.faces.view.facelets.TagHandlerDelegateFactory;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.security.AccessController;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.CopyOnWriteArrayList;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  /**
   * see Javadoc of <a href="http://java.sun.com/javaee/javaserverfaces/1.2/docs/api/index.html">JSF Specification</a>
   */
  public final class FactoryFinder
  {
      public static final String APPLICATION_FACTORY = "javax.faces.application.ApplicationFactory";
      public static final String EXCEPTION_HANDLER_FACTORY = "javax.faces.context.ExceptionHandlerFactory";
      public static final String EXTERNAL_CONTEXT_FACTORY = "javax.faces.context.ExternalContextFactory";
      public static final String FACES_CONTEXT_FACTORY = "javax.faces.context.FacesContextFactory";
      public static final String LIFECYCLE_FACTORY = "javax.faces.lifecycle.LifecycleFactory";
      public static final String PARTIAL_VIEW_CONTEXT_FACTORY = "javax.faces.context.PartialViewContextFactory";
      public static final String RENDER_KIT_FACTORY = "javax.faces.render.RenderKitFactory";
      public static final String TAG_HANDLER_DELEGATE_FACTORY = "javax.faces.view.facelets.TagHandlerDelegateFactory";
      public static final String VIEW_DECLARATION_LANGUAGE_FACTORY = "javax.faces.view.ViewDeclarationLanguageFactory";
      public static final String VISIT_CONTEXT_FACTORY = "javax.faces.component.visit.VisitContextFactory";
      public static final String FACELET_CACHE_FACTORY = "javax.faces.view.facelets.FaceletCacheFactory";
      public static final String FLASH_FACTORY = "javax.faces.context.FlashFactory";
      public static final String FLOW_HANDLER_FACTORY = "javax.faces.flow.FlowHandlerFactory";
      public static final String CLIENT_WINDOW_FACTORY = "javax.faces.lifecycle.ClientWindowFactory";
  
      /**
       * used as a monitor for itself and _factories. Maps in this map are used as monitors for themselves and the
       * corresponding maps in _factories.
       */
      private static Map<ClassLoader, Map<String, List<String>>> registeredFactoryNames
              = new HashMap<ClassLoader, Map<String, List<String>>>();
  
      /**
       * Maps from classLoader to another map, the container (i.e. Tomcat) will create a class loader for each web app
       * that it controls (typically anyway) and that class loader is used as the key.
       * 
       * The secondary map maps the factory name (i.e. FactoryFinder.APPLICATION_FACTORY) to actual instances that are
       * created via getFactory. The instances will be of the class specified in the setFactory method for the factory
       * name, i.e. FactoryFinder.setFactory(FactoryFinder.APPLICATION_FACTORY, MyFactory.class).
       */
      private static Map<ClassLoader, Map<String, Object>> factories
              = new HashMap<ClassLoader, Map<String, Object>>();
  
      private static final Set<String> VALID_FACTORY_NAMES = new HashSet<String>();
      private static final Map<String, Class<?>> ABSTRACT_FACTORY_CLASSES = new HashMap<String, Class<?>>();
      private static final ClassLoader MYFACES_CLASSLOADER;
      
      private static final String INJECTION_PROVIDER_INSTANCE = "oam.spi.INJECTION_PROVIDER_KEY";
      private static final String INJECTED_BEAN_STORAGE_KEY = "org.apache.myfaces.spi.BEAN_ENTRY_STORAGE";
      private static final String BEAN_ENTRY_CLASS_NAME = "org.apache.myfaces.cdi.dependent.BeanEntry";
  
      private static final Logger LOGGER = Logger.getLogger(FactoryFinder.class.getName());
  
      static
     {
         VALID_FACTORY_NAMES.add(APPLICATION_FACTORY);
         VALID_FACTORY_NAMES.add(EXCEPTION_HANDLER_FACTORY);
         VALID_FACTORY_NAMES.add(EXTERNAL_CONTEXT_FACTORY);
         VALID_FACTORY_NAMES.add(FACES_CONTEXT_FACTORY);
         VALID_FACTORY_NAMES.add(LIFECYCLE_FACTORY);
         VALID_FACTORY_NAMES.add(PARTIAL_VIEW_CONTEXT_FACTORY);
         VALID_FACTORY_NAMES.add(RENDER_KIT_FACTORY);
         VALID_FACTORY_NAMES.add(TAG_HANDLER_DELEGATE_FACTORY);
         VALID_FACTORY_NAMES.add(VIEW_DECLARATION_LANGUAGE_FACTORY);
         VALID_FACTORY_NAMES.add(VISIT_CONTEXT_FACTORY);
         VALID_FACTORY_NAMES.add(FACELET_CACHE_FACTORY);
         VALID_FACTORY_NAMES.add(FLASH_FACTORY);
         VALID_FACTORY_NAMES.add(FLOW_HANDLER_FACTORY);
         VALID_FACTORY_NAMES.add(CLIENT_WINDOW_FACTORY);
         
         ABSTRACT_FACTORY_CLASSES.put(APPLICATION_FACTORY, ApplicationFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(EXCEPTION_HANDLER_FACTORY, ExceptionHandlerFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(EXTERNAL_CONTEXT_FACTORY, ExternalContextFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(FACES_CONTEXT_FACTORY, FacesContextFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(LIFECYCLE_FACTORY, LifecycleFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(PARTIAL_VIEW_CONTEXT_FACTORY, PartialViewContextFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(RENDER_KIT_FACTORY, RenderKitFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(TAG_HANDLER_DELEGATE_FACTORY, TagHandlerDelegateFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(VIEW_DECLARATION_LANGUAGE_FACTORY, ViewDeclarationLanguageFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(VISIT_CONTEXT_FACTORY, VisitContextFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(FACELET_CACHE_FACTORY, FaceletCacheFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(FLASH_FACTORY, FlashFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(FLOW_HANDLER_FACTORY, FlowHandlerFactory.class);
         ABSTRACT_FACTORY_CLASSES.put(CLIENT_WINDOW_FACTORY, ClientWindowFactory.class);
         try
         {
             ClassLoader classLoader;
             if (System.getSecurityManager() != null)
             {
                 classLoader = (ClassLoader) AccessController.doPrivileged(new java.security.PrivilegedExceptionAction()
                 {
                     public Object run()
                     {
                         return FactoryFinder.class.getClassLoader();
                     }
                 });
             }
             else
             {
                 classLoader = FactoryFinder.class.getClassLoader();
             }
 
             if (classLoader == null)
             {
                 throw new FacesException("jsf api class loader cannot be identified", null);
             }
             MYFACES_CLASSLOADER = classLoader;
         }
         catch (Exception e)
         {
             throw new FacesException("jsf api class loader cannot be identified", e);
         }
     }
 
     // ~ Start FactoryFinderProvider Support
     
     private static Object factoryFinderProviderFactoryInstance;
     
     private static volatile boolean initialized = false;
     
     private static void initializeFactoryFinderProviderFactory()
     {
         if (!initialized)
         {
             factoryFinderProviderFactoryInstance = _FactoryFinderProviderFactory.getInstance();
             initialized = true;
         }
     }
 
     // ~ End FactoryFinderProvider Support
 
     // avoid instantiation
     FactoryFinder()
     {
     }
 
     /**
      * <p>
      * Create (if necessary) and return a per-web-application instance of the appropriate implementation class for the
      * specified JavaServer Faces factory class, based on the discovery algorithm described in the class description.
      * </p>
      * 
      * <p>
      * The standard factories and wrappers in JSF all implement the interface {@link FacesWrapper}. If the returned
      * <code>Object</code> is an implementation of one of the standard factories, it must be legal to cast it to an
      * instance of <code>FacesWrapper</code> and call {@link FacesWrapper#getWrapped()} on the instance.
      * </p>
      * 
      * @param factoryName
      *            Fully qualified name of the JavaServer Faces factory for which an implementation instance is requested
      * 
      * @return A per-web-application instance of the appropriate implementation class for the specified JavaServer Faces
      *         factory class
      * 
      * @throws FacesException
      *             if the web application class loader cannot be identified
      * @throws FacesException
      *             if an instance of the configured factory implementation class cannot be loaded
      * @throws FacesException
      *             if an instance of the configured factory implementation class cannot be instantiated
      * @throws IllegalArgumentException
      *             if <code>factoryname</code> does not identify a standard JavaServer Faces factory name
      * @throws IllegalStateException
      *             if there is no configured factory implementation class for the specified factory name
      * @throws NullPointerException
      *             if <code>factoryname</code> is null
      */
     public static Object getFactory(String factoryName) throws FacesException
     {
         if (factoryName == null)
         {
             throw new NullPointerException("factoryName may not be null");
         }
         
         initializeFactoryFinderProviderFactory();
         
         if (factoryFinderProviderFactoryInstance == null)
         {
             // Do the typical stuff
             return _getFactory(factoryName);
         }
         else
         {
             try
             {
                 //Obtain the FactoryFinderProvider instance for this context.
                 Object ffp = _FactoryFinderProviderFactory
                         .FACTORY_FINDER_PROVIDER_FACTORY_GET_FACTORY_FINDER_METHOD
                         .invoke(factoryFinderProviderFactoryInstance, null);
                 
                 //Call getFactory method and pass the params
                 return _FactoryFinderProviderFactory
                         .FACTORY_FINDER_PROVIDER_GET_FACTORY_METHOD.invoke(ffp, factoryName);
             }
             catch (InvocationTargetException e)
             {
                 Throwable targetException = e.getCause();
                 if (targetException instanceof NullPointerException)
                 {
                     throw (NullPointerException) targetException;
                 }
                 else if (targetException instanceof FacesException)
                 {
                     throw (FacesException) targetException;
                 }
                 else if (targetException instanceof IllegalArgumentException)
                 {
                     throw (IllegalArgumentException) targetException;
                 }
                 else if (targetException instanceof IllegalStateException)
                 {
                     throw (IllegalStateException) targetException;
                 }
                 else if (targetException == null)
                 {
                     throw new FacesException(e);
                 }
                 else
                 {
                     throw new FacesException(targetException);
                 }
             }
             catch (Exception e)
             {
                 //No Op
                 throw new FacesException(e);
             }
         }
     }
 
     private static Object _getFactory(String factoryName) throws FacesException
     {
         ClassLoader classLoader = getClassLoader();
 
         // This code must be synchronized because this could cause a problem when
         // using update feature each time of myfaces (org.apache.myfaces.CONFIG_REFRESH_PERIOD)
         // In this moment, a concurrency problem could happen
         Map<String, List<String>> factoryClassNames = null;
         Map<String, Object> factoryMap = null;
 
         synchronized (registeredFactoryNames)
         {
             factoryClassNames = registeredFactoryNames.get(classLoader);
 
             if (factoryClassNames == null)
             {
                 String message
                         = "No Factories configured for this Application. This happens if the faces-initialization "
                         + "does not work at all - make sure that you properly include all configuration "
                         + "settings necessary for a basic faces application "
                         + "and that all the necessary libs are included. Also check the logging output of your "
                         + "web application and your container for any exceptions!"
                         + "\nIf you did that and find nothing, the mistake might be due to the fact "
                         + "that you use some special web-containers which "
                         + "do not support registering context-listeners via TLD files and "
                         + "a context listener is not setup in your web.xml.\n"
                         + "A typical config looks like this;\n<listener>\n"
                         + "  <listener-class>org.apache.myfaces.webapp.StartupServletContextListener</listener-class>\n"
                         + "</listener>\n";
                 throw new IllegalStateException(message);
             }
 
             if (!factoryClassNames.containsKey(factoryName))
             {
                 throw new IllegalArgumentException("no factory " + factoryName + " configured for this application.");
             }
 
             factoryMap = factories.get(classLoader);
 
             if (factoryMap == null)
             {
                 factoryMap = new HashMap<String, Object>();
                 factories.put(classLoader, factoryMap);
             }
         }
 
         List beanEntryStorage;
 
         synchronized (factoryClassNames)
         {
             beanEntryStorage = (List)factoryMap.get(INJECTED_BEAN_STORAGE_KEY);
 
             if (beanEntryStorage == null)
             {
                 beanEntryStorage = new CopyOnWriteArrayList();
                 factoryMap.put(INJECTED_BEAN_STORAGE_KEY, beanEntryStorage);
             }
         }
 
         List<String> classNames;
         Object factory;
         Object injectionProvider;
         synchronized (factoryClassNames)
         {
             factory = factoryMap.get(factoryName);
             if (factory != null)
             {
                 return factory;
             }
 
             classNames = factoryClassNames.get(factoryName);
             
             injectionProvider = factoryMap.get(INJECTION_PROVIDER_INSTANCE);
         }
 
         if (injectionProvider == null)
         {
             injectionProvider = getInjectionProvider();
             synchronized (factoryClassNames)
             {
                 factoryMap.put(INJECTION_PROVIDER_INSTANCE, injectionProvider);
             }
         }
 
         // release lock while calling out
         factory = newFactoryInstance(ABSTRACT_FACTORY_CLASSES.get(factoryName), 
             classNames.iterator(), classLoader, injectionProvider, beanEntryStorage);
 
         synchronized (factoryClassNames)
         {
             // check if someone else already installed the factory
             if (factoryMap.get(factoryName) == null)
             {
                 factoryMap.put(factoryName, factory);
             }
         }
 
         return factory;
     }
     
     private static Object getInjectionProvider()
     {
         try
         {
             // Remember the first call in a webapp over FactoryFinder.getFactory(...) comes in the 
             // initialization block, so there is a startup FacesContext active and
             // also a valid startup ExternalContext. Note after that, we need to cache
             // the injection provider for the classloader, because in a normal
             // request there is no active FacesContext in the moment and this call will
             // surely fail.
             FacesContext facesContext = FacesContext.getCurrentInstance();
             if (facesContext != null)
             {
                 Object injectionProviderFactory =
                     _FactoryFinderProviderFactory.INJECTION_PROVIDER_FACTORY_GET_INSTANCE_METHOD
                         .invoke(_FactoryFinderProviderFactory.INJECTION_PROVIDER_CLASS);
                 Object injectionProvider = 
                     _FactoryFinderProviderFactory.INJECTION_PROVIDER_FACTORY_GET_INJECTION_PROVIDER_METHOD
                         .invoke(injectionProviderFactory, facesContext.getExternalContext());
                 return injectionProvider;
             }
         }
         catch (Exception e)
         {
         }
         return null;
     }
     
     private static void injectAndPostConstruct(Object injectionProvider, Object instance, List injectedBeanStorage)
     {
         if (injectionProvider != null)
         {
             try
             {
                 Object creationMetaData = _FactoryFinderProviderFactory.INJECTION_PROVIDER_INJECT_METHOD.invoke(
                     injectionProvider, instance);
 
                 addBeanEntry(instance, creationMetaData, injectedBeanStorage);
 
                 _FactoryFinderProviderFactory.INJECTION_PROVIDER_POST_CONSTRUCT_METHOD.invoke(
                     injectionProvider, instance, creationMetaData);
             }
             catch (Exception ex)
             {
                 throw new FacesException(ex);
             }
         }
     }
     
     private static void preDestroy(Object injectionProvider, Object beanEntry)
     {
         if (injectionProvider != null)
         {
             try
             {
                 _FactoryFinderProviderFactory.INJECTION_PROVIDER_PRE_DESTROY_METHOD.invoke(
                     injectionProvider, getInstance(beanEntry), getCreationMetaData(beanEntry));
             }
             catch (Exception ex)
             {
                 throw new FacesException(ex);
             }
         }
     }
 
     private static Object getInstance(Object beanEntry)
     {
         try
         {
             Method getterMethod = getMethod(beanEntry, "getInstance");
             return getterMethod.invoke(beanEntry);
         }
         catch (Exception e)
         {
             throw new IllegalStateException(e);
         }
     }
 
     private static Object getCreationMetaData(Object beanEntry)
     {
         try
         {
             Method getterMethod = getMethod(beanEntry, "getCreationMetaData");
             return getterMethod.invoke(beanEntry);
         }
         catch (Exception e)
         {
             throw new IllegalStateException(e);
         }
     }
 
     private static Method getMethod(Object beanEntry, String methodName) throws NoSuchMethodException
     {
         return beanEntry.getClass().getDeclaredMethod(methodName);
     }
 
     private static void addBeanEntry(Object instance, Object creationMetaData, List injectedBeanStorage)
     {
         try
         {
             Class<?> beanEntryClass = _FactoryFinderProviderFactory.classForName(BEAN_ENTRY_CLASS_NAME);
             Constructor beanEntryConstructor = beanEntryClass.getDeclaredConstructor(Object.class, Object.class);
 
             Object result = beanEntryConstructor.newInstance(instance, creationMetaData);
             injectedBeanStorage.add(result);
         }
         catch (Exception e)
         {
             throw new RuntimeException(e);
         }
     }
 
     private static Object newFactoryInstance(Class<?> interfaceClass, Iterator<String> classNamesIterator,
                                              ClassLoader classLoader, Object injectionProvider,
                                              List injectedBeanStorage)
     {
         try
         {
             Object current = null;
             
             while (classNamesIterator.hasNext())
             {
                 String implClassName = classNamesIterator.next();
                 Class<?> implClass = null;
                 try
                 {
                     implClass = classLoader.loadClass(implClassName);
                 }
                 catch (ClassNotFoundException e)
                 {
                     implClass = MYFACES_CLASSLOADER.loadClass(implClassName);
                 }
 
                 // check, if class is of expected interface type
                 if (!interfaceClass.isAssignableFrom(implClass))
                 {
                     throw new IllegalArgumentException("Class " + implClassName + " is no " + interfaceClass.getName());
                 }
 
                 if (current == null)
                 {
                     // nothing to decorate
                     current = implClass.newInstance();
                     injectAndPostConstruct(injectionProvider, current, injectedBeanStorage);
                 }
                 else
                 {
                     // let's check if class supports the decorator pattern
                     try
                     {
                         Constructor<?> delegationConstructor = implClass.getConstructor(new Class[] { interfaceClass });
                         // impl class supports decorator pattern,
                         try
                         {
                             // create new decorator wrapping current
                             current = delegationConstructor.newInstance(new Object[] { current });
                             injectAndPostConstruct(injectionProvider, current, injectedBeanStorage);
                         }
                         catch (InstantiationException e)
                         {
                             throw new FacesException(e);
                         }
                         catch (IllegalAccessException e)
                         {
                             throw new FacesException(e);
                         }
                         catch (InvocationTargetException e)
                         {
                             throw new FacesException(e);
                         }
                     }
                     catch (NoSuchMethodException e)
                     {
                         // no decorator pattern support
                         current = implClass.newInstance();
                         injectAndPostConstruct(injectionProvider, current, injectedBeanStorage);
                     }
                 }
             }
 
             return current;
         }
         catch (ClassNotFoundException e)
         {
             throw new FacesException(e);
         }
         catch (InstantiationException e)
         {
             throw new FacesException(e);
         }
         catch (IllegalAccessException e)
         {
             throw new FacesException(e);
         }
     }
 
     public static void setFactory(String factoryName, String implName)
     {
         if (factoryName == null)
         {
             throw new NullPointerException("factoryName may not be null");
         }
         
         initializeFactoryFinderProviderFactory();
         
         if (factoryFinderProviderFactoryInstance == null)
         {
             // Do the typical stuff
             _setFactory(factoryName, implName);
         }
         else
         {
             try
             {
                 //Obtain the FactoryFinderProvider instance for this context.
                 Object ffp = _FactoryFinderProviderFactory
                         .FACTORY_FINDER_PROVIDER_FACTORY_GET_FACTORY_FINDER_METHOD
                         .invoke(factoryFinderProviderFactoryInstance, null);
                 
                 //Call getFactory method and pass the params
                 _FactoryFinderProviderFactory
                         .FACTORY_FINDER_PROVIDER_SET_FACTORY_METHOD.invoke(ffp, factoryName, implName);
             }
             catch (InvocationTargetException e)
             {
                 Throwable targetException = e.getCause();
                 if (targetException instanceof NullPointerException)
                 {
                     throw (NullPointerException) targetException;
                 }
                 else if (targetException instanceof FacesException)
                 {
                     throw (FacesException) targetException;
                 }
                 else if (targetException instanceof IllegalArgumentException)
                 {
                     throw (IllegalArgumentException) targetException;
                 }
                 else if (targetException == null)
                 {
                     throw new FacesException(e);
                 }
                 else
                 {
                     throw new FacesException(targetException);
                 }
             }
             catch (Exception e)
             {
                 //No Op
                 throw new FacesException(e);
             }
             
         }
     }
 
     private static void _setFactory(String factoryName, String implName)
     {
         checkFactoryName(factoryName);
 
         ClassLoader classLoader = getClassLoader();
         Map<String, List<String>> factoryClassNames = null;
         synchronized (registeredFactoryNames)
         {
             Map<String, Object> factories = FactoryFinder.factories.get(classLoader);
 
             if (factories != null && factories.containsKey(factoryName))
             {
                 // Javadoc says ... This method has no effect if getFactory() has already been
                 // called looking for a factory for this factoryName.
                 return;
             }
 
             factoryClassNames = registeredFactoryNames.get(classLoader);
 
             if (factoryClassNames == null)
             {
                 factoryClassNames = new HashMap<String, List<String>>();
                 registeredFactoryNames.put(classLoader, factoryClassNames);
             }
         }
 
         synchronized (factoryClassNames)
         {
             List<String> classNameList = factoryClassNames.get(factoryName);
 
             if (classNameList == null)
             {
                 classNameList = new ArrayList<String>();
                 factoryClassNames.put(factoryName, classNameList);
             }
 
             classNameList.add(implName);
         }
     }
 
     public static void releaseFactories() throws FacesException
     {
         initializeFactoryFinderProviderFactory();
         
         if (factoryFinderProviderFactoryInstance == null)
         {
             // Do the typical stuff
             _releaseFactories();
         }
         else
         {
             try
             {
                 //Obtain the FactoryFinderProvider instance for this context.
                 Object ffp = _FactoryFinderProviderFactory
                         .FACTORY_FINDER_PROVIDER_FACTORY_GET_FACTORY_FINDER_METHOD
                         .invoke(factoryFinderProviderFactoryInstance, null);
                 
                 //Call getFactory method and pass the params
                 _FactoryFinderProviderFactory.FACTORY_FINDER_PROVIDER_RELEASE_FACTORIES_METHOD.invoke(ffp, null);
             }
             catch (InvocationTargetException e)
             {
                 Throwable targetException = e.getCause();
                 if (targetException instanceof FacesException)
                 {
                     throw (FacesException) targetException;
                 }
                 else if (targetException == null)
                 {
                     throw new FacesException(e);
                 }
                 else
                 {
                     throw new FacesException(targetException);
                 }
             }
             catch (Exception e)
             {
                 //No Op
                 throw new FacesException(e);
             }
             
         }
     }
 
     private static void _releaseFactories() throws FacesException
     {
         ClassLoader classLoader = getClassLoader();
 
         Map<String, Object> factoryMap;
         // This code must be synchronized
         synchronized (registeredFactoryNames)
         {
             factoryMap = factories.remove(classLoader);
 
             // _registeredFactoryNames has as value type Map<String,List> and this must
             // be cleaned before release (for gc).
             Map<String, List<String>> factoryClassNames = registeredFactoryNames.get(classLoader);
             if (factoryClassNames != null)
             {
                 factoryClassNames.clear();
             }
 
             registeredFactoryNames.remove(classLoader);
         }
 
         if (factoryMap != null)
         {
             Object injectionProvider = factoryMap.remove(INJECTION_PROVIDER_INSTANCE);
             if (injectionProvider != null)
             {
                 List injectedBeanStorage = (List)factoryMap.get(INJECTED_BEAN_STORAGE_KEY);
 
                 FacesException firstException = null;
                 for (Object entry : injectedBeanStorage)
                 {
                     try
                     {
                         preDestroy(injectionProvider, entry);
                     }
                     catch (FacesException e)
                     {
                         LOGGER.log(Level.SEVERE, "#preDestroy failed", e);
 
                         if (firstException == null)
                         {
                             firstException = e; //all preDestroy callbacks need to get invoked
                         }
                     }
                 }
                 injectedBeanStorage.clear();
 
                 if (firstException != null)
                 {
                     throw firstException;
                 }
             }
         }
     }
 
     private static void checkFactoryName(String factoryName)
     {
         if (!VALID_FACTORY_NAMES.contains(factoryName))
         {
             throw new IllegalArgumentException("factoryName '" + factoryName + "'");
         }
     }
 
     private static ClassLoader getClassLoader()
     {
         try
         {
             ClassLoader classLoader = null;
             if (System.getSecurityManager() != null)
             {
                 classLoader = (ClassLoader) AccessController.doPrivileged(new java.security.PrivilegedExceptionAction()
                 {
                     public Object run()
                     {
                         return Thread.currentThread().getContextClassLoader();
                     }
                 });
             }
             else
             {
                 classLoader = Thread.currentThread().getContextClassLoader();
             }
             
             if (classLoader == null)
             {
                 throw new FacesException("web application class loader cannot be identified", null);
             }
             return classLoader;
         }
         catch (Exception e)
         {
             throw new FacesException("web application class loader cannot be identified", e);
         }
     }
 }