/*
 * 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
 *
 *      https://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 static org.slf4j.spi.LocationAwareLogger.DEBUG_INT;
import static org.slf4j.spi.LocationAwareLogger.ERROR_INT;
import static org.slf4j.spi.LocationAwareLogger.INFO_INT;
import static org.slf4j.spi.LocationAwareLogger.TRACE_INT;
import static org.slf4j.spi.LocationAwareLogger.WARN_INT;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogConfigurationException;
import org.apache.commons.logging.LogFactory;
import org.slf4j.ILoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;
import org.slf4j.spi.LocationAwareLogger;

/**
 * Logger factory hardcoded to send everything to SLF4J.
 *
 * @since 1.3.0
 */
public final class Slf4jLogFactory extends LogFactory {

    private static final class Slf4jLocationAwareLog implements Log {

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

        private final LocationAwareLogger logger;

        public Slf4jLocationAwareLog(final LocationAwareLogger logger) {
            this.logger = logger;
        }

        @Override
        public void debug(final Object message) {
            log(DEBUG_INT, message, null);
        }

        @Override
        public void debug(final Object message, final Throwable t) {
            log(DEBUG_INT, message, t);
        }

        @Override
        public void error(final Object message) {
            log(ERROR_INT, message, null);
        }

        @Override
        public void error(final Object message, final Throwable t) {
            log(ERROR_INT, message, t);
        }

        @Override
        public void fatal(final Object message) {
            error(message);
        }

        @Override
        public void fatal(final Object message, final Throwable t) {
            error(message, t);
        }

        @Override
        public void info(final Object message) {
            log(INFO_INT, message, null);
        }

        @Override
        public void info(final Object message, final Throwable t) {
            log(INFO_INT, message, t);
        }

        @Override
        public boolean isDebugEnabled() {
            return logger.isDebugEnabled(MARKER);
        }

        @Override
        public boolean isErrorEnabled() {
            return logger.isErrorEnabled(MARKER);
        }

        @Override
        public boolean isFatalEnabled() {
            return isErrorEnabled();
        }

        @Override
        public boolean isInfoEnabled() {
            return logger.isInfoEnabled(MARKER);
        }

        @Override
        public boolean isTraceEnabled() {
            return logger.isTraceEnabled(MARKER);
        }

        @Override
        public boolean isWarnEnabled() {
            return logger.isWarnEnabled(MARKER);
        }

        private void log(final int level, final Object message, final Throwable t) {
            logger.log(MARKER, FQCN, level, String.valueOf(message), EMPTY_OBJECT_ARRAY, t);
        }

        @Override
        public void trace(final Object message) {
            log(TRACE_INT, message, null);
        }

        @Override
        public void trace(final Object message, final Throwable t) {
            log(TRACE_INT, message, t);
        }

        @Override
        public void warn(final Object message) {
            log(WARN_INT, message, null);
        }

        @Override
        public void warn(final Object message, final Throwable t) {
            log(WARN_INT, message, t);
        }
    }
    private static class Slf4jLog implements Log {

        private final Logger logger;

        public Slf4jLog(final Logger logger) {
            this.logger = logger;
        }

        @Override
        public void debug(final Object message) {
            logger.debug(MARKER, String.valueOf(message));
        }

        @Override
        public void debug(final Object message, final Throwable t) {
            logger.debug(MARKER, String.valueOf(message), t);
        }

        @Override
        public void error(final Object message) {
            logger.error(MARKER, String.valueOf(message));
        }

        @Override
        public void error(final Object message, final Throwable t) {
            logger.error(MARKER, String.valueOf(message), t);
        }

        @Override
        public void fatal(final Object message) {
            error(message);
        }

        @Override
        public void fatal(final Object message, final Throwable t) {
            error(message, t);
        }

        @Override
        public void info(final Object message) {
            logger.info(MARKER, String.valueOf(message));
        }

        @Override
        public void info(final Object message, final Throwable t) {
            logger.info(MARKER, String.valueOf(message), t);
        }

        @Override
        public boolean isDebugEnabled() {
            return logger.isDebugEnabled(MARKER);
        }

        @Override
        public boolean isErrorEnabled() {
            return logger.isErrorEnabled(MARKER);
        }

        @Override
        public boolean isFatalEnabled() {
            return isErrorEnabled();
        }

        @Override
        public boolean isInfoEnabled() {
            return logger.isInfoEnabled(MARKER);
        }

        @Override
        public boolean isTraceEnabled() {
            return logger.isTraceEnabled(MARKER);
        }

        @Override
        public boolean isWarnEnabled() {
            return logger.isWarnEnabled(MARKER);
        }

        @Override
        public void trace(final Object message) {
            logger.trace(MARKER, String.valueOf(message));
        }

        @Override
        public void trace(final Object message, final Throwable t) {
            logger.trace(MARKER, String.valueOf(message), t);
        }

        @Override
        public void warn(final Object message) {
            logger.warn(MARKER, String.valueOf(message));
        }

        @Override
        public void warn(final Object message, final Throwable t) {
            logger.warn(MARKER, String.valueOf(message), t);
        }
    }

    private static final Object[] EMPTY_OBJECT_ARRAY = {};

    private static final String[] EMPTY_STRING_ARRAY = {};

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

    /**
     * Caches Log instances.
     * <p>
     * The SLF4J reference implementation (Logback) has a single logger context, so each call to
     * {@link #getInstance(String)}
     * should give the same result.
     * </p>
     */
    private final ConcurrentMap<String, Log> loggers = new ConcurrentHashMap<>();

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

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

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

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

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

    @Override
    public Log getInstance(final String name) {
        return loggers.computeIfAbsent(name, n -> {
            final Logger logger = LoggerFactory.getLogger(n);
            return logger instanceof LocationAwareLogger ? new Slf4jLocationAwareLog((LocationAwareLogger) logger) : new Slf4jLog(
                    logger);
        });
    }

    /**
     * This method is supposed to clear all loggers.
     * <p>
     * In this implementation it calls a "stop" method if the logger factory supports it. This is the case of
     * Logback.
     * </p>
     */
    @Override
    public void release() {
        final ILoggerFactory factory = LoggerFactory.getILoggerFactory();
        try {
            factory.getClass().getMethod("stop").invoke(factory);
        } catch (final ReflectiveOperationException ignored) {
            // empty
        }
    }

    @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);
        }
    }
}
