/* 

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright (C) 1997-2016 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

package org.netbeans.lib.callgraph;

import org.netbeans.lib.callgraph.Arguments.InvalidArgumentsException;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_CLASSGRAPH;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_DISABLE_EIGHT_BIT_STRINGS;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_EXCLUDE;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_MAVEN;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_METHODGRAPH;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_NOSELF;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_OMIT_ABSTRACT;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_PACKAGEGRAPH;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_QUIET;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_REVERSE;

import static org.netbeans.lib.callgraph.CallgraphControl.CMD_SIMPLE;

import org.netbeans.lib.callgraph.io.JavaFilesIterator;

import org.netbeans.lib.callgraph.javac.JavacRunner;

import org.netbeans.lib.callgraph.javac.SourceElement;

import org.netbeans.lib.callgraph.javac.SourcesInfo;

import org.netbeans.lib.callgraph.util.MergeIterator;

import java.io.File;

import java.io.IOException;

import java.io.PrintStream;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Set;

import java.util.concurrent.atomic.AtomicReference;

import java.util.function.Consumer;

/**

 * Scans a source folder and runs javac against any Java sources present, and

 * builds graphs of what calls what within those. The library classpath does not

 * need to be set, and the folders do not need to be package roots - we are

 * instructing javac to treat errors as non-fatal. The available sources will be

 * attributed.

 *

 * @author Tim Boudreau

 */

public final class Callgraph {

    private boolean noself;

    private boolean maven;

    private boolean quiet;

    private boolean simple;

    private final Set<String> excludes = new HashSet<>();

    private final Set<File> folders = new HashSet<>();

    private File classgraphFile;

    private File methodgraphFile;

    private File packagegraphFile;

    private Listener listener;

    private boolean omitAbstract;

    private boolean useJavaStrings;

    private boolean reverse;

    private Callgraph() {

    }

    /**

     * Configure a Callgraph to build.

     *

     * @return A call graph to configure

     */

    public static Callgraph configure() {

        return new Callgraph();

    }

    public static void main(String[] args) throws IOException {

        CallgraphControl arguments = null;

        try {

            arguments = new Arguments(args);

        } catch (InvalidArgumentsException ex) {

            // this will be a help message describing usage and the invalid

            // arguments

            System.err.println(ex.getMessage());

            System.exit(1);

        }

        assert arguments != null;

        invoke(arguments, arguments.isVerbose() ? new LoggingListener() : null);

    }

    /**

     * Run javac and produce output.

     *

     * @param arguments The parsed arguments

     * @return The list of all methods found, sorted by qname

     * @throws IOException If i/o fails

     */

