/*

 * Copyright (c) 2013, 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.

 *

 * 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 toolbox;

import java.io.BufferedInputStream;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.io.IOError;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URI;

import java.nio.file.FileVisitResult;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.SimpleFileVisitor;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.EnumSet;

import java.util.HashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.ListIterator;

import java.util.Map;

import java.util.Set;

import java.util.jar.Attributes;

import java.util.jar.JarEntry;

import java.util.jar.JarOutputStream;

import java.util.jar.Manifest;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import javax.tools.FileObject;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import static toolbox.ToolBox.currDir;

/**

 * A task to configure and run the jar file utility.

 */

public class JarTask extends AbstractTask<JarTask> {

    private Path jar;

    private Manifest manifest;

    private String classpath;

    private String mainClass;

    private Path baseDir;

    private List<Path> paths;

    private Set<FileObject> fileObjects;

    /**

     * Creates a task to write jar files, using API mode.

     * @param toolBox the {@code ToolBox} to use

     */

    public JarTask(ToolBox toolBox) {

        super(toolBox, Task.Mode.API);

        paths = Collections.emptyList();

        fileObjects = new LinkedHashSet<>();

    }

    /**

     * Creates a JarTask for use with a given jar file.

     * @param toolBox the {@code ToolBox} to use

     * @param path the file

     */

    public JarTask(ToolBox toolBox, String path) {

        this(toolBox);

        jar = Paths.get(path);

    }

    /**

     * Creates a JarTask for use with a given jar file.

     * @param toolBox the {@code ToolBox} to use

     * @param path the file

     */

    public JarTask(ToolBox toolBox, Path path) {

        this(toolBox);

        jar = path;

    }

    /**

     * Sets a manifest for the jar file.

     * @param manifest the manifest

     * @return this task object

     */

    public JarTask manifest(Manifest manifest) {

        this.manifest = manifest;

        return this;

    }

    /**

     * Sets a manifest for the jar file.

     * @param manifest a string containing the contents of the manifest

     * @return this task object

     * @throws IOException if there is a problem creating the manifest

     */

    public JarTask manifest(String manifest) throws IOException {

        this.manifest = new Manifest(new ByteArrayInputStream(manifest.getBytes()));

        return this;

    }

    /**

     * Sets the classpath to be written to the {@code Class-Path}

     * entry in the manifest.

     * @param classpath the classpath

     * @return this task object

     */

    public JarTask classpath(String classpath) {

        this.classpath = classpath;

        return this;

    }

    /**

     * Sets the class to be written to the {@code Main-Class}

     * entry in the manifest..

     * @param mainClass the name of the main class

     * @return this task object

     */

    public JarTask mainClass(String mainClass) {

        this.mainClass = mainClass;

        return this;

    }

    /**

     * Sets the base directory for files to be written into the jar file.

     * @param baseDir the base directory

     * @return this task object

     */

    public JarTask baseDir(String baseDir) {

        this.baseDir = Paths.get(baseDir);

        return this;

    }

    /**

     * Sets the base directory for files to be written into the jar file.

     * @param baseDir the base directory

     * @return this task object

     */

    public JarTask baseDir(Path baseDir) {

        this.baseDir = baseDir;

        return this;

    }

    /**

     * Sets the files to be written into the jar file.

     * @param files the files

     * @return this task object

     */

    public JarTask files(String... files) {

        this.paths = Stream.of(files)

                .map(file -> Paths.get(file))

                .collect(Collectors.toList());

        return this;

    }

