/*

 * Copyright (c) 1996, 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 sun.tools.jar;

import java.io.*;

import java.lang.module.Configuration;

import java.lang.module.FindException;

import java.lang.module.InvalidModuleDescriptorException;

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

import java.lang.module.ModuleFinder;

import java.lang.module.ModuleReader;

import java.lang.module.ModuleReference;

import java.lang.module.ResolvedModule;

import java.net.URI;

import java.nio.ByteBuffer;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.StandardCopyOption;

import java.text.MessageFormat;

import java.util.*;

import java.util.function.Consumer;

import java.util.jar.Attributes;

import java.util.jar.JarFile;

import java.util.jar.JarOutputStream;

import java.util.jar.Manifest;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import java.util.zip.CRC32;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import java.util.zip.ZipInputStream;

import java.util.zip.ZipOutputStream;

import jdk.internal.module.Checks;

import jdk.internal.module.ModuleHashes;

import jdk.internal.module.ModuleHashesBuilder;

import jdk.internal.module.ModuleInfo;

import jdk.internal.module.ModuleInfoExtender;

import jdk.internal.module.ModuleResolution;

import jdk.internal.module.ModuleTarget;

import jdk.internal.util.jar.JarIndex;

import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;

import static java.util.jar.JarFile.MANIFEST_NAME;

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

import static jdk.internal.util.jar.JarIndex.INDEX_NAME;

/**

 * This class implements a simple utility for creating files in the JAR

 * (Java Archive) file format. The JAR format is based on the ZIP file

 * format, with optional meta-information stored in a MANIFEST entry.

 */

public class Main {

    String program;

    PrintWriter out, err;

    String fname, mname, ename;

    String zname = "";

    String rootjar = null;

    private static final int BASE_VERSION = 0;

    private static class Entry {

        final String name;

        final File file;

        final boolean isDir;

        Entry(File file, String name, boolean isDir) {

            this.file = file;

            this.isDir = isDir;

            this.name = name;

        }

        @Override

        public boolean equals(Object o) {

            if (this == o) return true;

            if (!(o instanceof Entry)) return false;

            return this.file.equals(((Entry)o).file);

        }

        @Override

        public int hashCode() {

            return file.hashCode();

        }

    }

    // An entryName(path)->Entry map generated during "expand", it helps to

    // decide whether or not an existing entry in a jar file needs to be

    // replaced, during the "update" operation.

    Map<String, Entry> entryMap = new HashMap<>();

    // All entries need to be added/updated.

    Set<Entry> entries = new LinkedHashSet<>();

    // module-info.class entries need to be added/updated.

    Map<String,byte[]> moduleInfos = new HashMap<>();

    // A paths Set for each version, where each Set contains directories

    // specified by the "-C" operation.

    Map<Integer,Set<String>> pathsMap = new HashMap<>();

    // There's also a files array per version

    Map<Integer,String[]> filesMap = new HashMap<>();

    // Do we think this is a multi-release jar?  Set to true

    // if --release option found followed by at least file

    boolean isMultiRelease;

    // The last parsed --release value, if any. Used in conjunction with

    // "-d,--describe-module" to select the operative module descriptor.

    int releaseValue = -1;

    /*

     * cflag: create

     * uflag: update

     * xflag: xtract

     * tflag: table

     * vflag: verbose

     * flag0: no zip compression (store only)

     * Mflag: DO NOT generate a manifest file (just ZIP)

     * iflag: generate jar index

     * nflag: Perform jar normalization at the end

     * pflag: preserve/don't strip leading slash and .. component from file name

     * dflag: print module descriptor

     */

    boolean cflag, uflag, xflag, tflag, vflag, flag0, Mflag, iflag, nflag, pflag, dflag;

    boolean suppressDeprecateMsg = false;

    /* To support additional GNU Style informational options */

    Consumer<PrintWriter> info;

    /* Modular jar related options */

    Version moduleVersion;

    Pattern modulesToHash;

    ModuleResolution moduleResolution = ModuleResolution.empty();

    ModuleFinder moduleFinder = ModuleFinder.of();

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

    static final String MANIFEST_DIR = "META-INF/";

    static final String VERSIONS_DIR = MANIFEST_DIR + "versions/";

    static final String VERSION = "1.0";

    static final int VERSIONS_DIR_LENGTH = VERSIONS_DIR.length();

    private static ResourceBundle rsrc;

    /**

     * If true, maintain compatibility with JDK releases prior to 6.0 by

     * timestamping extracted files with the time at which they are extracted.

     * Default is to use the time given in the archive.

     */

    private static final boolean useExtractionTime =

        Boolean.getBoolean("sun.tools.jar.useExtractionTime");

    /**

     * Initialize ResourceBundle

     */

    static {

        try {

            rsrc = ResourceBundle.getBundle("sun.tools.jar.resources.jar");

        } catch (MissingResourceException e) {

            throw new Error("Fatal: Resource for jar is missing");

        }

    }

