/*

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

 * @bug 8013852 8031744

 * @summary Annotations on types

 * @library /tools/javac/lib

 * @build JavacTestingAbstractProcessor DPrinter BasicAnnoTests

 * @compile/process -processor BasicAnnoTests -proc:only BasicAnnoTests.java

 */

import java.io.PrintWriter;

import java.io.Serializable;

import java.lang.annotation.Annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Repeatable;

import java.lang.annotation.Target;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.NavigableMap;

import java.util.Set;

import java.util.TreeMap;

import javax.annotation.processing.ProcessingEnvironment;

import javax.annotation.processing.RoundEnvironment;

import javax.lang.model.AnnotatedConstruct;

import javax.lang.model.element.AnnotationMirror;

import javax.lang.model.element.AnnotationValue;

import javax.lang.model.element.Element;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.type.ArrayType;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.type.ExecutableType;

import javax.lang.model.type.IntersectionType;

import javax.lang.model.type.TypeMirror;

import javax.lang.model.type.TypeVariable;

import javax.lang.model.type.WildcardType;

import javax.lang.model.util.Types;

import javax.tools.Diagnostic.Kind;

import com.sun.tools.javac.code.Attribute;

import com.sun.tools.javac.code.Symbol;

import com.sun.tools.javac.processing.JavacProcessingEnvironment;

import com.sun.tools.javac.util.Name;

import static com.sun.tools.javac.code.Attribute.Array;

import static com.sun.tools.javac.code.Attribute.Constant;

import static com.sun.tools.javac.code.Attribute.Compound;

/**

 * The test scans this file looking for test cases annotated with @Test.

 */

public class BasicAnnoTests extends JavacTestingAbstractProcessor {

    DPrinter dprinter;

    PrintWriter out;

    boolean verbose = true;

    @Override

    public void init(ProcessingEnvironment pEnv) {

        super.init(pEnv);

        dprinter = new DPrinter(((JavacProcessingEnvironment) pEnv).getContext());

        out = dprinter.out;

    }

    @Override

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

        TestElementScanner s = new TestElementScanner();

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

