/*
    * 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.log4j;
  
  import org.apache.log4j.helpers.LogLog;
  import org.apache.log4j.or.ObjectRenderer;
  import org.apache.log4j.or.RendererMap;
  import org.apache.log4j.plugins.Plugin;
  import org.apache.log4j.plugins.PluginRegistry;
  import org.apache.log4j.scheduler.Scheduler;
  import org.apache.log4j.spi.*;
  import org.apache.log4j.xml.DOMConfigurator;
  import org.apache.log4j.xml.UnrecognizedElementHandler;
  import org.w3c.dom.Element;
  
  import java.util.*;
  
  
  /**
   * This class implements LoggerRepositoryEx by
   * wrapping an existing LoggerRepository implementation
   * and implementing the newly added capabilities.
   */
  public final class LoggerRepositoryExImpl
      implements LoggerRepositoryEx,
      RendererSupport,
      UnrecognizedElementHandler {
  
      /**
       * Wrapped logger repository.
       */
      private final LoggerRepository repo;
  
      /**
       * Logger factory.  Does not affect class of logger
       * created by underlying repository.
       */
      private LoggerFactory loggerFactory;
  
      /**
       * Renderer support.
       */
      private final RendererSupport rendererSupport;
  
      /**
       * List of repository event listeners.
       */
      private final ArrayList<LoggerRepositoryEventListener> repositoryEventListeners = new ArrayList<>();
      /**
       * Map of HierarchyEventListener keyed by LoggingEventListener.
       */
      private final Map<LoggerEventListener, HierarchyEventListenerProxy> loggerEventListeners = new HashMap<>();
      /**
       * Name of hierarchy.
       */
      private String name;
      /**
       * Plug in registry.
       */
      private PluginRegistry pluginRegistry;
      /**
       * Properties.
       */
      private final Map<String, String> properties = new Hashtable<>();
      /**
       * Scheduler.
       */
      private Scheduler scheduler;
  
      /**
       * The repository can also be used as an object store
       * for various objects used by log4j components.
       */
      private Map<String, Object> objectMap = new HashMap<>();
  
  
      /**
       * Error list.
       */
      private List<ErrorItem> errorList = new Vector<>();
  
      /**
       * True if hierarchy has not been modified.
       */
     private boolean pristine = true;
 
     /**
      * Constructs a new logger hierarchy.
      *
      * @param repository Base implementation of repository.
      */
     public LoggerRepositoryExImpl(final LoggerRepository repository) {
         super();
         if (repository == null) {
             throw new NullPointerException("repository");
         }
         repo = repository;
         if (repository instanceof RendererSupport) {
             rendererSupport = (RendererSupport) repository;
         } else {
             rendererSupport = new RendererSupportImpl();
         }
     }
 
 
     /**
      * Add a {@link LoggerRepositoryEventListener} to the repository. The
      * listener will be called when repository events occur.
      *
      * @param listener listener
      */
     public void addLoggerRepositoryEventListener(
         final LoggerRepositoryEventListener listener) {
         synchronized (repositoryEventListeners) {
             if (repositoryEventListeners.contains(listener)) {
                 LogLog.warn(
                     "Ignoring attempt to add a previously "
                         + "registered LoggerRepositoryEventListener.");
             } else {
                 repositoryEventListeners.add(listener);
             }
         }
     }
 
 
     /**
      * Remove a {@link LoggerRepositoryEventListener} from the repository.
      *
      * @param listener listener
      */
     public void removeLoggerRepositoryEventListener(
         final LoggerRepositoryEventListener listener) {
         synchronized (repositoryEventListeners) {
             if (!repositoryEventListeners.contains(listener)) {
                 LogLog.warn(
                     "Ignoring attempt to remove a "
                         + "non-registered LoggerRepositoryEventListener.");
             } else {
                 repositoryEventListeners.remove(listener);
             }
         }
     }
 
     /**
      * Add a {@link LoggerEventListener} to the repository. The  listener
      * will be called when repository events occur.
      *
      * @param listener listener
      */
     public void addLoggerEventListener(final LoggerEventListener listener) {
         synchronized (loggerEventListeners) {
             if (loggerEventListeners.get(listener) != null) {
                 LogLog.warn(
                     "Ignoring attempt to add a previously registerd LoggerEventListener.");
             } else {
                 HierarchyEventListenerProxy proxy =
                     new HierarchyEventListenerProxy(listener);
                 loggerEventListeners.put(listener, proxy);
                 repo.addHierarchyEventListener(proxy);
             }
         }
     }
 
     /**
      * Add a {@link org.apache.log4j.spi.HierarchyEventListener}
      * event to the repository.
      *
      * @param listener listener
      * @deprecated Superceded by addLoggerEventListener
      */
     public void addHierarchyEventListener(final HierarchyEventListener listener) {
         repo.addHierarchyEventListener(listener);
     }
 
 
     /**
      * Remove a {@link LoggerEventListener} from the repository.
      *
      * @param listener listener to be removed
      */
     public void removeLoggerEventListener(final LoggerEventListener listener) {
         synchronized (loggerEventListeners) {
             HierarchyEventListenerProxy proxy =
                 loggerEventListeners.get(listener);
             if (proxy == null) {
                 LogLog.warn(
                     "Ignoring attempt to remove a non-registered LoggerEventListener.");
             } else {
                 loggerEventListeners.remove(listener);
                 proxy.disable();
             }
         }
     }
 
     /**
      * Issue warning that there are no appenders in hierarchy.
      *
      * @param cat logger, not currently used.
      */
     public void emitNoAppenderWarning(final Category cat) {
         repo.emitNoAppenderWarning(cat);
     }
 
     /**
      * Check if the named logger exists in the hierarchy. If so return
      * its reference, otherwise returns <code>null</code>.
      *
      * @param loggerName The name of the logger to search for.
      * @return true if logger exists.
      */
     public Logger exists(final String loggerName) {
         return repo.exists(loggerName);
     }
 
     /**
      * Return the name of this hierarchy.
      *
      * @return name of hierarchy
      */
     public String getName() {
         return name;
     }
 
     /**
      * Set the name of this repository.
      * <p>
      * Note that once named, a repository cannot be rerenamed.
      *
      * @param repoName name of hierarchy
      */
     public void setName(final String repoName) {
         if (name == null) {
             name = repoName;
         } else if (!name.equals(repoName)) {
             throw new IllegalStateException(
                 "Repository [" + name + "] cannot be renamed as [" + repoName + "].");
         }
     }
 
     /**
      * {@inheritDoc}
      */
     public Map<String, String> getProperties() {
         return properties;
     }
 
     /**
      * {@inheritDoc}
      */
     public String getProperty(final String key) {
         return properties.get(key);
     }
 
     /**
      * Set a property by key and value. The property will be shared by all
      * events in this repository.
      *
      * @param key   property name
      * @param value property value
      */
     public void setProperty(final String key,
                             final String value) {
         properties.put(key, value);
     }
 
     /**
      * The string form of {@link #setThreshold(Level)}.
      *
      * @param levelStr symbolic name for level
      */
     public void setThreshold(final String levelStr) {
         repo.setThreshold(levelStr);
     }
 
     /**
      * Enable logging for logging requests with level <code>l</code> or
      * higher. By default all levels are enabled.
      *
      * @param l The minimum level for which logging requests are sent to
      *          their appenders.
      */
     public void setThreshold(final Level l) {
         repo.setThreshold(l);
     }
 
     /**
      * {@inheritDoc}
      */
     public PluginRegistry getPluginRegistry() {
         if (pluginRegistry == null) {
             pluginRegistry = new PluginRegistry(this);
         }
         return pluginRegistry;
     }
 
 
     /**
      * Requests that a appender added event be sent to any registered
      * {@link LoggerEventListener}.
      *
      * @param logger   The logger to which the appender was added.
      * @param appender The appender added to the logger.
      */
     public void fireAddAppenderEvent(final Category logger,
                                      final Appender appender) {
         repo.fireAddAppenderEvent(logger, appender);
     }
 
 
     /**
      * Requests that a appender removed event be sent to any registered
      * {@link LoggerEventListener}.
      *
      * @param logger   The logger from which the appender was removed.
      * @param appender The appender removed from the logger.
      */
     public void fireRemoveAppenderEvent(final Category logger,
                                         final Appender appender) {
         if (repo instanceof Hierarchy) {
             ((Hierarchy) repo).fireRemoveAppenderEvent(logger, appender);
         }
     }
 
 
     /**
      * Requests that a level changed event be sent to any registered
      * {@link LoggerEventListener}.
      *
      * @param logger The logger which changed levels.
      */
     public void fireLevelChangedEvent(final Logger logger) {
     }
 
     /**
      * Requests that a configuration changed event be sent to any registered
      * {@link LoggerRepositoryEventListener}.
      */
     public void fireConfigurationChangedEvent() {
     }
 
 
     /**
      * Returns the current threshold.
      *
      * @return current threshold level
      * @since 1.2
      */
     public Level getThreshold() {
         return repo.getThreshold();
     }
 
 
     /**
      * Return a new logger instance named as the first parameter using
      * the default factory.
      * <p>
      * <p>If a logger of that name already exists, then it will be
      * returned.  Otherwise, a new logger will be instantiated and
      * then linked with its existing ancestors as well as children.
      *
      * @param loggerName The name of the logger to retrieve.
      * @return logger
      */
     public Logger getLogger(final String loggerName) {
         return repo.getLogger(loggerName);
     }
 
     /**
      * Return a new logger instance named as the first parameter using
      * <code>factory</code>.
      * <p>
      * <p>If a logger of that name already exists, then it will be
      * returned.  Otherwise, a new logger will be instantiated by the
      * <code>factory</code> parameter and linked with its existing
      * ancestors as well as children.
      *
      * @param loggerName The name of the logger to retrieve.
      * @param factory    The factory that will make the new logger instance.
      * @return logger
      */
     public Logger getLogger(final String loggerName,
                             final LoggerFactory factory) {
         return repo.getLogger(loggerName, factory);
     }
 
     /**
      * Returns all the currently defined categories in this hierarchy as
      * an {@link java.util.Enumeration Enumeration}.
      * <p>
      * <p>The root logger is <em>not</em> included in the returned
      * {@link Enumeration}.
      *
      * @return enumerator of current loggers
      */
     public Enumeration getCurrentLoggers() {
         return repo.getCurrentLoggers();
     }
 
     /**
      * Return the the list of previously encoutered {@link ErrorItem error items}.
      *
      * @return list of errors
      */
     public List<ErrorItem> getErrorList() {
         return errorList;
     }
 
     /**
      * Add an error item to the list of previously encountered errors.
      *
      * @param errorItem error to add to list of errors.
      */
     public void addErrorItem(final ErrorItem errorItem) {
         getErrorList().add(errorItem);
     }
 
     /**
      * Get enumerator over current loggers.
      *
      * @return enumerator over current loggers
      * @deprecated Please use {@link #getCurrentLoggers} instead.
      */
     public Enumeration getCurrentCategories() {
         return repo.getCurrentCategories();
     }
 
     /**
      * Get the renderer map for this hierarchy.
      *
      * @return renderer map
      */
     public RendererMap getRendererMap() {
         return rendererSupport.getRendererMap();
     }
 
     /**
      * Get the root of this hierarchy.
      *
      * @return root of hierarchy
      * @since 0.9.0
      */
     public Logger getRootLogger() {
         return repo.getRootLogger();
     }
 
     /**
      * This method will return <code>true</code> if this repository is
      * disabled for <code>level</code> value passed as parameter and
      * <code>false</code> otherwise. See also the {@link
      * #setThreshold(Level) threshold} method.
      *
      * @param level numeric value for level.
      * @return true if disabled for specified level
      */
     public boolean isDisabled(final int level) {
         return repo.isDisabled(level);
     }
 
     /**
      * Reset all values contained in this hierarchy instance to their
      * default.  This removes all appenders from all categories, sets
      * the level of all non-root categories to <code>null</code>,
      * sets their additivity flag to <code>true</code> and sets the level
      * of the root logger to DEBUG.  Moreover,
      * message disabling is set its default "off" value.
      * <p>
      * <p>Existing categories are not removed. They are just reset.
      * <p>
      * <p>This method should be used sparingly and with care as it will
      * block all logging until it is completed.</p>
      *
      * @since 0.8.5
      */
     public void resetConfiguration() {
         repo.resetConfiguration();
     }
 
     /**
      * Used by subclasses to add a renderer to the hierarchy passed as parameter.
      *
      * @param renderedClass class
      * @param renderer      object used to render class.
      */
     public void setRenderer(final Class renderedClass,
                             final ObjectRenderer renderer) {
         rendererSupport.setRenderer(renderedClass, renderer);
     }
 
     /**
      * {@inheritDoc}
      */
     public boolean isPristine() {
         return pristine;
     }
 
     /**
      * {@inheritDoc}
      */
     public void setPristine(final boolean state) {
         pristine = state;
     }
 
     /**
      * Shutting down a hierarchy will <em>safely</em> close and remove
      * all appenders in all categories including the root logger.
      * <p>
      * <p>Some appenders such as org.apache.log4j.net.SocketAppender
      * and AsyncAppender need to be closed before the
      * application exists. Otherwise, pending logging events might be
      * lost.
      * <p>
      * <p>The <code>shutdown</code> method is careful to close nested
      * appenders before closing regular appenders. This is allows
      * configurations where a regular appender is attached to a logger
      * and again to a nested appender.
      *
      * @since 1.0
      */
     public void shutdown() {
         repo.shutdown();
     }
 
 
     /**
      * Return this repository's own scheduler.
      * The scheduler is lazily instantiated.
      *
      * @return this repository's own scheduler.
      */
     public Scheduler getScheduler() {
         if (scheduler == null) {
             scheduler = new Scheduler();
             scheduler.setDaemon(true);
             scheduler.start();
         }
         return scheduler;
     }
 
     /**
      * Puts object by key.
      *
      * @param key   key, may not be null.
      * @param value object to associate with key.
      */
     public void putObject(final String key,
                           final Object value) {
         objectMap.put(key, value);
     }
 
     /**
      * Get object by key.
      *
      * @param key key, may not be null.
      * @return object associated with key or null.
      */
     public Object getObject(final String key) {
         return objectMap.get(key);
     }
 
     /**
      * Set logger factory.
      *
      * @param factory logger factory.
      */
     public void setLoggerFactory(final LoggerFactory factory) {
         if (factory == null) {
             throw new NullPointerException();
         }
         this.loggerFactory = factory;
     }
 
     /**
      * Get logger factory.
      *
      * @return logger factory.
      */
     public LoggerFactory getLoggerFactory() {
         return loggerFactory;
     }
 
     /**
      * {@inheritDoc}
      */
     public boolean parseUnrecognizedElement(
         final Element element,
         final Properties props) throws Exception {
         if ("plugin".equals(element.getNodeName())) {
             Object instance =
                 DOMConfigurator.parseElement(element, props, Plugin.class);
             if (instance instanceof Plugin) {
                 Plugin plugin = (Plugin) instance;
                 String pluginName = DOMConfigurator.subst(element.getAttribute("name"), props);
                 if (pluginName.length() > 0) {
                     plugin.setName(pluginName);
                 }
                 getPluginRegistry().addPlugin(plugin);
                 plugin.setLoggerRepository(this);
 
                 LogLog.debug("Pushing plugin on to the object stack.");
                 plugin.activateOptions();
                 return true;
             }
         }
         return false;
     }
 
 
     /**
      * Implementation of RendererSupportImpl if not
      * provided by LoggerRepository.
      */
     private static final class RendererSupportImpl implements RendererSupport {
         /**
          * Renderer map.
          */
         private final RendererMap renderers = new RendererMap();
 
         /**
          * Create new instance.
          */
         public RendererSupportImpl() {
             super();
         }
 
         /**
          * {@inheritDoc}
          */
         public RendererMap getRendererMap() {
             return renderers;
         }
 
         /**
          * {@inheritDoc}
          */
         public void setRenderer(final Class renderedClass,
                                 final ObjectRenderer renderer) {
             renderers.put(renderedClass, renderer);
         }
     }
 
     /**
      * Proxy that implements HierarchyEventListener
      * and delegates to LoggerEventListener.
      */
     private static final class HierarchyEventListenerProxy
         implements HierarchyEventListener {
         /**
          * Wrapper listener.
          */
         private LoggerEventListener listener;
 
         /**
          * Creates new instance.
          *
          * @param l listener
          */
         public HierarchyEventListenerProxy(final LoggerEventListener l) {
             super();
             if (l == null) {
                 throw new NullPointerException("l");
             }
             listener = l;
         }
 
         /**
          * {@inheritDoc}
          */
         public void addAppenderEvent(final Category cat,
                                      final Appender appender) {
             if (isEnabled() && cat instanceof Logger) {
                 listener.appenderAddedEvent((Logger) cat, appender);
             }
         }
 
         /**
          * {@inheritDoc}
          */
         public void removeAppenderEvent(final Category cat,
                                         final Appender appender) {
             if (isEnabled() && cat instanceof Logger) {
                 listener.appenderRemovedEvent((Logger) cat, appender);
             }
         }
 
         /**
          * Disable forwarding of notifications to
          * simulate removal of listener.
          */
         public synchronized void disable() {
             listener = null;
         }
 
         /**
          * Gets whether proxy is enabled.
          *
          * @return true if proxy is enabled.
          */
         private synchronized boolean isEnabled() {
             return listener != null;
         }
     }
 
 }