/*

 * Copyright (c) 2013, 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.io.*;

import java.util.*;

import java.util.logging.*;

/*

 * Custom LogManager implementation to verify that the implementation delegates

 * to the LogManager subclass to register both system logger and user logger.

 *

 * The LogManager implementation is the one configuring the logger's property

 * such as level, handler, etc.

 */

public class CustomLogManager extends LogManager {

    static LogManager INSTANCE;

    Map<String,Logger> namedLoggers = new HashMap<>();

    Properties props = initConfig();

    public CustomLogManager() {

        if (INSTANCE != null) {

            throw new RuntimeException("CustomLogManager already created");

        }

        INSTANCE = this;

    }

    private boolean useParentHandlers(String loggerName) {

        String s = props.getProperty(loggerName + ".useParentHandlers");

        if (s == null)

            return true;   // default is true

        s = s.toLowerCase();

        if (s.equals("true") || s.equals("1")) {

           return true;

        } else if (s.equals("false") || s.equals("0")) {

           return false;

        }

        return true;

    }

    public synchronized boolean addLogger(Logger logger) {

        String name = logger.getName();

        if (namedLoggers.containsKey(name)) {

            return false;

        }

        namedLoggers.put(name, logger);

        // set level

        if (props.get(name + ".level") != null) {

            logger.setLevel(Level.parse(props.getProperty(name + ".level")));

        }

        // add handlers

        if (props.get(name + ".handlers") != null && logger.getHandlers().length == 0) {

            logger.addHandler(new CustomHandler());

        }

        if (!useParentHandlers(name)) {

            logger.setUseParentHandlers(false);

        }

        // add parent loggers

        int ix = 1;

        for (;;) {

            int ix2 = name.indexOf(".", ix);

            if (ix2 < 0) {

                break;

            }

            String pname = name.substring(0, ix2);

            if (props.get(pname + ".level") != null ||

                props.get(pname + ".handlers") != null) {

                // This pname has a level/handlers definition.

                // Make sure it exists.

                //

                // The test doesn't set the parent for simplicity.

                if (!namedLoggers.containsKey(pname)) {

                    Logger parent = Logger.getLogger(pname);

                    if (!useParentHandlers(pname)) {

                        parent.setUseParentHandlers(false);

                    }

                }

            }

            ix = ix2 + 1;

        }

        return true;

    }

    public synchronized Logger getLogger(String name) {

        return namedLoggers.get(name);

    }

    public synchronized Enumeration<String> getLoggerNames() {

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

    }

    public String getProperty(String name) {

        return props.getProperty(name);

    }

    public void readConfiguration() {

        // do nothing

    }

    public void readConfiguration(InputStream ins) {

        // do nothing

    }

    private Properties initConfig() {

        Properties props = new Properties();

        props.put(".level", "CONFIG");

        props.put("CustomLogManagerTest.level", "WARNING");

        props.put("CustomLogManagerTest.handlers", "CustomLogManager$CustomHandler");

        props.put("SimpleLogManager.level", "INFO");

        props.put("SimpleLogManager.handlers", "CustomLogManager$CustomHandler");

        props.put("CustomLogManager$CustomHandler.level", "WARNING");

        props.put(".handlers", "CustomLogManager$CustomHandler");

        props.put("org.foo.bar.level", "SEVERE");

        props.put("org.foo.bar.useParentHandlers", "true");

        props.put("org.foo.handlers", "CustomLogManager$CustomHandler");

        props.put("org.foo.useParentHandlers", "false");

        props.put("org.openjdk.level", "SEVERE");

        props.put("org.openjdk.handlers", "CustomLogManager$CustomHandler");

        props.put("org.openjdk.core.level", "INFO");

        props.put("org.openjdk.core.useParentHandlers", "false");

        return props;

    }

    public static void checkLogger(String name) {

        checkLogger(name, null);

    }

    public static void checkLogger(String name, String resourceBundleName) {

        Logger logger = INSTANCE.getLogger(name);

        if (logger == null) {

            throw new RuntimeException("Logger \"" + name + "\" not exist");

        }

        System.out.format("Logger \"%s\" level=%s handlers=%s resourcebundle=%s useParentHandlers=%s%n",

            name, logger.getLevel(),

            Arrays.toString(logger.getHandlers()),

            logger.getResourceBundleName(),

            logger.getUseParentHandlers());

        String rb = logger.getResourceBundleName();

        if (rb != resourceBundleName && (rb == null || rb.equals(resourceBundleName))) {

            throw new RuntimeException("Logger \"" + name +

                "\" unexpected resource bundle: " + rb);

        }

        String value = INSTANCE.getProperty(name + ".level");

        String level = logger.getLevel() != null ? logger.getLevel().getName() : null;

        if (level != value && (level == null || level.equals(value))) {

            throw new RuntimeException("Logger \"" + name + "\" unexpected level: " + level);

        }

        Handler[] handlers = logger.getHandlers();

        String hdl = INSTANCE.getProperty(name + ".handlers");

        if ((hdl == null && handlers.length != 0) ||

            (hdl != null && handlers.length != 1)) {

            throw new RuntimeException("Logger \"" + name + "\" unexpected handler: " +

                Arrays.toString(handlers));

        }

        String s = INSTANCE.getProperty(name + ".useParentHandlers");

        boolean uph = (s != null && s.equals("false")) ? false : true;

        if (logger.getUseParentHandlers() != uph) {

            throw new RuntimeException("Logger \"" + name + "\" unexpected useParentHandlers: " +

                logger.getUseParentHandlers());

        }

        checkParents(name);

    }

    private static void checkParents(String name) {

        int ix = 1;

        for (;;) {

            int ix2 = name.indexOf(".", ix);

            if (ix2 < 0) {

                break;

            }

            String pname = name.substring(0, ix2);

            if (INSTANCE.getProperty(pname + ".level") != null ||

                INSTANCE.getProperty(pname + ".handlers") != null) {

                // This pname has a level/handlers definition.

                // Make sure it exists.

                checkLogger(pname);

            }

            ix = ix2 + 1;

        }

    }

    // only CustomLogManager can create an instance of CustomHandler

    private class CustomHandler extends StreamHandler {

    }

}