/*

 * Copyright (c) 2015, 2016, 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.PrintStream;

import java.io.PrintWriter;

import java.io.UncheckedIOException;

import java.lang.module.Configuration;

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.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.ArrayDeque;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.Deque;

import java.util.HashMap;

import java.util.HashSet;

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.function.Consumer;

import java.util.function.Function;

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.misc.JavaLangModuleAccess;

import jdk.internal.misc.SharedSecrets;

import jdk.internal.module.ModuleHashes;

import jdk.internal.module.ModuleInfoExtender;

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 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,

        LIST,

        DESCRIBE,

        HASH

    };

    static class Options {

        Mode mode;

        Path jmodFile;

        boolean help;

        boolean version;

        List<Path> classpath;

        List<Path> cmds;

        List<Path> configs;

        List<Path> libs;

        List<Path> headerFiles;

        List<Path> manPages;

        ModuleFinder moduleFinder;

        Version moduleVersion;

        String mainClass;

        String osName;

        String osArch;

        String osVersion;

        Pattern modulesToHash;

        boolean dryrun;

        List<PathMatcher> excludes;

    }

    public int run(String[] args) {

        try {

            handleOptions(args);

            if (options == null) {

                showUsageSummary();

                return EXIT_CMDERR;

            }

            if (options.help) {

                showHelp();

                return EXIT_OK;

            }

            if (options.version) {

                showVersion();

                return EXIT_OK;

            }

            boolean ok;

            switch (options.mode) {

                case CREATE:

                    ok = create();

                    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 hashModules() {

        return new Hasher(options.moduleFinder).run();

    }

    private boolean describe() throws IOException {

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

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

                ModuleDescriptor md = ModuleDescriptor.read(in);

                printModuleDescriptor(md);

                return true;

            } catch (IOException e) {

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

            }

        }

    }

                  .collect(joining(" "));

    }

    private static final JavaLangModuleAccess JLMA = SharedSecrets.getJavaLangModuleAccess();

    private void printModuleDescriptor(ModuleDescriptor md)

        throws IOException

    {

        StringBuilder sb = new StringBuilder();

        sb.append("\n").append(md.toNameAndVersion());

        md.requires().stream()

            .sorted(Comparator.comparing(Requires::name))

            .forEach(r -> {

                sb.append("\n  requires ");

                if (!r.modifiers().isEmpty())

                    sb.append(toString(r.modifiers())).append(" ");

                sb.append(r.name());

            });

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

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

        md.exports().stream()

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

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

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

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

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

        md.osName().ifPresent(v -> sb.append("\n  operating-system-name " + v));

        md.osArch().ifPresent(v -> sb.append("\n  operating-system-architecture " + v));

        md.osVersion().ifPresent(v -> sb.append("\n  operating-system-version " + v));

        JLMA.hashes(md).ifPresent(

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

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

        out.println(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 = target.resolveSibling(target.getFileName() + ".tmp");

        try {

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

                jmod.write(jos);

            }

            Files.move(tempTarget, target);

        } catch (Exception e) {

            if (Files.exists(tempTarget)) {

                try {

                    Files.delete(tempTarget);

                } catch (IOException ioe) {

                    e.addSuppressed(ioe);

                }

            }

            throw e;

        }

        return true;

    }

    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 Version moduleVersion = options.moduleVersion;

        final String mainClass = options.mainClass;

        final String osName = options.osName;

        final String osArch = options.osArch;

        final String osVersion = options.osVersion;

        final List<PathMatcher> excludes = options.excludes;

        final Hasher hasher = hasher();

        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.NATIVE_CMDS, cmds);

            processSection(out, Section.NATIVE_LIBS, libs);

            processSection(out, Section.CONFIG, configs);

            processSection(out, Section.HEADER_FILES, headerFiles);

            processSection(out, Section.MAN_PAGES, manPages);

        }

        /**

         * 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)) {

                        Files.copy(mi, baos);

                        break;

                    }

                } else if (Files.isRegularFile(e) && e.toString().endsWith(".jar")) {

                    try (JarFile jf = new JarFile(e.toFile())) {

                        ZipEntry entry = jf.getEntry(MODULE_INFO);

                        if (entry != null) {

                            jf.getInputStream(entry).transferTo(baos);

                            break;

                        }

                    } catch (ZipException x) {

                        // Skip. Do nothing. No packages will be added.

                    }

                }

            }

            if (baos.size() == 0) {

                return null;

            } else {

                byte[] bytes = baos.toByteArray();

                return () -> new ByteArrayInputStream(bytes);

            }

        }

        /**

         * Writes the updated module-info.class to the ZIP output stream.

         *

         * with the set of module-private/non-exported packages.

         *

         * If --module-version, --main-class, or other options were provided

         * then the corresponding class file attributes are added to the

         * module-info here.

         */

        void writeModuleInfo(JmodOutputStream out, Set<String> packages)

            throws IOException

        {

            Supplier<InputStream> miSupplier = newModuleInfoSupplier();

            if (miSupplier == null) {

                throw new IOException(MODULE_INFO + " not found");

            }

            ModuleDescriptor descriptor;

            try (InputStream in = miSupplier.get()) {

                descriptor = ModuleDescriptor.read(in);

            }

            // copy the module-info.class into the jmod with the additional

            // attributes for the version, main class and other meta data

            try (InputStream in = miSupplier.get()) {

                ModuleInfoExtender extender = ModuleInfoExtender.newExtender(in);

                if (packages != null) {

                }

                // --main-class

                if (mainClass != null)

                    extender.mainClass(mainClass);

                // --os-name, --os-arch, --os-version

                if (osName != null || osArch != null || osVersion != null)

                    extender.targetPlatform(osName, osArch, osVersion);

                // --module-version

                if (moduleVersion != null)

                    extender.version(moduleVersion);

                if (hasher != null) {

                    ModuleHashes moduleHashes = hasher.computeHashes(descriptor.name());

                    if (moduleHashes != null) {

                        extender.hashes(moduleHashes);

                    } else {

                        warning("warn.no.module.hashes", descriptor.name());

                    }

                }

                // write the (possibly extended or modified) module-info.class

                out.writeEntry(extender.toByteArray(), Section.CLASSES, MODULE_INFO);

            }

        }

        /*

         * Hasher resolves a module graph using the --hash-modules PATTERN

         * as the roots.

         *

         * The jmod file is being created and does not exist in the

         * given modulepath.

         */

        private Hasher hasher() {

            if (options.modulesToHash == null)

                return null;

            try {

                Supplier<InputStream> miSupplier = newModuleInfoSupplier();

                if (miSupplier == null) {

                    throw new IOException(MODULE_INFO + " not found");

                }

                ModuleDescriptor descriptor;

                try (InputStream in = miSupplier.get()) {

                    descriptor = ModuleDescriptor.read(in);

                }

                URI uri = options.jmodFile.toUri();

                ModuleReference mref = new ModuleReference(descriptor, uri, new Supplier<>() {

                    @Override

                    public ModuleReader get() {

                        throw new UnsupportedOperationException();

                    }

                });