/*

 * 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.jmod;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.io.UncheckedIOException;

import java.lang.module.Configuration;

import java.lang.module.FindException;

import java.lang.module.ModuleReader;

import java.lang.module.ModuleReference;

import java.lang.module.ModuleFinder;

import java.lang.module.ModuleDescriptor;

import java.lang.module.ModuleDescriptor.Exports;

import java.lang.module.ModuleDescriptor.Opens;

import java.lang.module.ModuleDescriptor.Provides;

import java.lang.module.ModuleDescriptor.Requires;

import java.lang.module.ModuleDescriptor.Version;

import java.lang.module.ResolutionException;

import java.lang.module.ResolvedModule;

import java.net.URI;

import java.nio.file.FileSystems;

import java.nio.file.FileVisitOption;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.InvalidPathException;

import java.nio.file.Path;

import java.nio.file.PathMatcher;

import java.nio.file.Paths;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.StandardCopyOption;

import java.nio.file.attribute.BasicFileAttributes;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Locale;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.Optional;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.TreeSet;

import java.util.function.Consumer;

import java.util.function.Predicate;

import java.util.function.Supplier;

import java.util.jar.JarEntry;

import java.util.jar.JarFile;

import java.util.jar.JarOutputStream;

import java.util.stream.Collectors;

import java.util.regex.Pattern;

import java.util.regex.PatternSyntaxException;

import java.util.zip.ZipEntry;

import java.util.zip.ZipException;

import java.util.zip.ZipFile;

import jdk.internal.jmod.JmodFile;

import jdk.internal.jmod.JmodFile.Section;

import jdk.internal.joptsimple.BuiltinHelpFormatter;

import jdk.internal.joptsimple.NonOptionArgumentSpec;

import jdk.internal.joptsimple.OptionDescriptor;

import jdk.internal.joptsimple.OptionException;

import jdk.internal.joptsimple.OptionParser;

import jdk.internal.joptsimple.OptionSet;

import jdk.internal.joptsimple.OptionSpec;

import jdk.internal.joptsimple.ValueConverter;

import jdk.internal.module.ModuleHashes;

import jdk.internal.module.ModuleHashesBuilder;

import jdk.internal.module.ModuleInfo;

import jdk.internal.module.ModuleInfoExtender;

import jdk.internal.module.ModulePath;

import jdk.internal.module.ModuleResolution;

import jdk.internal.module.ModuleTarget;

import jdk.internal.module.Resources;

import jdk.tools.jlink.internal.Utils;

import static java.util.stream.Collectors.joining;

/**

 * Implementation for the jmod tool.

 */

public class JmodTask {

    static class CommandException extends RuntimeException {

        private static final long serialVersionUID = 0L;

        boolean showUsage;

        CommandException(String key, Object... args) {

            super(getMessageOrKey(key, args));

        }

        CommandException showUsage(boolean b) {

            showUsage = b;

            return this;

        }

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

