/*

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

 *

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

import java.security.CodeSource;

import java.security.Permission;

import java.security.PermissionCollection;

import java.security.Permissions;

import java.security.Policy;

import java.security.PrivilegedAction;

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.lang.System.Logger.Level;

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

 * @build CustomSystemClassLoader 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("LoggerBridgeTest$LogProducerFinder");

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

        } catch (Exception ex) {

            throw new ExceptionInInitializerError(ex);

        }

    }

    public static class LogProducerFinder extends LoggerFinder {

        final ConcurrentHashMap<String, LoggerImpl> system = new ConcurrentHashMap<>();

        final ConcurrentHashMap<String, LoggerImpl> user = new ConcurrentHashMap<>();

        public class LoggerImpl implements Logger, PlatformLogger.Bridge {

            private final String name;

            private sun.util.logging.PlatformLogger.Level level = sun.util.logging.PlatformLogger.Level.INFO;

            private sun.util.logging.PlatformLogger.Level OFF = sun.util.logging.PlatformLogger.Level.OFF;

            private sun.util.logging.PlatformLogger.Level FINE = sun.util.logging.PlatformLogger.Level.FINE;

            private sun.util.logging.PlatformLogger.Level FINER = sun.util.logging.PlatformLogger.Level.FINER;

            private sun.util.logging.PlatformLogger.Level FINEST = sun.util.logging.PlatformLogger.Level.FINEST;

            private sun.util.logging.PlatformLogger.Level CONFIG = sun.util.logging.PlatformLogger.Level.CONFIG;

            private sun.util.logging.PlatformLogger.Level INFO = sun.util.logging.PlatformLogger.Level.INFO;

            private sun.util.logging.PlatformLogger.Level WARNING = sun.util.logging.PlatformLogger.Level.WARNING;

            private sun.util.logging.PlatformLogger.Level SEVERE = sun.util.logging.PlatformLogger.Level.SEVERE;

            public LoggerImpl(String name) {

                this.name = name;

            }

            @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(sun.util.logging.PlatformLogger.Level level, String msg) {

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

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

            }

            @Override

            public void log(sun.util.logging.PlatformLogger.Level level,

                    Supplier<String> msgSupplier) {

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

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

            }

            @Override

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

                    Object... params) {

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

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

            }

            @Override

            public void log(sun.util.logging.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(sun.util.logging.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(sun.util.logging.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(sun.util.logging.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(sun.util.logging.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(sun.util.logging.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(sun.util.logging.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(sun.util.logging.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(sun.util.logging.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(sun.util.logging.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(sun.util.logging.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(sun.util.logging.PlatformLogger.Level level) {

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

                        >= this.level.intValue();

            }

            @Override

            public boolean isEnabled() {

                return this.level != OFF;

            }

        }

        @Override

        public Logger getLogger(String name, Class<?> caller) {

            SecurityManager sm = System.getSecurityManager();

            if (sm != null) {

                sm.checkPermission(LOGGERFINDER_PERMISSION);

            }

            PrivilegedAction<ClassLoader> pa = () -> caller.getClassLoader();

            ClassLoader callerLoader = AccessController.doPrivileged(pa);

            if (callerLoader == null) {

                return system.computeIfAbsent(name, (n) -> new LoggerImpl(n));

            } else {

                return user.computeIfAbsent(name, (n) -> new LoggerImpl(n));

            }

        }

    }

    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, Class.class);

            lazyGetLogger.setAccessible(true);

        } catch (Throwable ex) {

            throw new ExceptionInInitializerError(ex);

        }

    }

    static Logger getLogger(LoggerFinder provider, String name, Class<?> 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

        // been thrown by the provider.

        if (logger != null && caller == Thread.class) {

            Logger log = provider.getLogger(name, caller);

        }

        return logger;

    }

    static Logger getLogger(LoggerFinder provider, String name, ResourceBundle bundle, Class<?> caller) {