/*

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

 */

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.io.Writer;

import java.text.BreakIterator;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Locale;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import javax.lang.model.element.Name;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import com.sun.source.doctree.*;

import com.sun.source.tree.ClassTree;

import com.sun.source.tree.CompilationUnitTree;

import com.sun.source.tree.MethodTree;

import com.sun.source.tree.Tree;

import com.sun.source.tree.VariableTree;

import com.sun.source.util.DocTreeScanner;

import com.sun.source.util.DocTrees;

import com.sun.source.util.JavacTask;

import com.sun.source.util.TreePath;

import com.sun.source.util.TreePathScanner;

import com.sun.tools.javac.api.JavacTool;

import com.sun.tools.javac.tree.DCTree;

import com.sun.tools.javac.tree.DCTree.DCDocComment;

import com.sun.tools.javac.tree.DCTree.DCErroneous;

import com.sun.tools.javac.tree.DocPretty;

public class DocCommentTester {

    public static final String BI_MARKER = "BREAK_ITERATOR";

    public final boolean useBreakIterator;

    public DocCommentTester(boolean useBreakIterator) {

        this.useBreakIterator = useBreakIterator;

    }

    public static void main(String... args) throws Exception {

        ArrayList<String> list = new ArrayList(Arrays.asList(args));

        if (!list.isEmpty() && "-useBreakIterator".equals(list.get(0))) {

            list.remove(0);

            new DocCommentTester(true).run(list);

        } else {

            new DocCommentTester(false).run(list);

        }

    }

    public void run(List<String> args) throws Exception {

        String testSrc = System.getProperty("test.src");

        List<File> files = args.stream()

                .map(arg -> new File(testSrc, arg))

                .collect(Collectors.toList());

        JavacTool javac = JavacTool.create();

        StandardJavaFileManager fm = javac.getStandardFileManager(null, null, null);

        Iterable<? extends JavaFileObject> fos = fm.getJavaFileObjectsFromFiles(files);

        JavacTask t = javac.getTask(null, fm, null, null, null, fos);

        final DocTrees trees = DocTrees.instance(t);

        if (useBreakIterator) {

            // BreakIterators are locale dependent wrt. behavior

            trees.setBreakIterator(BreakIterator.getSentenceInstance(Locale.ENGLISH));

        }

        final Checker[] checkers = {

            new ASTChecker(this, trees),

            new PosChecker(this, trees),

            new PrettyChecker(this, trees)

        };

        DeclScanner d = new DeclScanner() {

            @Override

            public Void visitCompilationUnit(CompilationUnitTree tree, Void ignore) {

                for (Checker c: checkers)

                    c.visitCompilationUnit(tree);

                return super.visitCompilationUnit(tree, ignore);

            }

            @Override

            void visitDecl(Tree tree, Name name) {

                TreePath path = getCurrentPath();

                String dc = trees.getDocComment(path);

                if (dc != null) {

                    for (Checker c : checkers) {

                        try {

                            System.err.println(path.getLeaf().getKind()

                                    + " " + name

                                    + " " + c.getClass().getSimpleName());

                            c.check(path, name);

                            System.err.println();

                        } catch (Exception e) {

                            error("Exception " + e);

                            e.printStackTrace(System.err);

                        }

                    }

                }

            }

        };

        Iterable<? extends CompilationUnitTree> units = t.parse();

        for (CompilationUnitTree unit: units) {

            d.scan(unit, null);

        }

        if (errors > 0)

            throw new Exception(errors + " errors occurred");

    }

    static abstract class DeclScanner extends TreePathScanner<Void, Void> {

        abstract void visitDecl(Tree tree, Name name);

        @Override

        public Void visitClass(ClassTree tree, Void ignore) {

            super.visitClass(tree, ignore);

            visitDecl(tree, tree.getSimpleName());

            return null;

        }

        @Override

        public Void visitMethod(MethodTree tree, Void ignore) {

            super.visitMethod(tree, ignore);

            visitDecl(tree, tree.getName());

            return null;

        }

        @Override

        public Void visitVariable(VariableTree tree, Void ignore) {

            super.visitVariable(tree, ignore);

            visitDecl(tree, tree.getName());

            return null;

        }

    }

    /**

     * Base class for checkers to check the doc comment on a declaration

     * (when present.)

     */

