/*

 * Copyright (c) 2007, 2019, 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.launcher;

/*

 *

 *  <p><b>This is NOT part of any API supported by Sun Microsystems.

 *  If you write code that depends on this, you do so at your own

 *  risk.  This code and its internal interfaces are subject to change

 *  or deletion without notice.</b>

 *

 */

/**

 * A utility package for the java(1), javaw(1) launchers.

 * The following are helper methods that the native launcher uses

 * to perform checks etc. using JNI, see src/share/bin/java.c

 */

import java.io.File;

import java.io.IOException;

import java.io.PrintStream;

import java.io.UnsupportedEncodingException;

import java.lang.module.Configuration;

import java.lang.module.ModuleDescriptor;

import java.lang.module.ModuleDescriptor.Requires;

import java.lang.module.ModuleDescriptor.Exports;

import java.lang.module.ModuleDescriptor.Opens;

import java.lang.module.ModuleDescriptor.Provides;

import java.lang.module.ModuleFinder;

import java.lang.module.ModuleReference;

import java.lang.module.ResolvedModule;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.net.URI;

import java.nio.charset.Charset;

import java.nio.file.DirectoryStream;

import java.nio.file.Files;

import java.nio.file.Path;

import java.text.Normalizer;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Locale.Category;

import java.util.Optional;

import java.util.Properties;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.TreeSet;

import java.util.jar.Attributes;

import java.util.jar.JarFile;

import java.util.jar.Manifest;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import jdk.internal.misc.VM;

import jdk.internal.module.ModuleBootstrap;

import jdk.internal.module.Modules;

import jdk.internal.platform.Container;

import jdk.internal.platform.Metrics;

public final class LauncherHelper {

    // No instantiation

    private LauncherHelper() {}

    // used to identify JavaFX applications

    private static final String JAVAFX_APPLICATION_MARKER =

            "JavaFX-Application-Class";

    private static final String JAVAFX_APPLICATION_CLASS_NAME =

            "javafx.application.Application";

    private static final String JAVAFX_FXHELPER_CLASS_NAME_SUFFIX =

            "sun.launcher.LauncherHelper$FXHelper";

    private static final String LAUNCHER_AGENT_CLASS = "Launcher-Agent-Class";

    private static final String MAIN_CLASS = "Main-Class";

    private static final String ADD_EXPORTS = "Add-Exports";

    private static final String ADD_OPENS = "Add-Opens";

    private static StringBuilder outBuf = new StringBuilder();

    private static final String INDENT = "    ";

    private static final String VM_SETTINGS     = "VM settings:";

    private static final String PROP_SETTINGS   = "Property settings:";

    private static final String LOCALE_SETTINGS = "Locale settings:";

    // sync with java.c and jdk.internal.misc.VM

    private static final String diagprop = "sun.java.launcher.diag";

    static final boolean trace = VM.getSavedProperty(diagprop) != null;

    private static final String defaultBundleName =

            "sun.launcher.resources.launcher";

    private static class ResourceBundleHolder {

        private static final ResourceBundle RB =

                ResourceBundle.getBundle(defaultBundleName);

    }

    private static PrintStream ostream;

    private static Class<?> appClass; // application class, for GUI/reporting purposes

    /*

     * A method called by the launcher to print out the standard settings,

     * by default -XshowSettings is equivalent to -XshowSettings:all,

     * Specific information may be gotten by using suboptions with possible

     * values vm, properties and locale.

     *

     * printToStderr: choose between stdout and stderr

     *

     * optionFlag: specifies which options to print default is all other

     *    possible values are vm, properties, locale.

     *

     * initialHeapSize: in bytes, as set by the launcher, a zero-value indicates

     *    this code should determine this value, using a suitable method or

     *    the line could be omitted.

     *

     * maxHeapSize: in bytes, as set by the launcher, a zero-value indicates

     *    this code should determine this value, using a suitable method.

     *

     * stackSize: in bytes, as set by the launcher, a zero-value indicates

     *    this code determine this value, using a suitable method or omit the

     *    line entirely.

     */

    @SuppressWarnings("fallthrough")

    static void showSettings(boolean printToStderr, String optionFlag,

            long initialHeapSize, long maxHeapSize, long stackSize) {

        initOutput(printToStderr);

        String opts[] = optionFlag.split(":");

        String optStr = (opts.length > 1 && opts[1] != null)

                ? opts[1].trim()

                : "all";

        switch (optStr) {

            case "vm":

                printVmSettings(initialHeapSize, maxHeapSize, stackSize);

                break;

            case "properties":

                printProperties();

                break;

            case "locale":

                printLocale();

                break;

            case "system":

                if (System.getProperty("os.name").contains("Linux")) {

                    printSystemMetrics();

                    break;

                }

            default:

                printVmSettings(initialHeapSize, maxHeapSize, stackSize);

                printProperties();

                printLocale();

                if (System.getProperty("os.name").contains("Linux")) {

                    printSystemMetrics();

                }

                break;

        }

    }

