package org.slf4j.impl;

import com.nordlicht.mine.common.logger.ILogger;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.ILoggerFactory;
import org.slf4j.Logger;
import org.slf4j.Marker;
import org.slf4j.spi.LoggerFactoryBinder;

/**
 * Binds SLF4J to the Fabric3 monitor subsystem.
 */
//CHECKSTYLE:OFF
public final class StaticLoggerBinder implements LoggerFactoryBinder, ILoggerFactory {

    //CHECKSTYLE:OFF
    protected static final int                          TRACE = 0;
    protected static final int                          DEBUG = 1;
    protected static final int                          INFO = 2;
    protected static final int                          WARNING = 3;
    protected static final int                          ERROR = 4;
    protected static final Map<String, LoggerDelegate>  LOGGERS = new ConcurrentHashMap<>();
    public static final StaticLoggerBinder              SINGLETON = new StaticLoggerBinder();
    //CHECKSTYLE:ON
    private static final NoOpLogger                     NOOP_LOGGGER = new NoOpLogger();

    /**
     *
     * @param pLogger logger
     */
    public static void setLogger(ILogger pLogger) {
        for (LoggerDelegate delegate : LOGGERS.values()) {
            delegate.setLogger(pLogger);
        }
    }
    /**
     *
     * @return
     */
    public static StaticLoggerBinder getSingleton() {
        return SINGLETON;
    }

    /**
     *
     * @return
     */
    public ILoggerFactory getLoggerFactory() {
        return this;
    }

    /**
     *
     * @return
     */
    public String getLoggerFactoryClassStr() {
        return getClass().getName();
    }

    /**
     *
     * @param pName name
     * @return logger
     */
    public Logger getLogger(String pName) {
        LoggerDelegate delegate = LOGGERS.get(pName);
        if (delegate != null) {
            return delegate;
        }
        int level = 0;
        switch (pName) {
            case "com.amazonaws":
                level = DEBUG;
                break;
            case "org.apache.http":
                level = INFO;
                break;
            default:
                level = DEBUG;
        }
        if (delegate != null) {
            delegate = new LoggerDelegate(level, pName);
            LOGGERS.put(pName, delegate);
            return delegate;
        }
        return NOOP_LOGGGER;
    }

    /**
     *
     */
    // CHECKSTYLE:OFF
    protected static final class LoggerDelegate implements Logger {

        private ILogger             mLogger;
        private int                 mLevel;
        private String              mName;

        /**
         *
         * @param pLogger logger
         */
        private LoggerDelegate(ILogger pLogger) {
            mLogger = pLogger;
        }

        /**
         *
         * @param pLevel level
         * @param pName name
         */
        public LoggerDelegate(int pLevel, String pName) {
            mLevel = pLevel;
            mName = pName;
        }

        /**
         *
         * @param pLogger logger
         */
        private void setLogger(ILogger pLogger) {
            mLogger = pLogger;
        }

        @Override
        public String getName() {
            return "mineLogger";
        }

        @Override
        public boolean isTraceEnabled() {
            return mLevel == TRACE;
        }

        @Override
        public void trace(String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(msg);
        }

        @Override
        public void trace(String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(String.valueOf(arg));
        }

        @Override
        public void trace(String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(String.valueOf(arg1));
        }

        @Override
        public void trace(String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(String.valueOf(argArray));
        }

        @Override
        public void trace(String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(String.valueOf(msg));
        }

        @Override
        public boolean isTraceEnabled(Marker marker) {
            return mLevel == TRACE;
        }

        @Override
        public void trace(Marker marker, String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(String.valueOf(msg));
        }

        @Override
        public void trace(Marker marker, String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(String.valueOf(arg));
        }

        @Override
        public void trace(Marker marker, String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(String.valueOf(arg1));
        }

        @Override
        public void trace(Marker marker, String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(String.valueOf(argArray));
        }

        @Override
        public void trace(Marker marker, String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logTrace(String.valueOf(msg));
        }

        @Override
        public boolean isDebugEnabled() {
            return mLevel <= DEBUG;
        }

        @Override
        public void debug(String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(String.valueOf(msg));
        }

        @Override
        public void debug(String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(String.valueOf(arg));
        }

        @Override
        public void debug(String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(String.valueOf(arg1));
        }

        @Override
        public void debug(String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(String.valueOf(argArray));
        }

        @Override
        public void debug(String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(String.valueOf(msg));
        }

        @Override
        public boolean isDebugEnabled(Marker marker) {
            return mLevel <= DEBUG;
        }

        @Override
        public void debug(Marker marker, String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(msg);
        }

        @Override
        public void debug(Marker marker, String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(String.valueOf(arg));
        }

        @Override
        public void debug(Marker marker, String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(String.valueOf(arg1));
        }

        @Override
        public void debug(Marker marker, String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(String.valueOf(argArray));
        }

        @Override
        public void debug(Marker marker, String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logDebug(msg, t);
        }

        @Override
        public boolean isInfoEnabled() {
            return mLevel <= INFO;
        }

        @Override
        public void info(String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(msg);
        }

        @Override
        public void info(String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(String.valueOf(arg));
        }

        @Override
        public void info(String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(String.valueOf(arg1));
        }

        @Override
        public void info(String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(String.valueOf(argArray));
        }

        @Override
        public void info(String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(msg);
        }

        @Override
        public boolean isInfoEnabled(Marker marker) {
            return mLevel <= INFO;
        }

        @Override
        public void info(Marker marker, String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(msg);
        }

        @Override
        public void info(Marker marker, String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(String.valueOf(arg));
        }

        @Override
        public void info(Marker marker, String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(String.valueOf(arg1));
        }

        @Override
        public void info(Marker marker, String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(String.valueOf(argArray));
        }

        @Override
        public void info(Marker marker, String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logInfo(msg, t);
        }

        @Override
        public boolean isWarnEnabled() {
            return mLevel <= WARNING;
        }

        @Override
        public void warn(String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(msg);
        }

        @Override
        public void warn(String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(arg));

        }

        @Override
        public void warn(String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(argArray));
        }

        @Override
        public void warn(String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(arg1));
        }

        @Override
        public void warn(String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(msg, t);
        }

        @Override
        public boolean isWarnEnabled(Marker marker) {
            return mLevel <= WARNING;
        }

        @Override
        public void warn(Marker marker, String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(msg);
        }

        @Override
        public void warn(Marker marker, String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(arg));
        }

        @Override
        public void warn(Marker marker, String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(arg1));
        }

        @Override
        public void warn(Marker marker, String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(argArray));
        }

        @Override
        public void warn(Marker marker, String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(msg, t);
        }

        @Override
        public boolean isErrorEnabled() {
            return mLevel <= ERROR;
        }

        @Override
        public void error(String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(msg);
        }

        @Override
        public void error(String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(arg));
        }

        @Override
        public void error(String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(arg1));
        }

        @Override
        public void error(String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(argArray));
        }

        @Override
        public void error(String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(msg, t);
        }

        @Override
        public boolean isErrorEnabled(Marker marker) {
            return mLevel <= ERROR;
        }

        @Override
        public void error(Marker marker, String msg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(msg);
        }

        @Override
        public void error(Marker marker, String format, Object arg) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(arg));
        }

        @Override
        public void error(Marker marker, String format, Object arg1, Object arg2) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(arg1));
        }

        @Override
        public void error(Marker marker, String format, Object[] argArray) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(String.valueOf(argArray));
        }

        @Override
        public void error(Marker marker, String msg, Throwable t) {
            if (mLogger == null) {
                return;
            }
            mLogger.logWarn(msg, t);
        }
    }
}