/*
 * 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.commons.logging.impl;

import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Marker;
import org.apache.logging.log4j.MarkerManager;
import org.apache.logging.log4j.spi.AbstractLoggerAdapter;
import org.apache.logging.log4j.spi.ExtendedLogger;
import org.apache.logging.log4j.spi.LoggerAdapter;
import org.apache.logging.log4j.spi.LoggerContext;
import org.apache.logging.log4j.util.StackLocatorUtil;

/**
 * Logger factory hardcoded to send everything to Log4j API.
 * <p>
 * Based on the `log4j-jcl` artifact from Apache Logging Services.
 * </p>
 *
 * @since 1.3.0
 */
public final class Log4jApiLogFactory extends LogFactory {

    private static final class Log4j2Log implements Log {

        private static final String FQCN = Log4j2Log.class.getName();

        private final ExtendedLogger logger;

        public Log4j2Log(final ExtendedLogger logger) {
            this.logger = logger;
        }

        @Override
        public void debug(final Object message) {
            logIfEnabled(Level.DEBUG, message, null);
        }

        @Override
        public void debug(final Object message, final Throwable t) {
            logIfEnabled(Level.DEBUG, message, t);
        }

        @Override
        public void error(final Object message) {
            logIfEnabled(Level.ERROR, message, null);
        }

        @Override
        public void error(final Object message, final Throwable t) {
            logIfEnabled(Level.ERROR, message, t);
        }

        @Override
        public void fatal(final Object message) {
            logIfEnabled(Level.FATAL, message, null);
        }

        @Override
        public void fatal(final Object message, final Throwable t) {
            logIfEnabled(Level.FATAL, message, t);
        }

        @Override
        public void info(final Object message) {
            logIfEnabled(Level.INFO, message, null);
        }

        @Override
        public void info(final Object message, final Throwable t) {
            logIfEnabled(Level.INFO, message, t);
        }

        @Override
        public boolean isDebugEnabled() {
            return isEnabled(Level.DEBUG);
        }

        private boolean isEnabled(final Level level) {
            return logger.isEnabled(level, MARKER, null);
        }

        @Override
        public boolean isErrorEnabled() {
            return isEnabled(Level.ERROR);
        }

        @Override
        public boolean isFatalEnabled() {
            return isEnabled(Level.FATAL);
        }

        @Override
        public boolean isInfoEnabled() {
            return isEnabled(Level.INFO);
        }

        @Override
        public boolean isTraceEnabled() {
            return isEnabled(Level.TRACE);
        }

        @Override
        public boolean isWarnEnabled() {
            return isEnabled(Level.WARN);
        }

        private void logIfEnabled(final Level level, final Object message, final Throwable t) {
            if (message instanceof CharSequence) {
                logger.logIfEnabled(FQCN, level, MARKER, (CharSequence) message, t);
            } else {
                logger.logIfEnabled(FQCN, level, MARKER, message, t);
            }
        }

        @Override
        public void trace(final Object message) {
            logIfEnabled(Level.TRACE, message, null);
        }

        @Override
        public void trace(final Object message, final Throwable t) {
            logIfEnabled(Level.TRACE, message, t);
        }

        @Override
        public void warn(final Object message) {
            logIfEnabled(Level.WARN, message, null);
        }

        @Override
        public void warn(final Object message, final Throwable t) {
            logIfEnabled(Level.WARN, message, t);
        }
    }
    private static final class LogAdapter extends AbstractLoggerAdapter<Log> {

        @Override
        protected LoggerContext getContext() {
            return getContext(LogManager.getFactory().isClassLoaderDependent() ? StackLocatorUtil.getCallerClass(
                    LogFactory.class) : null);
        }

        @Override
        protected Log newLogger(final String name, final LoggerContext context) {
            return new Log4j2Log(context.getLogger(name));
        }

    }

    private static final String[] EMPTY_ARRAY = {};

    /**
     * Marker used by all messages coming from Apache Commons Logging.
     */
    private static final Marker MARKER = MarkerManager.getMarker("COMMONS-LOGGING");

    /**
     * Caches Log instances
     */
    private final LoggerAdapter<Log> adapter = new LogAdapter();

    private final ConcurrentMap<String, Object> attributes = new ConcurrentHashMap<>();

    /**
     * Constructs a new instance.
     */
    public Log4jApiLogFactory() {
        // empty
    }

    @Override
    public Object getAttribute(final String name) {
        return attributes.get(name);
    }

    @Override
    public String[] getAttributeNames() {
        return attributes.keySet().toArray(EMPTY_ARRAY);
    }

    @Override
    public Log getInstance(final Class<?> clazz) {
        return getInstance(clazz.getName());
    }

    @Override
    public Log getInstance(final String name) {
        return adapter.getLogger(name);
    }

    /**
     * This method is supposed to clear all loggers. In this implementation it will clear all the logger
     * wrappers but the loggers managed by the underlying logger context will not be.
     */
    @Override
    public void release() {
        try {
            adapter.close();
        } catch (final IOException ignored) {
            // Ignore
        }
    }

    @Override
    public void removeAttribute(final String name) {
        attributes.remove(name);
    }

    @Override
    public void setAttribute(final String name, final Object value) {
        if (value != null) {
            attributes.put(name, value);
        } else {
            removeAttribute(name);
        }
    }
}