/*

 * Copyright (c) 2014, 2018, 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 jdk.internal.module;

import java.io.File;

import java.io.PrintStream;

import java.lang.module.Configuration;

import java.lang.module.ModuleDescriptor;

import java.lang.module.ModuleFinder;

import java.lang.module.ModuleReference;

import java.lang.module.ResolvedModule;

import java.net.URI;

import java.nio.file.Path;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.NoSuchElementException;

import java.util.Objects;

import java.util.Optional;

import java.util.Set;

import java.util.function.Function;

import java.util.stream.Collectors;

import jdk.internal.loader.BootLoader;

import jdk.internal.loader.BuiltinClassLoader;

import jdk.internal.misc.JavaLangAccess;

import jdk.internal.misc.JavaLangModuleAccess;

import jdk.internal.misc.SharedSecrets;

import jdk.internal.perf.PerfCounter;

/**

 * Initializes/boots the module system.

 *

 * The {@link #boot() boot} method is called early in the startup to initialize

 * the module system. In summary, the boot method creates a Configuration by

 * resolving a set of module names specified via the launcher (or equivalent)

 * -m and --add-modules options. The modules are located on a module path that

 * is constructed from the upgrade module path, system modules, and application

 * module path. The Configuration is instantiated as the boot layer with each

 * module in the configuration defined to a class loader.

 */

public final class ModuleBootstrap {

    private ModuleBootstrap() { }

    private static final String JAVA_BASE = "java.base";

    // the token for "all default modules"

    private static final String ALL_DEFAULT = "ALL-DEFAULT";

    // the token for "all unnamed modules"

    private static final String ALL_UNNAMED = "ALL-UNNAMED";

    // the token for "all system modules"

    private static final String ALL_SYSTEM = "ALL-SYSTEM";

    // the token for "all modules on the module path"

    private static final String ALL_MODULE_PATH = "ALL-MODULE-PATH";

    // access to java.lang/module

    private static final JavaLangModuleAccess JLMA

        = SharedSecrets.getJavaLangModuleAccess();

    // The ModulePatcher for the initial configuration

    private static final ModulePatcher patcher = initModulePatcher();

    /**

     * Returns the ModulePatcher for the initial configuration.

     */

    public static ModulePatcher patcher() {

        return patcher;

    }

    // ModuleFinders for the initial configuration

    private static volatile ModuleFinder unlimitedFinder;

    private static volatile ModuleFinder limitedFinder;

    /**

     * Returns the ModuleFinder for the initial configuration before

     * observability is limited by the --limit-modules command line option.

     *

     * @apiNote Used to support locating modules {@code java.instrument} and

     * {@code jdk.management.agent} modules when they are loaded dynamically.

     */

    public static ModuleFinder unlimitedFinder() {

        ModuleFinder finder = unlimitedFinder;

        if (finder == null) {

            return ModuleFinder.ofSystem();

        } else {

            return finder;

        }

    }

    /**

     * Returns the ModuleFinder for the initial configuration.

     *

     * @apiNote Used to support "{@code java --list-modules}".

     */

    public static ModuleFinder limitedFinder() {

        ModuleFinder finder = limitedFinder;

        if (finder == null) {

            return unlimitedFinder();

        } else {

            return finder;

        }

    }

    /**

     * Initialize the module system, returning the boot layer.

     *

     * @see java.lang.System#initPhase2(boolean, boolean)

     */

