/*

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

 */

/**

 * @test

 * @summary Verify that annotation processing works.

 * @library /tools/lib

 * @modules

 *      jdk.compiler/com.sun.tools.javac.api

 *      jdk.compiler/com.sun.tools.javac.main

 * @build toolbox.ToolBox toolbox.JavacTask ModuleTestBase

 * @run main AnnotationProcessing

 */

import java.io.File;

import java.io.IOException;

import java.io.OutputStream;

import java.io.Reader;

import java.io.Writer;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.concurrent.Callable;

import java.util.function.Function;

import java.util.stream.Collectors;

import javax.annotation.processing.AbstractProcessor;

import javax.annotation.processing.Filer;

import javax.annotation.processing.FilerException;

import javax.annotation.processing.Messager;

import javax.annotation.processing.ProcessingEnvironment;

import javax.annotation.processing.RoundEnvironment;

import javax.annotation.processing.SupportedAnnotationTypes;

import javax.annotation.processing.SupportedOptions;

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.ModuleElement.ProvidesDirective;

import javax.lang.model.element.ModuleElement.UsesDirective;

import javax.lang.model.element.PackageElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.element.VariableElement;

import javax.lang.model.type.TypeKind;

import javax.lang.model.util.ElementFilter;

import javax.lang.model.util.ElementScanner9;

import javax.tools.Diagnostic.Kind;

import javax.tools.FileObject;

import javax.tools.JavaCompiler;

import javax.tools.JavaCompiler.CompilationTask;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileManager.Location;

import javax.tools.JavaFileObject;

import javax.tools.StandardJavaFileManager;

import javax.tools.StandardLocation;

import javax.tools.ToolProvider;

import toolbox.JavacTask;

import toolbox.Task;

import toolbox.Task.Mode;

import toolbox.Task.OutputKind;

public class AnnotationProcessing extends ModuleTestBase {

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

