/*
    * 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.core;
  
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.io.File;
  import java.lang.ref.Reference;
  import java.lang.ref.SoftReference;
  import java.net.URI;
  import java.util.Collection;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  import java.util.concurrent.CopyOnWriteArrayList;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  
  import org.apache.logging.log4j.LogManager;
  import org.apache.logging.log4j.Marker;
  import org.apache.logging.log4j.MarkerManager;
  import org.apache.logging.log4j.core.config.Configuration;
  import org.apache.logging.log4j.core.config.ConfigurationFactory;
  import org.apache.logging.log4j.core.config.ConfigurationListener;
  import org.apache.logging.log4j.core.config.ConfigurationSource;
  import org.apache.logging.log4j.core.config.DefaultConfiguration;
  import org.apache.logging.log4j.core.config.NullConfiguration;
  import org.apache.logging.log4j.core.config.Reconfigurable;
  import org.apache.logging.log4j.core.jmx.Server;
  import org.apache.logging.log4j.core.util.Assert;
  import org.apache.logging.log4j.core.util.NetUtils;
  import org.apache.logging.log4j.message.MessageFactory;
  import org.apache.logging.log4j.spi.AbstractLogger;
  import org.apache.logging.log4j.util.PropertiesUtil;
  
  /**
   * The LoggerContext is the anchor for the logging system. It maintains a list
   * of all the loggers requested by applications and a reference to the
   * Configuration. The Configuration will contain the configured loggers,
   * appenders, filters, etc and will be atomically updated whenever a reconfigure
   * occurs.
   */
  public class LoggerContext extends AbstractLifeCycle implements org.apache.logging.log4j.spi.LoggerContext, ConfigurationListener {
  
      private static final boolean SHUTDOWN_HOOK_ENABLED =
          PropertiesUtil.getProperties().getBooleanProperty("log4j.shutdownHookEnabled", true);
  
      public static final String PROPERTY_CONFIG = "config";
      private static final Marker SHUTDOWN_HOOK = MarkerManager.getMarker("SHUTDOWN HOOK");
      private static final Configuration NULL_CONFIGURATION = new NullConfiguration();
  
      private final ConcurrentMap<String, Logger> loggers = new ConcurrentHashMap<String, Logger>();
      private final CopyOnWriteArrayList<PropertyChangeListener> propertyChangeListeners = new CopyOnWriteArrayList<PropertyChangeListener>();
  
      /**
       * The Configuration is volatile to guarantee that initialization of the
       * Configuration has completed before the reference is updated.
       */
      private volatile Configuration config = new DefaultConfiguration();
      private Object externalContext;
      private final String name;
      private URI configLocation;
  
      /**
       * Once a shutdown hook thread executes, we can't remove it from the runtime (throws an exception). Therefore,
       * it's really pointless to keep a strongly accessible reference to said thread. Thus, please use a
       * SoftReference here to prevent possible cyclic memory references.
       */
      private Reference<Thread> shutdownThread;
  
      private final Lock configLock = new ReentrantLock();
  
      /**
       * Constructor taking only a name.
       * @param name The context name.
       */
      public LoggerContext(final String name) {
          this(name, null, (URI) null);
      }
  
      /**
       * Constructor taking a name and a reference to an external context.
       * @param name The context name.
       * @param externalContext The external context.
       */
      public LoggerContext(final String name, final Object externalContext) {
         this(name, externalContext, (URI) null);
     }
 
     /**
      * Constructor taking a name, external context and a configuration URI.
      * @param name The context name.
      * @param externalContext The external context.
      * @param configLocn The location of the configuration as a URI.
      */
     public LoggerContext(final String name, final Object externalContext, final URI configLocn) {
         this.name = name;
         this.externalContext = externalContext;
         this.configLocation = configLocn;
     }
 
     /**
      * Constructor taking a name external context and a configuration location
      * String. The location must be resolvable to a File.
      *
      * @param name The configuration location.
      * @param externalContext The external context.
      * @param configLocn The configuration location.
      */
     public LoggerContext(final String name, final Object externalContext, final String configLocn) {
         this.name = name;
         this.externalContext = externalContext;
         if (configLocn != null) {
             URI uri;
             try {
                 uri = new File(configLocn).toURI();
             } catch (final Exception ex) {
                 uri = null;
             }
             configLocation = uri;
         } else {
             configLocation = null;
         }
     }
 
     @Override
     public void start() {
         LOGGER.debug("Starting LoggerContext[name={}, {}]...", getName(), this);
         if (configLock.tryLock()) {
             try {
                 if (this.isInitialized() || this.isStopped()) {
                     this.setStarting();
                     reconfigure();
                     setUpShutdownHook();
                     this.setStarted();
                 }
             } finally {
                 configLock.unlock();
             }
         }
         LOGGER.debug("LoggerContext[name={}, {}] started OK.", getName(), this);
     }
 
     /**
      * Start with a specific configuration.
      * @param config The new Configuration.
      */
     public void start(final Configuration config) {
         LOGGER.debug("Starting LoggerContext[name={}, {}] with configuration {}...", getName(), this, config);
         if (configLock.tryLock()) {
             try {
                 if (this.isInitialized() || this.isStopped()) {
                     setUpShutdownHook();
                     this.setStarted();
                 }
             } finally {
                 configLock.unlock();
             }
         }
         setConfiguration(config);
         LOGGER.debug("LoggerContext[name={}, {}] started OK with configuration {}.", getName(), this, config);
     }
 
     private void setUpShutdownHook() {
         if (config.isShutdownHookEnabled() && SHUTDOWN_HOOK_ENABLED) {
             LOGGER.debug(SHUTDOWN_HOOK, "Shutdown hook enabled. Registering a new one.");
             shutdownThread = new SoftReference<Thread>(
                     new Thread(new ShutdownThread(this), "log4j-shutdown")
             );
             addShutdownHook();
         }
     }
 
     private void addShutdownHook() {
         final Thread hook = getShutdownThread();
         if (hook != null) {
             try {
                 Runtime.getRuntime().addShutdownHook(hook);
             } catch (final IllegalStateException ise) {
                 LOGGER.warn(SHUTDOWN_HOOK, "Unable to register shutdown hook due to JVM state");
             } catch (final SecurityException se) {
                 LOGGER.warn(SHUTDOWN_HOOK, "Unable to register shutdown hook due to security restrictions");
             }
         }
     }
 
     private Thread getShutdownThread() {
         return shutdownThread == null ? null : shutdownThread.get();
     }
 
     @Override
     public void stop() {
         LOGGER.debug("Stopping LoggerContext[name={}, {}]...", getName(), this);
         configLock.lock();
         try {
             if (this.isStopped()) {
                 return;
             }
             this.setStopping();
             tearDownShutdownHook();
             final Configuration prev = config;
             config = NULL_CONFIGURATION;
             updateLoggers();
             prev.stop();
             externalContext = null;
             LogManager.getFactory().removeContext(this);
             this.setStopped();
         } finally {
             configLock.unlock();
 
             // in finally: unregister MBeans even if an exception occurred while stopping
             Server.unregisterLoggerContext(getName()); // LOG4J2-406, LOG4J2-500
         }
         LOGGER.debug("Stopped LoggerContext[name={}, {}]...", getName(), this);
     }
 
     private void tearDownShutdownHook() {
         if (shutdownThread != null) {
             LOGGER.debug(SHUTDOWN_HOOK, "Enqueue shutdown hook for garbage collection.");
             shutdownThread.enqueue();
         }
     }
 
     /**
      * Gets the name.
      *
      * @return the name.
      */
     public String getName() {
         return name;
     }
 
     /**
      * Set the external context.
      * @param context The external context.
      */
     public void setExternalContext(final Object context) {
         this.externalContext = context;
     }
 
     /**
      * Returns the external context.
      * @return The external context.
      */
     @Override
     public Object getExternalContext() {
         return this.externalContext;
     }
 
     /**
      * Obtain a Logger from the Context.
      * @param name The name of the Logger to return.
      * @return The Logger.
      */
     @Override
     public Logger getLogger(final String name) {
         return getLogger(name, null);
     }
 
     /**
      * Gets a collection of the current loggers.
      * <p>
      * Whether this collection is a copy of the underlying collection or not is undefined. Therefore, modify this collection at your own
      * risk.
      * </p>
      *
      * @return a collection of the current loggers.
      */
     public Collection<Logger> getLoggers() {
         return loggers.values();
     }
 
     /**
      * Obtain a Logger from the Context.
      * @param name The name of the Logger to return.
      * @param messageFactory The message factory is used only when creating a
      *            logger, subsequent use does not change the logger but will log
      *            a warning if mismatched.
      * @return The Logger.
      */
     @Override
     public Logger getLogger(final String name, final MessageFactory messageFactory) {
         Logger logger = loggers.get(name);
         if (logger != null) {
             AbstractLogger.checkMessageFactory(logger, messageFactory);
             return logger;
         }
 
         logger = newInstance(this, name, messageFactory);
         final Logger prev = loggers.putIfAbsent(name, logger);
         return prev == null ? logger : prev;
     }
 
     /**
      * Determine if the specified Logger exists.
      * @param name The Logger name to search for.
      * @return True if the Logger exists, false otherwise.
      */
     @Override
     public boolean hasLogger(final String name) {
         return loggers.containsKey(name);
     }
 
     /**
      * Returns the current Configuration. The Configuration will be replaced
      * when a reconfigure occurs.
      *
      * @return The Configuration.
      */
     public Configuration getConfiguration() {
         return config;
     }
 
     /**
      * Add a Filter to the Configuration. Filters that are added through the API will be lost
      * when a reconfigure occurs.
      * @param filter The Filter to add.
      */
     public void addFilter(final Filter filter) {
         config.addFilter(filter);
     }
 
     /**
      * Removes a Filter from the current Configuration.
      * @param filter The Filter to remove.
      */
     public void removeFilter(final Filter filter) {
         config.removeFilter(filter);
     }
 
     /**
      * Set the Configuration to be used.
      * @param config The new Configuration.
      * @return The previous Configuration.
      */
     private synchronized Configuration setConfiguration(final Configuration config) {
         if (config == null) {
             throw new NullPointerException("No Configuration was provided");
         }
         final Configuration prev = this.config;
         config.addListener(this);
         final ConcurrentMap<String, String> map = config.getComponent(Configuration.CONTEXT_PROPERTIES);
         
         try { // LOG4J2-719 network access may throw android.os.NetworkOnMainThreadException
             map.putIfAbsent("hostName", NetUtils.getLocalHostname());
         } catch (final Exception ex) {
             LOGGER.debug("Ignoring {}, setting hostName to 'unknown'", ex.toString());
             map.putIfAbsent("hostName", "unknown");
         }
         map.putIfAbsent("contextName", name);
         config.start();
         this.config = config;
         updateLoggers();
         if (prev != null) {
             prev.removeListener(this);
             prev.stop();
         }
 
         firePropertyChangeEvent(new PropertyChangeEvent(this, PROPERTY_CONFIG, prev, config));
 
         try {
             Server.reregisterMBeansAfterReconfigure();
         } catch (final Throwable t) { // LOG4J2-716: Android has no java.lang.management
             LOGGER.error("Could not reconfigure JMX", t);
         }
         return prev;
     }
 
     private void firePropertyChangeEvent(final PropertyChangeEvent event) {
         for (final PropertyChangeListener listener : propertyChangeListeners) {
             listener.propertyChange(event);
         }
     }
 
     public void addPropertyChangeListener(final PropertyChangeListener listener) {
         propertyChangeListeners.add(Assert.requireNonNull(listener, "listener"));
     }
 
     public void removePropertyChangeListener(final PropertyChangeListener listener) {
         propertyChangeListeners.remove(listener);
     }
 
     /**
      * Returns the initial configuration location or {@code null}. The returned value may not be the location of the
      * current configuration. Use 
      * {@link #getConfiguration()}.{@link Configuration#getConfigurationSource() getConfigurationSource()}.{@link 
      * ConfigurationSource#getLocation() getLocation()} to get the actual source of the current configuration.
      * @return the initial configuration location or {@code null}
      */
     public synchronized URI getConfigLocation() {
         return configLocation;
     }
 
     /**
      * Sets the configLocation to the specified value and reconfigures this context.
      * @param configLocation the location of the new configuration
      */
     public synchronized void setConfigLocation(final URI configLocation) {
         this.configLocation = configLocation;
         reconfigure();
     }
 
     /**
      * Reconfigure the context.
      */
     public synchronized void reconfigure() {
         LOGGER.debug("Reconfiguration started for context[name={}] at {} ({})", name, configLocation, this);
         final Configuration instance = ConfigurationFactory.getInstance().getConfiguration(name, configLocation);
         setConfiguration(instance);
         /*
          * instance.start(); Configuration old = setConfiguration(instance);
          * updateLoggers(); if (old != null) { old.stop(); }
          */
 
         LOGGER.debug("Reconfiguration complete for context[name={}] at {} ({})", name, configLocation, this);
     }
 
     /**
      * Cause all Loggers to be updated against the current Configuration.
      */
     public void updateLoggers() {
         updateLoggers(this.config);
     }
 
     /**
      * Cause all Logger to be updated against the specified Configuration.
      * @param config The Configuration.
      */
     public void updateLoggers(final Configuration config) {
         for (final Logger logger : loggers.values()) {
             logger.updateConfiguration(config);
         }
     }
 
     /**
      * Cause a reconfiguration to take place when the underlying configuration
      * file changes.
      *
      * @param reconfigurable The Configuration that can be reconfigured.
      */
     @Override
     public synchronized void onChange(final Reconfigurable reconfigurable) {
         LOGGER.debug("Reconfiguration started for context {} ({})", name, this);
         final Configuration config = reconfigurable.reconfigure();
         if (config != null) {
             setConfiguration(config);
             LOGGER.debug("Reconfiguration completed for {} ({})", name, this);
         } else {
             LOGGER.debug("Reconfiguration failed for {} ({})", name, this);
         }
     }
 
     // LOG4J2-151: changed visibility from private to protected
     protected Logger newInstance(final LoggerContext ctx, final String name, final MessageFactory messageFactory) {
         return new Logger(ctx, name, messageFactory);
     }
 
     private static class ShutdownThread implements Runnable {
 
         private final LoggerContext context;
 
         public ShutdownThread(final LoggerContext context) {
             this.context = context;
         }
 
         @Override
         public void run() {
             LOGGER.debug("ShutdownThread stopping LoggerContext[name={}, {}]...", context.getName(), context);
             context.stop();
             LOGGER.debug("ShutdownThread stopped LoggerContext[name={}, {}].", context.getName(), context);
         }
     }
 
 }