    static List<SourceElement> invoke(CallgraphControl arguments, Listener listener) throws IOException {

        SourcesInfo info = new SourcesInfo(arguments.isDisableEightBitStrings(), arguments.isAggressive());

        // Build an iterable of all Java sources (without collecting them all ahead of time)

        List<Iterable<File>> iterables = new LinkedList<>();

        for (File folder : arguments) {

            iterables.add(JavaFilesIterator.iterable(folder));

        }

        // The thing that will run javac

        JavacRunner runner = new JavacRunner(info, MergeIterator.toIterable(iterables), listener);

        AtomicReference<File> lastFile = new AtomicReference<>();

        Consumer<File> monitor = lastFile::set;

        // run javac

        Set<SourceElement> allElements = runner.go(monitor, lastFile);

        List<SourceElement> all = new ArrayList<>(allElements);

        // Sort, so textual output is more human-friendly

        Collections.sort(all);

        // Now write files and print output

        if (!all.isEmpty()) {

            PrintStream outStream = createPrintStreamIfNotNull(arguments.methodGraphFile());

            PrintStream packageStream = createPrintStreamIfNotNull(arguments.packageGraphFile());

            PrintStream classStream = createPrintStreamIfNotNull(arguments.classGraphFile());

            // duplicate avoidance

            Set<CharSequence> emittedPackageLines = new HashSet<>();

            Set<CharSequence> emittedClassLines = new HashSet<>();

            List<Object> clazz = new ArrayList<>(5);

            CharSequence lastClass = null;

            List<Object> pkg = new ArrayList<>(5);

            CharSequence lastPackage = null;

            try {

                // Iterate every method

                outer:

                for (SourceElement sce : all) {

                    if (arguments.isExcluded(sce.qname().toString())) { // Ignore matches

                        continue;

                    }

                    List<SourceElement> outbounds = new ArrayList<>(arguments.isReverse() ? sce.getInboundReferences() : sce.getOutboundReferences());

                    Collections.sort(outbounds); // also sort connections

                    // Iterate the current method's connections

                    List<Object> mth = new ArrayList<>(5);

                    CharSequence currClazz = arguments.isShortNames() ? sce.typeName() : info.strings.concat(sce.packageName(), info.strings.DOT, sce.typeName());

                    if (!currClazz.equals(lastClass)) {

                        if (classStream != null) {

                            writeLine(clazz, info, emittedClassLines, classStream);

                        }

                        clazz.clear();

                        lastClass = currClazz;

                    }

                    if (clazz.isEmpty()) {

                        clazz.add(currClazz);

                        if (arguments.isExtendedProperties()) {

                            clazz.add(sce.isAbstract());

                        }

                    }

                    CharSequence currPkg = sce.packageName();

                    if (pkg.isEmpty()) {

                        pkg.add(currPkg);

                    }

                    if (!currPkg.equals(lastPackage)) {

                        if (packageStream != null) {

                            writeLine(pkg, info, emittedPackageLines, packageStream);

                        }

                        lastPackage = currPkg;

                        pkg.clear();

                    }

                    for (SourceElement outbound : outbounds) {

                        if (arguments.isExcluded(outbound.qname().toString())) { // Ignore matches

                            continue;

                        }

                        // If we are ignoring abstract methods, do that - has no effect on classes

                        if (arguments.isOmitAbstract() && (outbound.isAbstract() | sce.isAbstract())) {

                            continue;

                        }

                        // If the argument is set, ignore cases where it's a class' method

                        // referencing another method on that class

                        if (!arguments.isSelfReferences() && sce.typeName().equals(outbound.typeName())) {

                            continue;

                        }

                        if (outStream != null || !arguments.isQuiet()) {

                            if (arguments.isShortNames()) {

                                mth.add(outbound.shortName());

                            } else {

                                mth.add(outbound.qname());

                            }

                            if (arguments.isExtendedProperties()) {

                                mth.add(outbound.isAbstract());

                            }

                        }

                        // Build the package graph output if necessary

                        if (packageStream != null) {

                            if (!outbound.packageName().equals(currPkg) || arguments.isSelfReferences()) {

                                pkg.add(outbound.packageName());

                            }

                        }

                        // Build the class graph output if necessary

                        if (classStream != null) {

                            CharSequence type1 = sce.typeName();

                            CharSequence type2 = outbound.typeName();

                            if (!arguments.isShortNames()) {

//                                type1 = info.strings.concat(sce.packageName(), info.strings.DOT, type1);

                                type2 = info.strings.concat(outbound.packageName(), info.strings.DOT, type2);

                            }

                            if (!type1.equals(type2) && !clazz.contains(type2)) {

                                clazz.add(type2);

                                if (arguments.isExtendedProperties()) {

                                    clazz.add(outbound.isAbstract());

                                }

                            }

                        }

                    }

                    if (!arguments.isQuiet() || outStream != null) {

                        if (!mth.isEmpty()) {

                            CharSequence nm = arguments.isShortNames() ? sce.shortName() : sce.qname();

                            List<Object> l = mth;

                            if (arguments.isExtendedProperties()) {

                                mth.add(0, sce.isAbstract());

                            }

                            l.add(0, nm);

                            CharSequence line = info.strings.concatQuoted(l);

                            if (!arguments.isQuiet()) {

                                System.out.println(line);

                            }

                            if (outStream != null) {

                                outStream.println(line);

                            }

                        }

                    }

                }

                if (classStream != null && !clazz.isEmpty()) {

                    writeLine(clazz, info, emittedClassLines, classStream);

                }

                if (packageStream != null && !pkg.isEmpty()) {

                    writeLine(pkg, info, emittedPackageLines, packageStream);

                }

            } finally {

                for (PrintStream ps : new PrintStream[]{outStream, packageStream, classStream}) {

                    if (ps != null) {

                        ps.close();

                    }

                }

            }

        }

        return all;

    }

    private static void writeLine(List<Object> clazz, SourcesInfo info, Set<CharSequence> emittedClassLines, PrintStream classStream) {

        if (!clazz.isEmpty()) {

            CharSequence cs = info.strings.concatQuoted(clazz);

            if (!emittedClassLines.contains(cs)) {

                classStream.println(cs);

                emittedClassLines.add(cs);

            }

        }

    }