    /**

     * Adds a set of file objects to be written into the jar file, by copying them

     * from a Location in a JavaFileManager.

     * The file objects to be written are specified by a series of paths;

     * each path can be in one of the following forms:

     * <ul>

     * <li>The name of a class. For example, java.lang.Object.

     * In this case, the corresponding .class file will be written to the jar file.

     * <li>the name of a package followed by {@code .*}. For example, {@code java.lang.*}.

     * In this case, all the class files in the specified package will be written to

     * the jar file.

     * <li>the name of a package followed by {@code .**}. For example, {@code java.lang.**}.

     * In this case, all the class files in the specified package, and any subpackages

     * will be written to the jar file.

     * </ul>

     *

     * @param fm the file manager in which to find the file objects

     * @param l  the location in which to find the file objects

     * @param paths the paths specifying the file objects to be copied

     * @return this task object

     * @throws IOException if errors occur while determining the set of file objects

     */

    public JarTask files(JavaFileManager fm, JavaFileManager.Location l, String... paths)

            throws IOException {

        for (String p : paths) {

            if (p.endsWith(".**"))

                addPackage(fm, l, p.substring(0, p.length() - 3), true);

            else if (p.endsWith(".*"))

                addPackage(fm, l, p.substring(0, p.length() - 2), false);

            else

                addFile(fm, l, p);

        }

        return this;

    }

    private void addPackage(JavaFileManager fm, JavaFileManager.Location l, String pkg, boolean recurse)

            throws IOException {

        for (JavaFileObject fo : fm.list(l, pkg, EnumSet.allOf(JavaFileObject.Kind.class), recurse)) {

            fileObjects.add(fo);

        }

    }

    private void addFile(JavaFileManager fm, JavaFileManager.Location l, String path) throws IOException {

        JavaFileObject fo = fm.getJavaFileForInput(l, path, JavaFileObject.Kind.CLASS);

        fileObjects.add(fo);

    }

    /**

     * Provides limited jar command-like functionality.

     * The supported commands are:

     * <ul>

     * <li> jar cf jarfile -C dir files...

     * <li> jar cfm jarfile manifestfile -C dir files...

     * </ul>

     * Any values specified by other configuration methods will be ignored.

     * @param args arguments in the style of those for the jar command

     * @return a Result object containing the results of running the task

     */

    public Task.Result run(String... args) {

        if (args.length < 2)

            throw new IllegalArgumentException();

        ListIterator<String> iter = Arrays.asList(args).listIterator();

        String first = iter.next();

        switch (first) {

            case "cf":

                jar = Paths.get(iter.next());

                break;

            case "cfm":

                jar = Paths.get(iter.next());

                try (InputStream in = Files.newInputStream(Paths.get(iter.next()))) {

                    manifest = new Manifest(in);

                } catch (IOException e) {

                    throw new IOError(e);

                }

                break;

        }

        if (iter.hasNext()) {

            if (iter.next().equals("-C"))

                baseDir = Paths.get(iter.next());

            else

                iter.previous();

        }

        paths = new ArrayList<>();

        while (iter.hasNext())

            paths.add(Paths.get(iter.next()));

        return run();

    }

    /**

     * {@inheritDoc}

     * @return the name "jar"

     */

    @Override

    public String name() {

        return "jar";

    }

    /**

     * Creates a jar file with the arguments as currently configured.

     * @return a Result object indicating the outcome of the compilation

     * and the content of any output written to stdout, stderr, or the

     * main stream by the compiler.

     * @throws TaskError if the outcome of the task is not as expected.

     */

    @Override

    public Task.Result run() {

        Manifest m = (manifest == null) ? new Manifest() : manifest;

        Attributes mainAttrs = m.getMainAttributes();

        if (mainClass != null)

            mainAttrs.put(Attributes.Name.MAIN_CLASS, mainClass);

        if (classpath != null)

            mainAttrs.put(Attributes.Name.CLASS_PATH, classpath);

        AbstractTask.StreamOutput sysOut = new AbstractTask.StreamOutput(System.out, System::setOut);

        AbstractTask.StreamOutput sysErr = new AbstractTask.StreamOutput(System.err, System::setErr);

        Map<Task.OutputKind, String> outputMap = new HashMap<>();

        try (OutputStream os = Files.newOutputStream(jar);

                JarOutputStream jos = openJar(os, m)) {

            writeFiles(jos);

            writeFileObjects(jos);

        } catch (IOException e) {

            error("Exception while opening " + jar, e);

        } finally {

            outputMap.put(Task.OutputKind.STDOUT, sysOut.close());

            outputMap.put(Task.OutputKind.STDERR, sysErr.close());

        }

        return checkExit(new Task.Result(toolBox, this, (errors == 0) ? 0 : 1, outputMap));

    }