    /*

     * prints the main vm settings subopt/section

     */

    private static void printVmSettings(

            long initialHeapSize, long maxHeapSize,

            long stackSize) {

        ostream.println(VM_SETTINGS);

        if (stackSize != 0L) {

            ostream.println(INDENT + "Stack Size: " +

                    SizePrefix.scaleValue(stackSize));

        }

        if (initialHeapSize != 0L) {

             ostream.println(INDENT + "Min. Heap Size: " +

                    SizePrefix.scaleValue(initialHeapSize));

        }

        if (maxHeapSize != 0L) {

            ostream.println(INDENT + "Max. Heap Size: " +

                    SizePrefix.scaleValue(maxHeapSize));

        } else {

            ostream.println(INDENT + "Max. Heap Size (Estimated): "

                    + SizePrefix.scaleValue(Runtime.getRuntime().maxMemory()));

        }

        ostream.println(INDENT + "Using VM: "

                + System.getProperty("java.vm.name"));

        ostream.println();

    }

    /*

     * prints the properties subopt/section

     */

    private static void printProperties() {

        Properties p = System.getProperties();

        ostream.println(PROP_SETTINGS);

        List<String> sortedPropertyKeys = new ArrayList<>();

        sortedPropertyKeys.addAll(p.stringPropertyNames());

        Collections.sort(sortedPropertyKeys);

        for (String x : sortedPropertyKeys) {

            printPropertyValue(x, p.getProperty(x));

        }

        ostream.println();

    }

    private static boolean isPath(String key) {

        return key.endsWith(".dirs") || key.endsWith(".path");

    }

    private static void printPropertyValue(String key, String value) {

        ostream.print(INDENT + key + " = ");

        if (key.equals("line.separator")) {

            for (byte b : value.getBytes()) {

                switch (b) {

                    case 0xd:

                        ostream.print("\\r ");

                        break;

                    case 0xa:

                        ostream.print("\\n ");

                        break;

                    default:

                        // print any bizzare line separators in hex, but really

                        // shouldn't happen.

                        ostream.printf("0x%02X", b & 0xff);

                        break;

                }

            }

            ostream.println();

            return;

        }

        if (!isPath(key)) {

            ostream.println(value);

            return;

        }

        String[] values = value.split(System.getProperty("path.separator"));

        boolean first = true;

        for (String s : values) {

            if (first) { // first line treated specially

                ostream.println(s);

                first = false;

            } else { // following lines prefix with indents

                ostream.println(INDENT + INDENT + s);

            }

        }

    }

    /*

     * prints the locale subopt/section

     */

    private static void printLocale() {

        Locale locale = Locale.getDefault();

        ostream.println(LOCALE_SETTINGS);

        ostream.println(INDENT + "default locale = " +

                locale.getDisplayName());

        ostream.println(INDENT + "default display locale = " +

                Locale.getDefault(Category.DISPLAY).getDisplayName());

        ostream.println(INDENT + "default format locale = " +

                Locale.getDefault(Category.FORMAT).getDisplayName());

        printLocales();

        ostream.println();

    }

    private static void printLocales() {

        Locale[] tlocales = Locale.getAvailableLocales();

        final int len = tlocales == null ? 0 : tlocales.length;

        if (len < 1 ) {

            return;

        }

        // Locale does not implement Comparable so we convert it to String

        // and sort it for pretty printing.

        Set<String> sortedSet = new TreeSet<>();

        for (Locale l : tlocales) {

            sortedSet.add(l.toString());

        }

        ostream.print(INDENT + "available locales = ");

        Iterator<String> iter = sortedSet.iterator();

        final int last = len - 1;

        for (int i = 0 ; iter.hasNext() ; i++) {

            String s = iter.next();

            ostream.print(s);

            if (i != last) {

                ostream.print(", ");

            }

            // print columns of 8

            if ((i + 1) % 8 == 0) {

                ostream.println();

                ostream.print(INDENT + INDENT);

            }

        }

    }

