/*

 * Copyright (c) 2012, 2014, 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 com.sun.tools.jdeps;

import static com.sun.tools.jdeps.Analyzer.Type.*;

import static com.sun.tools.jdeps.JdepsWriter.*;

import java.io.IOException;

import java.io.PrintWriter;

import java.lang.module.ResolutionException;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.text.MessageFormat;

import java.util.*;

import java.util.jar.JarFile;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.Stream;

/**

 * Implementation for the jdeps tool for static class dependency analysis.

 */

class JdepsTask {

    static interface BadArguments {

        String getKey();

        Object[] getArgs();

        boolean showUsage();

    }

    static class BadArgs extends Exception implements BadArguments {

        static final long serialVersionUID = 8765093759964640721L;

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

            super(JdepsTask.getMessage(key, args));

            this.key = key;

            this.args = args;

        }

        BadArgs showUsage(boolean b) {

            showUsage = b;

            return this;

        }

        final String key;

        final Object[] args;

        boolean showUsage;

        @Override

        public String getKey() {

            return key;

        }

        @Override

        public Object[] getArgs() {

            return args;

        }

        @Override

        public boolean showUsage() {

            return showUsage;

        }

    }

    static class UncheckedBadArgs extends RuntimeException implements BadArguments {

        static final long serialVersionUID = -1L;

        final BadArgs cause;

        UncheckedBadArgs(BadArgs cause) {

            super(cause);

            this.cause = cause;

        }

        @Override

        public String getKey() {

            return cause.key;

        }

        @Override

        public Object[] getArgs() {

            return cause.args;

        }

        @Override

        public boolean showUsage() {

            return cause.showUsage;

        }

    }

    static abstract class Option {

        Option(boolean hasArg, String... aliases) {

            this.hasArg = hasArg;

            this.aliases = aliases;

        }

        boolean isHidden() {

            return false;

        }

        boolean matches(String opt) {

            for (String a : aliases) {

                if (a.equals(opt))

                    return true;

                if (hasArg && opt.startsWith(a + "="))

                    return true;

            }

            return false;

        }

        boolean ignoreRest() {

            return false;

        }

        abstract void process(JdepsTask task, String opt, String arg) throws BadArgs;

        final boolean hasArg;

        final String[] aliases;

    }

    static abstract class HiddenOption extends Option {

        HiddenOption(boolean hasArg, String... aliases) {

            super(hasArg, aliases);

        }

        boolean isHidden() {

            return true;

        }

    }

    static Option[] recognizedOptions = {

        new Option(false, "-h", "-?", "-help", "--help") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.help = true;

            }

        },

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                Path p = Paths.get(arg);

                if (Files.exists(p) && (!Files.isDirectory(p) || !Files.isWritable(p))) {

                    throw new BadArgs("err.invalid.path", arg);

                }

                task.options.dotOutputDir = Paths.get(arg);;

            }

        },

        new Option(false, "-s", "-summary") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.showSummary = true;

                task.options.verbose = SUMMARY;

            }

        },

        new Option(false, "-v", "-verbose",

                                "-verbose:module",

                                "-verbose:package",

                                "-verbose:class") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                switch (opt) {

                    case "-v":

                    case "-verbose":

                        task.options.verbose = VERBOSE;

                        task.options.filterSameArchive = false;

                        task.options.filterSamePackage = false;

                        break;

                    case "-verbose:module":

                        task.options.verbose = MODULE;

                        break;

                    case "-verbose:package":

                        task.options.verbose = PACKAGE;

                        break;

                    case "-verbose:class":

                        task.options.verbose = CLASS;

                        break;

                    default:

                        throw new BadArgs("err.invalid.arg.for.option", opt);

                }

            }

        },

            void process(JdepsTask task, String opt, String arg) {

                task.options.apiOnly = true;

            }

        },

        new Option(true, "--check") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                Set<String> mods =  Set.of(arg.split(","));

                task.options.checkModuleDeps = mods;

                task.options.addmods.addAll(mods);

            }

        },

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                Path p = Paths.get(arg);

                if (Files.exists(p) && (!Files.isDirectory(p) || !Files.isWritable(p))) {

                    throw new BadArgs("err.invalid.path", arg);

                }

                task.options.genModuleInfo = Paths.get(arg);

            }

        },

            void process(JdepsTask task, String opt, String arg) {

                task.options.findJDKInternals = true;

                task.options.verbose = CLASS;

                if (task.options.includePattern == null) {

                    task.options.includePattern = Pattern.compile(".*");

                }

            }

        },

        // ---- paths option ----

        new Option(true, "-cp", "-classpath", "--class-path") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.classpath = arg;

            }

        },

        new Option(true, "--module-path") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                task.options.modulePath = arg;

            }

        },

        new Option(true, "--upgrade-module-path") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                task.options.upgradeModulePath = arg;

            }

        },

        new Option(true, "--system") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

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

                    task.options.systemModulePath = null;

                } else {

                    Path path = Paths.get(arg);

                    if (Files.isRegularFile(path.resolve("lib").resolve("modules")))

                        task.options.systemModulePath = arg;

                    else

                        throw new BadArgs("err.invalid.path", arg);

                }

            }

        },

        new Option(true, "--add-modules") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                Set<String> mods = Set.of(arg.split(","));

                task.options.addmods.addAll(mods);

            }

        },

        new Option(true, "-m", "--module") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                task.options.rootModule = arg;

                task.options.addmods.add(arg);

            }

        },

        // ---- Target filtering options ----

            void process(JdepsTask task, String opt, String arg) {

                task.options.packageNames.add(arg);

            }

        },

            void process(JdepsTask task, String opt, String arg) {

                task.options.regex = Pattern.compile(arg);

            }

        },

            void process(JdepsTask task, String opt, String arg) {

                task.options.requires.add(arg);

            }

        },

        new Option(true, "-f", "-filter") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.filterRegex = Pattern.compile(arg);

            }

        },

        new Option(false, "-filter:package",

                          "-filter:archive", "-filter:module",

                          "-filter:none") {

            void process(JdepsTask task, String opt, String arg) {

                switch (opt) {

                    case "-filter:package":

                        task.options.filterSamePackage = true;

                        task.options.filterSameArchive = false;

                        break;

                    case "-filter:archive":

                    case "-filter:module":

                        task.options.filterSameArchive = true;

                        task.options.filterSamePackage = false;

                        break;

                    case "-filter:none":

                        task.options.filterSameArchive = false;

                        task.options.filterSamePackage = false;

                        break;

                }

            }

        },

        // ---- Source filtering options ----

        new Option(true, "-include") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                task.options.includePattern = Pattern.compile(arg);

            }

        },

        // Another alternative to list modules in --add-modules option

        new HiddenOption(true, "--include-system-modules") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                task.options.includeSystemModulePattern = Pattern.compile(arg);

            }

        },

        new Option(false, "-P", "-profile") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                task.options.showProfile = true;

            }

        },

        new Option(false, "-R", "-recursive") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.depth = 0;

                // turn off filtering

                task.options.filterSameArchive = false;

                task.options.filterSamePackage = false;

            }

        },

            void process(JdepsTask task, String opt, String arg) {

                task.options.inverse = true;

                // equivalent to the inverse of compile-time view analysis

                task.options.compileTimeView = true;

                task.options.filterSamePackage = true;

                task.options.filterSameArchive = true;

            }

        },

        new Option(false, "--compile-time") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.compileTimeView = true;

                task.options.filterSamePackage = true;

                task.options.filterSameArchive = true;

                task.options.depth = 0;

            }

        },

        new Option(false, "-q", "-quiet") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.nowarning = true;

            }

        },

            void process(JdepsTask task, String opt, String arg) {

                task.options.version = true;

            }

        },

        new HiddenOption(false, "-fullversion") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.fullVersion = true;

            }

        },

        new HiddenOption(false, "-showlabel") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.showLabel = true;

            }

        },

        new HiddenOption(false, "--hide-show-module") {

            void process(JdepsTask task, String opt, String arg) {

                task.options.showModule = false;

            }

        },

        new HiddenOption(true, "-depth") {

            void process(JdepsTask task, String opt, String arg) throws BadArgs {

                try {

                    task.options.depth = Integer.parseInt(arg);

                } catch (NumberFormatException e) {

                    throw new BadArgs("err.invalid.arg.for.option", opt);

                }

            }

        },

    };

    private static final String PROGNAME = "jdeps";

    private final Options options = new Options();

    private final List<String> inputArgs = new ArrayList<>();

    private PrintWriter log;

    void setLog(PrintWriter out) {

        log = 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

    int run(String... args) {

        if (log == null) {

            log = new PrintWriter(System.out);

        }

        try {

            handleOptions(args);

            if (options.help) {

                showHelp();

            }

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

                showVersion(options.fullVersion);

            }

            if (!inputArgs.isEmpty() && options.rootModule != null) {

                reportError("err.invalid.arg.for.option", "-m");

            }

            if (inputArgs.isEmpty() && options.addmods.isEmpty() && options.includePattern == null

                    && options.includeSystemModulePattern == null && options.checkModuleDeps == null) {

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

                    return EXIT_OK;

                } else {

                    showHelp();

                    return EXIT_CMDERR;

                }

            }

            if (options.genModuleInfo != null) {

                if (options.dotOutputDir != null || options.classpath != null || options.hasFilter()) {

                    showHelp();

                    return EXIT_CMDERR;

                }

            }

            if (options.numFilters() > 1) {

                reportError("err.invalid.filters");

                return EXIT_CMDERR;

            }

            if (options.inverse && options.depth != 1) {

                reportError("err.invalid.inverse.option", "-R");

                return EXIT_CMDERR;

            }

            if (options.inverse && options.numFilters() == 0) {

                reportError("err.invalid.filters");

                return EXIT_CMDERR;

            }

            if ((options.findJDKInternals) && (options.hasFilter() || options.showSummary)) {

                showHelp();

                return EXIT_CMDERR;

            }

            if (options.showSummary && options.verbose != SUMMARY) {

                showHelp();

                return EXIT_CMDERR;

            }

            if (options.checkModuleDeps != null && !inputArgs.isEmpty()) {

                reportError("err.invalid.module.option", inputArgs, "--check");

            }

            boolean ok = run();

            return ok ? EXIT_OK : EXIT_ERROR;

        } catch (BadArgs|UncheckedBadArgs e) {

            reportError(e.getKey(), e.getArgs());

            if (e.showUsage()) {

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

            }

            return EXIT_CMDERR;

        } catch (ResolutionException e) {