/*

 * Copyright (c) 2015, 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.tools.jlink.internal;

import java.io.BufferedInputStream;

import java.io.File;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.UncheckedIOException;

import java.lang.module.Configuration;

import java.lang.module.FindException;

import java.lang.module.ModuleDescriptor;

import java.lang.module.ModuleFinder;

import java.lang.module.ModuleReference;

import java.lang.module.ResolutionException;

import java.lang.module.ResolvedModule;

import java.net.URI;

import java.nio.ByteOrder;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.Objects;

import java.util.Optional;

import java.util.Set;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import jdk.tools.jlink.internal.TaskHelper.BadArgs;

import static jdk.tools.jlink.internal.TaskHelper.JLINK_BUNDLE;

import jdk.tools.jlink.internal.Jlink.JlinkConfiguration;

import jdk.tools.jlink.internal.Jlink.PluginsConfiguration;

import jdk.tools.jlink.internal.TaskHelper.Option;

import jdk.tools.jlink.internal.TaskHelper.OptionsHelper;

import jdk.tools.jlink.internal.ImagePluginStack.ImageProvider;

import jdk.tools.jlink.plugin.PluginException;

import jdk.tools.jlink.builder.DefaultImageBuilder;

import jdk.tools.jlink.plugin.Plugin;

import jdk.internal.module.ModulePath;

import jdk.internal.module.ModuleResolution;

/**

 * Implementation for the jlink tool.

 *

 * ## Should use jdk.joptsimple some day.

 */

public class JlinkTask {

    static final boolean DEBUG = Boolean.getBoolean("jlink.debug");

    // jlink API ignores by default. Remove when signing is implemented.

    static final boolean IGNORE_SIGNING_DEFAULT = true;

    private static final TaskHelper taskHelper

            = new TaskHelper(JLINK_BUNDLE);

    private static final Option<?>[] recognizedOptions = {

        new Option<JlinkTask>(false, (task, opt, arg) -> {

            task.options.help = true;

        }, "--help", "-h", "-?"),

        new Option<JlinkTask>(true, (task, opt, arg) -> {

            // if used multiple times, the last one wins!

            // So, clear previous values, if any.

            task.options.modulePath.clear();

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

            int i = 0;

            Arrays.stream(dirs)

                  .map(Paths::get)

                  .forEach(task.options.modulePath::add);

        }, "--module-path", "-p"),

        new Option<JlinkTask>(true, (task, opt, arg) -> {

            // if used multiple times, the last one wins!

            // So, clear previous values, if any.

            task.options.limitMods.clear();

            for (String mn : arg.split(",")) {

                if (mn.isEmpty()) {

                    throw taskHelper.newBadArgs("err.mods.must.be.specified",

                            "--limit-modules");

                }

                task.options.limitMods.add(mn);

            }

        }, "--limit-modules"),

        new Option<JlinkTask>(true, (task, opt, arg) -> {

            for (String mn : arg.split(",")) {

                if (mn.isEmpty()) {

                    throw taskHelper.newBadArgs("err.mods.must.be.specified",

                            "--add-modules");

                }

                task.options.addMods.add(mn);

            }

        }, "--add-modules"),

        new Option<JlinkTask>(true, (task, opt, arg) -> {

            Path path = Paths.get(arg);

            task.options.output = path;

        }, "--output"),

        new Option<JlinkTask>(false, (task, opt, arg) -> {

            task.options.bindServices = true;

        }, "--bind-services"),

        new Option<JlinkTask>(false, (task, opt, arg) -> {

            task.options.suggestProviders = true;

        }, "--suggest-providers", "", true),

        new Option<JlinkTask>(true, (task, opt, arg) -> {

            String[] values = arg.split("=");

            // check values

            if (values.length != 2 || values[0].isEmpty() || values[1].isEmpty()) {

                throw taskHelper.newBadArgs("err.launcher.value.format", arg);

            } else {

                String commandName = values[0];

                String moduleAndMain = values[1];

                int idx = moduleAndMain.indexOf("/");

                if (idx != -1) {

                    if (moduleAndMain.substring(0, idx).isEmpty()) {

                        throw taskHelper.newBadArgs("err.launcher.module.name.empty", arg);

                    }

                    if (moduleAndMain.substring(idx + 1).isEmpty()) {

                        throw taskHelper.newBadArgs("err.launcher.main.class.empty", arg);

                    }

                }

                task.options.launchers.put(commandName, moduleAndMain);

            }

        }, "--launcher"),

        new Option<JlinkTask>(true, (task, opt, arg) -> {

            if ("little".equals(arg)) {

                task.options.endian = ByteOrder.LITTLE_ENDIAN;

            } else if ("big".equals(arg)) {

                task.options.endian = ByteOrder.BIG_ENDIAN;

            } else {

                throw taskHelper.newBadArgs("err.unknown.byte.order", arg);

            }

        }, "--endian"),

        new Option<JlinkTask>(false, (task, opt, arg) -> {

            task.options.verbose = true;

        }, "--verbose", "-v"),

        new Option<JlinkTask>(false, (task, opt, arg) -> {

            task.options.version = true;

        }, "--version"),

        new Option<JlinkTask>(true, (task, opt, arg) -> {

            Path path = Paths.get(arg);

            if (Files.exists(path)) {

                throw taskHelper.newBadArgs("err.dir.exists", path);

            }

            task.options.packagedModulesPath = path;

        }, true, "--keep-packaged-modules"),

        new Option<JlinkTask>(true, (task, opt, arg) -> {

            task.options.saveoptsfile = arg;

        }, "--save-opts"),

        new Option<JlinkTask>(false, (task, opt, arg) -> {

            task.options.fullVersion = true;

        }, true, "--full-version"),

        new Option<JlinkTask>(false, (task, opt, arg) -> {

            task.options.ignoreSigning = true;

        }, "--ignore-signing-information"),};