    public static void printSystemMetrics() {

        Metrics c = Container.metrics();

        ostream.println("Operating System Metrics:");

        if (c == null) {

            ostream.println(INDENT + "No metrics available for this platform");

            return;

        }

        ostream.println(INDENT + "Provider: " + c.getProvider());

        ostream.println(INDENT + "Effective CPU Count: " + c.getEffectiveCpuCount());

        ostream.println(INDENT + "CPU Period: " + c.getCpuPeriod() +

               (c.getCpuPeriod() == -1 ? "" : "us"));

        ostream.println(INDENT + "CPU Quota: " + c.getCpuQuota() +

               (c.getCpuQuota() == -1 ? "" : "us"));

        ostream.println(INDENT + "CPU Shares: " + c.getCpuShares());

        int cpus[] = c.getCpuSetCpus();

        ostream.println(INDENT + "List of Processors, "

                + cpus.length + " total: ");

        ostream.print(INDENT);

        for (int i = 0; i < cpus.length; i++) {

            ostream.print(cpus[i] + " ");

        }

        if (cpus.length > 0) {

            ostream.println("");

        }

        cpus = c.getEffectiveCpuSetCpus();

        ostream.println(INDENT + "List of Effective Processors, "

                + cpus.length + " total: ");

        ostream.print(INDENT);

        for (int i = 0; i < cpus.length; i++) {

            ostream.print(cpus[i] + " ");

        }

        if (cpus.length > 0) {

            ostream.println("");

        }

        int mems[] = c.getCpuSetMems();

        ostream.println(INDENT + "List of Memory Nodes, "

                + mems.length + " total: ");

        ostream.print(INDENT);

        for (int i = 0; i < mems.length; i++) {

            ostream.print(mems[i] + " ");

        }

        if (mems.length > 0) {

            ostream.println("");

        }

        mems = c.getEffectiveCpuSetMems();

        ostream.println(INDENT + "List of Available Memory Nodes, "

                + mems.length + " total: ");

        ostream.print(INDENT);

        for (int i = 0; i < mems.length; i++) {

            ostream.print(mems[i] + " ");

        }

        if (mems.length > 0) {

            ostream.println("");

        }

        ostream.println(INDENT + "CPUSet Memory Pressure Enabled: "

                + c.isCpuSetMemoryPressureEnabled());

        long limit = c.getMemoryLimit();

        ostream.println(INDENT + "Memory Limit: " +

                ((limit >= 0) ? SizePrefix.scaleValue(limit) : "Unlimited"));

        limit = c.getMemorySoftLimit();

        ostream.println(INDENT + "Memory Soft Limit: " +

                ((limit >= 0) ? SizePrefix.scaleValue(limit) : "Unlimited"));

        limit = c.getMemoryAndSwapLimit();

        ostream.println(INDENT + "Memory & Swap Limit: " +

                ((limit >= 0) ? SizePrefix.scaleValue(limit) : "Unlimited"));

        limit = c.getKernelMemoryLimit();

        ostream.println(INDENT + "Kernel Memory Limit: " +

                ((limit >= 0) ? SizePrefix.scaleValue(limit) : "Unlimited"));

        limit = c.getTcpMemoryLimit();

        ostream.println(INDENT + "TCP Memory Limit: " +

                ((limit >= 0) ? SizePrefix.scaleValue(limit) : "Unlimited"));

        ostream.println(INDENT + "Out Of Memory Killer Enabled: "

                + c.isMemoryOOMKillEnabled());

        ostream.println("");

    }

    private enum SizePrefix {

        KILO(1024, "K"),

        MEGA(1024 * 1024, "M"),

        GIGA(1024 * 1024 * 1024, "G"),

        TERA(1024L * 1024L * 1024L * 1024L, "T");

        long size;

        String abbrev;

        SizePrefix(long size, String abbrev) {

            this.size = size;

            this.abbrev = abbrev;

        }

        private static String scale(long v, SizePrefix prefix) {

            return BigDecimal.valueOf(v).divide(BigDecimal.valueOf(prefix.size),

                    2, RoundingMode.HALF_EVEN).toPlainString() + prefix.abbrev;

        }

        /*

         * scale the incoming values to a human readable form, represented as

         * K, M, G and T, see java.c parse_size for the scaled values and

         * suffixes. The lowest possible scaled value is Kilo.

         */

        static String scaleValue(long v) {

            if (v < MEGA.size) {

                return scale(v, KILO);

            } else if (v < GIGA.size) {

                return scale(v, MEGA);

            } else if (v < TERA.size) {

                return scale(v, GIGA);

            } else {

                return scale(v, TERA);

            }

        }

    }

    /**

     * A private helper method to get a localized message and also

     * apply any arguments that we might pass.

     */

    private static String getLocalizedMessage(String key, Object... args) {

        String msg = ResourceBundleHolder.RB.getString(key);

        return (args != null) ? MessageFormat.format(msg, args) : msg;

    }

    /**

     * The java -help message is split into 3 parts, an invariant, followed

     * by a set of platform dependent variant messages, finally an invariant

     * set of lines.

     * This method initializes the help message for the first time, and also

     * assembles the invariant header part of the message.

     */

    static void initHelpMessage(String progname) {

        outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.header",

                (progname == null) ? "java" : progname ));

    }

    /**

     * Appends the vm selection messages to the header, already created.

     * initHelpSystem must already be called.

     */

    static void appendVmSelectMessage(String vm1, String vm2) {

        outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.vmselect",

                vm1, vm2));

    }

    /**

     * Appends the vm synoym message to the header, already created.

     * initHelpSystem must be called before using this method.

     */

    static void appendVmSynonymMessage(String vm1, String vm2) {

        outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.hotspot",

                vm1, vm2));

    }

    /**

     * Appends the last invariant part to the previously created messages,

     * and finishes up the printing to the desired output stream.

     * initHelpSystem must be called before using this method.

     */

    static void printHelpMessage(boolean printToStderr) {

        initOutput(printToStderr);

        outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.footer",

                File.pathSeparator));