/*

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

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Comparator;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.el.ELResolver;

 import javax.el.ExpressionFactory;

 import javax.faces.context.ExternalContext;

 import javax.faces.el.PropertyResolver;

 import javax.faces.el.VariableResolver;

 import org.apache.commons.collections.Predicate;

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

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

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

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

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

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

 import org.apache.myfaces.config.element.facelets.FaceletTagLibrary;

 /**

  * Holds all configuration information (from the faces-config xml files) that is needed later during runtime. The config

  * information in this class is only available to the MyFaces core implementation classes (i.e. the myfaces source

  * tree). See MyfacesConfig for config parameters that can be used for shared or component classes.

  * 

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

  * @version $Revision$ $Date$

  */

 @SuppressWarnings("deprecation")

 public class RuntimeConfig

 {

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

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

     private static final String APPLICATION_MAP_PARAM_NAME = RuntimeConfig.class.getName();

     private final Collection<NavigationRule> _navigationRules = new ArrayList<NavigationRule>();

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

     private boolean _navigationRulesChanged = false;

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

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

     private String _facesVersion;

     private List<ELResolver> facesConfigElResolvers;

     private List<ELResolver> applicationElResolvers;

     private VariableResolver _variableResolver;

     private PropertyResolver _propertyResolver;

     private ExpressionFactory _expressionFactory;

     private PropertyResolver _propertyResolverChainHead;

     private VariableResolver _variableResolverChainHead;

     private Comparator<ELResolver> _elResolverComparator;

     private Predicate _elResolverPredicate;

     private final Map<String, org.apache.myfaces.config.element.Converter> _converterClassNameToConfigurationMap =

         new ConcurrentHashMap<String, org.apache.myfaces.config.element.Converter>();

     private NamedEventManager _namedEventManager;

     private final Map<String, FaceletsProcessing> _faceletsProcessingByFileExtension =

         new HashMap<String, FaceletsProcessing>();

     /**

      * JSF 2.2 section 11.4.2.1. 

      * 

      * Scanning for all available contracts is necessary because the spec says 

      * "... if the information from the application configuration resources refers 

      * to a contract that is not available to the application, an informative error 

      * message must be logged. ..."

      */

     private Set<String> _externalContextResourceLibraryContracts = new HashSet<String>();

     private Set<String> _classLoaderResourceLibraryContracts = new HashSet<String>();

     private Set<String> _resourceLibraryContracts = new HashSet<String>();

     private Map<String, List<String>> _contractMappings = new HashMap<String, List<String>>();

     private List<ComponentTagDeclaration> _componentTagDeclarations = 

             new ArrayList<ComponentTagDeclaration>();

     private List<String> _resourceResolvers = new ArrayList<String>();

     private List<Object> _injectedObjects = new ArrayList<Object>();

     private List<FaceletTagLibrary> _faceletTagLibraries = new ArrayList<FaceletTagLibrary>();

     private Map<Integer, String> _namespaceById = new HashMap<Integer, String>();

     private Map<String, Integer> _idByNamespace = new HashMap<String, Integer>();

     private List<ViewPoolMapping> _viewPoolMappings = new ArrayList<ViewPoolMapping>();

     public static RuntimeConfig getCurrentInstance(ExternalContext externalContext)

     {

         RuntimeConfig runtimeConfig = (RuntimeConfig) externalContext.getApplicationMap().get(

                 APPLICATION_MAP_PARAM_NAME);

         if (runtimeConfig == null)

         {

             runtimeConfig = new RuntimeConfig();

             externalContext.getApplicationMap().put(APPLICATION_MAP_PARAM_NAME, runtimeConfig);

         }

         return runtimeConfig;

     }

     public void purge()

     {

         _navigationRules.clear();

         _oldManagedBeans.clear();

         _oldManagedBeans.putAll(_managedBeans);

         _managedBeans.clear();

         _navigationRulesChanged = false;

         _converterClassNameToConfigurationMap.clear();

         _externalContextResourceLibraryContracts.clear();

         _classLoaderResourceLibraryContracts.clear();

         _resourceLibraryContracts.clear();

         _injectedObjects.clear();

         _faceletTagLibraries.clear();

         _resourceBundles.clear();

         if (facesConfigElResolvers != null)

         {

             facesConfigElResolvers.clear();

         }

         if (applicationElResolvers != null)

         {

             applicationElResolvers.clear();

         }

         _faceletsProcessingByFileExtension.clear();

         _contractMappings.clear();

         _componentTagDeclarations.clear();

         _resourceResolvers.clear();

         _namespaceById = new HashMap<Integer, String>();

         _idByNamespace = new HashMap<String, Integer>();

         _viewPoolMappings.clear();

     }

     /**

      * Return the navigation rules that can be used by the NavigationHandler implementation.

      * 

      * @return a Collection of {@link org.apache.myfaces.config.element.NavigationRule NavigationRule}s

      */

     public Collection<NavigationRule> getNavigationRules()

     {

         return Collections.unmodifiableCollection(_navigationRules);

     }

     public void addNavigationRule(NavigationRule navigationRule)

     {

         _navigationRules.add(navigationRule);

         _navigationRulesChanged = true;

     }

     public boolean isNavigationRulesChanged()

     {

         return _navigationRulesChanged;

     }

     public void setNavigationRulesChanged(boolean navigationRulesChanged)

     {

         _navigationRulesChanged = navigationRulesChanged;

     }

     /**

      * Return the managed bean info that can be used by the VariableResolver implementation.

      * 

      * @return a {@link org.apache.myfaces.config.element.ManagedBean ManagedBean}

      */

     public ManagedBean getManagedBean(String name)

     {

         return _managedBeans.get(name);

     }

     public Map<String, ManagedBean> getManagedBeans()

     {

         return Collections.unmodifiableMap(_managedBeans);

     }

     public void addManagedBean(String name, ManagedBean managedBean)

     {

         _managedBeans.put(name, managedBean);

         if(_oldManagedBeans!=null)

         {

             _oldManagedBeans.remove(name);

         }

     }

     public void addComponentTagDeclaration(ComponentTagDeclaration declaration)

     {

         _componentTagDeclarations.add(declaration);

     }

     public List<ComponentTagDeclaration> getComponentTagDeclarations()

     {

         return Collections.unmodifiableList(_componentTagDeclarations);

     }

     public void addFaceletTagLibrary(FaceletTagLibrary library)

     {

         _faceletTagLibraries.add(library);

     }

     public List<FaceletTagLibrary> getFaceletTagLibraries()

     {

         return Collections.unmodifiableList(_faceletTagLibraries);

     }

     public final void addConverterConfiguration(final String converterClassName,

             final org.apache.myfaces.config.element.Converter configuration)

     {

         checkNull(converterClassName, "converterClassName");

         checkEmpty(converterClassName, "converterClassName");

         checkNull(configuration, "configuration");

         _converterClassNameToConfigurationMap.put(converterClassName, configuration);

     }

     public org.apache.myfaces.config.element.Converter getConverterConfiguration(String converterClassName)

     {

         return (org.apache.myfaces.config.element.Converter)

                 _converterClassNameToConfigurationMap.get(converterClassName);

     }

     private void checkNull(final Object param, final String paramName)

     {

         if (param == null)

         {

             throw new NullPointerException(paramName + " can not be null.");

         }

     }

     private void checkEmpty(final String param, final String paramName)

     {

         if (param.length() == 0)

         {

             throw new NullPointerException("String " + paramName + " can not be empty.");

         }

     }

     /**

      * Return the resourcebundle which was configured in faces config by var name

      * 

      * @param name

      *            the name of the resource bundle (content of var)

      * @return the resource bundle or null if not found

      */

     public ResourceBundle getResourceBundle(String name)

     {

         return _resourceBundles.get(name);

     }

     /**

      * @return the resourceBundles

      */

     public Map<String, ResourceBundle> getResourceBundles()

     {

         return _resourceBundles;

     }

     public void addResourceBundle(ResourceBundle bundle)

     {

         if (bundle == null)

         {

             throw new IllegalArgumentException("bundle must not be null");

         }

         String var = bundle.getVar();

         if (_resourceBundles.containsKey(var) && log.isLoggable(Level.WARNING))

         {

             log.warning("Another resource bundle for var '" + var + "' with base name '"

                     + _resourceBundles.get(var).getBaseName() + "' is already registered. '"

                     + _resourceBundles.get(var).getBaseName() + "' will be replaced with '" + bundle.getBaseName()

                     + "'.");

         }

         _resourceBundles.put(var, bundle);

     }

     public void addFacesConfigElResolver(ELResolver resolver)

     {

         if (facesConfigElResolvers == null)

         {

             facesConfigElResolvers = new ArrayList<ELResolver>();

         }

         facesConfigElResolvers.add(resolver);

     }

     public List<ELResolver> getFacesConfigElResolvers()

     {

         return facesConfigElResolvers;

     }

     public void addApplicationElResolver(ELResolver resolver)

     {

         if (applicationElResolvers == null)

         {

             applicationElResolvers = new ArrayList<ELResolver>();

         }

         applicationElResolvers.add(resolver);

     }

     public List<ELResolver> getApplicationElResolvers()

     {

         return applicationElResolvers;

     }

     public void setVariableResolver(VariableResolver variableResolver)

     {

         _variableResolver = variableResolver;

     }

     public VariableResolver getVariableResolver()

     {

         return _variableResolver;

     }

     public void setPropertyResolver(PropertyResolver propertyResolver)

     {

         _propertyResolver = propertyResolver;

     }

     public PropertyResolver getPropertyResolver()

     {

         return _propertyResolver;

     }

     public ExpressionFactory getExpressionFactory()

     {

         return _expressionFactory;

     }

     public void setExpressionFactory(ExpressionFactory expressionFactory)

     {

         _expressionFactory = expressionFactory;

     }

     public void setPropertyResolverChainHead(PropertyResolver resolver)

     {

         _propertyResolverChainHead = resolver;

     }

     public PropertyResolver getPropertyResolverChainHead()

     {

         return _propertyResolverChainHead;

     }

     public void setVariableResolverChainHead(VariableResolver resolver)

     {

         _variableResolverChainHead = resolver;

     }

     public VariableResolver getVariableResolverChainHead()

     {

         return _variableResolverChainHead;

     }

     public Map<String, ManagedBean> getManagedBeansNotReaddedAfterPurge()

     {

         return _oldManagedBeans;

     }

     public void resetManagedBeansNotReaddedAfterPurge()

     {

         _oldManagedBeans.clear();

     }

     public String getFacesVersion ()

     {

         return _facesVersion;

     }

     void setFacesVersion (String facesVersion)

     {

         _facesVersion = facesVersion;

     }

     public NamedEventManager getNamedEventManager()

     {

         return _namedEventManager;

     }

     public void setNamedEventManager(NamedEventManager namedEventManager)

     {

         this._namedEventManager = namedEventManager;

     }

     public Comparator<ELResolver> getELResolverComparator()

     {

         return _elResolverComparator;

     }

     public void setELResolverComparator(Comparator<ELResolver> elResolverComparator)

     {

         _elResolverComparator = elResolverComparator;

     }

     public Predicate getELResolverPredicate()

     {

         return _elResolverPredicate;

     }

     public void setELResolverPredicate(Predicate elResolverPredicate)

     {

         _elResolverPredicate = elResolverPredicate;

     }

     public void addFaceletProcessingConfiguration(String fileExtension, FaceletsProcessing configuration)

     {

         checkNull(fileExtension, "fileExtension");

         checkEmpty(fileExtension, "fileExtension");

         checkNull(configuration, "configuration");

         this._faceletsProcessingByFileExtension.put(fileExtension, configuration);

     }

     public FaceletsProcessing getFaceletProcessingConfiguration(String fileExtensions)

     {

         return _faceletsProcessingByFileExtension.get(fileExtensions);

     }

     public Collection<FaceletsProcessing> getFaceletProcessingConfigurations()

     {

         return _faceletsProcessingByFileExtension.values();

     }

     /**

      * @return the _externalContextResourceLibraryContracts

      */

     public Set<String> getExternalContextResourceLibraryContracts()

     {

         return _externalContextResourceLibraryContracts;

     }

     /**

      * @param externalContextResourceLibraryContracts the _externalContextResourceLibraryContracts to set

      */

     public void setExternalContextResourceLibraryContracts(Set<String> externalContextResourceLibraryContracts)

     {

         this._externalContextResourceLibraryContracts = externalContextResourceLibraryContracts;

         this._resourceLibraryContracts.clear();

         this._resourceLibraryContracts.addAll(this._externalContextResourceLibraryContracts);

         this._resourceLibraryContracts.addAll(this._classLoaderResourceLibraryContracts);

     }

     /**

      * @return the _classLoaderResourceLibraryContracts

      */

     public Set<String> getClassLoaderResourceLibraryContracts()

     {

         return _classLoaderResourceLibraryContracts;

     }

     /**

      * @param classLoaderResourceLibraryContracts the _classLoaderResourceLibraryContracts to set

      */

     public void setClassLoaderResourceLibraryContracts(Set<String> classLoaderResourceLibraryContracts)

     {

         this._classLoaderResourceLibraryContracts = classLoaderResourceLibraryContracts;

         this._resourceLibraryContracts.clear();

         this._resourceLibraryContracts.addAll(this._externalContextResourceLibraryContracts);

         this._resourceLibraryContracts.addAll(this._classLoaderResourceLibraryContracts);

     }

     /**

      * @return the _resourceLibraryContracts

      */

     public Set<String> getResourceLibraryContracts()

     {

         return _resourceLibraryContracts;

     }

     /**

      * @return the _contractMappings

      */

     public Map<String, List<String>> getContractMappings()

     {

         return _contractMappings;

     }

     public void addContractMapping(String urlPattern, String[] contracts)

     {

         List<String> contractsList = _contractMappings.get(urlPattern);

         if (contractsList == null)

         {

             contractsList = new ArrayList<String>();

             _contractMappings.put(urlPattern, contractsList);

         }

         for (String contract : contracts)

         {

             contractsList.add(contract);

         }

     }

     public void addContractMapping(String urlPattern, String contract)

     {

         List<String> contractsList = _contractMappings.get(urlPattern);

         if (contractsList == null)

         {

             contractsList = new ArrayList<String>();

             _contractMappings.put(urlPattern, contractsList);

         }

         contractsList.add(contract);

     }    

     public List<String> getResourceResolvers()

     {

         return _resourceResolvers;

     }

     public void addResourceResolver(String resourceResolver)

     {

         _resourceResolvers.add(resourceResolver);

     }

     /**

      * @return the _injectedObjects

      */

     public List<Object> getInjectedObjects()

     {

         return _injectedObjects;

     }

     public void addInjectedObject(Object object)

     {

         _injectedObjects.add(object);

     }

     public Map<Integer, String> getNamespaceById()

     {

         return _namespaceById;

     }

     public void setNamespaceById(Map<Integer, String> namespaceById)

     {

         this._namespaceById = namespaceById;

     }

     public Map<String, Integer> getIdByNamespace()

     {

         return _idByNamespace;

     }

     public void setIdByNamespace(Map<String, Integer> idByNamespace)

     {

         this._idByNamespace = idByNamespace;

     }

     public List<ViewPoolMapping> getViewPoolMappings()

     {

         return _viewPoolMappings;

     }

     public void addViewPoolMapping(ViewPoolMapping mapping)

     {

         _viewPoolMappings.add(mapping);

     }

 }