    private static final String PROGNAME = "jlink";

    private final OptionsValues options = new OptionsValues();

    private static final OptionsHelper<JlinkTask> optionsHelper

            = taskHelper.newOptionsHelper(JlinkTask.class, recognizedOptions);

    private PrintWriter log;

    void setLog(PrintWriter out, PrintWriter err) {

        log = out;

        taskHelper.setLog(log);

    }

    /**

     * Result codes.

     */

    static final int

            EXIT_OK = 0, // Completed with no errors.

            EXIT_ERROR = 1, // Completed but reported errors.

            EXIT_CMDERR = 2, // Bad command-line arguments

            EXIT_SYSERR = 3, // System error or resource exhaustion.

            EXIT_ABNORMAL = 4;// terminated abnormally

    static class OptionsValues {

        boolean help;

        String  saveoptsfile;

        boolean verbose;

        boolean version;

        boolean fullVersion;

        final List<Path> modulePath = new ArrayList<>();

        final Set<String> limitMods = new HashSet<>();

        final Set<String> addMods = new HashSet<>();

        Path output;

        final Map<String, String> launchers = new HashMap<>();

        Path packagedModulesPath;

        ByteOrder endian = ByteOrder.nativeOrder();

        boolean ignoreSigning = false;

        boolean bindServices = false;

        boolean suggestProviders = false;

    }