            try {

                return MessageFormat.format(ResourceBundleHelper.bundle.getString(key), args);

            } catch (MissingResourceException e) {

                return key;

            }

        }

    }

    private static final String PROGNAME = "jmod";

    private static final String MODULE_INFO = "module-info.class";

    private static final Path CWD = Paths.get("");

    private Options options;

    private PrintWriter out = new PrintWriter(System.out, true);

    void setLog(PrintWriter out, PrintWriter err) {

        this.out = out;

    }

    /* 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

    enum Mode {

        CREATE,

        EXTRACT,

        LIST,

        DESCRIBE,

        HASH

    };

    static class Options {

        Mode mode;

        Path jmodFile;

        boolean help;

        boolean helpExtra;

        boolean version;

        List<Path> classpath;

        List<Path> cmds;

        List<Path> configs;

        List<Path> libs;

        List<Path> headerFiles;

        List<Path> manPages;

        List<Path> legalNotices;;

        ModuleFinder moduleFinder;

        Version moduleVersion;

        String mainClass;

        String targetPlatform;

        Pattern modulesToHash;

        ModuleResolution moduleResolution;

        boolean dryrun;

        List<PathMatcher> excludes;

        Path extractDir;

    }

    public int run(String[] args) {

        try {

            handleOptions(args);

            if (options == null) {

                showUsageSummary();

                return EXIT_CMDERR;

            }

            if (options.help || options.helpExtra) {

                showHelp();

                return EXIT_OK;

            }

            if (options.version) {

                showVersion();

                return EXIT_OK;

            }

            boolean ok;

            switch (options.mode) {

                case CREATE:

                    ok = create();

                    break;

                case EXTRACT:

                    ok = extract();

                    break;

                case LIST:

                    ok = list();

                    break;

                case DESCRIBE:

                    ok = describe();

                    break;

                case HASH:

                    ok = hashModules();

                    break;

                default:

                    throw new AssertionError("Unknown mode: " + options.mode.name());

            }

            return ok ? EXIT_OK : EXIT_ERROR;

        } catch (CommandException e) {

            reportError(e.getMessage());

            if (e.showUsage)

                showUsageSummary();

            return EXIT_CMDERR;

        } catch (Exception x) {

            reportError(x.getMessage());

            x.printStackTrace();

            return EXIT_ABNORMAL;

        } finally {

            out.flush();

        }

    }

    private boolean list() throws IOException {

        ZipFile zip = null;

        try {

            try {

                zip = new ZipFile(options.jmodFile.toFile());

            } catch (IOException x) {

                throw new IOException("error opening jmod file", x);

            }

            // Trivially print the archive entries for now, pending a more complete implementation

            zip.stream().forEach(e -> out.println(e.getName()));

            return true;

        } finally {

            if (zip != null)

                zip.close();

        }

    }

    private boolean extract() throws IOException {

        Path dir = options.extractDir != null ? options.extractDir : CWD;

        try (JmodFile jf = new JmodFile(options.jmodFile)) {

            jf.stream().forEach(e -> {

                try {

                    ZipEntry entry = e.zipEntry();

                    String name = entry.getName();

                    int index = name.lastIndexOf("/");

                    if (index != -1) {

                        Path p = dir.resolve(name.substring(0, index));

                        if (Files.notExists(p))

                            Files.createDirectories(p);

                    }

                    try (OutputStream os = Files.newOutputStream(dir.resolve(name))) {

                        jf.getInputStream(e).transferTo(os);

                    }

                } catch (IOException x) {

                    throw new UncheckedIOException(x);

                }

            });

            return true;

        }

    }

    private boolean hashModules() {

        if (options.dryrun) {

            out.println("Dry run:");

        }

        Hasher hasher = new Hasher(options.moduleFinder);

        hasher.computeHashes().forEach((mn, hashes) -> {

            if (options.dryrun) {

                out.format("%s%n", mn);

                hashes.names().stream()

                    .sorted()

                    .forEach(name -> out.format("  hashes %s %s %s%n",

                        name, hashes.algorithm(), toHex(hashes.hashFor(name))));

            } else {

                try {

                    hasher.updateModuleInfo(mn, hashes);

                } catch (IOException ex) {

                    throw new UncheckedIOException(ex);

                }

            }

        });

        return true;

    }

    private boolean describe() throws IOException {

        try (JmodFile jf = new JmodFile(options.jmodFile)) {

            try (InputStream in = jf.getInputStream(Section.CLASSES, MODULE_INFO)) {

                ModuleInfo.Attributes attrs = ModuleInfo.read(in, null);

                describeModule(attrs.descriptor(),

                               attrs.target(),

                               attrs.recordedHashes());

                return true;

            } catch (IOException e) {

                throw new CommandException("err.module.descriptor.not.found");

            }

        }

    }

    static <T> String toLowerCaseString(Collection<T> c) {

        if (c.isEmpty()) { return ""; }

        return " " + c.stream().map(e -> e.toString().toLowerCase(Locale.ROOT))

                .sorted().collect(joining(" "));

    }

    static <T> String toString(Collection<T> c) {

        if (c.isEmpty()) { return ""; }

        return " " + c.stream().map(e -> e.toString()).sorted().collect(joining(" "));

    }

    private void describeModule(ModuleDescriptor md,

                                ModuleTarget target,

                                ModuleHashes hashes)

        throws IOException

    {

        StringBuilder sb = new StringBuilder();

        sb.append(md.toNameAndVersion());

        if (md.isOpen())

            sb.append(" open");

        if (md.isAutomatic())

            sb.append(" automatic");

        sb.append("\n");

        // unqualified exports (sorted by package)

        md.exports().stream()

                .sorted(Comparator.comparing(Exports::source))

                .filter(e -> !e.isQualified())

                .forEach(e -> sb.append("exports ").append(e.source())

                                .append(toLowerCaseString(e.modifiers())).append("\n"));

        // dependences

        md.requires().stream().sorted()

                .forEach(r -> sb.append("requires ").append(r.name())

                                .append(toLowerCaseString(r.modifiers())).append("\n"));

        // service use and provides

        md.uses().stream().sorted()

                .forEach(s -> sb.append("uses ").append(s).append("\n"));

        md.provides().stream()

                .sorted(Comparator.comparing(Provides::service))

                .forEach(p -> sb.append("provides ").append(p.service())

                                .append(" with")

                                .append(toString(p.providers()))

                                .append("\n"));

        // qualified exports

        md.exports().stream()

                .sorted(Comparator.comparing(Exports::source))

                .filter(Exports::isQualified)

                .forEach(e -> sb.append("qualified exports ").append(e.source())

                                .append(" to").append(toLowerCaseString(e.targets()))

                                .append("\n"));

        // open packages

        md.opens().stream()

                .sorted(Comparator.comparing(Opens::source))

                .filter(o -> !o.isQualified())

                .forEach(o -> sb.append("opens ").append(o.source())

                                 .append(toLowerCaseString(o.modifiers()))

                                 .append("\n"));

        md.opens().stream()

                .sorted(Comparator.comparing(Opens::source))

                .filter(Opens::isQualified)

                .forEach(o -> sb.append("qualified opens ").append(o.source())

                                 .append(toLowerCaseString(o.modifiers()))

                                 .append(" to").append(toLowerCaseString(o.targets()))

                                 .append("\n"));

        // non-exported/non-open packages

        Set<String> concealed = new TreeSet<>(md.packages());

        md.exports().stream().map(Exports::source).forEach(concealed::remove);

        md.opens().stream().map(Opens::source).forEach(concealed::remove);

        concealed.forEach(p -> sb.append("contains ").append(p).append("\n"));

        md.mainClass().ifPresent(v -> sb.append("main-class ").append(v).append("\n"));

        if (target != null) {

            String targetPlatform = target.targetPlatform();

            if (!targetPlatform.isEmpty())

                sb.append("platform ").append(targetPlatform).append("\n");

       }

       if (hashes != null) {

           hashes.names().stream().sorted().forEach(

                   mod -> sb.append("hashes ").append(mod).append(" ")

                            .append(hashes.algorithm()).append(" ")

                            .append(toHex(hashes.hashFor(mod)))

                            .append("\n"));

        }

        out.println(sb.toString());

    }

    private String toHex(byte[] ba) {

        StringBuilder sb = new StringBuilder(ba.length);

        for (byte b: ba) {

            sb.append(String.format("%02x", b & 0xff));

        }

        return sb.toString();

    }

    private boolean create() throws IOException {

        JmodFileWriter jmod = new JmodFileWriter();

        // create jmod with temporary name to avoid it being examined

        // when scanning the module path

        Path target = options.jmodFile;

        Path tempTarget = jmodTempFilePath(target);

        try {

            try (JmodOutputStream jos = JmodOutputStream.newOutputStream(tempTarget)) {

                jmod.write(jos);

            }

            Files.move(tempTarget, target);

        } catch (Exception e) {

            try {

                Files.deleteIfExists(tempTarget);

            } catch (IOException ioe) {

                e.addSuppressed(ioe);

            }

            throw e;

        }

        return true;

    }

    /*

     * Create a JMOD .tmp file for the given target JMOD file

     */

    private static Path jmodTempFilePath(Path target) throws IOException {

        return target.resolveSibling("." + target.getFileName() + ".tmp");

    }

    private class JmodFileWriter {

        final List<Path> cmds = options.cmds;

        final List<Path> libs = options.libs;

        final List<Path> configs = options.configs;

        final List<Path> classpath = options.classpath;

        final List<Path> headerFiles = options.headerFiles;

        final List<Path> manPages = options.manPages;

        final List<Path> legalNotices = options.legalNotices;

        final Version moduleVersion = options.moduleVersion;

        final String mainClass = options.mainClass;

        final String targetPlatform = options.targetPlatform;

        final List<PathMatcher> excludes = options.excludes;

        final ModuleResolution moduleResolution = options.moduleResolution;

        JmodFileWriter() { }

        /**

         * Writes the jmod to the given output stream.

         */

        void write(JmodOutputStream out) throws IOException {

            // module-info.class

            writeModuleInfo(out, findPackages(classpath));

            // classes

            processClasses(out, classpath);

            processSection(out, Section.CONFIG, configs);

            processSection(out, Section.HEADER_FILES, headerFiles);

            processSection(out, Section.LEGAL_NOTICES, legalNotices);

            processSection(out, Section.MAN_PAGES, manPages);

            processSection(out, Section.NATIVE_CMDS, cmds);

            processSection(out, Section.NATIVE_LIBS, libs);

        }

        /**

         * Returns a supplier of an input stream to the module-info.class

         * on the class path of directories and JAR files.

         */

        Supplier<InputStream> newModuleInfoSupplier() throws IOException {

            ByteArrayOutputStream baos = new ByteArrayOutputStream();

            for (Path e: classpath) {

                if (Files.isDirectory(e)) {

                    Path mi = e.resolve(MODULE_INFO);

                    if (Files.isRegularFile(mi)) {