    static String getMsg(String key) {

        try {

            return (rsrc.getString(key));

        } catch (MissingResourceException e) {

            throw new Error("Error in message file");

        }

    }

    static String formatMsg(String key, String arg) {

        String msg = getMsg(key);

        String[] args = new String[1];

        args[0] = arg;

        return MessageFormat.format(msg, (Object[]) args);

    }

    static String formatMsg2(String key, String arg, String arg1) {

        String msg = getMsg(key);

        String[] args = new String[2];

        args[0] = arg;

        args[1] = arg1;

        return MessageFormat.format(msg, (Object[]) args);

    }

    public Main(PrintStream out, PrintStream err, String program) {

        this.out = new PrintWriter(out, true);

        this.err = new PrintWriter(err, true);

        this.program = program;

    }

    public Main(PrintWriter out, PrintWriter err, String program) {

        this.out = out;

        this.err = err;

        this.program = program;

    }

    /**

     * Creates a new empty temporary file in the same directory as the

     * specified file.  A variant of File.createTempFile.

     */

    private static File createTempFileInSameDirectoryAs(File file)

        throws IOException {

        File dir = file.getParentFile();

        if (dir == null)

            dir = new File(".");

        return File.createTempFile("jartmp", null, dir);

    }

    private boolean ok;

    /**

     * Starts main program with the specified arguments.

     */

    @SuppressWarnings({"removal"})

    public synchronized boolean run(String args[]) {

        ok = true;

        if (!parseArgs(args)) {

            return false;

        }

        File tmpFile = null;

        try {

            if (cflag || uflag) {

                if (fname != null) {

                    // The name of the zip file as it would appear as its own

                    // zip file entry. We use this to make sure that we don't

                    // add the zip file to itself.

                    zname = fname.replace(File.separatorChar, '/');

                    if (zname.startsWith("./")) {

                        zname = zname.substring(2);

                    }

                }

            }

            if (cflag) {

                Manifest manifest = null;

                if (!Mflag) {

                    if (mname != null) {

                        try (InputStream in = new FileInputStream(mname)) {

                            manifest = new Manifest(new BufferedInputStream(in));

                        }

                    } else {

                        manifest = new Manifest();

                    }

                    addVersion(manifest);

                    addCreatedBy(manifest);

                    if (isAmbiguousMainClass(manifest)) {

                        return false;

                    }

                    if (ename != null) {

                        addMainClass(manifest, ename);

                    }

                    if (isMultiRelease) {

                        addMultiRelease(manifest);

                    }

                }

                expand();

                if (!moduleInfos.isEmpty()) {

                    // All actual file entries (excl manifest and module-info.class)

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

                    // all packages if it's a class or resource

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

                    entries.stream()

                           .filter(e -> !e.isDir)

                           .forEach( e -> {

                               addPackageIfNamed(packages, e.name);

                               jentries.add(e.name);

                    });

                    addExtendedModuleAttributes(moduleInfos, packages);

                    // Basic consistency checks for modular jars.

                    if (!checkModuleInfo(moduleInfos.get(MODULE_INFO), jentries))

                        return false;

                } else if (moduleVersion != null || modulesToHash != null) {

                    error(getMsg("error.module.options.without.info"));

                    return false;

                }

                if (vflag && fname == null) {

                    // Disable verbose output so that it does not appear

                    // on stdout along with file data

                    // error("Warning: -v option ignored");

                    vflag = false;

                }

                final String tmpbase = (fname == null)

                        ? "tmpjar"

                        : fname.substring(fname.indexOf(File.separatorChar) + 1);

                tmpFile = createTemporaryFile(tmpbase, ".jar");

                try (OutputStream out = new FileOutputStream(tmpFile)) {

                    create(new BufferedOutputStream(out, 4096), manifest);

                }

                if (nflag) {

                    if (!suppressDeprecateMsg) {

                        warn(formatMsg("warn.flag.is.deprecated", "-n"));

                    }

                    File packFile = createTemporaryFile(tmpbase, ".pack");

                    try {

                        java.util.jar.Pack200.Packer packer = java.util.jar.Pack200.newPacker();

                        Map<String, String> p = packer.properties();

                        p.put(java.util.jar.Pack200.Packer.EFFORT, "1"); // Minimal effort to conserve CPU

                        try (JarFile jarFile = new JarFile(tmpFile.getCanonicalPath());

                             OutputStream pack = new FileOutputStream(packFile))

                        {

                            packer.pack(jarFile, pack);

                        }

                        if (tmpFile.exists()) {

                            tmpFile.delete();

                        }

                        tmpFile = createTemporaryFile(tmpbase, ".jar");

                        try (OutputStream out = new FileOutputStream(tmpFile);

                             JarOutputStream jos = new JarOutputStream(out))

                        {

                            java.util.jar.Pack200.Unpacker unpacker = java.util.jar.Pack200.newUnpacker();

                            unpacker.unpack(packFile, jos);

                        }

                    } finally {

                        Files.deleteIfExists(packFile.toPath());

                    }

                }

                validateAndClose(tmpFile);

            } else if (uflag) {

                File inputFile = null;

                if (fname != null) {

                    inputFile = new File(fname);

                    tmpFile = createTempFileInSameDirectoryAs(inputFile);

                } else {

                    vflag = false;

                    tmpFile = createTemporaryFile("tmpjar", ".jar");

                }

                expand();

                try (FileInputStream in = (fname != null) ? new FileInputStream(inputFile)

                        : new FileInputStream(FileDescriptor.in);

                     FileOutputStream out = new FileOutputStream(tmpFile);

                     InputStream manifest = (!Mflag && (mname != null)) ?

                            (new FileInputStream(mname)) : null;

                ) {

                    boolean updateOk = update(in, new BufferedOutputStream(out),

                        manifest, moduleInfos, null);

                    if (ok) {

                        ok = updateOk;

                    }

                }

                validateAndClose(tmpFile);

            } else if (tflag) {

                replaceFSC(filesMap);

                // For the "list table contents" action, access using the

                // ZipFile class is always most efficient since only a

                // "one-finger" scan through the central directory is required.

                String[] files = filesMapToFiles(filesMap);

                if (fname != null) {

                    list(fname, files);

                } else {

                    InputStream in = new FileInputStream(FileDescriptor.in);

                    try {

                        list(new BufferedInputStream(in), files);

                    } finally {

                        in.close();

                    }

                }

            } else if (xflag) {

                replaceFSC(filesMap);

                // For the extract action, when extracting all the entries,

                // access using the ZipInputStream class is most efficient,

                // since only a single sequential scan through the zip file is

                // required.  When using the ZipFile class, a "two-finger" scan

                // is required, but this is likely to be more efficient when a

                // partial extract is requested.  In case the zip file has

                // "leading garbage", we fall back from the ZipInputStream

                // implementation to the ZipFile implementation, since only the

                // latter can handle it.

                String[] files = filesMapToFiles(filesMap);

                if (fname != null && files != null) {

                    extract(fname, files);

                } else {

                    InputStream in = (fname == null)

                        ? new FileInputStream(FileDescriptor.in)

                        : new FileInputStream(fname);

                    try {

                        if (!extract(new BufferedInputStream(in), files) && fname != null) {

                            extract(fname, files);

                        }

                    } finally {

                        in.close();

                    }

                }

            } else if (iflag) {

                String[] files = filesMap.get(BASE_VERSION);  // base entries only, can be null

                genIndex(rootjar, files);

            } else if (dflag) {

                boolean found;

                if (fname != null) {

                    try (ZipFile zf = new ZipFile(fname)) {

                        found = describeModule(zf);

                    }

                } else {

                    try (FileInputStream fin = new FileInputStream(FileDescriptor.in)) {

                        found = describeModuleFromStream(fin);

                    }

                }

                if (!found)

                    error(getMsg("error.module.descriptor.not.found"));

            }

        } catch (IOException e) {

            fatalError(e);

            ok = false;

        } catch (Error ee) {

            ee.printStackTrace();

            ok = false;

        } catch (Throwable t) {

            t.printStackTrace();

            ok = false;

        } finally {

            if (tmpFile != null && tmpFile.exists())

                tmpFile.delete();

        }

        out.flush();

        err.flush();

        return ok;

    }