    int run(String[] args) {

        if (log == null) {

            setLog(new PrintWriter(System.out, true),

                   new PrintWriter(System.err, true));

        }

        try {

            List<String> remaining = optionsHelper.handleOptions(this, args);

            if (remaining.size() > 0 && !options.suggestProviders) {

                                .showUsage(true);

            }

            if (options.help) {

                optionsHelper.showHelp(PROGNAME);

                return EXIT_OK;

            }

            if (optionsHelper.shouldListPlugins()) {

                optionsHelper.listPlugins();

                return EXIT_OK;

            }

            if (options.version || options.fullVersion) {

                taskHelper.showVersion(options.fullVersion);

                return EXIT_OK;

            }

            if (taskHelper.getExistingImage() != null) {

                postProcessOnly(taskHelper.getExistingImage());

                return EXIT_OK;

            }

            if (options.modulePath.isEmpty()) {

                // no --module-path specified - try to set $JAVA_HOME/jmods if that exists

                Path jmods = getDefaultModulePath();

                if (jmods != null) {

                    options.modulePath.add(jmods);

                }

                if (options.modulePath.isEmpty()) {

                     throw taskHelper.newBadArgs("err.modulepath.must.be.specified")

                                 .showUsage(true);

                }

            }

            JlinkConfiguration config = initJlinkConfig();

            if (options.suggestProviders) {

                suggestProviders(config, remaining);

            } else {

                createImage(config);

                if (options.saveoptsfile != null) {

                    Files.write(Paths.get(options.saveoptsfile), getSaveOpts().getBytes());

                }

            }

            return EXIT_OK;

        } catch (PluginException | IllegalArgumentException |

                 UncheckedIOException |IOException | FindException | ResolutionException e) {

            log.println(taskHelper.getMessage("error.prefix") + " " + e.getMessage());

            if (DEBUG) {

                e.printStackTrace(log);

            }

            return EXIT_ERROR;

        } catch (BadArgs e) {

            taskHelper.reportError(e.key, e.args);

            if (e.showUsage) {

                log.println(taskHelper.getMessage("main.usage.summary", PROGNAME));

            }

            if (DEBUG) {

                e.printStackTrace(log);

            }

            return EXIT_CMDERR;

        } catch (Throwable x) {

            log.println(taskHelper.getMessage("error.prefix") + " " + x.getMessage());

            x.printStackTrace(log);

            return EXIT_ABNORMAL;

        } finally {

            log.flush();

        }

    }

    /*

     * Jlink API entry point.

     */

    public static void createImage(JlinkConfiguration config,

                                   PluginsConfiguration plugins)

            throws Exception {

        Objects.requireNonNull(config);

        Objects.requireNonNull(config.getOutput());

        plugins = plugins == null ? new PluginsConfiguration() : plugins;

        // First create the image provider

        ImageProvider imageProvider =

                createImageProvider(config,

                                    null,

                                    IGNORE_SIGNING_DEFAULT,

                                    false,

                                    false,

                                    null);

        // Then create the Plugin Stack

        ImagePluginStack stack = ImagePluginConfiguration.parseConfiguration(plugins);

        //Ask the stack to proceed;

        stack.operate(imageProvider);

    }

    /*

     * Jlink API entry point.

     */

    public static void postProcessImage(ExecutableImage image, List<Plugin> postProcessorPlugins)

            throws Exception {

        Objects.requireNonNull(image);

        Objects.requireNonNull(postProcessorPlugins);

        PluginsConfiguration config = new PluginsConfiguration(postProcessorPlugins);

        ImagePluginStack stack = ImagePluginConfiguration.

                parseConfiguration(config);

        stack.operate((ImagePluginStack stack1) -> image);

    }

    private void postProcessOnly(Path existingImage) throws Exception {

        PluginsConfiguration config = taskHelper.getPluginsConfig(null, null);

        ExecutableImage img = DefaultImageBuilder.getExecutableImage(existingImage);

        if (img == null) {

            throw taskHelper.newBadArgs("err.existing.image.invalid");

        }

        postProcessImage(img, config.getPlugins());

    }

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

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

    private JlinkConfiguration initJlinkConfig() throws BadArgs {

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

        for (String mod : options.addMods) {

            if (mod.equals(ALL_MODULE_PATH)) {

                ModuleFinder finder = newModuleFinder(options.modulePath, options.limitMods, Set.of());

                // all observable modules are roots

                finder.findAll()

                      .stream()

                      .map(ModuleReference::descriptor)

                      .map(ModuleDescriptor::name)

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

            } else {

                roots.add(mod);

            }

        }

        ModuleFinder finder = newModuleFinder(options.modulePath, options.limitMods, roots);

        if (!finder.find("java.base").isPresent()) {

            Path defModPath = getDefaultModulePath();

            if (defModPath != null) {

                options.modulePath.add(defModPath);

            }

            finder = newModuleFinder(options.modulePath, options.limitMods, roots);

        }

        return new JlinkConfiguration(options.output,

                                      roots,

                                      options.endian,

                                      finder);

    }

