/*

 * Copyright (c) 2016, 2017, 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.

 *

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

import java.io.PrintWriter;

import java.io.StringWriter;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

import java.util.Locale;

import java.util.Set;

import java.util.TreeSet;

import java.util.stream.Collectors;

import javax.lang.model.SourceVersion;

import javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.ModuleElement;

import javax.lang.model.element.PackageElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.util.ElementFilter;

import javax.lang.model.util.SimpleElementVisitor9;

import jdk.javadoc.doclet.Doclet;

import jdk.javadoc.doclet.DocletEnvironment;

import jdk.javadoc.doclet.Reporter;

import toolbox.JavadocTask;

import toolbox.Task;

import toolbox.Task.Expect;

import toolbox.TestRunner;

import toolbox.ToolBox;

import static toolbox.Task.OutputKind.*;

/**

 * Base class for module tests.

 */

public class ModuleTestBase extends TestRunner {

    // Field Separator

    private static final String FS = " ";

    protected ToolBox tb;

    private final Class<?> docletClass;

    private Task.Result currentTask = null;

    ModuleTestBase() {

        super(System.err);

        tb = new ToolBox();

        ClassLoader cl = ModuleTestBase.class.getClassLoader();

        try {

            docletClass = cl.loadClass("ModuleTestBase$ModulesTesterDoclet");

        } catch (ClassNotFoundException cfe) {

            throw new Error(cfe);

        }

    }

    /**

     * Execute methods annotated with @Test, and throw an exception if any

     * errors are reported..

     *

     * @throws Exception if any errors occurred

     */

    protected void runTests() throws Exception {

        runTests(m -> new Object[] { Paths.get(m.getName()) });

    }

    Task.Result execTask(String... args) {

        return execTask0(false, args);

    }

    Task.Result execNegativeTask(String... args) {

        return execTask0(true, args);

    }

    private Task.Result execTask0(boolean isNegative, String... args) {

        JavadocTask et = new JavadocTask(tb, Task.Mode.API);

        et.docletClass(docletClass);

        //Arrays.asList(args).forEach((a -> System.err.println("arg: " + a)));

        System.err.println(Arrays.asList(args));

        currentTask = isNegative

                ? et.options(args).run(Expect.FAIL)

                : et.options(args).run();

        return currentTask;

    }

    Path[] findHtmlFiles(Path... paths) throws IOException {

        return tb.findFiles(".html", paths);

    }

    boolean grep(String regex, Path file) throws Exception {

        List<String> lines = tb.readAllLines(file);

        List<String> foundList = tb.grep(regex, lines);

        return !foundList.isEmpty();

    }

    String normalize(String in) {

        return in.replace('\\', '/');

    }

