/*

 * 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 com.sun.tools.classfile.AccessFlags;

import com.sun.tools.classfile.ClassFile;

import com.sun.tools.classfile.ConstantPoolException;

import com.sun.tools.classfile.Dependencies;

import com.sun.tools.classfile.Dependencies.ClassFileError;

import com.sun.tools.classfile.Dependency;

import com.sun.tools.classfile.Dependency.Location;

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

import java.io.*;

import java.nio.file.DirectoryStream;

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.regex.Pattern;

/**

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

 */

class JdepsTask {

    static class BadArgs extends Exception {

        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;

    }

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

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

                task.options.help = true;

            }

        },

        new Option(true, "-dotoutput") {

            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 = 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: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: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(true, "-cp", "-classpath") {

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

                task.options.classpath = arg;

            }

        },

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

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

                task.options.packageNames.add(arg);

            }

        },

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

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

                task.options.regex = arg;

            }

        },

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

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

                task.options.filterRegex = arg;

            }

        },

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

                          "-filter:archive",

                          "-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":

                        task.options.filterSameArchive = true;

                        task.options.filterSamePackage = false;

                        break;

                    case "-filter:none":

                        task.options.filterSameArchive = false;

                        task.options.filterSamePackage = false;

                        break;

                }

            }

        },

        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;

                task.options.showModule = false;

            }

        },

        new Option(false, "-M", "-module") {

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

                task.options.showModule = true;

                task.options.showProfile = false;

            }

        },

        new Option(false, "-apionly") {

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

                task.options.apiOnly = 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, "-jdkinternals") {

            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(".*");

                }

            }

        },

            new HiddenOption(false, "-verify:access") {

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

                    task.options.verifyAccess = true;

                    task.options.verbose = VERBOSE;

                    task.options.filterSameArchive = false;

                    task.options.filterSamePackage = false;

                }

            },

            new HiddenOption(true, "-mp") {

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

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

                    if (!Files.isDirectory(task.options.mpath)) {

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

                    }

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

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

                    }

                }

            },

        new Option(false, "-version") {

            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, "-q", "-quiet") {

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

                task.options.nowarning = true;

            }

        },

        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> classes = 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 (classes.isEmpty() && options.includePattern == null) {

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

                    return EXIT_OK;

                } else {

                    showHelp();

                    return EXIT_CMDERR;

                }

            }

            if (options.regex != null && options.packageNames.size() > 0) {

                showHelp();

                return EXIT_CMDERR;

            }

            if ((options.findJDKInternals || options.verifyAccess) &&

                   (options.regex != null || options.packageNames.size() > 0 || options.showSummary)) {

                showHelp();

                return EXIT_CMDERR;

            }

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

                showHelp();

                return EXIT_CMDERR;

            }

            boolean ok = run();

            return ok ? EXIT_OK : EXIT_ERROR;

        } catch (BadArgs e) {

            reportError(e.key, e.args);

            if (e.showUsage) {

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

            }

            return EXIT_CMDERR;

        } catch (IOException e) {

            return EXIT_ABNORMAL;

        } finally {

            log.flush();

        }

    }

    private final List<Archive> sourceLocations = new ArrayList<>();

    private final List<Archive> classpaths = new ArrayList<>();

    private final List<Archive> initialArchives = new ArrayList<>();

    private boolean run() throws IOException {

        buildArchives();

        if (options.verifyAccess) {

            return verifyModuleAccess();

        } else {

            return analyzeDeps();

        }

    }

    private boolean analyzeDeps() throws IOException {

        Analyzer analyzer = new Analyzer(options.verbose, new Analyzer.Filter() {

            @Override

            public boolean accepts(Location origin, Archive originArchive,

                                   Location target, Archive targetArchive)

            {

                if (options.findJDKInternals) {

                    // accepts target that is JDK class but not exported

                    return isJDKModule(targetArchive) &&

                              !((Module) targetArchive).isExported(target.getClassName());

                } else if (options.filterSameArchive) {

                    // accepts origin and target that from different archive

                    return originArchive != targetArchive;

                }

                return true;

            }

        });

        // parse classfiles and find all dependencies

        findDependencies(options.apiOnly);

        // analyze the dependencies

        analyzer.run(sourceLocations);

        // output result

        if (options.dotOutputDir != null) {

            Path dir = Paths.get(options.dotOutputDir);

            Files.createDirectories(dir);

            generateDotFiles(dir, analyzer);

        } else {

            printRawOutput(log, analyzer);

        }

        if (options.findJDKInternals && !options.nowarning) {

            showReplacements(analyzer);

        }

        return true;

    }

    private boolean verifyModuleAccess() throws IOException {

        // two passes

        // 1. check API dependences where the types of dependences must be re-exported

        // 2. check all dependences where types must be accessible

        // pass 1

        findDependencies(true /* api only */);

        Analyzer analyzer = Analyzer.getExportedAPIsAnalyzer();

        boolean pass1 = analyzer.run(sourceLocations);

        if (!pass1) {

            System.out.println("ERROR: Failed API access verification");

        }

        // pass 2

        findDependencies(false);

        analyzer =  Analyzer.getModuleAccessAnalyzer();

        boolean pass2 = analyzer.run(sourceLocations);

        if (!pass2) {

            System.out.println("ERROR: Failed module access verification");

        }

        if (pass1 & pass2) {

            System.out.println("Access verification succeeded.");

        }

        return pass1 & pass2;

    }

    private void generateSummaryDotFile(Path dir, Analyzer analyzer) throws IOException {

        // If verbose mode (-v or -verbose option),

        // the summary.dot file shows package-level dependencies.

        Analyzer.Type summaryType =

            (options.verbose == PACKAGE || options.verbose == SUMMARY) ? SUMMARY : PACKAGE;

        Path summary = dir.resolve("summary.dot");

        try (PrintWriter sw = new PrintWriter(Files.newOutputStream(summary));

             SummaryDotFile dotfile = new SummaryDotFile(sw, summaryType)) {

            for (Archive archive : sourceLocations) {

                if (!archive.isEmpty()) {

                    if (options.verbose == PACKAGE || options.verbose == SUMMARY) {

                        if (options.showLabel) {

                            // build labels listing package-level dependencies

                            analyzer.visitDependences(archive, dotfile.labelBuilder(), PACKAGE);

                        }

                    }

                    analyzer.visitDependences(archive, dotfile, summaryType);

                }

            }

        }

    }

    private void generateDotFiles(Path dir, Analyzer analyzer) throws IOException {

        // output individual .dot file for each archive

        if (options.verbose != SUMMARY) {

            for (Archive archive : sourceLocations) {

                if (analyzer.hasDependences(archive)) {

                    Path dotfile = dir.resolve(archive.getName() + ".dot");

                    try (PrintWriter pw = new PrintWriter(Files.newOutputStream(dotfile));

                         DotFileFormatter formatter = new DotFileFormatter(pw, archive)) {

                        analyzer.visitDependences(archive, formatter);

                    }

                }

            }

        }

        // generate summary dot file

        generateSummaryDotFile(dir, analyzer);

    }

    private void printRawOutput(PrintWriter writer, Analyzer analyzer) {

        RawOutputFormatter depFormatter = new RawOutputFormatter(writer);

        RawSummaryFormatter summaryFormatter = new RawSummaryFormatter(writer);

        for (Archive archive : sourceLocations) {

            if (!archive.isEmpty()) {

                analyzer.visitDependences(archive, summaryFormatter, SUMMARY);

                if (analyzer.hasDependences(archive) && options.verbose != SUMMARY) {

                    analyzer.visitDependences(archive, depFormatter);

                }

            }

        }

    }

    private boolean isValidClassName(String name) {

        if (!Character.isJavaIdentifierStart(name.charAt(0))) {

            return false;

        }

        for (int i=1; i < name.length(); i++) {

            char c = name.charAt(i);

            if (c != '.'  && !Character.isJavaIdentifierPart(c)) {

                return false;

            }

        }

        return true;

    }

    /*

     * Dep Filter configured based on the input jdeps option

     * 1. -p and -regex to match target dependencies

     * 2. -filter:package to filter out same-package dependencies

     *

     * This filter is applied when jdeps parses the class files

     * and filtered dependencies are not stored in the Analyzer.

     *

     * -filter:archive is applied later in the Analyzer as the

     * containing archive of a target class may not be known until

     * the entire archive

     */

    class DependencyFilter implements Dependency.Filter {

        final Dependency.Filter filter;

        final Pattern filterPattern;

        DependencyFilter() {