    abstract class Checker {

        final DocTrees trees;

        Checker(DocTrees trees) {

            this.trees = trees;

        }

        void visitCompilationUnit(CompilationUnitTree tree) { }

        abstract void check(TreePath tree, Name name) throws Exception;

        void error(String msg) {

            DocCommentTester.this.error(msg);

        }

    }

    void error(String msg) {

        System.err.println("Error: " + msg);

        errors++;

    }

    int errors;

    /**

     * Verify the structure of the DocTree AST by comparing it against golden text.

     */

    static class ASTChecker extends Checker {

        static final String NEWLINE = System.getProperty("line.separator");

        Printer printer = new Printer();

        String source;

        DocCommentTester test;

        ASTChecker(DocCommentTester test, DocTrees t) {

            test.super(t);

            this.test = test;

        }

        @Override

        void visitCompilationUnit(CompilationUnitTree tree) {

            try {

                source = tree.getSourceFile().getCharContent(true).toString();

            } catch (IOException e) {

                source = "";

            }

        }

        void check(TreePath path, Name name) {

            StringWriter out = new StringWriter();

            DocCommentTree dc = trees.getDocCommentTree(path);

            printer.print(dc, out);

            out.flush();

            String found = out.toString().replace(NEWLINE, "\n");

            /*

             * Look for the first block comment after the first occurrence

             * of name, noting that, block comments with BI_MARKER may

             * very well be present.

             */

            int start = test.useBreakIterator

                    ? source.indexOf("\n/*\n" + BI_MARKER + "\n", findName(source, name))

                    : source.indexOf("\n/*\n", findName(source, name));

            int end = source.indexOf("\n*/\n", start);

            int startlen = start + (test.useBreakIterator ? BI_MARKER.length() + 1 : 0) + 4;

            String expect = source.substring(startlen, end + 1);

            if (!found.equals(expect)) {

                if (test.useBreakIterator) {

                    System.err.println("Using BreakIterator");

                }

                System.err.println("Expect:\n" + expect);

                System.err.println("Found:\n" + found);

                error("AST mismatch for " + name);

            }

        }

        /**

         * This main program is to set up the golden comments used by this

         * checker.

         * Usage:

         *     java DocCommentTester$ASTChecker -o dir file...

         * The given files are written to the output directory with their

         * golden comments updated. The intent is that the files should

         * then be compared with the originals, e.g. with meld, and if the

         * changes are approved, the new files can be used to replace the old.

         */

        public static void main(String... args) throws Exception {

            List<File> files = new ArrayList<File>();

            File o = null;

            for (int i = 0; i < args.length; i++) {

                String arg = args[i];

                if (arg.equals("-o"))

                    o = new File(args[++i]);

                else if (arg.startsWith("-"))

                    throw new IllegalArgumentException(arg);

                else {

                    files.add(new File(arg));

                }

            }

            if (o == null)

                throw new IllegalArgumentException("no output dir specified");

            final File outDir = o;

            JavacTool javac = JavacTool.create();

            StandardJavaFileManager fm = javac.getStandardFileManager(null, null, null);

            Iterable<? extends JavaFileObject> fos = fm.getJavaFileObjectsFromFiles(files);

            JavacTask t = javac.getTask(null, fm, null, null, null, fos);

            final DocTrees trees = DocTrees.instance(t);

            DeclScanner d = new DeclScanner() {

                Printer p = new Printer();

                String source;

                @Override

                public Void visitCompilationUnit(CompilationUnitTree tree, Void ignore) {

                    System.err.println("processing " + tree.getSourceFile().getName());

                    try {

                        source = tree.getSourceFile().getCharContent(true).toString();

                    } catch (IOException e) {

                        source = "";

                    }

                    // remove existing gold by removing all block comments after the first '{'.

                    int start = source.indexOf("{");

                    while ((start = source.indexOf("\n/*\n", start)) != -1) {

                        int end = source.indexOf("\n*/\n");

                        source = source.substring(0, start + 1) + source.substring(end + 4);

                    }

                    // process decls in compilation unit

                    super.visitCompilationUnit(tree, ignore);

                    // write the modified source

                    File f = new File(tree.getSourceFile().getName());

                    File outFile = new File(outDir, f.getName());

                    try {

                        FileWriter out = new FileWriter(outFile);

                        try {

                            out.write(source);

                        } finally {

                            out.close();

                        }

                    } catch (IOException e) {

                        System.err.println("Can't write " + tree.getSourceFile().getName()

                                + " to " + outFile + ": " + e);

                    }

                    return null;

                }

                @Override

                void visitDecl(Tree tree, Name name) {

                    DocTree dc = trees.getDocCommentTree(getCurrentPath());

                    if (dc != null) {

                        StringWriter out = new StringWriter();

                        p.print(dc, out);

                        String found = out.toString();

                        // Look for the empty line after the first occurrence of name

                        int pos = source.indexOf("\n\n", findName(source, name));

                        // Insert the golden comment

                        source = source.substring(0, pos)

                                + "\n/*\n"

                                + found

                                + "*/"

                                + source.substring(pos);

                    }

                }

            };

            Iterable<? extends CompilationUnitTree> units = t.parse();

            for (CompilationUnitTree unit: units) {

                d.scan(unit, null);

            }

        }

