/*

 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.util.logging.internal;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.ResourceBundle;

import java.util.function.Supplier;

import java.lang.System.LoggerFinder;

import java.lang.System.Logger;

import java.util.Objects;

import java.util.logging.LogManager;

import jdk.internal.logger.DefaultLoggerFinder;

import java.util.logging.LoggingPermission;

import sun.util.logging.PlatformLogger;

import sun.util.logging.PlatformLogger.ConfigurableBridge.LoggerConfiguration;

/**

 * This {@code LoggingProviderImpl} is the JDK internal implementation of the

 * {@link jdk.internal.logger.DefaultLoggerFinder} which is used by

 * the default implementation of the {@link Logger}

 * when no {@link LoggerFinder} is found

 * and {@code java.util.logging} is present.

 * When {@code java.util.logging} is present, the {@code LoggingProviderImpl}

 * is {@linkplain java.util.ServiceLoader#loadInstalled(Class) installed} as

 * an internal service provider, making it possible to use {@code java.util.logging}

 * as the backend for loggers returned by the default LoggerFinder implementation.

 * <p>

 * This implementation of {@link DefaultLoggerFinder} returns instances of

 * {@link java.lang.System.Logger} which

 * delegate to a wrapped instance of {@link java.util.logging.Logger

 * java.util.logging.Logger}.

 * <br>

 * Loggers returned by this class can therefore be configured by accessing

 * their wrapped implementation through the regular {@code java.util.logging}

 * APIs - such as {@link java.util.logging.LogManager java.util.logging.LogManager}

 * and {@link java.util.logging.Logger java.util.logging.Logger}.

 *

 * @apiNote Programmers are not expected to call this class directly.

 * Instead they should rely on the static methods defined by

 * {@link java.lang.System java.lang.System}.

 * <p>

 * To replace this default

 * {@code java.util.logging} backend, an application is expected to install

 * its own {@link java.lang.System.LoggerFinder}.

 *

 * @see java.lang.System.Logger

 * @see java.lang.System.LoggerFinder

 * @see sun.util.logging.PlatformLogger.Bridge

 * @see java.lang.System

 * @see jdk.internal.logger

 * @see jdk.internal.logger

 *

 */

public final class LoggingProviderImpl extends DefaultLoggerFinder {

    static final RuntimePermission LOGGERFINDER_PERMISSION =

                new RuntimePermission("loggerFinder");

    private static final LoggingPermission LOGGING_CONTROL_PERMISSION =

            new LoggingPermission("control", null);

    /**

     * Creates a new instance of LoggingProviderImpl.

     * @throws SecurityException if the calling code does not have the

     * {@code RuntimePermission("loggerFinder")}.

     */

    public LoggingProviderImpl() {

    }

    /**

     * A logger that delegates to a java.util.logging.Logger delegate.

     */

    static final class JULWrapper extends LoggerConfiguration

            implements System.Logger, PlatformLogger.Bridge,

