/*

 * 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.

 *

 * 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.

 */

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.security.AccessControlException;

import java.security.CodeSource;

import java.security.Permission;

import java.security.PermissionCollection;

import java.security.Permissions;

import java.security.Policy;

import java.security.ProtectionDomain;

import java.util.Arrays;

import java.util.Collections;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Map;

import java.util.Objects;

import java.util.Queue;

import java.util.ResourceBundle;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicLong;

import java.util.function.Supplier;

import java.util.logging.Handler;

import java.util.logging.LogRecord;

import java.lang.System.LoggerFinder;

import java.lang.System.Logger;

import java.util.stream.Stream;

import sun.util.logging.PlatformLogger;

/**

 * @test

 * @bug     8140364

 * @summary JDK implementation specific unit test for JDK internal artifacts.

 *          Tests all bridge methods with the a custom backend whose

 *          loggers implement PlatformLogger.Bridge.

 * @modules java.base/sun.util.logging

 *          java.base/jdk.internal.logger

 *          java.logging

 * @build CustomSystemClassLoader LogProducerFinder LoggerBridgeTest

 * @run  main/othervm -Djava.system.class.loader=CustomSystemClassLoader LoggerBridgeTest NOSECURITY

 * @run  main/othervm -Djava.system.class.loader=CustomSystemClassLoader LoggerBridgeTest NOPERMISSIONS

 * @run  main/othervm -Djava.system.class.loader=CustomSystemClassLoader LoggerBridgeTest WITHPERMISSIONS

 * @author danielfuchs

 */

public class LoggerBridgeTest {

    public static final RuntimePermission LOGGERFINDER_PERMISSION =

                new RuntimePermission("loggerFinder");

    final static AtomicLong sequencer = new AtomicLong();

    final static boolean VERBOSE = false;

    static final ThreadLocal<AtomicBoolean> allowControl = new ThreadLocal<AtomicBoolean>() {

        @Override

        protected AtomicBoolean initialValue() {

            return  new AtomicBoolean(false);

        }

    };

    static final ThreadLocal<AtomicBoolean> allowAccess = new ThreadLocal<AtomicBoolean>() {

        @Override

        protected AtomicBoolean initialValue() {

            return  new AtomicBoolean(false);

        }

    };

    static final ThreadLocal<AtomicBoolean> allowAll = new ThreadLocal<AtomicBoolean>() {

        @Override

        protected AtomicBoolean initialValue() {

            return  new AtomicBoolean(false);

        }

    };

    public static final Queue<LogEvent> eventQueue = new ArrayBlockingQueue<>(128);

    public static final class LogEvent implements Cloneable {

        public LogEvent() {

            this(sequencer.getAndIncrement());

        }

        LogEvent(long sequenceNumber) {

            this.sequenceNumber = sequenceNumber;

        }

        long sequenceNumber;

        boolean isLoggable;

        String loggerName;

        sun.util.logging.PlatformLogger.Level level;

        ResourceBundle bundle;

        Throwable thrown;

        Object[] args;

        String msg;

        Supplier<String> supplier;

        String className;

        String methodName;

        Object[] toArray() {

            return new Object[] {

                sequenceNumber,

                loggerName,

                level,

                isLoggable,

                bundle,

                msg,

                supplier,

                thrown,

                args,

                className,

                methodName,

            };

        }

        @Override

        public String toString() {

            return Arrays.deepToString(toArray());

        }

        @Override

        public boolean equals(Object obj) {

            return obj instanceof LogEvent

                    && Objects.deepEquals(this.toArray(), ((LogEvent)obj).toArray());

        }

        @Override

        public int hashCode() {

            return Objects.hash(toArray());

        }

        public LogEvent cloneWith(long sequenceNumber)

                throws CloneNotSupportedException {

            LogEvent cloned = (LogEvent)super.clone();

            cloned.sequenceNumber = sequenceNumber;

            return cloned;

        }

