/*

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

 import java.net.URL;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.HashSet;

 import java.util.Map;

 import java.util.Set;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.faces.application.ResourceDependencies;

 import javax.faces.application.ResourceDependency;

 import javax.faces.bean.ApplicationScoped;

 import javax.faces.bean.CustomScoped;

 import javax.faces.bean.ManagedBean;

 import javax.faces.bean.ManagedProperty;

 import javax.faces.bean.NoneScoped;

 import javax.faces.bean.ReferencedBean;

 import javax.faces.bean.RequestScoped;

 import javax.faces.bean.SessionScoped;

 import javax.faces.bean.ViewScoped;

 import javax.faces.component.FacesComponent;

 import javax.faces.component.UIComponent;

 import javax.faces.component.behavior.FacesBehavior;

 import javax.faces.context.ExternalContext;

 import javax.faces.convert.Converter;

 import javax.faces.convert.FacesConverter;

 import javax.faces.event.ListenerFor;

 import javax.faces.event.ListenersFor;

 import javax.faces.event.NamedEvent;

 import javax.faces.render.FacesBehaviorRenderer;

 import javax.faces.render.FacesRenderer;

 import javax.faces.render.Renderer;

 import javax.faces.validator.FacesValidator;

 import javax.faces.validator.Validator;

 import javax.faces.webapp.FacesServlet;

 import javax.servlet.Servlet;

 import javax.servlet.ServletContainerInitializer;

 import javax.servlet.ServletContext;

 import javax.servlet.ServletException;

 import javax.servlet.ServletRegistration;

 import javax.servlet.annotation.HandlesTypes;

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

 import org.apache.myfaces.context.servlet.StartupServletExternalContextImpl;

 import org.apache.myfaces.shared_impl.webapp.webxml.DelegatedFacesServlet;

 import org.apache.myfaces.spi.FacesConfigResourceProvider;

 import org.apache.myfaces.spi.FacesConfigResourceProviderFactory;

 /**

  * This class is called by any Java EE 6 complaint container at startup.

  * It checks if the current webapp is a JSF-webapp by checking if some of 

  * the JSF related annotations are specified in the webapp classpath or if

  * the faces-config.xml file is present. If so, the listener checks if 

  * the FacesServlet has already been defined in web.xml and if not, it adds

  * the FacesServlet with the mappings (/faces/*, *.jsf, *.faces) dynamically.

  * 

  * @author Jakob Korherr (latest modification by $Author$)

  * @version $Revision$ $Date$

  */

 @HandlesTypes({

         ApplicationScoped.class,

         CustomScoped.class,

         FacesBehavior.class,

         FacesBehaviorRenderer.class,

         FacesComponent.class,

         FacesConverter.class,

         FacesRenderer.class,

         FacesValidator.class,

         ListenerFor.class,

         ListenersFor.class,

         ManagedBean.class,

         ManagedProperty.class,

         NamedEvent.class,

         NoneScoped.class,

         ReferencedBean.class,

         RequestScoped.class,

         ResourceDependencies.class,

         ResourceDependency.class,

         SessionScoped.class,

         ViewScoped.class,

         UIComponent.class,

         Converter.class,

         Renderer.class,

         Validator.class

     })

 public class MyFacesContainerInitializer implements ServletContainerInitializer

 {

     /**

      * If the servlet mapping for the FacesServlet is added dynamically, Boolean.TRUE 

      * is stored under this key in the ServletContext.

      * ATTENTION: this constant is duplicate in AbstractFacesInitializer.

      */

     private static final String FACES_SERVLET_ADDED_ATTRIBUTE = "org.apache.myfaces.DYNAMICALLY_ADDED_FACES_SERVLET";

     /**

      * If the servlet mapping for the FacesServlet is found on the ServletContext, Boolean.TRUE 

      * is stored under this key in the ServletContext.

      * ATTENTION: this constant is duplicate in AbstractFacesInitializer.

      */

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

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

     /**

      * If the flag is true, the algoritm skip jar scanning for faces-config files to check if the current

      * application requires FacesServlet to be added dynamically (servlet spec 3). This param can be set using 

      * a system property with the same name too.

      */

     @JSFWebConfigParam(since="2.2.10", expectedValues = "true, false", defaultValue = "false", 

             tags = "performance")

     private static final String INITIALIZE_SKIP_JAR_FACES_CONFIG_SCAN = 

             "org.apache.myfaces.INITIALIZE_SKIP_JAR_FACES_CONFIG_SCAN";

     private static final String FACES_CONFIG_RESOURCE = "/WEB-INF/faces-config.xml";

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

     private static final String[] FACES_SERVLET_MAPPINGS = { "/faces/*", "*.jsf", "*.faces" };

     private static final String FACES_SERVLET_NAME = "FacesServlet";

     private static final Class<? extends Servlet> FACES_SERVLET_CLASS = FacesServlet.class;

     private static final Class<?> DELEGATED_FACES_SERVLET_CLASS = DelegatedFacesServlet.class;

     public void onStartup(Set<Class<?>> clazzes, ServletContext servletContext) throws ServletException

     {

         boolean startDireclty = shouldStartupRegardless(servletContext);

         if (startDireclty)

         {

             // if the INITIALIZE_ALWAYS_STANDALONE param was set to true,

             // we do not want to have the FacesServlet being added, we simply 

             // do no extra configuration in here.

             return;

         }

         // Check for one or more of this conditions:

         // 1. A faces-config.xml file is found in WEB-INF

         // 2. A faces-config.xml file is found in the META-INF directory of a jar in the application's classpath.

         // 3. A filename ending in .faces-config.xml is found in the META-INF directory of a jar in the 

         //    application's classpath.

         // 4. The javax.faces.CONFIG_FILES context param is declared in web.xml or web-fragment.xml.

         // 5. The Set of classes passed to the onStartup() method of the ServletContainerInitializer 

         //    implementation is not empty.

         if ((clazzes != null && !clazzes.isEmpty()) || isFacesConfigPresent(servletContext))

         {

             // look for the FacesServlet

             Map<String, ? extends ServletRegistration> servlets = servletContext.getServletRegistrations();

             for (Map.Entry<String, ? extends ServletRegistration> servletEntry : servlets.entrySet())

             {

                 String className = servletEntry.getValue().getClassName();

                 if (FACES_SERVLET_CLASS.getName().equals(className)

                         || isDelegatedFacesServlet(className))

                 {

                     // we found a FacesServlet; set an attribute for use during initialization

                     servletContext.setAttribute(FACES_SERVLET_FOUND, Boolean.TRUE);                    

                     return;

                 }

             }

             // the FacesServlet is not installed yet - install it

             ServletRegistration.Dynamic servlet = servletContext.addServlet(FACES_SERVLET_NAME, FACES_SERVLET_CLASS);

             //try to add typical JSF mappings

             String[] mappings = FACES_SERVLET_MAPPINGS;

             Set<String> conflictMappings = servlet.addMapping(mappings);

             if (conflictMappings != null && !conflictMappings.isEmpty())

             {

                 //at least one of the attempted mappings is in use, remove and try again

                 Set<String> newMappings = new HashSet<String>(Arrays.asList(mappings));

                 newMappings.removeAll(conflictMappings);

                 mappings = newMappings.toArray(new String[newMappings.size()]);

                 servlet.addMapping(mappings);

             }

             if (mappings != null && mappings.length > 0)

             {

                 // at least one mapping was added 

                 // now we have to set a field in the ServletContext to indicate that we have

                 // added the mapping dynamically, because MyFaces just parsed the web.xml to

                 // find mappings and thus it would abort initializing

                 servletContext.setAttribute(FACES_SERVLET_ADDED_ATTRIBUTE, Boolean.TRUE);

                 // add a log message

                 log.log(Level.INFO, "Added FacesServlet with mappings="

                         + Arrays.toString(mappings));

             }

         }

     }

     /**

      * Checks if the <code>INITIALIZE_ALWAYS_STANDALONE</code> flag is ture in <code>web.xml</code>.

      * If the flag is true, this means we should not add the FacesServlet, instead we want to

      * init MyFaces regardless...

      */

     private boolean shouldStartupRegardless(ServletContext servletContext)

     {

         try

         {

             String standaloneStartup = servletContext.getInitParameter(INITIALIZE_ALWAYS_STANDALONE);

             // "true".equalsIgnoreCase(param) is faster than Boolean.valueOf()

             return "true".equalsIgnoreCase(standaloneStartup);

         }

         catch (Exception e)

         {

             return false;

         }

     }

     /**

      * Checks if the <code>INITIALIZE_SCAN_JARS_FOR_FACES_CONFIG</code> flag is true in <code>web.xml</code>.

      * If the flag is true, this means we should scan app jars for *.faces-config.xml before adding

      * any FacesServlet; in false, we skip that scan for performance.

      */

     private boolean shouldSkipJarFacesConfigScan(ServletContext servletContext)

     {

         try

         {

             String skipJarScan = servletContext.getInitParameter(INITIALIZE_SKIP_JAR_FACES_CONFIG_SCAN);

             if (skipJarScan == null)

             {

                 skipJarScan = System.getProperty(INITIALIZE_SKIP_JAR_FACES_CONFIG_SCAN);

             }

             return "true".equalsIgnoreCase(skipJarScan);

         }

         catch (Exception e)

         {

             return false;

         }

     }

     /**

      * Checks if /WEB-INF/faces-config.xml is present.

      * @return

      */

     private boolean isFacesConfigPresent(ServletContext servletContext)

     {

         try

         {

             // 1. A faces-config.xml file is found in WEB-INF

             if (servletContext.getResource(FACES_CONFIG_RESOURCE) != null)

             {

                 return true;

             }

             // 4. The javax.faces.CONFIG_FILES context param is declared in web.xml or web-fragment.xml.

             // check for alternate faces-config files specified by javax.faces.CONFIG_FILES

             String configFilesAttrValue = servletContext.getInitParameter(FacesServlet.CONFIG_FILES_ATTR);

             if (configFilesAttrValue != null)

             {

                 String[] configFiles = configFilesAttrValue.split(",");

                 for (String file : configFiles)

                 {

                     if (servletContext.getResource(file.trim()) != null)

                     {

                         return true;

                     }

                 }

             }

             // Skip this scan - for performance - if INITIALIZE_SKIP_JAR_FACES_CONFIG_SCAN is set to true 

             // 2. A faces-config.xml file is found in the META-INF directory of a jar in the 

             //    application's classpath.

             // 3. A filename ending in .faces-config.xml is found in the META-INF directory of a jar in 

             //    the application's classpath.

             // To do this properly it is necessary to use some SPI interfaces MyFaces already has, to 

             // deal with OSGi and other

             // environments properly.

             if (!shouldSkipJarFacesConfigScan(servletContext)) 

             {

                 ExternalContext externalContext = new StartupServletExternalContextImpl(servletContext, true);

                 FacesConfigResourceProviderFactory factory = FacesConfigResourceProviderFactory.

                     getFacesConfigResourceProviderFactory(externalContext);

                 FacesConfigResourceProvider provider = factory.createFacesConfigResourceProvider(externalContext);

                 Collection<URL> metaInfFacesConfigUrls =  provider.getMetaInfConfigurationResources(externalContext);

                 if (metaInfFacesConfigUrls != null && !metaInfFacesConfigUrls.isEmpty())

                 {

                     return true;

                 }

             }

             return false;

         }

         catch (Exception e)

         {

             return false;

         }

     }

     /**

      * Checks if the class represented by className implements DelegatedFacesServlet.

      * @param className

      * @return

      */

     private boolean isDelegatedFacesServlet(String className)

     {

         if (className == null)

         {

             // The class name can be null if this is e.g., a JSP mapped to

             // a servlet.

             return false;

         }

         try

         {

             Class<?> clazz = Class.forName(className);

             return DELEGATED_FACES_SERVLET_CLASS.isAssignableFrom(clazz);

         }

         catch (ClassNotFoundException cnfe)

         {

             return false;

         }

     }

 }