    void checkModulesSpecified(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputPresent("Specified", ElementKind.MODULE, arg);

        }

    }

    void checkPackagesSpecified(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputPresent("Specified", ElementKind.PACKAGE, arg);

        }

    }

    void checkTypesSpecified(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputPresent("Specified", ElementKind.CLASS, arg);

        }

    }

    void checkModulesIncluded(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputPresent("Included", ElementKind.MODULE, arg);

        }

    }

    void checkPackagesIncluded(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputPresent("Included", ElementKind.PACKAGE, arg);

        }

    }

    void checkTypesIncluded(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputPresent("Included", ElementKind.CLASS, arg);

        }

    }

    void checkMembersSelected(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputPresent("Selected", ElementKind.METHOD, arg);

        }

    }

    void checkModuleMode(String mode) throws Exception {

        assertPresent("^ModuleMode" + FS + mode);

    }

    void checkStringPresent(String regex) throws Exception {

        assertPresent(regex);

    }

    void checkDocletOutputPresent(String category, ElementKind kind, String regex) throws Exception {

        assertPresent("^" + category + " " + kind.toString() + " " + regex);

    }

    void assertPresent(String regex) throws Exception {

        assertPresent(regex, STDOUT);

    }

        assertPresent(regex, Task.OutputKind.DIRECT);

    }

        assertNotPresent(regex, Task.OutputKind.DIRECT);

    }

    void assertPresent(String regex, Task.OutputKind kind) throws Exception {

        List<String> foundList = tb.grep(regex, currentTask.getOutputLines(kind));

        if (foundList.isEmpty()) {

            dumpDocletDiagnostics();

            throw new Exception(regex + " not found in: " + kind);

        }

    }

    void assertNotPresent(String regex, Task.OutputKind kind) throws Exception {

        List<String> foundList = tb.grep(regex, currentTask.getOutputLines(kind));

        if (!foundList.isEmpty()) {

            dumpDocletDiagnostics();

            throw new Exception(regex + " found in: " + kind);

        }

    }

    void dumpDocletDiagnostics() {

        for (Task.OutputKind kind : Task.OutputKind.values()) {

            String output = currentTask.getOutput(kind);

            if (output != null && !output.isEmpty()) {

                System.err.println("<" + kind + ">");

                System.err.println(output);

            }

        }

    }

    void checkModulesNotSpecified(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputAbsent("Specified", ElementKind.MODULE, arg);

        }

    }

    void checkPackagesNotSpecified(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputAbsent("Specified", ElementKind.PACKAGE, arg);

        }

    }

    void checkTypesNotSpecified(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputAbsent("Specified", ElementKind.CLASS, arg);

        }

    }

    void checkModulesNotIncluded(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputAbsent("Included", ElementKind.MODULE, arg);

        }

    }

    void checkPackagesNotIncluded(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputAbsent("Included", ElementKind.PACKAGE, arg);

        }

    }

    void checkTypesNotIncluded(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputAbsent("Included", ElementKind.CLASS, arg);

        }

    }

    void checkMembersNotSelected(String... args) throws Exception {

        for (String arg : args) {

            checkDocletOutputAbsent("Selected", ElementKind.METHOD, arg);

        }

    }

    void checkStringAbsent(String regex) throws Exception {

        assertAbsent(regex);

    }

    void checkDocletOutputAbsent(String category, ElementKind kind, String regex) throws Exception {

        assertAbsent("^" + category + FS + kind.toString() + FS + regex);

    }

    void assertAbsent(String regex) throws Exception {

        assertAbsent(regex, STDOUT);

    }

    void assertAbsent(String regex, Task.OutputKind kind) throws Exception {

        List<String> foundList = tb.grep(regex, currentTask.getOutputLines(kind));

        if (!foundList.isEmpty()) {

            dumpDocletDiagnostics();

            throw new Exception(regex + " found in: " + kind);

        }

    }

    public static class ModulesTesterDoclet implements Doclet {

        StringWriter sw = new StringWriter();

        PrintWriter ps = new PrintWriter(sw);

        // csv style output, for simple regex verification

        void printDataSet(String header, Set<? extends Element> set) {

            for (Element e : set) {

                ps.print(header);

                new SimpleElementVisitor9<Void, Void>() {

                    @Override

                    public Void visitModule(ModuleElement e, Void p) {

                        ps.print(FS);

                        ps.print(e.getKind());

                        ps.print(FS);

                        ps.println(e.getQualifiedName());

                        return null;

                    }

                    @Override

                    public Void visitPackage(PackageElement e, Void p) {

                        ps.print(FS);

                        ps.print(e.getKind());

                        ps.print(FS);

                        ps.println(e.getQualifiedName());

                        return null;

                    }

                    @Override

                    public Void visitType(TypeElement e, Void p) {

                        ps.print(FS);

                        ps.print(ElementKind.CLASS);

                        ps.print(FS);

                        ps.println(e.getQualifiedName());

                        return null;

                    }

                    @Override

                    protected Void defaultAction(Element e, Void p) {

                        Element encl = e.getEnclosingElement();

                        CharSequence fqn = new SimpleElementVisitor9<CharSequence, Void>() {

                            @Override

                            public CharSequence visitModule(ModuleElement e, Void p) {

                                return e.getQualifiedName();

                            }

                            @Override

                            public CharSequence visitType(TypeElement e, Void p) {

                                return e.getQualifiedName();

                            }

                            @Override

                            public CharSequence visitPackage(PackageElement e, Void p) {

                                return e.getQualifiedName();

                            }

                        }.visit(encl);

                        ps.print(FS);

                        ps.print(ElementKind.METHOD); // always METHOD

                        ps.print(FS);

                        ps.print(fqn);

                        ps.print(".");

                        ps.println(e.getSimpleName());

                        return null;

                    }

                }.visit(e);

            }

        }

        @Override

        public boolean run(DocletEnvironment docenv) {

            ps.println("ModuleMode" + FS + docenv.getModuleMode());

            printDataSet("Specified", docenv.getSpecifiedElements());

            printDataSet("Included", docenv.getIncludedElements());

            printDataSet("Selected", getAllSelectedElements(docenv));

            System.out.println(sw);

            return true;

        }

        Set<Element> getAllSelectedElements(DocletEnvironment docenv) {

            Set<Element> result = new TreeSet<Element>((Element e1, Element e2) -> {

                // some grouping by kind preferred

                int rc = e1.getKind().compareTo(e2.getKind());

                if (rc != 0) return rc;

                rc = e1.toString().compareTo(e2.toString());

                if (rc != 0) return rc;

                return Integer.compare(e1.hashCode(), e2.hashCode());

            });

            Set<? extends Element> elements = docenv.getIncludedElements();

            for (ModuleElement me : ElementFilter.modulesIn(elements)) {

                addEnclosedElements(docenv, result, me);

            }

            for (PackageElement pe : ElementFilter.packagesIn(elements)) {

                addEnclosedElements(docenv, result, docenv.getElementUtils().getModuleOf(pe));

                addEnclosedElements(docenv, result, pe);

            }

            for (TypeElement te : ElementFilter.typesIn(elements)) {

                addEnclosedElements(docenv, result, te);

            }

            return result;

        }

        void addEnclosedElements(DocletEnvironment docenv, Set<Element> result, Element e) {

            List<Element> elems = e.getEnclosedElements().stream()

                    .filter(el -> docenv.isIncluded(el))

                    .collect(Collectors.toList());

            result.addAll(elems);

            for (TypeElement t : ElementFilter.typesIn(elems)) {

                addEnclosedElements(docenv, result, t);

            }

        }

        @Override

        public Set<Doclet.Option> getSupportedOptions() {

            return Collections.emptySet();

        }

        @Override

        public void init(Locale locale, Reporter reporter) {}

        @Override

        public String getName() {

            return "ModulesTesterDoclet";

        }

        @Override

        public SourceVersion getSupportedSourceVersion() {

            return SourceVersion.latest();

        }

    }

}