/*
    * 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.logging.log4j.web;
  
  import java.net.URI;
  import java.net.URL;
  import java.text.SimpleDateFormat;
  import java.util.Arrays;
  import java.util.Date;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.TimeUnit;
  
  import javax.servlet.ServletContext;
  
  import org.apache.logging.log4j.LogManager;
  import org.apache.logging.log4j.core.AbstractLifeCycle;
  import org.apache.logging.log4j.core.LoggerContext;
  import org.apache.logging.log4j.core.async.AsyncLoggerContext;
  import org.apache.logging.log4j.core.config.Configurator;
  import org.apache.logging.log4j.core.impl.ContextAnchor;
  import org.apache.logging.log4j.core.impl.Log4jContextFactory;
  import org.apache.logging.log4j.core.lookup.Interpolator;
  import org.apache.logging.log4j.core.lookup.StrSubstitutor;
  import org.apache.logging.log4j.core.selector.ContextSelector;
  import org.apache.logging.log4j.core.selector.NamedContextSelector;
  import org.apache.logging.log4j.core.util.Loader;
  import org.apache.logging.log4j.core.util.NetUtils;
  import org.apache.logging.log4j.core.util.SetUtils;
  import org.apache.logging.log4j.spi.LoggerContextFactory;
  import org.apache.logging.log4j.util.LoaderUtil;
  
  /**
   * This class initializes and deinitializes Log4j no matter how the initialization occurs.
   */
  final class Log4jWebInitializerImpl extends AbstractLifeCycle implements Log4jWebLifeCycle {
  
      private static final String WEB_INF = "/WEB-INF/";
  
      static {
          if (Loader.isClassAvailable("org.apache.logging.log4j.core.web.JNDIContextFilter")) {
              throw new IllegalStateException("You are using Log4j 2 in a web application with the old, extinct "
                      + "log4j-web artifact. This is not supported and could cause serious runtime problems. Please"
                      + "remove the log4j-web JAR file from your application.");
          }
      }
  
      private final Map<String, String> map = new ConcurrentHashMap<>();
      private final StrSubstitutor substitutor = new StrSubstitutor(new Interpolator(map));
      private final ServletContext servletContext;
  
      private String name;
      private NamedContextSelector namedContextSelector;
      private LoggerContext loggerContext;
  
      private Log4jWebInitializerImpl(final ServletContext servletContext) {
          this.servletContext = servletContext;
          this.map.put("hostName", NetUtils.getLocalHostname());
      }
  
      /**
       * Initializes the Log4jWebLifeCycle attribute of a ServletContext. Those who wish to obtain this object should use
       * the {@link org.apache.logging.log4j.web.WebLoggerContextUtils#getWebLifeCycle(javax.servlet.ServletContext)}
       * method instead.
       *
       * @param servletContext
       *        the ServletContext to initialize
       * @return a new Log4jWebLifeCycle
       * @since 2.0.1
       */
      protected static Log4jWebInitializerImpl initialize(final ServletContext servletContext) {
          final Log4jWebInitializerImpl initializer = new Log4jWebInitializerImpl(servletContext);
          servletContext.setAttribute(SUPPORT_ATTRIBUTE, initializer);
          return initializer;
      }
  
      @Override
      public synchronized void start() {
          if (this.isStopped() || this.isStopping()) {
              throw new IllegalStateException("Cannot start this Log4jWebInitializerImpl after it was stopped.");
          }
  
          // only do this once
          if (this.isInitialized()) {
              super.setStarting();
 
             this.name = this.substitutor.replace(this.servletContext.getInitParameter(LOG4J_CONTEXT_NAME));
             final String location = this.substitutor.replace(this.servletContext
                     .getInitParameter(LOG4J_CONFIG_LOCATION));
             final boolean isJndi = "true".equalsIgnoreCase(this.servletContext
                     .getInitParameter(IS_LOG4J_CONTEXT_SELECTOR_NAMED));
 
             if (isJndi) {
                 this.initializeJndi(location);
             } else {
                 this.initializeNonJndi(location);
             }
             if (this.loggerContext instanceof AsyncLoggerContext) {
                 ((AsyncLoggerContext) this.loggerContext).setUseThreadLocals(false);
             }
 
             this.servletContext.setAttribute(CONTEXT_ATTRIBUTE, this.loggerContext);
             super.setStarted();
         }
     }
 
     private void initializeJndi(final String location) {
         final URI configLocation = getConfigURI(location);
 
         if (this.name == null) {
             throw new IllegalStateException("A log4jContextName context parameter is required");
         }
 
         LoggerContext context;
         final LoggerContextFactory factory = LogManager.getFactory();
         if (factory instanceof Log4jContextFactory) {
             final ContextSelector selector = ((Log4jContextFactory) factory).getSelector();
             if (selector instanceof NamedContextSelector) {
                 this.namedContextSelector = (NamedContextSelector) selector;
                 context = this.namedContextSelector.locateContext(this.name, this.servletContext, configLocation);
                 ContextAnchor.THREAD_CONTEXT.set(context);
                 if (context.isInitialized()) {
                     context.start();
                 }
                 ContextAnchor.THREAD_CONTEXT.remove();
             } else {
                 LOGGER.warn("Potential problem: Selector is not an instance of NamedContextSelector.");
                 return;
             }
         } else {
             LOGGER.warn("Potential problem: LoggerContextFactory is not an instance of Log4jContextFactory.");
             return;
         }
         this.loggerContext = context;
         LOGGER.debug("Created logger context for [{}] using [{}].", this.name, context.getClass().getClassLoader());
     }
 
     private void initializeNonJndi(final String location) {
         if (this.name == null) {
             this.name = this.servletContext.getServletContextName();
             LOGGER.debug("Using the servlet context name \"{}\".", this.name);
         }
         if (this.name == null) {
             this.name = this.servletContext.getContextPath();
             LOGGER.debug("Using the servlet context context-path \"{}\".", this.name);
         }
 
         if (this.name == null && location == null) {
             LOGGER.error("No Log4j context configuration provided. This is very unusual.");
             this.name = new SimpleDateFormat("yyyyMMdd_HHmmss.SSS").format(new Date());
         }
 
         final URI uri = getConfigURI(location);
         this.loggerContext = Configurator.initialize(this.name, this.getClassLoader(), uri, this.servletContext);
     }
 
     private URI getConfigURI(final String location) {
         try {
             String configLocation = location;
             if (configLocation == null) {
                 final String[] paths = SetUtils.prefixSet(servletContext.getResourcePaths(WEB_INF), WEB_INF + "log4j2");
                 LOGGER.debug("getConfigURI found resource paths {} in servletContext at [{}]", Arrays.toString(paths), WEB_INF);
                 if (paths.length == 1) {
                     configLocation = paths[0];
                 } else if (paths.length > 1) {
                     final String prefix = WEB_INF + "log4j2-" + this.name + ".";
                     boolean found = false;
                     for (final String str : paths) {
                         if (str.startsWith(prefix)) {
                             configLocation = str;
                             found = true;
                             break;
                         }
                     }
                     if (!found) {
                         configLocation = paths[0];
                     }
                 }
             }
             if (configLocation != null) {
                 final URL url = servletContext.getResource(configLocation);
                 if (url != null) {
                     final URI uri = url.toURI();
                     LOGGER.debug("getConfigURI found resource [{}] in servletContext at [{}]", uri, configLocation);
                     return uri;
                 }
             }
         } catch (final Exception ex) {
             // Just try passing the location.
         }
         if (location != null) {
             try {
                 final URI correctedFilePathUri = NetUtils.toURI(location);
                 LOGGER.debug("getConfigURI found [{}] in servletContext at [{}]", correctedFilePathUri, location);
                 return correctedFilePathUri;
             } catch (final Exception e) {
                 LOGGER.error("Unable to convert configuration location [{}] to a URI", location, e);
             }
         }
         return null;
     }
 
     @Override
     public synchronized boolean stop(final long timeout, final TimeUnit timeUnit) {
         if (!this.isStarted() && !this.isStopped()) {
             throw new IllegalStateException("Cannot stop this Log4jWebInitializer because it has not started.");
         }
 
         // only do this once
         if (this.isStarted()) {
             this.setStopping();
             if (this.loggerContext != null) {
                 LOGGER.debug("Removing LoggerContext for [{}].", this.name);
                 this.servletContext.removeAttribute(CONTEXT_ATTRIBUTE);
                 if (this.namedContextSelector != null) {
                     this.namedContextSelector.removeContext(this.name);
                 }
                 this.loggerContext.stop(timeout, timeUnit);
                 this.loggerContext.setExternalContext(null);
                 this.loggerContext = null;
             }
             this.setStopped();
         }
         return super.stop(timeout, timeUnit);
     }
 
     @Override
     public void setLoggerContext() {
         if (this.loggerContext != null) {
             ContextAnchor.THREAD_CONTEXT.set(this.loggerContext);
         }
     }
 
     @Override
     public void clearLoggerContext() {
         ContextAnchor.THREAD_CONTEXT.remove();
     }
 
     @Override
     public void wrapExecution(final Runnable runnable) {
         this.setLoggerContext();
 
         try {
             runnable.run();
         } finally {
             this.clearLoggerContext();
         }
     }
 
     private ClassLoader getClassLoader() {
         try {
             // if container is Servlet 3.0, use its getClassLoader method
             // this may look odd, but the call below will throw NoSuchMethodError if user is on Servlet 2.5
             // we compile against 3.0 to support Log4jServletContainerInitializer, but we don't require 3.0
             return this.servletContext.getClassLoader();
         } catch (final Throwable ignore) {
             // LOG4J2-248: use TCCL if possible
             return LoaderUtil.getThreadContextClassLoader();
         }
     }
 
 }