            s.scan(e, null);

        }

        return true;

    }

    void error(Element e, String msg) {

        messager.printMessage(Kind.ERROR, msg, e);

        errors++;

    }

    int errors;

    /**

     * Scan an element looking for declarations annotated with @Test.

     * Run a TestTypeScanner on the annotations that are found.

     */

    class TestElementScanner extends ElementScanner<Void,Void> {

        public Void scan(Element elem, Void ignore) {

            List<AnnotationMirror> tests = new ArrayList<>();

            AnnotationMirror test = getAnnotation(elem, Test.class.getName().replace('$', '.'));

            if (test != null) {

                tests.add(test);

            }

            tests.addAll(getAnnotations(elem, Tests.class.getName().replace('$', '.')));

            if (tests.size() > 0) {

                out.println("Test: " + elem + " " + test);

                TestTypeScanner s = new TestTypeScanner(elem, tests, types);

                s.test(elem.asType());

                out.println();

            }

            return super.scan(elem, ignore);

        }

    }

    /**

     * Scan the type of an element, looking for an annotation

     * to match the expected annotation specified in the @Test annotation.

     */

    class TestTypeScanner extends TypeScanner<Void, Void> {

        Element elem;

        NavigableMap<Integer, AnnotationMirror> toBeFound;

        int count = 0;

        Set<TypeMirror> seen = new HashSet<>();

        TestTypeScanner(Element elem, List<AnnotationMirror> tests, Types types) {

            super(types);

            this.elem = elem;

            NavigableMap<Integer, AnnotationMirror> testByPos = new TreeMap<>();

            for (AnnotationMirror test : tests) {

                for (int pos : getPosn(test)) {

                    testByPos.put(pos, test);

                }

            }

            this.toBeFound = testByPos;

        }

        public void test(TypeMirror t) {

            scan(t, null);

        }

        @Override

        Void scan(TypeMirror t, Void ignore) {

            if (t == null)

                return DEFAULT_VALUE;

            if (!seen.contains(t)) {

                try {

                    seen.add(t);

                    if (verbose)

                        out.println("scan " + count + ": " + t);

                    if (toBeFound.size() > 0) {

                        if (toBeFound.firstKey().equals(count)) {

                            AnnotationMirror test = toBeFound.pollFirstEntry().getValue();

                            String annoType = getAnnoType(test);

                            AnnotationMirror anno = getAnnotation(t, annoType);

                            if (anno == null) {

                                error(elem, "annotation not found on " + count + ": " + t);

                            } else {

                                String v = getValue(anno, "value").toString();

                                if (v.equals(getExpect(test))) {

                                    out.println("found " + anno + " as expected");

                                } else {

                                    error(elem, "Unexpected value: " + v + ", expected: " + getExpect(test));

                                }

                            }

                        } else if (count > toBeFound.firstKey()) {

                            rescue();

                        } else {

                            List<? extends AnnotationMirror> annos = t.getAnnotationMirrors();

                            if (annos.size() > 0) {

                                for (AnnotationMirror a : annos)

                                    error(elem, "annotation " + a + " found on " + count + ": " + t);

                            }

                        }

                    } else {

                        List<? extends AnnotationMirror> annos = t.getAnnotationMirrors();

                        if (annos.size() > 0) {

                            for (AnnotationMirror a : annos)

                                error(elem, "annotation " + a + " found on " + count + ": " + t);

                        }

                    }

                    count++;

                    return super.scan(t, ignore);

                } finally {

                    seen.remove(t);

                }

            }

            return DEFAULT_VALUE;

        }

        private void rescue() {

            while (toBeFound.size() > 0 && toBeFound.firstKey() >= count)

                toBeFound.pollFirstEntry();

        }

    }

    /** Get the position value from an element annotated with a @Test annotation mirror. */

    static int[] getPosn(Element elem) {

        return elem.getAnnotation(Test.class).posn();

    }

    /** Get the position value from a @Test annotation mirror. */

    static Integer[] getPosn(AnnotationMirror test) {

        AnnotationValue v = getValue(test, "posn");

        Object value = v.getValue();

        Integer i = 0;

        if (value instanceof Constant) {

            i = (Integer)((Constant)value).getValue();

            Integer[] res = new Integer[1];

            res[0] = i;

            return res;

        } else if (value instanceof List) {

            List<Constant> l = (List<Constant>)value;

            Integer[] res = new Integer[l.size()];

            for (int c = 0; c < l.size(); c++) {

                res[c] = (Integer)l.get(c).getValue();

            }

            return res;

        }

        return null;

    }

    /** Get the expect value from an @Test annotation mirror. */

    static String getExpect(AnnotationMirror test) {

        AnnotationValue v = getValue(test, "expect");

        return (String) v.getValue();

    }

    /** Get the annoType value from an @Test annotation mirror. */

    static String getAnnoType(AnnotationMirror test) {

        AnnotationValue v = getValue(test, "annoType");

        TypeMirror m = (TypeMirror) v.getValue();

        return m.toString();

    }

    /**

     * Get a specific annotation mirror from an annotated construct.

     */

    static AnnotationMirror getAnnotation(AnnotatedConstruct e, String name) {

        for (AnnotationMirror m: e.getAnnotationMirrors()) {

            TypeElement te = (TypeElement) m.getAnnotationType().asElement();

            if (te.getQualifiedName().contentEquals(name)) {

                return m;

            }

        }

        return null;

    }

    static List<AnnotationMirror> getAnnotations(Element e, String name) {

        Name valueName = ((Symbol)e).getSimpleName().table.names.value;

        List<AnnotationMirror> res = new ArrayList<>();

        for (AnnotationMirror m : e.getAnnotationMirrors()) {

            TypeElement te = (TypeElement) m.getAnnotationType().asElement();

            if (te.getQualifiedName().contentEquals(name)) {

                Compound theAnno = (Compound)m;

                Array valueArray = (Array)theAnno.member(valueName);

                for (Attribute a : valueArray.getValue()) {

                    AnnotationMirror theMirror = (AnnotationMirror) a;

                    res.add(theMirror);

                }

            }

        }

        return res;

    }

    /**

     * Get a specific value from an annotation mirror.

     */

    static AnnotationValue getValue(AnnotationMirror anno, String name) {

        Map<? extends ExecutableElement, ? extends AnnotationValue> map = anno.getElementValues();

        for (Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> e: map.entrySet()) {

            if (e.getKey().getSimpleName().contentEquals(name)) {

                return e.getValue();

            }

        }

        return null;

    }

    /**

     * The Language Model API does not provide a type scanner, so provide

     * one sufficient for our needs.

     */

    static class TypeScanner<R, P> extends SimpleTypeVisitor<R, P> {

        private Types types;

        public TypeScanner(Types types) {

            super();

            this.types = types;

        }

        @Override

        public R visitArray(ArrayType t, P p) {

            scan(t.getComponentType(), p);

            return super.visitArray(t, p);

        }

        @Override

        public R visitExecutable(ExecutableType t, P p) {

            //out.println("  type parameters: " + t.getTypeVariables());

            scan(t.getTypeVariables(), p);

            //out.println("  return: " + t.getReturnType());

            scan(t.getReturnType(), p);

            //out.println("  receiver: " + t.getReceiverTypes());

            scan(t.getReceiverType());

            //out.println("  params: " + t.getParameterTypes());

            scan(t.getParameterTypes(), p);

            //out.println("  throws: " + t.getThrownTypes());

            scan(t.getThrownTypes(), p);

            return super.visitExecutable(t, p);

        }

        @Override

        public R visitDeclared(DeclaredType t, P p) {

            scan(t.getTypeArguments(), p);

            // don't scan enclosing

            scan(types.directSupertypes(t), p);

            return super.visitDeclared(t, p);

        }

        @Override

        public R visitIntersection(IntersectionType t, P p) {

            scan(t.getBounds(), p);

            return super.visitIntersection(t, p);

        }

        @Override

        public R visitTypeVariable(TypeVariable t, P p) {

            scan(t.getLowerBound(), p);

            scan(t.getUpperBound(), p);

            return super.visitTypeVariable(t, p);

        }

        @Override

        public R visitWildcard(WildcardType t, P p) {

            scan(t.getExtendsBound(), p);

            scan(t.getSuperBound(), p);

            return super.visitWildcard(t, p);

        }

        R scan(TypeMirror t) {

            return scan(t, null);

        }

        R scan(TypeMirror t, P p) {

            return (t == null) ? DEFAULT_VALUE : t.accept(this, p);

        }

        R scan(Iterable<? extends TypeMirror> iter, P p) {

            if (iter == null)

                return DEFAULT_VALUE;

            R result = DEFAULT_VALUE;

            for (TypeMirror t: iter)

                result = scan(t, p);

            return result;

        }

    }

    /** Annotation to identify test cases. */

    @Repeatable(Tests.class)

    @interface Test {

        /** Where to look for the annotation, expressed as a scan index. */

        int[] posn();

        /** The annotation to look for. */

        Class<? extends Annotation> annoType();

        /** The string representation of the annotation's value. */

        String expect();

    }

    @interface Tests {

        Test[] value();

    }

    /** Type annotation to use in test cases. */

    @Target(ElementType.TYPE_USE)

    public @interface TA {

        int value();

    }

    @Target(ElementType.TYPE_USE)

    public @interface TB {

        int value();

    }

    // Test cases

    // TODO: add more cases for arrays

    //       all annotated

    //       all but one annotated

    //             vary position of one not annotated

    //       only one annotated

    //             vary position of one annotated

    //       the three above with the corner case of the ambiguos decl + type anno added

    @Test(posn=0, annoType=TA.class, expect="1")

    public @TA(1) int f1;

    @Test(posn=0, annoType=TA.class, expect="11")

    @TA(11) public int f11;

    @Test(posn=1, annoType=TA.class, expect="111")

    @TA(111) public int [] f111;

    @Test(posn=1, annoType=TA.class, expect="1120")

    @Test(posn=0, annoType=TB.class, expect="1121")

    @TA(1120) public int @TB(1121) [] f112;

    @Test(posn=0, annoType=TB.class, expect="11211")

    @Test(posn=1, annoType=TA.class, expect="11200")

    public @TA(11200) int @TB(11211) [] f112b;

    @Test(posn=1, annoType=TB.class, expect="1131")

    @Test(posn=2, annoType=TA.class, expect="1130")

    @TA(1130) public int [] @TB(1131) [] f113;

    @Test(posn=5, annoType=TA.class, expect="12")

    public @TA(12) int [] [] [] [] [] f12;

    @Test(posn=6, annoType=TA.class, expect="13")

    public @TA(13) int [] [] [] [] [] [] f13;

    @Test(posn=7, annoType=TA.class, expect="14")

    @TA(14) public int [] [] [] [] [] [] [] f14;

    @Test(posn=6, annoType=TA.class, expect="150")

    @Test(posn=7, annoType=TB.class, expect="151")

    @TB(151) public int [] [] [] [] [] [] @TA(150) [] f15;

    @Test(posn=0, annoType=TB.class, expect="1511")

    @Test(posn=3, annoType=TA.class, expect="1512")

    @Test(posn=6, annoType=TA.class, expect="150")

    @Test(posn=7, annoType=TB.class, expect="151")

    @TB(151) public int @TB(1511) [] [] [] @TA(1512) [] [] [] @TA(150) [] f15b;

    @Test(posn=0, annoType=TB.class, expect="1521")

    @Test(posn=3, annoType=TA.class, expect="1522")

    @Test(posn=6, annoType=TA.class, expect="152")

    public int @TB(1521) [] [] [] @TA(1522) [] [] [] @TA(152) [] f15c;

    @Test(posn=5, annoType=TA.class, expect="160")

    @Test(posn=6, annoType=TB.class, expect="161")

    public int [] [] [] [] [] @TA(160) [] @TB(161) [] f16;

    @Test(posn=0, annoType=TA.class, expect="2")

    public int @TA(2) [] f2;

    @Test(posn=0, annoType=TB.class, expect="33")

    @Test(posn=1, annoType=TA.class, expect="3")

    public @TA(3) int @TB(33) [] f3;

    @Test(posn=2, annoType=TA.class, expect="4")

    public int m1(@TA(4) float a) throws Exception { return 0; }

    @Test(posn=1, annoType=TA.class, expect="5")

    public @TA(5) int m2(float a) throws Exception { return 0; }

    @Test(posn=3, annoType=TA.class, expect="6")

    public int m3(float a) throws @TA(6) Exception { return 0; }

    // Also tests that a decl anno on a typevar doesn't show up on the Type

    @Test(posn=7, annoType=TA.class, expect="8")

    public <@TA(7) M> M m4(@TA(8) float a) throws Exception { return null; }

    // Also tests that a decl anno on a typevar doesn't show up on the Type

    @Test(posn=4, annoType=TA.class, expect="10")

    public class Inner1<@TA(9) S> extends @TA(10) Object implements Cloneable {}

    // Also tests that a decl anno on a typevar doesn't show up on the Type

    @Test(posn=5, annoType=TA.class, expect="12")

    public class Inner2<@TA(11) S> extends Object implements @TA(12) Cloneable {}

    @Test(posn={3,6}, annoType=TA.class, expect="13")

    public <M extends @TA(13) Object> M m5(float a) { return null; }

    @Test(posn=3, annoType=TA.class, expect="14")

    public class Inner3<QQQ extends @TA(14) Map> {}

    @Test(posn=4, annoType=TA.class, expect="15")

    public class Inner4<T extends @TA(15) Object & Cloneable & Serializable> {}

    @Test(posn=5, annoType=TA.class, expect="16")

    public class Inner5<T extends Object & @TA(16) Cloneable & Serializable> {}