        static int findName(String source, Name name) {

            Pattern p = Pattern.compile("\\s" + name + "[(;]");

            Matcher m = p.matcher(source);

            if (!m.find())

                throw new Error("cannot find " + name);

            return m.start();

        }

        static class Printer implements DocTreeVisitor<Void, Void> {

            PrintWriter out;

            void print(DocTree tree, Writer out) {

                this.out = (out instanceof PrintWriter)

                        ? (PrintWriter) out : new PrintWriter(out);

                tree.accept(this, null);

                this.out.flush();

            }

            public Void visitAttribute(AttributeTree node, Void p) {

                header(node);

                indent(+1);

                print("name", node.getName().toString());

                print("vkind", node.getValueKind().toString());

                print("value", node.getValue());

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitAuthor(AuthorTree node, Void p) {

                header(node);

                indent(+1);

                print("name", node.getName());

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitComment(CommentTree node, Void p) {

                header(node, compress(node.getBody()));

                return null;

            }

            public Void visitDeprecated(DeprecatedTree node, Void p) {

                header(node);

                indent(+1);

                print("body", node.getBody());

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitDocComment(DocCommentTree node, Void p) {

                header(node);

                indent(+1);

                print("firstSentence", node.getFirstSentence());

                print("body", node.getBody());

                print("block tags", node.getBlockTags());

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitDocRoot(DocRootTree node, Void p) {

                header(node, "");

                return null;

            }

            public Void visitEndElement(EndElementTree node, Void p) {

                header(node, node.getName().toString());

                return null;

            }

            public Void visitEntity(EntityTree node, Void p) {

                header(node, node.getName().toString());

                return null;

            }

            public Void visitErroneous(ErroneousTree node, Void p) {

                header(node);

                indent(+1);

                print("code", ((DCErroneous) node).diag.getCode());

                print("body", compress(node.getBody()));

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitHidden(HiddenTree node, Void p) {

                header(node);

                indent(+1);

                print("body", node.getBody());

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitIdentifier(IdentifierTree node, Void p) {

                header(node, compress(node.getName().toString()));

                return null;

            }

            @Override

            public Void visitIndex(IndexTree node, Void p) {

                header(node);

                indent(+1);

                print("term", node.getSearchTerm());

                print("description", node.getDescription());

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitInheritDoc(InheritDocTree node, Void p) {

                header(node, "");

                return null;

            }

            public Void visitLink(LinkTree node, Void p) {

                header(node);

                indent(+1);

                print("reference", node.getReference());

                print("body", node.getLabel());

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitLiteral(LiteralTree node, Void p) {

                header(node, compress(node.getBody().getBody()));

                return null;

            }

            public Void visitParam(ParamTree node, Void p) {

                header(node);

                indent(+1);

                print("name", node.getName());

                print("description", node.getDescription());

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitProvides(ProvidesTree node, Void p) {

                header(node);

                indent(+1);

                print("serviceName", node.getServiceType());

                print("description", node.getDescription());

                indent(-1);

                indent();

                out.println("]");

                return null;

            }

            public Void visitReference(ReferenceTree node, Void p) {

                header(node, compress(node.getSignature()));

                return null;

            }

            public Void visitReturn(ReturnTree node, Void p) {

                header(node);

                indent(+1);

                print("description", node.getDescription());

                indent(-1);