    private static PrintStream createPrintStreamIfNotNull(File outputFile) throws IOException {

        PrintStream outStream = null;

        if (outputFile != null) {

            if (!outputFile.exists()) {

                if (!outputFile.createNewFile()) {

                    throw new IllegalStateException("Could not create " + outputFile);

                }

            }

            outStream = new PrintStream(outputFile);

        }

        return outStream;

    }

    public List<String> toCommandLineArguments() {

        List<String> args = new ArrayList<>();

        addBoolean(CMD_NOSELF, noself, args);

        addBoolean(CMD_MAVEN, maven, args);

        addBoolean(CMD_QUIET, quiet, args);

        addBoolean(CMD_SIMPLE, simple, args);

        addBoolean(CMD_REVERSE, reverse, args);

        addBoolean(CMD_DISABLE_EIGHT_BIT_STRINGS, useJavaStrings, args);

        addBoolean(CMD_OMIT_ABSTRACT, omitAbstract, args);

        if (!excludes.isEmpty()) {

            StringBuilder concat = new StringBuilder();

            for (Iterator<String> it = excludes.iterator(); it.hasNext();) {

                String next = it.next();

                concat.append(next);

                if (it.hasNext()) {

                    concat.append(",");

                }

            }

            args.add("--" + CMD_EXCLUDE);

            args.add(concat.toString());

        }

        addFile(CMD_CLASSGRAPH, classgraphFile, args);

        addFile(CMD_METHODGRAPH, methodgraphFile, args);

        addFile(CMD_PACKAGEGRAPH, packagegraphFile, args);

        for (File fld : folders) {

            args.add(fld.getAbsolutePath());

        }

        return args;

    }

    CallgraphControl build() throws IOException {

        List<String> args = toCommandLineArguments();

        // We use regular string processing so we get the argument validation

        String[] argList = args.toArray(new String[args.size()]);

        Arguments arguments = new Arguments(false, argList);

        return arguments;

    }

    /**

     * Run this callgraph, writing output and returning the set of all methods

     * found, sorted in qname order. Call SourceElement.getInboundReferences()

     * and SourceElement.getOutboundReferences() to explore the graph.

     *

     * @return Sorted set of source elements

     * @throws IOException If i/o fails

     */

    public List<SourceElement> run() throws IOException {

        return Callgraph.invoke(build(), listener);

    }

    private void addFile(String command, File file, List<String> args) {

        if (file != null) {

            args.add("--" + command);

            args.add(file.getAbsolutePath());

        }

    }

    private void addBoolean(String command, boolean val, List<String> args) {

        if (val) {

            args.add("--" + command);

        }

    }

    public Callgraph setListener(Listener listener) {

        this.listener = listener;

        return this;

    }

    public Callgraph packageGraphOutput(File file) {

        packagegraphFile = file;

        return this;

    }

    public Callgraph methodGraphOutput(File file) {

        methodgraphFile = file;

        return this;

    }

    public Callgraph classGraphOutput(File file) {

        classgraphFile = file;

        return this;

    }

    public Callgraph addSourceParent(File folder) {

        folders.add(folder);

        return this;

    }

    public Callgraph excludePrefix(String prefix) {

        excludes.add(prefix);

        return this;

    }

    public Callgraph useSimpleClassNames() {

        simple = true;

        return this;

    }

    public Callgraph quiet() {

        quiet = true;

        return this;

    }

    public Callgraph ignoreSelfReferences() {

        noself = true;

        return this;

    }

    public Callgraph scanFoldersForMavenProjects() {

        maven = true;

        return this;

    }

    public Callgraph reverse() {

        reverse = true;

        return this;

    }

    public Callgraph useJavaStrings() {

        useJavaStrings = true;

        return this;

    }

    public Callgraph omitAbstract() {

        omitAbstract = true;

        return this;

    }

    private static final class LoggingListener implements Listener {

        @Override

        public void onStart() {

            //do nothing

        }

        @Override

        public void onFinish() {

            System.out.println("Done.");

        }

        @Override

        public void onStartActivity(String activity, int steps) {

            if (steps > 0) {

                System.out.println(activity + " (" + steps + " steps)");

            }

        }

        @Override

        public void onStep(String step) {

            System.out.println("\t" + step);

        }

    }

}