    public static ModuleLayer boot() throws Exception {

        // Step 0: Command line options

        long t0 = System.nanoTime();

        ModuleFinder upgradeModulePath = finderFor("jdk.module.upgrade.path");

        ModuleFinder appModulePath = finderFor("jdk.module.path");

        boolean isPatched = patcher.hasPatches();

        String mainModule = System.getProperty("jdk.module.main");

        Set<String> addModules = addModules();

        Set<String> limitModules = limitModules();

        PrintStream traceOutput = null;

        String trace = getAndRemoveProperty("jdk.module.showModuleResolution");

        if (trace != null && Boolean.parseBoolean(trace))

            traceOutput = System.out;

        // Step 1: The observable system modules, either all system modules

        // or the system modules pre-generated for the initial module (the

        // initial module may be the unnamed module). If the system modules

        // are pre-generated for the initial module then resolution can be

        // skipped.

        long t1 = System.nanoTime();

        SystemModules systemModules = null;

        ModuleFinder systemModuleFinder;

        boolean haveModulePath = (appModulePath != null || upgradeModulePath != null);

        boolean needResolution = true;

            }

        }

        Counters.add("jdk.module.boot.1.systemModulesTime", t1);

        // Step 2: Define and load java.base. This patches all classes loaded

        // to date so that they are members of java.base. Once java.base is

        // loaded then resources in java.base are available for error messages

        // needed from here on.

        long t2 = System.nanoTime();

        ModuleReference base = systemModuleFinder.find(JAVA_BASE).orElse(null);

        if (base == null)

            throw new InternalError(JAVA_BASE + " not found");

        URI baseUri = base.location().orElse(null);

        if (baseUri == null)

            throw new InternalError(JAVA_BASE + " does not have a location");

        BootLoader.loadModule(base);

        Modules.defineModule(null, base.descriptor(), baseUri);

        Counters.add("jdk.module.boot.2.defineBaseTime", t2);

        // Step 2a: Scan all modules when --validate-modules specified

        if (getAndRemoveProperty("jdk.module.validation") != null) {

            int errors = ModulePathValidator.scanAllModules(System.out);

            if (errors > 0) {

                fail("Validation of module path failed");

            }

        }

        // Step 3: If resolution is needed then create the module finder and

        // the set of root modules to resolve.

        long t3 = System.nanoTime();

        ModuleFinder savedModuleFinder = null;

        ModuleFinder finder;

        Set<String> roots;

        if (needResolution) {

            // upgraded modules override the modules in the run-time image

            if (upgradeModulePath != null)

                systemModuleFinder = ModuleFinder.compose(upgradeModulePath,

                                                          systemModuleFinder);

            // The module finder: [--upgrade-module-path] system [--module-path]

            if (appModulePath != null) {

                finder = ModuleFinder.compose(systemModuleFinder, appModulePath);

            } else {

                finder = systemModuleFinder;

            }

            // The root modules to resolve

            roots = new HashSet<>();

            // launcher -m option to specify the main/initial module

            if (mainModule != null)

                roots.add(mainModule);

            // additional module(s) specified by --add-modules

            boolean addAllDefaultModules = false;

            boolean addAllSystemModules = false;

            boolean addAllApplicationModules = false;

            for (String mod : addModules) {

                switch (mod) {

                    case ALL_DEFAULT:

                        addAllDefaultModules = true;

                        break;

                    case ALL_SYSTEM:

                        addAllSystemModules = true;

                        break;

                    case ALL_MODULE_PATH:

                        addAllApplicationModules = true;

                        break;

                    default:

                        roots.add(mod);

                }

            }

            // --limit-modules

            savedModuleFinder = finder;

            if (!limitModules.isEmpty()) {

                finder = limitFinder(finder, limitModules, roots);

            }

            // If there is no initial module specified then assume that the initial

            // module is the unnamed module of the application class loader. This

            // is implemented by resolving all observable modules that export an

            // API. Modules that have the DO_NOT_RESOLVE_BY_DEFAULT bit set in

            // their ModuleResolution attribute flags are excluded from the

            // default set of roots.

            if (mainModule == null || addAllDefaultModules) {

                roots.addAll(DefaultRoots.compute(systemModuleFinder, finder));

            }

            // If `--add-modules ALL-SYSTEM` is specified then all observable system

            // modules will be resolved.

            if (addAllSystemModules) {

                ModuleFinder f = finder;  // observable modules

                systemModuleFinder.findAll()

                    .stream()

                    .map(ModuleReference::descriptor)

                    .map(ModuleDescriptor::name)

                    .filter(mn -> f.find(mn).isPresent())  // observable

                    .forEach(mn -> roots.add(mn));

            }

            // If `--add-modules ALL-MODULE-PATH` is specified then all observable

            // modules on the application module path will be resolved.

            if (appModulePath != null && addAllApplicationModules) {

                ModuleFinder f = finder;  // observable modules

                appModulePath.findAll()

                    .stream()

                    .map(ModuleReference::descriptor)

                    .map(ModuleDescriptor::name)

                    .filter(mn -> f.find(mn).isPresent())  // observable

                    .forEach(mn -> roots.add(mn));

            }

        } else {

            // no resolution case

            finder = systemModuleFinder;

            roots = null;

        }

        Counters.add("jdk.module.boot.3.optionsAndRootsTime", t3);

        // Step 4: Resolve the root modules, with service binding, to create

        // the configuration for the boot layer. If resolution is not needed

        // then create the configuration for the boot layer from the

        // readability graph created at link time.

        long t4 = System.nanoTime();

        Configuration cf;

        if (needResolution) {

            cf = JLMA.resolveAndBind(finder, roots, traceOutput);

        } else {

            Map<String, Set<String>> map = systemModules.moduleReads();

            cf = JLMA.newConfiguration(systemModuleFinder, map);

        }

        // check that modules specified to --patch-module are resolved

        if (isPatched) {

            patcher.patchedModules()

                    .stream()

                    .filter(mn -> !cf.findModule(mn).isPresent())

                    .forEach(mn -> warnUnknownModule(PATCH_MODULE, mn));

        }

        Counters.add("jdk.module.boot.4.resolveTime", t4);

        // Step 5: Map the modules in the configuration to class loaders.

        // The static configuration provides the mapping of standard and JDK

        // modules to the boot and platform loaders. All other modules (JDK

        // tool modules, and both explicit and automatic modules on the

        // application module path) are defined to the application class

        // loader.

        long t5 = System.nanoTime();

        // mapping of modules to class loaders

        Function<String, ClassLoader> clf = ModuleLoaderMap.mappingFunction(cf);

        // check that all modules to be mapped to the boot loader will be

        // loaded from the runtime image

        if (haveModulePath) {

            for (ResolvedModule resolvedModule : cf.modules()) {

                ModuleReference mref = resolvedModule.reference();

                String name = mref.descriptor().name();

                ClassLoader cl = clf.apply(name);

                if (cl == null) {

                    if (upgradeModulePath != null

                            && upgradeModulePath.find(name).isPresent())

                        fail(name + ": cannot be loaded from upgrade module path");

                    if (!systemModuleFinder.find(name).isPresent())

                        fail(name + ": cannot be loaded from application module path");

                }

            }

        }

        // check for split packages in the modules mapped to the built-in loaders

        if (systemModules.hasSplitPackages() || isPatched || haveModulePath) {

            checkSplitPackages(cf, clf);

        }

        // load/register the modules with the built-in class loaders

        loadModules(cf, clf);

        Counters.add("jdk.module.boot.5.loadModulesTime", t5);

        // Step 6: Define all modules to the VM

        long t6 = System.nanoTime();

        ModuleLayer bootLayer = ModuleLayer.empty().defineModules(cf, clf);

        Counters.add("jdk.module.boot.6.layerCreateTime", t6);

        // Step 7: Miscellaneous

        // check incubating status

        if (systemModules.hasIncubatorModules() || haveModulePath) {

            checkIncubatingStatus(cf);

        }

        // --add-reads, --add-exports/--add-opens, and --illegal-access

        long t7 = System.nanoTime();

        addExtraReads(bootLayer);

        boolean extraExportsOrOpens = addExtraExportsAndOpens(bootLayer);

        addIllegalAccess(upgradeModulePath, systemModules, bootLayer, extraExportsOrOpens);

        Counters.add("jdk.module.boot.7.adjustModulesTime", t7);

        // save module finders for later use

        if (savedModuleFinder != null) {

            unlimitedFinder = new SafeModuleFinder(savedModuleFinder);

            if (savedModuleFinder != finder)

                limitedFinder = new SafeModuleFinder(finder);

        }

        // total time to initialize

        Counters.add("jdk.module.boot.totalTime", t0);

        Counters.publish();

        return bootLayer;

    }

    /**

     * Load/register the modules to the built-in class loaders.

     */

    private static void loadModules(Configuration cf,

                                    Function<String, ClassLoader> clf) {

        for (ResolvedModule resolvedModule : cf.modules()) {

            ModuleReference mref = resolvedModule.reference();

            String name = resolvedModule.name();

            ClassLoader loader = clf.apply(name);

            if (loader == null) {

                // skip java.base as it is already loaded

                if (!name.equals(JAVA_BASE)) {

                    BootLoader.loadModule(mref);

                }

            } else if (loader instanceof BuiltinClassLoader) {

                ((BuiltinClassLoader) loader).loadModule(mref);

            }

        }

    }

    /**

     * Checks for split packages between modules defined to the built-in class

     * loaders.

     */

    private static void checkSplitPackages(Configuration cf,

                                           Function<String, ClassLoader> clf) {

        Map<String, String> packageToModule = new HashMap<>();

        for (ResolvedModule resolvedModule : cf.modules()) {

            ModuleDescriptor descriptor = resolvedModule.reference().descriptor();

            String name = descriptor.name();

            ClassLoader loader = clf.apply(name);

            if (loader == null || loader instanceof BuiltinClassLoader) {

                for (String p : descriptor.packages()) {

                    String other = packageToModule.putIfAbsent(p, name);

                    if (other != null) {

                        String msg = "Package " + p + " in both module "

                                     + name + " and module " + other;

                        throw new LayerInstantiationException(msg);

                    }

                }

            }

        }

    }

    /**

     * Returns a ModuleFinder that limits observability to the given root

     * modules, their transitive dependences, plus a set of other modules.

     */