/*

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

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

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

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

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

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;

/**

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

        }

        Option(boolean hasArg, CommandOption cmd) {

            this(hasArg, cmd.names());

        }

        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;

        }

    }

    enum CommandOption {

        ANALYZE_DEPS(""),

        GENERATE_DOT_FILE("-dotoutput", "--dot-output"),

        GENERATE_MODULE_INFO("--generate-module-info"),

        GENERATE_OPEN_MODULE("--generate-open-module"),

        LIST_DEPS("--list-deps"),

        LIST_REDUCED_DEPS("--list-reduced-deps"),

        PRINT_MODULE_DEPS("--print-module-deps"),

        CHECK_MODULES("--check");

        private final String[] names;

        CommandOption(String... names) {

            this.names = names;

        }

        String[] names() {

            return names;

        }

        @Override

        public String toString() {

            return names[0];

        }

    }

    static Option[] recognizedOptions = {

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

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

                task.options.help = true;

            }

        },

        new Option(true, CommandOption.GENERATE_DOT_FILE) {

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

                if (task.command != null) {

                    throw new BadArgs("err.command.set", task.command, opt);

                }

                task.command = task.genDotFile(Paths.get(arg));

            }

        },

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

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

                task.options.showSummary = true;

            }

        },

        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);

                }

            }

        },

        new Option(false, "-apionly", "--api-only") {

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

                task.options.apiOnly = true;

            }

        },

        new Option(false, "-jdkinternals", "--jdk-internals") {

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

                task.options.findJDKInternals = true;

                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, "--multi-release") {

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

                if (arg.equalsIgnoreCase("base")) {

                    task.options.multiRelease = JarFile.baseVersion();

                } else {

                    try {

                        int v = Integer.parseInt(arg);

                        if (v < 9) {

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

                        }

                    } catch (NumberFormatException x) {

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

                    }

                    task.options.multiRelease = Runtime.Version.parse(arg);

                }

            }

        },

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

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

                task.options.nowarning = true;

            }

        },

        new Option(false, "-version", "--version") {

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

                task.options.version = true;

            }

        },

        // ---- module-specific options ----

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

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

                if (!task.options.rootModules.isEmpty()) {

                    throw new BadArgs("err.option.already.specified", opt);

                }

                task.options.rootModules.add(arg);

                task.options.addmods.add(arg);

            }

        },

        new Option(true, CommandOption.GENERATE_MODULE_INFO) {

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

                if (task.command != null) {

                    throw new BadArgs("err.command.set", task.command, opt);

                }

                task.command = task.genModuleInfo(Paths.get(arg), false);

            }

        },

        new Option(true, CommandOption.GENERATE_OPEN_MODULE) {

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

                if (task.command != null) {

                    throw new BadArgs("err.command.set", task.command, opt);

                }

                task.command = task.genModuleInfo(Paths.get(arg), true);

            }

        },

        new Option(true, CommandOption.CHECK_MODULES) {

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

                if (task.command != null) {

                    throw new BadArgs("err.command.set", task.command, opt);

                }

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

                task.options.addmods.addAll(mods);

                task.command = task.checkModuleDeps(mods);

            }

        },

        new Option(false, CommandOption.LIST_DEPS) {

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

                if (task.command != null) {

                    throw new BadArgs("err.command.set", task.command, opt);

                }

                task.command = task.listModuleDeps(CommandOption.LIST_DEPS);

            }

        },

        new Option(false, CommandOption.LIST_REDUCED_DEPS) {

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

                if (task.command != null) {

                    throw new BadArgs("err.command.set", task.command, opt);

                }

                task.command = task.listModuleDeps(CommandOption.LIST_REDUCED_DEPS);

            }

        },

        new Option(false, CommandOption.PRINT_MODULE_DEPS) {

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

                if (task.command != null) {

                    throw new BadArgs("err.command.set", task.command, opt);

                }

                task.command = task.listModuleDeps(CommandOption.PRINT_MODULE_DEPS);

            }

        },

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

        new Option(true, "-p", "-package", "--package") {

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

                task.options.packageNames.add(arg);

            }

        },

        new Option(true, "-e", "-regex", "--regex") {

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

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

            }

        },

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

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

                task.options.requires.add(arg);

                task.options.addmods.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);

            }

        },

        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;

            }

        },

        new Option(false, "-I", "--inverse") {

            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 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 Command command;

    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);