/*

 * Copyright (c) 2014, 2017, 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.nio.file.Paths;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.Set;

import java.util.function.Function;

import jdk.internal.loader.BootLoader;

import jdk.internal.loader.BuiltinClassLoader;

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

 */

public final class ModuleBootstrap {

    private ModuleBootstrap() { }

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

    private static final String JAVA_SE = "java.se";

    // 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";

    // The ModulePatcher for the initial configuration

    private static final ModulePatcher patcher = initModulePatcher();

    // ModuleFinders for the initial configuration

    private static ModuleFinder unlimitedFinder;

    private static ModuleFinder limitedFinder;

    /**

     * Returns the ModulePatcher for the initial configuration.

     */

    public static ModulePatcher patcher() {

        return patcher;

    }

    /**

     * Returns the ModuleFinder for the initial configuration before observability

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

     */

    public static ModuleFinder unlimitedFinder() {

        assert unlimitedFinder != null;

        return unlimitedFinder;

    }

    /**

     * Returns the ModuleFinder for the initial configuration.

     */

    public static ModuleFinder limitedFinder() {

        assert limitedFinder != null;

        return limitedFinder;

    }

    /**

     * Initialize the module system, returning the boot layer.

     *

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

     */

    public static ModuleLayer boot() {

        ModuleFinder systemModules = ModuleFinder.ofSystem();

        ModuleReference base = systemModules.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);

        String propValue = getAndRemoveProperty("jdk.module.minimumBoot");

        if (propValue != null) {

            return createMinimalBootLayer();

        }

        // --upgrade-module-path option specified to launcher

        ModuleFinder upgradeModulePath

            = createModulePathFinder("jdk.module.upgrade.path");

        if (upgradeModulePath != null)

            systemModules = ModuleFinder.compose(upgradeModulePath, systemModules);

        // --module-path option specified to the launcher

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

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

        ModuleFinder finder = systemModules;

        if (appModulePath != null)

            finder = ModuleFinder.compose(finder, appModulePath);

        // The root modules to resolve

        Set<String> roots = new HashSet<>();

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

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

        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: getExtraAddModules()) {

            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

        unlimitedFinder = finder;

        propValue = getAndRemoveProperty("jdk.module.limitmods");

        if (propValue != null) {

            Set<String> mods = new HashSet<>();

            for (String mod: propValue.split(",")) {

                mods.add(mod);

            }

            finder = limitFinder(finder, mods, roots);

        }

        limitedFinder = finder;

        // 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 "java.se" and all (non-java.*) modules

        // that export an API. If "java.se" is not observable then all java.*

        // modules are resolved. 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) {

            boolean hasJava = false;

            if (systemModules.find(JAVA_SE).isPresent()) {

                // java.se is a system module

                if (finder == systemModules || finder.find(JAVA_SE).isPresent()) {

                    // java.se is observable

                    hasJava = true;

                    roots.add(JAVA_SE);

                }

            }

            for (ModuleReference mref : systemModules.findAll()) {

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

                if (hasJava && mn.startsWith("java."))

                    continue;

                if (ModuleResolution.doNotResolveByDefault(mref))

                    continue;

                // add as root if observable and exports at least one package

                if ((finder == systemModules || finder.find(mn).isPresent())) {

                    ModuleDescriptor descriptor = mref.descriptor();

                    for (ModuleDescriptor.Exports e : descriptor.exports()) {

                        if (!e.isQualified()) {

                            roots.add(mn);

                            break;

                        }

                    }

                }

            }

        }

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

        // modules will be resolved.

        if (addAllSystemModules) {

            ModuleFinder f = finder;  // observable modules

            systemModules.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));

        }

        // determine if post resolution checks are needed

        boolean needPostResolutionChecks = true;

        if (baseUri.getScheme().equals("jrt")   // toLowerCase not needed here

                && (upgradeModulePath == null)

                && (appModulePath == null)

                && (patcher.isEmpty())) {

            needPostResolutionChecks = false;

        }

        PrintStream traceOutput = null;

        propValue = getAndRemoveProperty("jdk.module.showModuleResolution");

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

            traceOutput = System.out;

        // run the resolver to create the configuration

        Configuration cf = SharedSecrets.getJavaLangModuleAccess()

                .resolveAndBind(finder,

                                roots,

                                needPostResolutionChecks,

                                traceOutput);

        // 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 (needPostResolutionChecks) {

            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 (!systemModules.find(name).isPresent())

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

                }

            }

            // check if module specified in --patch-module is present

            for (String mn: patcher.patchedModules()) {

                if (!cf.findModule(mn).isPresent()) {

                    warnUnknownModule(PATCH_MODULE, mn);

                }

            }

        }

        if (SystemModules.hasSplitPackages() || needPostResolutionChecks) {

        }

        PerfCounters.loadModulesTime.addElapsedTimeFrom(t5);

        addExtraReads(bootLayer);

        // total time to initialize

        return bootLayer;

    }

    /**

     * Create a "minimal" boot module layer that only contains java.base.

     */

    private static ModuleLayer createMinimalBootLayer() {

        Configuration cf = SharedSecrets.getJavaLangModuleAccess()

            .resolveAndBind(ModuleFinder.ofSystem(),

                            Set.of(JAVA_BASE),

                            false,

                            null);

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

        return ModuleLayer.empty().defineModules(cf, clf);

    }

    /**

     * Returns a ModuleFinder that limits observability to the given root

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

     */

    private static ModuleFinder limitFinder(ModuleFinder finder,

                                            Set<String> roots,

                                            Set<String> otherMods)

    {

        // resolve all root modules

        Configuration cf = Configuration.empty().resolve(finder,

                                                         ModuleFinder.of(),

                                                         roots);

        // module name -> reference

        Map<String, ModuleReference> map = new HashMap<>();

        // root modules and their transitive dependences

        cf.modules().stream()

            .map(ResolvedModule::reference)

            .forEach(mref -> map.put(mref.descriptor().name(), mref));

        // additional modules

        otherMods.stream()

            .map(finder::find)

            .flatMap(Optional::stream)

            .forEach(mref -> map.putIfAbsent(mref.descriptor().name(), mref));

        // set of modules that are observable

        Set<ModuleReference> mrefs = new HashSet<>(map.values());

        return new ModuleFinder() {

            @Override

            public Optional<ModuleReference> find(String name) {

                return Optional.ofNullable(map.get(name));

            }

            @Override

            public Set<ModuleReference> findAll() {

                return mrefs;

            }

        };

    }

    /**

     * Creates a finder from the module path that is the value of the given

     * system property and optionally patched by --patch-module

     */

    private static ModuleFinder createModulePathFinder(String prop) {

        String s = System.getProperty(prop);

        if (s == null) {

            return null;

        } else {

            String[] dirs = s.split(File.pathSeparator);