        public static LogEvent of(long sequenceNumber,

                boolean isLoggable, String name,

                sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle,

                String key, Throwable thrown, Object... params) {

            return LogEvent.of(sequenceNumber, isLoggable, name,

                    null, null, level, bundle, key,

                    thrown, params);

        }

        public static LogEvent of(long sequenceNumber,

                boolean isLoggable, String name,

                sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle,

                Supplier<String> supplier, Throwable thrown, Object... params) {

            return LogEvent.of(sequenceNumber, isLoggable, name,

                    null, null, level, bundle, supplier,

                    thrown, params);

        }

        public static LogEvent of(long sequenceNumber,

                boolean isLoggable, String name,

                String className, String methodName,

                sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle,

                String key, Throwable thrown, Object... params) {

            LogEvent evt = new LogEvent(sequenceNumber);

            evt.loggerName = name;

            evt.level = level;

            evt.args = params;

            evt.bundle = bundle;

            evt.thrown = thrown;

            evt.msg = key;

            evt.isLoggable = isLoggable;

            evt.className = className;

            evt.methodName = methodName;

            return evt;

        }

        public static LogEvent of(boolean isLoggable, String name,

                String className, String methodName,

                sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle,

                String key, Throwable thrown, Object... params) {

            return LogEvent.of(sequencer.getAndIncrement(), isLoggable, name,

                    className, methodName, level, bundle, key, thrown, params);

        }

        public static LogEvent of(long sequenceNumber,

                boolean isLoggable, String name,

                String className, String methodName,

                sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle,

                Supplier<String> supplier, Throwable thrown, Object... params) {

            LogEvent evt = new LogEvent(sequenceNumber);

            evt.loggerName = name;

            evt.level = level;

            evt.args = params;

            evt.bundle = bundle;

            evt.thrown = thrown;

            evt.supplier = supplier;

            evt.isLoggable = isLoggable;

            evt.className = className;

            evt.methodName = methodName;

            return evt;

        }

        public static LogEvent of(boolean isLoggable, String name,

                String className, String methodName,

                sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle,

                Supplier<String> supplier, Throwable thrown, Object... params) {

            return LogEvent.of(sequencer.getAndIncrement(), isLoggable, name,

                    className, methodName, level, bundle, supplier, thrown, params);

        }

    }

    static final Class<?> providerClass;

    static {

        try {

            // Preload classes before the security manager is on.

            providerClass = ClassLoader.getSystemClassLoader().loadClass("LogProducerFinder");

            ((LoggerFinder)providerClass.newInstance()).getLogger("foo", providerClass.getModule());

        } catch (Exception ex) {

            throw new ExceptionInInitializerError(ex);

        }

    }

    public static class LoggerImpl implements System.Logger, PlatformLogger.Bridge {

        private final String name;

        private PlatformLogger.Level level = PlatformLogger.Level.INFO;

        private PlatformLogger.Level OFF = PlatformLogger.Level.OFF;

        private PlatformLogger.Level FINE = PlatformLogger.Level.FINE;

        private PlatformLogger.Level FINER = PlatformLogger.Level.FINER;

        private PlatformLogger.Level FINEST = PlatformLogger.Level.FINEST;

        private PlatformLogger.Level CONFIG = PlatformLogger.Level.CONFIG;

        private PlatformLogger.Level INFO = PlatformLogger.Level.INFO;

        private PlatformLogger.Level WARNING = PlatformLogger.Level.WARNING;

        private PlatformLogger.Level SEVERE = PlatformLogger.Level.SEVERE;

        public LoggerImpl(String name) {

            this.name = name;

        }

        public void configureLevel(PlatformLogger.Level level) {

            this.level = level;

        }

        @Override

        public String getName() {

            return name;

        }

        @Override

        public boolean isLoggable(Level level) {

            return this.level != OFF && this.level.intValue() <= level.getSeverity();

        }