        new AnnotationProcessing().runTests();

    }

    @Test

    public void testAPSingleModule(Path base) throws Exception {

        Path moduleSrc = base.resolve("module-src");

        Path m1 = moduleSrc.resolve("m1x");

        Path classes = base.resolve("classes");

        Files.createDirectories(classes);

        tb.writeJavaFiles(m1,

                          "module m1x { }",

                          "package impl; public class Impl { }");

        String log = new JavacTask(tb)

                .options("--module-source-path", moduleSrc.toString(),

                         "-processor", AP.class.getName(),

                         "-AexpectedEnclosedElements=m1x=>impl")

                .outdir(classes)

                .files(findJavaFiles(moduleSrc))

                .run()

                .writeAll()

                .getOutput(Task.OutputKind.DIRECT);

        if (!log.isEmpty())

            throw new AssertionError("Unexpected output: " + log);

    }

    @Test

    public void testAPMultiModule(Path base) throws Exception {

        Path moduleSrc = base.resolve("module-src");

        Path m1 = moduleSrc.resolve("m1x");

        Path m2 = moduleSrc.resolve("m2x");

        Path classes = base.resolve("classes");

        Files.createDirectories(classes);

        tb.writeJavaFiles(m1,

                          "module m1x { }",

                          "package impl1; public class Impl1 { }");

        tb.writeJavaFiles(m2,

                          "module m2x { }",

                          "package impl2; public class Impl2 { }");

        String log = new JavacTask(tb)

                .options("--module-source-path", moduleSrc.toString(),

                         "-processor", AP.class.getName(),

                         "-AexpectedEnclosedElements=m1x=>impl1,m2x=>impl2")

                .outdir(classes)

                .files(findJavaFiles(moduleSrc))

                .run()

                .writeAll()

                .getOutput(Task.OutputKind.DIRECT);

        if (!log.isEmpty())

            throw new AssertionError("Unexpected output: " + log);

    }

    @SupportedAnnotationTypes("*")

    @SupportedOptions("expectedEnclosedElements")

    public static final class AP extends AbstractProcessor {

        private Map<String, List<String>> module2ExpectedEnclosedElements;

        private Set<String> seenModules = new HashSet<>();

        @Override

        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

            if (module2ExpectedEnclosedElements == null) {

                module2ExpectedEnclosedElements = new HashMap<>();

                String expectedEnclosedElements =

                        processingEnv.getOptions().get("expectedEnclosedElements");

                for (String moduleDef : expectedEnclosedElements.split(",")) {

                    String[] module2Packages = moduleDef.split("=>");

                    module2ExpectedEnclosedElements.put(module2Packages[0],

                                                        Arrays.asList(module2Packages[1].split(":")));

                }

            }

            //verify ModuleType and ModuleSymbol behavior:

            for (Element root : roundEnv.getRootElements()) {

                ModuleElement module = processingEnv.getElementUtils().getModuleOf(root);

                assertEquals(TypeKind.MODULE, module.asType().getKind());

                boolean[] seenModule = new boolean[1];

                module.accept(new ElementScanner9<Void, Void>() {

                    @Override

                    public Void visitModule(ModuleElement e, Void p) {

                        seenModule[0] = true;

                        return null;

                    }

                    @Override

                    public Void scan(Element e, Void p) {

                        throw new AssertionError("Shouldn't get here.");

                    }

                }, null);

                assertEquals(true, seenModule[0]);

                List<String> actualElements =

                        module.getEnclosedElements()

                              .stream()

                              .map(s -> (PackageElement) s)

                              .map(p -> p.getQualifiedName().toString())

                              .collect(Collectors.toList());

                String moduleName = module.getQualifiedName().toString();

                assertEquals(module2ExpectedEnclosedElements.get(moduleName),

                             actualElements);

                seenModules.add(moduleName);

            }

            if (roundEnv.processingOver()) {

                assertEquals(module2ExpectedEnclosedElements.keySet(), seenModules);

            }

            return false;

        }

        @Override

        public SourceVersion getSupportedSourceVersion() {

            return SourceVersion.latest();

        }

    }

    @Test

    public void testVerifyUsesProvides(Path base) throws Exception {

        Path moduleSrc = base.resolve("module-src");

        Path m1 = moduleSrc.resolve("m1x");

        Path classes = base.resolve("classes");

        Files.createDirectories(classes);

        tb.writeJavaFiles(m1,

                          "module m1x { exports api; uses api.Api; provides api.Api with impl.Impl; }",

                          "package api; public class Api { }",

                          "package impl; public class Impl extends api.Api { }");

        String log = new JavacTask(tb)

                .options("-doe", "-processor", VerifyUsesProvidesAP.class.getName())

                .outdir(classes)

                .files(findJavaFiles(moduleSrc))

                .run()

                .writeAll()

                .getOutput(Task.OutputKind.DIRECT);

        if (!log.isEmpty())

            throw new AssertionError("Unexpected output: " + log);

    }

    @SupportedAnnotationTypes("*")

    public static final class VerifyUsesProvidesAP extends AbstractProcessor {

        @Override

        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

            TypeElement api = processingEnv.getElementUtils().getTypeElement("api.Api");

            assertNonNull("Cannot find api.Api", api);

            ModuleElement modle = (ModuleElement) processingEnv.getElementUtils().getPackageOf(api).getEnclosingElement();

            assertNonNull("modle is null", modle);

            List<? extends UsesDirective> uses = ElementFilter.usesIn(modle.getDirectives());

            assertEquals(1, uses.size());

            assertEquals("api.Api", uses.iterator().next().getService().getQualifiedName().toString());

            List<? extends ProvidesDirective> provides = ElementFilter.providesIn(modle.getDirectives());

            assertEquals(1, provides.size());

            assertEquals("api.Api", provides.iterator().next().getService().getQualifiedName().toString());

            assertEquals("impl.Impl", provides.iterator().next().getImplementations().get(0).getQualifiedName().toString());

            return false;

        }

        @Override

        public SourceVersion getSupportedSourceVersion() {

            return SourceVersion.latest();

        }

    }

    @Test

    public void testPackageNoModule(Path base) throws Exception {

        Path src = base.resolve("src");

        Path classes = base.resolve("classes");

        Files.createDirectories(classes);

        tb.writeJavaFiles(src,

                          "package api; public class Api { }");

        String log = new JavacTask(tb)

                .options("-processor", VerifyPackageNoModule.class.getName(),

                         "-source", "8",

                         "-Xlint:-options")

                .outdir(classes)

                .files(findJavaFiles(src))

                .run()

                .writeAll()

                .getOutput(Task.OutputKind.DIRECT);

        if (!log.isEmpty())

            throw new AssertionError("Unexpected output: " + log);

    }

    @SupportedAnnotationTypes("*")

    public static final class VerifyPackageNoModule extends AbstractProcessor {

        @Override

        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

            TypeElement api = processingEnv.getElementUtils().getTypeElement("api.Api");

            assertNonNull("Cannot find api.Api", api);

            ModuleElement modle = (ModuleElement) processingEnv.getElementUtils().getPackageOf(api).getEnclosingElement();

            assertNull("modle is not null", modle);

            return false;

        }

        @Override

        public SourceVersion getSupportedSourceVersion() {

            return SourceVersion.latest();

        }

    }

    @Test

    public void testQualifiedClassForProcessing(Path base) throws Exception {

        Path moduleSrc = base.resolve("module-src");

        Path m1 = moduleSrc.resolve("m1x");

        Path m2 = moduleSrc.resolve("m2x");

        Path classes = base.resolve("classes");

        Files.createDirectories(classes);

        tb.writeJavaFiles(m1,

                          "module m1x { }",

                          "package impl; public class Impl { int m1x; }");

        tb.writeJavaFiles(m2,

                          "module m2x { }",

                          "package impl; public class Impl { int m2x; }");

        new JavacTask(tb)

            .options("--module-source-path", moduleSrc.toString())

            .outdir(classes)

            .files(findJavaFiles(moduleSrc))

            .run()

            .writeAll()

            .getOutput(Task.OutputKind.DIRECT);

        List<String> expected = Arrays.asList("Note: field: m1x");

        for (Mode mode : new Mode[] {Mode.API, Mode.CMDLINE}) {

            List<String> log = new JavacTask(tb, mode)

                    .options("-processor", QualifiedClassForProcessing.class.getName(),

                             "--module-path", classes.toString())

                    .classes("m1x/impl.Impl")

                    .outdir(classes)

                    .run()

                    .writeAll()

                    .getOutputLines(Task.OutputKind.DIRECT);

            if (!expected.equals(log))

                throw new AssertionError("Unexpected output: " + log);

        }

    }

    @SupportedAnnotationTypes("*")

    public static final class QualifiedClassForProcessing extends AbstractProcessor {

        @Override

        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

            if (processingEnv.getElementUtils().getModuleElement("m1x") == null) {

                throw new AssertionError("No m1x module found.");

            }

            Messager messager = processingEnv.getMessager();

            for (TypeElement clazz : ElementFilter.typesIn(roundEnv.getRootElements())) {

                for (VariableElement field : ElementFilter.fieldsIn(clazz.getEnclosedElements())) {

                    messager.printMessage(Kind.NOTE, "field: " + field.getSimpleName());

                }

            }

            return false;

        }

        @Override

        public SourceVersion getSupportedSourceVersion() {

            return SourceVersion.latest();

        }

    }

    @Test

    public void testModuleInRootElements(Path base) throws Exception {

        Path moduleSrc = base.resolve("module-src");

        Path m1 = moduleSrc.resolve("m1");

        Path classes = base.resolve("classes");

        Files.createDirectories(classes);

        tb.writeJavaFiles(m1,

                          "module m1x { exports api; }",

                          "package api; public class Api { }");

        List<String> log = new JavacTask(tb)

                .options("-processor", ModuleInRootElementsAP.class.getName())

                .outdir(classes)

                .files(findJavaFiles(moduleSrc))

                .run()

                .writeAll()

                .getOutputLines(Task.OutputKind.STDERR);

        assertEquals(Arrays.asList("module: m1x"), log);

    }

    @SupportedAnnotationTypes("*")

    public static final class ModuleInRootElementsAP extends AbstractProcessor {

        @Override

        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

            roundEnv.getRootElements()

                    .stream()

                    .filter(el -> el.getKind() == ElementKind.MODULE)

                    .forEach(mod -> System.err.println("module: " + mod.getSimpleName()));

            return false;

        }

        @Override

        public SourceVersion getSupportedSourceVersion() {

            return SourceVersion.latest();

        }

    }

    @Test

    public void testAnnotationsInModuleInfo(Path base) throws Exception {

        Path moduleSrc = base.resolve("module-src");

        Path m1 = moduleSrc.resolve("m1");

        tb.writeJavaFiles(m1,

                          "@Deprecated module m1x { }");

        Path m2 = moduleSrc.resolve("m2x");

        tb.writeJavaFiles(m2,

                          "@SuppressWarnings(\"\") module m2x { }");

        Path classes = base.resolve("classes");

        Files.createDirectories(classes);

        List<String> log = new JavacTask(tb)

                .options("-processor", AnnotationsInModuleInfoPrint.class.getName())

                .outdir(classes)

                .files(findJavaFiles(m1))

                .run()

                .writeAll()

                .getOutputLines(Task.OutputKind.DIRECT);

        List<String> expectedLog = Arrays.asList("Note: AP Invoked",

                                                 "Note: AP Invoked");

        assertEquals(expectedLog, log);

        new JavacTask(tb)

            .options("-processor", AnnotationsInModuleInfoFail.class.getName())

            .outdir(classes)

            .files(findJavaFiles(m2))

            .run()

            .writeAll();

    }

    @SupportedAnnotationTypes("java.lang.Deprecated")

    public static final class AnnotationsInModuleInfoPrint extends AbstractProcessor {

        @Override

        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

            processingEnv.getMessager().printMessage(Kind.NOTE, "AP Invoked");

            return false;

        }

        @Override

        public SourceVersion getSupportedSourceVersion() {

            return SourceVersion.latest();

        }

    }

    @SupportedAnnotationTypes("java.lang.Deprecated")

    public static final class AnnotationsInModuleInfoFail extends AbstractProcessor {