                       PlatformLogger.ConfigurableBridge {

        private static final java.util.logging.Level[] spi2JulLevelMapping = {

                java.util.logging.Level.ALL,     // mapped from ALL

                java.util.logging.Level.FINER,   // mapped from TRACE

                java.util.logging.Level.FINE,    // mapped from DEBUG

                java.util.logging.Level.INFO,    // mapped from INFO

                java.util.logging.Level.WARNING, // mapped from WARNING

                java.util.logging.Level.SEVERE,  // mapped from ERROR

                java.util.logging.Level.OFF      // mapped from OFF

        };

        private static final java.util.logging.Level[] platform2JulLevelMapping = {

                java.util.logging.Level.ALL,     // mapped from ALL

                java.util.logging.Level.FINEST,  // mapped from FINEST

                java.util.logging.Level.FINER,   // mapped from FINER

                java.util.logging.Level.FINE,    // mapped from FINE

                java.util.logging.Level.CONFIG,  // mapped from CONFIG

                java.util.logging.Level.INFO,    // mapped from INFO

                java.util.logging.Level.WARNING, // mapped from WARNING

                java.util.logging.Level.SEVERE,  // mapped from SEVERE

                java.util.logging.Level.OFF      // mapped from OFF

        };

        private final java.util.logging.Logger julLogger;

        private JULWrapper(java.util.logging.Logger logger) {

            this.julLogger = logger;

        }

        @Override

        public String getName() {

            return julLogger.getName();

        }

        @Override

        public void log(sun.util.logging.PlatformLogger.Level level, String msg, Throwable throwable) {

            julLogger.log(toJUL(level), msg, throwable);

        }

        @Override

        public void log(sun.util.logging.PlatformLogger.Level level, String format, Object... params) {

            julLogger.log(toJUL(level), format, params);

        }

        @Override

        public void log(sun.util.logging.PlatformLogger.Level level, String msg) {

            julLogger.log(toJUL(level), msg);

        }

        @Override

        public void log(sun.util.logging.PlatformLogger.Level level, Supplier<String> msgSuppier) {

            julLogger.log(toJUL(level), msgSuppier);

        }

        @Override

        public void log(sun.util.logging.PlatformLogger.Level level, Throwable thrown, Supplier<String> msgSuppier) {

            julLogger.log(toJUL(level), thrown, msgSuppier);

        }

        @Override

        public void logrb(sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle, String key, Throwable throwable) {

            julLogger.logrb(toJUL(level), bundle, key, throwable);

        }

        @Override

        public void logrb(sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle, String key, Object... params) {

            julLogger.logrb(toJUL(level), bundle, key, params);

        }

        @Override

        public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod, String msg) {

            julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg);

        }

        @Override

        public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,

                Supplier<String> msgSupplier) {

            julLogger.logp(toJUL(level), sourceClass, sourceMethod, msgSupplier);

        }

        @Override

        public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,

                String msg, Object... params) {

            julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg, params);

        }

        @Override

        public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,

                String msg, Throwable thrown) {

            julLogger.logp(toJUL(level), sourceClass, sourceMethod, msg, thrown);

        }

        @Override

        public void logp(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,

                Throwable thrown, Supplier<String> msgSupplier) {

            julLogger.logp(toJUL(level), sourceClass, sourceMethod,

                    thrown, msgSupplier);

        }

        @Override

        public void logrb(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,

                ResourceBundle bundle, String key, Object... params) {

            julLogger.logrb(toJUL(level), sourceClass, sourceMethod,

                    bundle, key, params);

        }

        @Override

        public void logrb(sun.util.logging.PlatformLogger.Level level, String sourceClass, String sourceMethod,

                ResourceBundle bundle, String key, Throwable thrown) {

            julLogger.logrb(toJUL(level), sourceClass, sourceMethod,

                    bundle, key, thrown);

        }

        @Override

        public  boolean isLoggable(sun.util.logging.PlatformLogger.Level level) {

            return julLogger.isLoggable(toJUL(level));

        }

        // -----------------------------------------------------------------

        // Generic methods taking a Level as parameter

        // -----------------------------------------------------------------

        @Override

        public boolean isLoggable(Level level) {

            return julLogger.isLoggable(toJUL(level));

        }

        @Override

        public void log(Level level, String msg) {

            julLogger.log(toJUL(level), msg);

        }

        @Override

        public void log(Level level,

                        Supplier<String> msgSupplier) {

            // We need to check for null here to satisfy the contract

            // of System.Logger - because the underlying implementation

            // of julLogger will check for it only if the level is

            // loggable

            Objects.requireNonNull(msgSupplier);

            julLogger.log(toJUL(level), msgSupplier);

        }

        @Override

        public void log(Level level, Object obj) {

            // We need to check for null here to satisfy the contract

            // of System.Logger - because the underlying implementation

            // of julLogger will check for it only if the level is

            // loggable

            Objects.requireNonNull(obj);

            julLogger.log(toJUL(level), () -> obj.toString());

        }

        @Override

        public void log(Level level,

                        String msg, Throwable thrown) {

            julLogger.log(toJUL(level), msg, thrown);

        }

        @Override

        public void log(Level level, Supplier<String> msgSupplier,

                        Throwable thrown) {

            // We need to check for null here to satisfy the contract

            // of System.Logger - because the underlying implementation

            // of julLogger will check for it only if the level is

            // loggable

            Objects.requireNonNull(msgSupplier);

            julLogger.log(toJUL(level), thrown, msgSupplier);

        }

        @Override

        public void log(Level level,

                        String format, Object... params) {

            julLogger.log(toJUL(level), format, params);

        }

        @Override

        public void log(Level level, ResourceBundle bundle,

                        String key, Throwable thrown) {

            julLogger.logrb(toJUL(level), bundle, key, thrown);

        }

        @Override

        public void log(Level level, ResourceBundle bundle,

                        String format, Object... params) {

            julLogger.logrb(toJUL(level), bundle, format, params);

        }

        static java.util.logging.Level toJUL(Level level) {

            if (level == null) return null;

            assert level.ordinal() < spi2JulLevelMapping.length;

            return spi2JulLevelMapping[level.ordinal()];

        }

        // ---------------------------------------------------------

        // Methods from PlatformLogger.Bridge

        // ---------------------------------------------------------

        @Override

        public boolean isEnabled() {

            return julLogger.getLevel() != java.util.logging.Level.OFF;

        }

        @Override

        public PlatformLogger.Level getPlatformLevel() {

            final java.util.logging.Level javaLevel = julLogger.getLevel();

            if (javaLevel == null) return null;

            try {

                return PlatformLogger.Level.valueOf(javaLevel.getName());

            } catch (IllegalArgumentException e) {

                return PlatformLogger.Level.valueOf(javaLevel.intValue());

            }

        }

        @Override

        public void setPlatformLevel(PlatformLogger.Level level) {

            // null is allowed here

            julLogger.setLevel(toJUL(level));

        }

        @Override

        public LoggerConfiguration getLoggerConfiguration() {

            return this;

        }

        static java.util.logging.Level toJUL(PlatformLogger.Level level) {

            // The caller will throw if null is invalid in its context.

            // There's at least one case where a null level is valid.

            if (level == null) return null;

            assert level.ordinal() < platform2JulLevelMapping.length;

            return platform2JulLevelMapping[level.ordinal()];

        }

        @Override

        public boolean equals(Object obj) {

            return (obj instanceof JULWrapper)

                    && obj.getClass() == this.getClass()

                    && ((JULWrapper)obj).julLogger == this.julLogger;

        }

        @Override

        public int hashCode() {

            return julLogger.hashCode();

        }

        // A JULWrapper is just a stateless thin shell over a JUL logger - so

        // for a given JUL logger, we could always return the same wrapper.

        //

        // This is an optimization which may - or may not - be worth the

        // trouble: if many classes use the same logger, and if each class

        // keeps a reference to that logger, then caching the wrapper will

        // be worthwhile. Otherwise, if each logger is only referred once,

        // then the cache will eat up more memory than would be necessary...

        //

        // Here is an example of how we could implement JULWrapper.of(...)

        // if we wanted to create at most one wrapper instance for each logger

        // instance:

        //

        //        static final WeakHashMap<JULWrapper, WeakReference<JULWrapper>>

        //                wrappers = new WeakHashMap<>();

        //

        //        static JULWrapper of(java.util.logging.Logger logger) {

        //

        //            // First access without synchronizing

        //            final JULWrapper candidate = new JULWrapper(logger);

        //            WeakReference<JULWrapper> ref = wrappers.get(candidate);

        //            JULWrapper found = ref.get();

        //

        //            // OK - we found it - lets return it.

        //            if (found != null) return found;

        //

        //            // Not found. Need to synchronize.

        //            synchronized (wrappers) {

        //                ref = wrappers.get(candidate);

        //                found = ref.get();

        //                if (found == null) {

        //                    wrappers.put(candidate, new WeakReference<>(candidate));

        //                    found = candidate;

        //                }

        //            }

        //            assert found != null;

        //            return found;

        //        }

        //

        // But given that it may end up eating more memory in the nominal case

        // (where each class that does logging has its own logger with the

        //  class name as logger name and stashes that logger away in a static

        //  field, thus making the cache redundant - as only one wrapper will

        //  ever be created anyway) - then we will simply return a new wrapper

        // for each invocation of JULWrapper.of(...) - which may

        // still prove more efficient in terms of memory consumption...

        //

        static JULWrapper of(java.util.logging.Logger logger) {

            return new JULWrapper(logger);

        }

    }

    /**

     * Creates a java.util.logging.Logger for the given module.

     * @param name the logger name.

     * @param module the module for which the logger should be created.

     * @return a Logger suitable for use in the given module.

     */

    private static java.util.logging.Logger demandJULLoggerFor(final String name,

                                                               Module module) {

        final LogManager manager = LogManager.getLogManager();

        final SecurityManager sm = System.getSecurityManager();

        if (sm == null) {

            return logManagerAccess.demandLoggerFor(manager, name, module);

        } else {

            final PrivilegedAction<java.util.logging.Logger> pa =

                    () -> logManagerAccess.demandLoggerFor(manager, name, module);

            return AccessController.doPrivileged(pa, null, LOGGING_CONTROL_PERMISSION);

        }

    }

    /**

     * {@inheritDoc}

     *

     * @apiNote The logger returned by this method can be configured through

     * its {@linkplain java.util.logging.LogManager#getLogger(String)

     * corresponding java.util.logging.Logger backend}.

     *

     * @return {@inheritDoc}

     * @throws SecurityException if the calling code doesn't have the

     * {@code RuntimePermission("loggerFinder")}.

     */

    @Override

    protected Logger demandLoggerFor(String name, Module module) {

        final SecurityManager sm = System.getSecurityManager();

        if (sm != null) {

            sm.checkPermission(LOGGERFINDER_PERMISSION);

        }

        return JULWrapper.of(demandJULLoggerFor(name,module));

    }

    public static interface LogManagerAccess {

        java.util.logging.Logger demandLoggerFor(LogManager manager,

                String name, Module module);

    }

    // Hook for tests

    public static LogManagerAccess getLogManagerAccess() {

        final SecurityManager sm = System.getSecurityManager();

        if (sm != null) {

            sm.checkPermission(LOGGING_CONTROL_PERMISSION);

        }

        // Triggers initialization of accessJulLogger if not set.

        if (logManagerAccess == null) LogManager.getLogManager();

        return logManagerAccess;

    }

    private static volatile LogManagerAccess logManagerAccess;

    public static void setLogManagerAccess(LogManagerAccess accesLoggers) {

        final SecurityManager sm = System.getSecurityManager();

        if (sm != null) {

            sm.checkPermission(LOGGING_CONTROL_PERMISSION);

        }

        logManagerAccess = accesLoggers;

    }

}