        @Override

        public void log(Level level, ResourceBundle bundle,

                        String key, Throwable thrown) {

            throw new UnsupportedOperationException();

        }

        @Override

        public void log(Level level, ResourceBundle bundle,

                        String format, Object... params) {

            throw new UnsupportedOperationException();

        }

        void log(LogEvent event) {

            eventQueue.add(event);

        }

        @Override

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

            throw new UnsupportedOperationException();

        }

        @Override

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

                        Throwable thrown) {

            throw new UnsupportedOperationException();

        }

        @Override

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

            log(LogEvent.of(isLoggable(level), name, null, null,

                    level, null, msg, null, (Object[]) null));

        }

        @Override

        public void log(PlatformLogger.Level level,

                        Supplier<String> msgSupplier) {

            log(LogEvent.of(isLoggable(level), name, null, null,

                    level, null, msgSupplier, null, (Object[]) null));

        }

        @Override

        public void log(PlatformLogger.Level level, String msg,

                        Object... params) {

            log(LogEvent.of(isLoggable(level), name, null, null,

                    level, null, msg, null, params));

        }

        @Override

        public void log(PlatformLogger.Level level, String msg,

                        Throwable thrown) {

            log(LogEvent.of(isLoggable(level), name, null, null,

                    level, null, msg, thrown, (Object[]) null));

        }

        @Override

        public void log(PlatformLogger.Level level, Throwable thrown,

                        Supplier<String> msgSupplier) {

            log(LogEvent.of(isLoggable(level), name, null, null,

                    level, null, msgSupplier, thrown, (Object[]) null));

        }

        @Override

        public void logp(PlatformLogger.Level level, String sourceClass,

                         String sourceMethod, String msg) {

            log(LogEvent.of(isLoggable(level), name,

                    sourceClass, sourceMethod,

                    level, null, msg, null, (Object[]) null));

        }

        @Override

        public void logp(PlatformLogger.Level level, String sourceClass,

                         String sourceMethod, Supplier<String> msgSupplier) {

            log(LogEvent.of(isLoggable(level), name,

                    sourceClass, sourceMethod,

                    level, null, msgSupplier, null, (Object[]) null));

        }

        @Override

        public void logp(PlatformLogger.Level level, String sourceClass,

                         String sourceMethod, String msg, Object... params) {

            log(LogEvent.of(isLoggable(level), name,

                    sourceClass, sourceMethod,

                    level, null, msg, null, params));

        }

        @Override

        public void logp(PlatformLogger.Level level, String sourceClass,

                         String sourceMethod, String msg, Throwable thrown) {

            log(LogEvent.of(isLoggable(level), name,

                    sourceClass, sourceMethod,

                    level, null, msg, thrown, (Object[]) null));

        }

        @Override

        public void logp(PlatformLogger.Level level, String sourceClass,

                         String sourceMethod, Throwable thrown,

                         Supplier<String> msgSupplier) {

            log(LogEvent.of(isLoggable(level), name,

                    sourceClass, sourceMethod,

                    level, null, msgSupplier, thrown, (Object[]) null));

        }

        @Override

        public void logrb(PlatformLogger.Level level, String sourceClass,

                          String sourceMethod, ResourceBundle bundle, String msg,

                          Object... params) {

            log(LogEvent.of(isLoggable(level), name,

                    sourceClass, sourceMethod,

                    level, bundle, msg, null, params));

        }

        @Override

        public void logrb(PlatformLogger.Level level, ResourceBundle bundle,

                          String msg, Object... params) {

            log(LogEvent.of(isLoggable(level), name, null, null,

                    level, bundle, msg, null, params));

        }

        @Override

        public void logrb(PlatformLogger.Level level, String sourceClass,

                          String sourceMethod, ResourceBundle bundle, String msg,

                          Throwable thrown) {

            log(LogEvent.of(isLoggable(level), name,

                    sourceClass, sourceMethod,

                    level, bundle, msg, thrown, (Object[]) null));

        }

        @Override

        public void logrb(PlatformLogger.Level level, ResourceBundle bundle,

                          String msg, Throwable thrown) {

            log(LogEvent.of(isLoggable(level), name, null, null,

                    level, bundle, msg, thrown, (Object[]) null));

        }

        @Override

        public boolean isLoggable(PlatformLogger.Level level) {

            return this.level != OFF && level.intValue()

                    >= this.level.intValue();

        }

        @Override

        public boolean isEnabled() {

            return this.level != OFF;

        }

    }

    static ClassLoader getClassLoader(Module m) {

        final boolean before = allowAll.get().getAndSet(true);

        try {

            return m.getClassLoader();

        } finally {

            allowAll.get().set(before);

        }

    }

    static final sun.util.logging.PlatformLogger.Level[] julLevels = {

        sun.util.logging.PlatformLogger.Level.ALL,

        sun.util.logging.PlatformLogger.Level.FINEST,

        sun.util.logging.PlatformLogger.Level.FINER,

        sun.util.logging.PlatformLogger.Level.FINE,

        sun.util.logging.PlatformLogger.Level.CONFIG,

        sun.util.logging.PlatformLogger.Level.INFO,

        sun.util.logging.PlatformLogger.Level.WARNING,

        sun.util.logging.PlatformLogger.Level.SEVERE,

        sun.util.logging.PlatformLogger.Level.OFF,

    };

    public static class MyBundle extends ResourceBundle {

        final ConcurrentHashMap<String,String> map = new ConcurrentHashMap<>();

        @Override

        protected Object handleGetObject(String key) {

            if (key.contains(" (translated)")) {

                throw new RuntimeException("Unexpected key: " + key);

            }

            return map.computeIfAbsent(key, k -> k + " (translated)");

        }

        @Override

        public Enumeration<String> getKeys() {

            return Collections.enumeration(map.keySet());

        }

    }

    public static class MyHandler extends Handler {

        @Override

        public java.util.logging.Level getLevel() {

            return java.util.logging.Level.ALL;

        }

        @Override

        public void publish(LogRecord record) {

            eventQueue.add(LogEvent.of(sequencer.getAndIncrement(),

                    true, record.getLoggerName(),

                    record.getSourceClassName(),

                    record.getSourceMethodName(),

                    PlatformLogger.Level.valueOf(record.getLevel().getName()),

                    record.getResourceBundle(), record.getMessage(),

                    record.getThrown(), record.getParameters()));

        }

        @Override

        public void flush() {

        }

        @Override

        public void close() throws SecurityException {

        }

    }

    public static class MyLoggerBundle extends MyBundle {

    }

    final static Method lazyGetLogger;

    static {

        // jdk.internal.logging.LoggerBridge.getLogger(name, caller)

        try {

            Class<?> bridgeClass = Class.forName("jdk.internal.logger.LazyLoggers");

            lazyGetLogger = bridgeClass.getDeclaredMethod("getLogger",

                    String.class, Module.class);

            lazyGetLogger.setAccessible(true);

        } catch (Throwable ex) {

            throw new ExceptionInInitializerError(ex);

        }

    }

    static Logger getLogger(LoggerFinder provider, String name, Module caller) {

        Logger logger;

        try {

            logger = Logger.class.cast(lazyGetLogger.invoke(null, name, caller));

        } catch (Throwable x) {

            Throwable t = (x instanceof InvocationTargetException) ?

                    ((InvocationTargetException)x).getTargetException() : x;

            if (t instanceof RuntimeException) {

                throw (RuntimeException)t;

            } else if (t instanceof Exception) {

                throw new RuntimeException(t);

            } else {

                throw (Error)t;

            }

        }

        // The method above does not throw exception...

        // call the provider here to verify that an exception would have