    private void createImage(JlinkConfiguration config) throws Exception {

        if (options.output == null) {

            throw taskHelper.newBadArgs("err.output.must.be.specified").showUsage(true);

        }

        if (options.addMods.isEmpty()) {

            throw taskHelper.newBadArgs("err.mods.must.be.specified", "--add-modules")

                            .showUsage(true);

        }

        // First create the image provider

        ImageProvider imageProvider = createImageProvider(config,

                                                          options.packagedModulesPath,

                                                          options.ignoreSigning,

                                                          options.bindServices,

                                                          options.verbose,

                                                          log);

        // Then create the Plugin Stack

        ImagePluginStack stack = ImagePluginConfiguration.parseConfiguration(

            taskHelper.getPluginsConfig(options.output, options.launchers));

        //Ask the stack to proceed

        stack.operate(imageProvider);

    }

    /**

     * @return the system module path or null

     */

    public static Path getDefaultModulePath() {

        Path jmods = Paths.get(System.getProperty("java.home"), "jmods");

        return Files.isDirectory(jmods)? jmods : null;

    }

    /*

     * Returns a module finder of the given module path that limits

     * the observable modules to those in the transitive closure of

     * the modules specified in {@code limitMods} plus other modules

     * specified in the {@code roots} set.

     *

     * @throws IllegalArgumentException if java.base module is present

     * but its descriptor has no version

     */

    public static ModuleFinder newModuleFinder(List<Path> paths,

                                               Set<String> limitMods,

                                               Set<String> roots)

    {

        if (Objects.requireNonNull(paths).isEmpty()) {

             throw new IllegalArgumentException(taskHelper.getMessage("err.empty.module.path"));

        }

        Path[] entries = paths.toArray(new Path[0]);

        Runtime.Version version = Runtime.version();

        ModuleFinder finder = ModulePath.of(version, true, entries);

        if (finder.find("java.base").isPresent()) {

            // use the version of java.base module, if present, as

            // the release version for multi-release JAR files

            ModuleDescriptor.Version v = finder.find("java.base").get()

                .descriptor().version().orElseThrow(() ->

                    new IllegalArgumentException("No version in java.base descriptor")

                );

            // java.base version is different than the current runtime version

            version = Runtime.Version.parse(v.toString());

            if (Runtime.version().feature() != version.feature() ||

                Runtime.version().interim() != version.interim())

            {

                // jlink version and java.base version do not match.

                // We do not (yet) support this mode.

                throw new IllegalArgumentException(taskHelper.getMessage("err.jlink.version.mismatch",

                    Runtime.version().feature(), Runtime.version().interim(),

                    version.feature(), version.interim()));

            }

        }

        // if limitmods is specified then limit the universe

        if (limitMods != null && !limitMods.isEmpty()) {

            finder = limitFinder(finder, limitMods, Objects.requireNonNull(roots));

        }

        return finder;

    }

    private static Path toPathLocation(ResolvedModule m) {

        Optional<URI> ouri = m.reference().location();

        if (!ouri.isPresent())

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

        URI uri = ouri.get();

        return Paths.get(uri);

    }

    private static ImageProvider createImageProvider(JlinkConfiguration config,

                                                     Path retainModulesPath,

                                                     boolean ignoreSigning,

                                                     boolean bindService,

                                                     boolean verbose,

                                                     PrintWriter log)

            throws IOException

    {

        Configuration cf = bindService ? config.resolveAndBind()

                                       : config.resolve();

        cf.modules().stream()

            .map(ResolvedModule::reference)

            .filter(mref -> mref.descriptor().isAutomatic())

            .findAny()

            .ifPresent(mref -> {

                String loc = mref.location().map(URI::toString).orElse("<unknown>");

                throw new IllegalArgumentException(

                    taskHelper.getMessage("err.automatic.module", mref.descriptor().name(), loc));

            });

        if (verbose && log != null) {

            // print modules to be linked in

            cf.modules().stream()