/*
    * 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.logging.log4j.core.LoggerContext;
  import org.apache.logging.log4j.core.helpers.NameUtil;
  import org.apache.logging.log4j.message.LocalizedMessage;
  import org.apache.logging.log4j.message.Message;
  import org.apache.logging.log4j.message.ObjectMessage;
  
  import java.util.Map;
  import java.util.ResourceBundle;
  import java.util.WeakHashMap;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  
  /**
   * Implementation of the Category class for compatibility, despite it having been deprecated a long, long time ago.
   */
  public class Category {
  
      private static org.apache.log4j.LoggerFactory loggerFactory = new PrivateFactory();
  
      private static final Map<LoggerContext, ConcurrentMap<String, Logger>> CONTEXT_MAP =
          new WeakHashMap<LoggerContext, ConcurrentMap<String, Logger>>();
  
      private static final String FQCN = Category.class.getName();
  
      /**
       * Resource bundle for localized messages.
       */
      protected ResourceBundle bundle = null;
  
      private final org.apache.logging.log4j.core.Logger logger;
  
      /**
       * Constructor used by Logger to specify a LoggerContext.
       * @param context The LoggerContext.
       * @param name The name of the Logger.
       */
      protected Category(LoggerContext context, String name) {
          this.logger = context.getLogger(name);
      }
  
      /**
       * Constructor exposed by Log4j 1.2.
       * @param name The name of the Logger.
       */
      protected Category(String name) {
          this((LoggerContext) PrivateManager.getContext(), name);
      }
  
      private Category(org.apache.logging.log4j.core.Logger logger) {
          this.logger = logger;
      }
  
      public static Category getInstance(String name) {
          return getInstance((LoggerContext) PrivateManager.getContext(), name, loggerFactory);
      }
  
      static Category getInstance(LoggerContext context, String name) {
          return getInstance(context, name, loggerFactory);
      }
  
      static Category getInstance(LoggerContext context, String name, org.apache.log4j.LoggerFactory factory) {
          ConcurrentMap<String, Logger> loggers = getLoggersMap(context);
          Logger logger = loggers.get(name);
          if (logger != null) {
              return logger;
          }
          logger = factory.makeNewLoggerInstance(context, name);
          Logger prev = loggers.putIfAbsent(name, logger);
          return prev == null ? logger : prev;
      }
  
      public static Category getInstance(Class clazz) {
          return getInstance(clazz.getName());
      }
  
      static Category getInstance(LoggerContext context, Class clazz) {
          return getInstance(context, clazz.getName());
      }
  
      public final String getName() {
         return logger.getName();
     }
 
     org.apache.logging.log4j.core.Logger getLogger() {
         return logger;
     }
 
     public final Category getParent() {
         org.apache.logging.log4j.core.Logger parent = logger.getParent();
         if (parent == null) {
             return null;
         }
         ConcurrentMap<String, Logger> loggers = getLoggersMap(logger.getContext());
         Logger l = loggers.get(parent.getName());
         return l == null ? new Category(parent) : l;
     }
 
     public static Category getRoot() {
         return getInstance("");
     }
 
 
     static Category getRoot(LoggerContext context) {
         return getInstance(context, "");
     }
 
     private static ConcurrentMap<String, Logger> getLoggersMap(LoggerContext context) {
         synchronized (CONTEXT_MAP) {
             ConcurrentMap<String, Logger> map = CONTEXT_MAP.get(context);
             if (map == null) {
                 map = new ConcurrentHashMap<String, Logger>();
                 CONTEXT_MAP.put(context, map);
             }
             return map;
         }
     }
 
     public final Level getEffectiveLevel() {
         org.apache.logging.log4j.Level level = logger.getLevel();
 
         switch (level) {
             case TRACE:
                 return Level.TRACE;
             case DEBUG:
                 return Level.DEBUG;
             case INFO:
                 return Level.INFO;
             case WARN:
                 return Level.WARN;
             default:
                 return Level.ERROR;
         }
     }
 
     public final Priority getChainedPriority() {
         return getEffectiveLevel();
     }
 
     public final Level getLevel() {
         return getEffectiveLevel();
     }
 
     public void setLevel(Level level) {
         logger.setLevel(org.apache.logging.log4j.Level.toLevel(level.levelStr));
     }
 
     public final Level getPriority() {
         return getEffectiveLevel();
     }
 
     public void setPriority(Priority priority) {
         logger.setLevel(org.apache.logging.log4j.Level.toLevel(priority.levelStr));
     }
 
     public void debug(Object message) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.DEBUG, message, null);
     }
 
     public void debug(Object message, Throwable t) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.DEBUG, message, t);
     }
 
     public boolean isDebugEnabled() {
         return logger.isDebugEnabled();
     }
 
     public void error(Object message) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.ERROR, message, null);
     }
 
     public void error(Object message, Throwable t) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.ERROR, message, t);
     }
 
     public boolean isErrorEnabled() {
         return logger.isErrorEnabled();
     }
 
     public void warn(Object message) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.WARN, message, null);
     }
 
     public void warn(Object message, Throwable t) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.WARN, message, t);
     }
 
     public boolean isWarnEnabled() {
         return logger.isWarnEnabled();
     }
 
     public void fatal(Object message) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.FATAL, message, null);
     }
 
     public void fatal(Object message, Throwable t) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.FATAL, message, t);
     }
 
     public boolean isFatalEnabled() {
         return logger.isFatalEnabled();
     }
 
     public void info(Object message) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.INFO, message, null);
     }
 
     public void info(Object message, Throwable t) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.INFO, message, t);
     }
 
     public boolean isInfoEnabled() {
         return logger.isInfoEnabled();
     }
 
     public void trace(Object message) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.TRACE, message, null);
     }
 
     public void trace(Object message, Throwable t) {
         maybeLog(FQCN, org.apache.logging.log4j.Level.TRACE, message, t);
     }
 
     public boolean isTraceEnabled() {
         return logger.isTraceEnabled();
     }
 
     public boolean isEnabledFor(Priority level) {
         org.apache.logging.log4j.Level lvl = org.apache.logging.log4j.Level.toLevel(level.toString());
         return isEnabledFor(lvl);
     }
 
     public void forcedLog(String fqcn, Priority level, Object message, Throwable t) {
         org.apache.logging.log4j.Level lvl = org.apache.logging.log4j.Level.toLevel(level.toString());
         logger.log(null, fqcn, lvl, new ObjectMessage(message), t);
     }
 
     public boolean exists(String name) {
         return PrivateManager.getContext().hasLogger(name);
     }
 
     public boolean getAdditivity() {
         return logger.isAdditive();
     }
 
     public void setAdditivity(boolean additivity) {
         logger.setAdditive(additivity);
     }
 
     public void setResourceBundle(ResourceBundle bundle) {
         this.bundle = bundle;
     }
 
     public ResourceBundle getResourceBundle() {
         if (bundle != null) {
             return bundle;
         }
         int i = 0;
         String name = logger.getName();
         ConcurrentMap<String, Logger> loggers = getLoggersMap(logger.getContext());
         while ((name = NameUtil.getSubName(name)) != null) {
             if (loggers.containsKey(name)) {
                 ResourceBundle rb = loggers.get(name).bundle;
                 if (rb != null) {
                     return rb;
                 }
             }
         }
         return null;
     }
 
     public void l7dlog(Priority priority, String key, Throwable t) {
         if (isEnabledFor(priority)) {
             Message msg = new LocalizedMessage(bundle, key, null);
             forcedLog(FQCN, priority, msg, t);
         }
     }
 
     public void l7dlog(Priority priority, String key, Object[] params, Throwable t) {
         if (isEnabledFor(priority)) {
             Message msg = new LocalizedMessage(bundle, key, params);
             forcedLog(FQCN, priority, msg, t);
         }
     }
 
     private void maybeLog(String fqcn, org.apache.logging.log4j.Level level,
             Object message, Throwable throwable) {
         if (logger.isEnabled(level, null, message, throwable)) {
             logger.log(null, FQCN, level, new ObjectMessage(message), throwable);
         }
     }
 
     /**
      * Private logger factory.
      */
     private static class PrivateFactory implements org.apache.log4j.LoggerFactory {
 
         public Logger makeNewLoggerInstance(LoggerContext context, String name) {
             return new Logger(context, name);
         }
     }
 
     /**
      * Private LogManager.
      */
     private static class PrivateManager extends org.apache.logging.log4j.LogManager {
         private static final String FQCN = Category.class.getName();
 
         public static org.apache.logging.log4j.spi.LoggerContext getContext() {
             return getContext(FQCN, false);
         }
 
         public static org.apache.logging.log4j.Logger getLogger(String name) {
             return getLogger(FQCN, name);
         }
     }
 
     private boolean isEnabledFor(org.apache.logging.log4j.Level level) {
         return logger.isEnabled(level, null, null);
     }
 
 }