/**
    * This file Copyright (c) 2003-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.init;
  
  import info.magnolia.cms.beans.config.ConfigLoader;
  import info.magnolia.cms.core.FileSystemHelper;
  import info.magnolia.cms.core.SystemProperty;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.logging.Log4jConfigurer;
  import info.magnolia.module.ModuleManager;
  import info.magnolia.module.ModuleRegistry;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.objectfactory.configuration.ComponentProviderConfiguration;
  import info.magnolia.objectfactory.configuration.ComponentProviderConfigurationBuilder;
  import info.magnolia.objectfactory.guice.GuiceComponentProvider;
  import info.magnolia.objectfactory.guice.GuiceComponentProviderBuilder;
  
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.List;
  
  import javax.inject.Singleton;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletContextEvent;
  import javax.servlet.ServletContextListener;
  
  import org.apache.commons.lang3.StringUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import com.google.inject.Stage;
  
  /**
   * Point of entry for Magnolia CMS, initializes the component providers, starts logging, triggers loading of
   * properties and finally delegates to {@link ConfigLoader} for completing initialization.
   *
   * <h3>Component providers</h3>
   * <p>
   * When Magnolia starts up the first thing that happens is the creation of the <i>platform</i> component provider. It
   * contains the essential singletons that constitutes the platform on which the rest of the system builds. These
   * components are defined in a file called <code>platform-components.xml</code>, it's on the classpath in package
   * /info/magnolia/init.
   * </p>
   * <p>
   * The location can be customized using a servlet context parameter called
   * <code>magnolia.platform.components.config.location</code>. It's specified as a list of comma-separated files on the
   * classpath. The files are loaded in the specified order allowing definitions to override definitions from earlier
   * files.
   * </p>
   * <pre>
   * &lt;context-param&gt;
   *   &lt;param-name&gt;magnolia.platform.components.config.location&lt;/param-name&gt;
   *   &lt;param-value&gt;/info/magnolia/init/platform-components.xml,/com/mycompany/custom-platform-components.xml&lt;/param-value&gt;
   * &lt;/context-param&gt;
   * </pre>
   * <p>
   * The platform components include the {@link ModuleManager} which is called by this listener to load the descriptors of
   * all the modules present. Modules define additional components that are loaded into a second component provider called
   * <i>system</i>.
   * </p>
   * <p>
   * When {@link ConfigLoader} takes over the initialization procedure it will create a third component provider called
   * <i>main</i> which contain components defined in modules as belonging to the main component provider.
   * </p>
   * <h3>Property loading</h3>
   * <p>
   * Properties are loaded by an implementation of {@link MagnoliaConfigurationProperties}. It's configured as a platform
   * component and is called by this class to do initialization. See {@link DefaultMagnoliaPropertiesResolver} and
  * {@link DefaultMagnoliaInitPaths} for details on how to customize the default behavior.
  * </p>
  *
  * @see ModuleManager
  * @see MagnoliaInitPaths
  * @see MagnoliaPropertiesResolver
  * @see DefaultMagnoliaPropertiesResolver
  * @see DefaultMagnoliaConfigurationProperties
  * @see DefaultMagnoliaInitPaths
  * @see ConfigLoader
  * @see Log4jConfigurer
  */
 @Singleton
 public class MagnoliaServletContextListener implements ServletContextListener {
 
     public static final String PLATFORM_COMPONENTS_CONFIG_LOCATION_NAME = "magnolia.platform.components.config.location";
     public static final String DEFAULT_PLATFORM_COMPONENTS_CONFIG_LOCATION = "/info/magnolia/init/platform-components.xml";
 
     private static final Logger log = LoggerFactory.getLogger(MagnoliaServletContextListener.class);
 
     private ServletContext servletContext;
     private GuiceComponentProvider platform;
     private GuiceComponentProvider system;
     private ModuleManager moduleManager;
     private ConfigLoader loader;
 
     @Override
     public void contextInitialized(final ServletContextEvent sce) {
         contextInitialized(sce, true);
     }
 
     public void contextInitialized(final ServletContextEvent sce, boolean startServer) {
         try {
             servletContext = sce.getServletContext();
 
             // Start 'platform' ComponentProvider
             GuiceComponentProviderBuilderrBuilder.html#GuiceComponentProviderBuilder">GuiceComponentProviderBuilder builder = new GuiceComponentProviderBuilder();
             builder.withConfiguration(getPlatformComponents());
             builder.inStage(Stage.PRODUCTION);
             builder.exposeGlobally();
             platform = builder.build();
 
             // Expose server name as a system property, so it can be used in log4j configurations
             // rootPath and webapp are not exposed since there can be different webapps running in the same jvm
 
             String serverName = platform.getComponent(MagnoliaInitPaths.class).getServerName();
 
             System.setProperty("server", serverName);
 
             // Set up init-phase MagnoliaConfigurationProperties simply for the module registry
             MagnoliaConfigurationProperties configurationProperties = platform.getComponent(MagnoliaConfigurationProperties.class);
             configurationProperties.init();
 
             // Connect legacy properties to the MagnoliaConfigurationProperties object
             SystemProperty.setMagnoliaConfigurationProperties(configurationProperties);
 
             // Load module definitions
             moduleManager = platform.getComponent(ModuleManager.class);
             moduleManager.loadDefinitions();
 
             // Initialize logging now that properties are available
             Log4jConfigurer.initLogging(configurationProperties, platform.getComponent(FileSystemHelper.class));
 
             // Start 'system' ComponentProvider
             builder = new GuiceComponentProviderBuilder();
             builder.withConfiguration(getSystemComponents());
             builder.withParent(platform);
             builder.exposeGlobally();
             system = builder.build();
 
             // Now initialize module-aware MagnoliaConfigurationProperties
             configurationProperties = system.getComponent(MagnoliaConfigurationProperties.class);
             configurationProperties.init();
             log.info("Property sources loaded: {}", configurationProperties.describe());
 
             // Re-connect legacy properties to the new MagnoliaConfigurationProperties object
             SystemProperty.setMagnoliaConfigurationProperties(configurationProperties);
 
             // Delegate to ConfigLoader to complete initialization
             loader = system.getComponent(ConfigLoader.class);
             if (startServer) {
                 loader.loadJaasConfig(system.getComponent(FileSystemHelper.class));
                 startServer();
             }
 
         } catch (Throwable t) {
             log.error("Oops, Magnolia could not be started", t);
             t.printStackTrace();
             if (t instanceof Error) {
                 throw (Error) t;
             }
             if (t instanceof RuntimeException) {
                 throw (RuntimeException) t;
             }
             throw new RuntimeException(t);
         }
     }
 
     @Override
     public void contextDestroyed(final ServletContextEvent sce) {
 
         // avoid disturbing NPEs if the context has never been started (classpath problems, etc)
         if (moduleManager != null) {
             moduleManager.stopModules();
         }
 
         stopServer();
 
         // We set the global ComponentProvider to its parent here, then we destroy it, components in it that expects the
         // global ComponentProvider to be the one it lives in and the one that was there when the component was created
         // might fail because of this. Maybe we can solve it by using the ThreadLocal override we already have and call
         // scopes.
 
         if (system != null) {
             Components.setComponentProvider(system.getParent());
             system.destroy();
         }
 
         if (platform != null) {
             Components.setComponentProvider(platform.getParent());
             platform.destroy();
         }
 
         Log4jConfigurer.shutdownLogging();
     }
 
     protected ComponentProviderConfiguration getPlatformComponents() {
         ComponentProviderConfigurationBuilderder.html#ComponentProviderConfigurationBuilder">ComponentProviderConfigurationBuilder configurationBuilder = new ComponentProviderConfigurationBuilder();
         List<String> resources = getPlatformComponentsResources();
         ComponentProviderConfiguration platformComponents = configurationBuilder.readConfiguration(resources, "platform");
         platformComponents.registerInstance(ServletContext.class, servletContext);
         // This is needed by DefaultMagnoliaInitPaths for backwards compatibility
         platformComponents.registerInstance(MagnoliaServletContextListener.class, this);
         return platformComponents;
     }
 
     /**
      * Returns a list of resources that contain platform components. Definitions for the same type will override giving
      * preference to the last read definition. Checks for an init parameter in web.xml for an overridden location
      * Subclasses can override this method to provide alternative strategies. The returned locations are used to find
      * the resource on the class path.
      */
     protected List<String> getPlatformComponentsResources() {
         String configLocation = servletContext.getInitParameter(PLATFORM_COMPONENTS_CONFIG_LOCATION_NAME);
         if (StringUtils.isNotBlank(configLocation)) {
             return Arrays.asList(StringUtils.split(configLocation, ", \n"));
         }
         return Collections.singletonList(DEFAULT_PLATFORM_COMPONENTS_CONFIG_LOCATION);
     }
 
     protected ComponentProviderConfiguration getSystemComponents() {
         ComponentProviderConfigurationBuilderder.html#ComponentProviderConfigurationBuilder">ComponentProviderConfigurationBuilder configurationBuilder = new ComponentProviderConfigurationBuilder();
         return configurationBuilder.getComponentsFromModules("system", platform.getComponent(ModuleRegistry.class).getModuleDefinitions());
     }
 
     protected void startServer() {
         MgnlContext.doInSystemContext(new MgnlContext.VoidOp() {
             @Override
             public void doExec() {
                 loader.load();
             }
         }, true);
     }
 
     protected void stopServer() {
         if (loader != null) {
             MgnlContext.doInSystemContext(new MgnlContext.VoidOp() {
                 @Override
                 public void doExec() {
                     loader.unload();
                 }
             }, true);
         }
     }
 
     /**
      * @deprecated since 4.5, use or subclass {@link MagnoliaInitPaths}.
      */
     @Deprecated
     protected String initWebappName(String rootPath) {
         return null;
     }
 
     /**
      * @deprecated since 4.5, use or subclass {@link MagnoliaInitPaths}.
      */
     @Deprecated
     protected String initRootPath(final ServletContext context) {
         return null;
     }
 
     /**
      * @deprecated since 4.5, use or subclass {@link MagnoliaInitPaths}.
      */
     @Deprecated
     protected String initServername(boolean unqualified) {
         return null;
     }
 
 }