    private JarOutputStream openJar(OutputStream os, Manifest m) throws IOException {

        if (m == null || m.getMainAttributes().isEmpty() && m.getEntries().isEmpty()) {

            return new JarOutputStream(os);

        } else {

            if (m.getMainAttributes().get(Attributes.Name.MANIFEST_VERSION) == null)

                m.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");

            return new JarOutputStream(os, m);

        }

    }

    private void writeFiles(JarOutputStream jos) throws IOException {

            Path base = (baseDir == null) ? currDir : baseDir;

            for (Path path : paths) {

                Files.walkFileTree(base.resolve(path), new SimpleFileVisitor<Path>() {

                    @Override

                    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {

                        try {

                        String p = base.relativize(file)

                                .normalize()

                                .toString()

                                .replace(File.separatorChar, '/');

                        JarEntry e = new JarEntry(p);

                            jos.putNextEntry(e);

                        try {

                            jos.write(Files.readAllBytes(file));

                        } finally {

                            jos.closeEntry();

                        }

                            return FileVisitResult.CONTINUE;

                        } catch (IOException e) {

                        error("Exception while adding " + file + " to jar file", e);

                            return FileVisitResult.TERMINATE;

                        }

                    }

                });

            }

    }

    private void writeFileObjects(JarOutputStream jos) throws IOException {

        for (FileObject fo : fileObjects) {

            String p = guessPath(fo);

            JarEntry e = new JarEntry(p);

            jos.putNextEntry(e);

            try {

                byte[] buf = new byte[1024];

                try (BufferedInputStream in = new BufferedInputStream(fo.openInputStream())) {

                    int n;

                    while ((n = in.read(buf)) > 0)

                        jos.write(buf, 0, n);

                } catch (IOException ex) {

                    error("Exception while adding " + fo.getName() + " to jar file", ex);

                }

        } finally {

                jos.closeEntry();

        }

        }

    }

    /*

     * A jar: URL is of the form  jar:URL!/<entry>  where URL is a URL for the .jar file itself.

     * In Symbol files (i.e. ct.sym) the underlying entry is prefixed META-INF/sym/<base>.

     */

    private final Pattern jarEntry = Pattern.compile(".*!/(?:META-INF/sym/[^/]+/)?(.*)");

    /*

     * A jrt: URL is of the form  jrt:/modules/<module>/<package>/<file>

     */

    private final Pattern jrtEntry = Pattern.compile("/modules/([^/]+)/(.*)");

    /*

     * A file: URL is of the form  file:/path/to/{modules,patches}/<module>/<package>/<file>

     */

    private final Pattern fileEntry = Pattern.compile(".*/(?:modules|patches)/([^/]+)/(.*)");

    private String guessPath(FileObject fo) {

        URI u = fo.toUri();

        switch (u.getScheme()) {

            case "jar": {

                Matcher m = jarEntry.matcher(u.getSchemeSpecificPart());

                if (m.matches()) {

                    return m.group(1);

                }

                break;

            }

            case "jrt": {

                Matcher m = jrtEntry.matcher(u.getSchemeSpecificPart());

                if (m.matches()) {

                    return m.group(2);

                }

                break;

            }

            case "file": {

                Matcher m = fileEntry.matcher(u.getSchemeSpecificPart());

                if (m.matches()) {

                    return m.group(2);

                }

                break;

            }

        }

        throw new IllegalArgumentException(fo.getName() + "--" + fo.toUri());

    }

    private void error(String message, Throwable t) {

        toolBox.out.println("Error: " + message + ": " + t);

        errors++;

    }

    private int errors;

}