    private void validateAndClose(File tmpfile) throws IOException {

        if (ok && isMultiRelease) {

            try (ZipFile zf = new ZipFile(tmpfile)) {

                ok = Validator.validate(this, zf);

                if (!ok) {

                    error(formatMsg("error.validator.jarfile.invalid", fname));

                }

            } catch (IOException e) {

                error(formatMsg2("error.validator.jarfile.exception", fname, e.getMessage()));

            }

        }

        Path path = tmpfile.toPath();

        try {

            if (ok) {

                if (fname != null) {

                    Files.move(path, Paths.get(fname), StandardCopyOption.REPLACE_EXISTING);

                } else {

                    Files.copy(path, new FileOutputStream(FileDescriptor.out));

                }

            }

        } finally {

            Files.deleteIfExists(path);

        }

    }

    private String[] filesMapToFiles(Map<Integer,String[]> filesMap) {

        if (filesMap.isEmpty()) return null;

        return filesMap.entrySet()

                .stream()

                .flatMap(this::filesToEntryNames)

                .toArray(String[]::new);

    }

    Stream<String> filesToEntryNames(Map.Entry<Integer,String[]> fileEntries) {

        int version = fileEntries.getKey();

        Set<String> cpaths = pathsMap.get(version);

        return Stream.of(fileEntries.getValue())

            .map(f -> toVersionedName(toEntryName(f, cpaths, false), version));

    }

    /**

     * Parses command line arguments.

     */