/*

 * Copyright (c) 2003, 2014, 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.  Oracle designates this

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

 * by Oracle in the LICENSE file that accompanied this code.

 *

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

 */

package com.sun.tools.javac.comp;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.Map;

import javax.tools.JavaFileObject;

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

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

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

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

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

import com.sun.tools.javac.tree.JCTree.*;

import static com.sun.tools.javac.code.Kinds.*;

import static com.sun.tools.javac.code.TypeTag.ARRAY;

import static com.sun.tools.javac.code.TypeTag.CLASS;

import static com.sun.tools.javac.tree.JCTree.Tag.*;

/** Enter annotations on symbols.  Annotations accumulate in a queue,

 *  which is processed at the top level of any set of recursive calls

 *  requesting it be processed.

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class Annotate {

    protected static final Context.Key<Annotate> annotateKey = new Context.Key<>();

    public static Annotate instance(Context context) {

        Annotate instance = context.get(annotateKey);

        if (instance == null)

            instance = new Annotate(context);

        return instance;

    }

    private final Attr attr;

    private final TreeMaker make;

    private final Log log;

    private final Symtab syms;

    private final Names names;

    private final Resolve rs;

    private final Types types;

    private final ConstFold cfolder;

    private final Check chk;

    private final Lint lint;

    private final DeferredLintHandler deferredLintHandler;

    private final Source source;

    private boolean allowTypeAnnos;

    private boolean allowRepeatedAnnos;

    protected Annotate(Context context) {

        context.put(annotateKey, this);

        attr = Attr.instance(context);

        make = TreeMaker.instance(context);

        log = Log.instance(context);

        syms = Symtab.instance(context);

        names = Names.instance(context);

        rs = Resolve.instance(context);

        types = Types.instance(context);

        cfolder = ConstFold.instance(context);

        chk = Check.instance(context);

        source = Source.instance(context);

        lint = Lint.instance(context);

        deferredLintHandler = DeferredLintHandler.instance(context);

        allowRepeatedAnnos = source.allowRepeatedAnnotations();

        allowTypeAnnos = source.allowTypeAnnotations();

    }

/* ********************************************************************

 * Queue maintenance

 *********************************************************************/

    private int enterCount = 0;

    ListBuffer<Worker> q = new ListBuffer<>();

    ListBuffer<Worker> typesQ = new ListBuffer<>();

    ListBuffer<Worker> repeatedQ = new ListBuffer<>();

    ListBuffer<Worker> afterRepeatedQ = new ListBuffer<>();

    ListBuffer<Worker> validateQ = new ListBuffer<>();

    public void earlier(Worker a) {

        q.prepend(a);

    }

    public void normal(Worker a) {

        q.append(a);

    }

    public void typeAnnotation(Worker a) {

        typesQ.append(a);

    }

    public void repeated(Worker a) {

        repeatedQ.append(a);

    }

    public void afterRepeated(Worker a) {

        afterRepeatedQ.append(a);

    }

    public void validate(Worker a) {

        validateQ.append(a);

    }

    /** Called when the Enter phase starts. */

    public void enterStart() {

        enterCount++;

    }

    /** Called after the Enter phase completes. */

    public void enterDone() {

        enterCount--;

        flush();

    }

    /** Variant which allows for a delayed flush of annotations.

     * Needed by ClassReader */

    public void enterDoneWithoutFlush() {

        enterCount--;

    }

    public void flush() {

        if (enterCount != 0) return;

        enterCount++;

        try {

            while (q.nonEmpty()) {

                q.next().run();

            }

            while (typesQ.nonEmpty()) {

                typesQ.next().run();

            }

            while (repeatedQ.nonEmpty()) {

                repeatedQ.next().run();

            }

            while (afterRepeatedQ.nonEmpty()) {

                afterRepeatedQ.next().run();

            }

            while (validateQ.nonEmpty()) {

                validateQ.next().run();

            }

        } finally {

            enterCount--;

        }

    }

    /** A client that needs to run during {@link #flush()} registers an worker

     *  into one of the queues defined in this class. The queues are: {@link #earlier(Worker)},

     *  {@link #normal(Worker)}, {@link #typeAnnotation(Worker)}, {@link #repeated(Worker)},

     *  {@link #afterRepeated(Worker)}, {@link #validate(Worker)}.

     *  The {@link Worker#run()} method will called inside the {@link #flush()}

     *  call. Queues are empties in the abovementioned order.

     */

    public interface Worker {

        void run();

        String toString();

    }

    /**

     * This context contains all the information needed to synthesize new

     * annotations trees by the completer for repeating annotations.

     */

        public final Env<AttrContext> env;

        public final Map<Symbol.TypeSymbol, ListBuffer<T>> annotated;

        public final Map<T, JCDiagnostic.DiagnosticPosition> pos;

        public final boolean isTypeCompound;

            Assert.checkNonNull(env);

            Assert.checkNonNull(annotated);

            Assert.checkNonNull(pos);

            this.env = env;

            this.annotated = annotated;

            this.pos = pos;

            this.isTypeCompound = isTypeCompound;

        }

        }

        }

    }

/* ********************************************************************

 * Compute an attribute from its annotation.

 *********************************************************************/

    /** Process a single compound annotation, returning its

     *  Attribute. Used from MemberEnter for attaching the attributes

     *  to the annotated symbol.

     */

    Attribute.Compound enterAnnotation(JCAnnotation a,

                                       Type expected,

                                       Env<AttrContext> env) {

    }

    Attribute.TypeCompound enterTypeAnnotation(JCAnnotation a,

    }

        Type at = (a.annotationType.type != null ? a.annotationType.type

                  : attr.attribType(a.annotationType, env));

        a.type = chk.checkType(a.annotationType.pos(), at, expected);

        boolean isError = a.type.isErroneous();

        if ((a.type.tsym.flags() & Flags.ANNOTATION) == 0 && !isError) {

            log.error(a.annotationType.pos(),

                      "not.annotation.type", a.type.toString());

            isError = true;

        }

        List<JCExpression> args = a.args;

        if (args.length() == 1 && !args.head.hasTag(ASSIGN)) {

            // special case: elided "value=" assumed

            args.head = make.at(args.head.pos).

                Assign(make.Ident(names.value), args.head);

        }

        ListBuffer<Pair<MethodSymbol,Attribute>> buf =

            new ListBuffer<>();

        for (List<JCExpression> tl = args; tl.nonEmpty(); tl = tl.tail) {

            JCExpression t = tl.head;

            if (!t.hasTag(ASSIGN)) {

                log.error(t.pos(), "annotation.value.must.be.name.value");

                enterAttributeValue(t.type = syms.errType, t, env);

                continue;

            }

            JCAssign assign = (JCAssign)t;

            if (!assign.lhs.hasTag(IDENT)) {

                log.error(t.pos(), "annotation.value.must.be.name.value");

                enterAttributeValue(t.type = syms.errType, t, env);

                continue;

            }

            JCIdent left = (JCIdent)assign.lhs;

            Symbol method = rs.resolveQualifiedMethod(assign.rhs.pos(),

                                                          env,

                                                          a.type,

                                                          left.name,

                                                          List.<Type>nil(),

                                                          null);

            left.sym = method;

            left.type = method.type;

            if (method.owner != a.type.tsym && !isError)

                log.error(left.pos(), "no.annotation.member", left.name, a.type);

            Type result = method.type.getReturnType();

            Attribute value = enterAttributeValue(result, assign.rhs, env);

            if (!method.type.isErroneous())

                buf.append(new Pair<>((MethodSymbol)method, value));

            t.type = result;

        }

    }

    Attribute enterAttributeValue(Type expected,

                                  JCExpression tree,

                                  Env<AttrContext> env) {

        //first, try completing the attribution value sym - if a completion

        //error is thrown, we should recover gracefully, and display an

        //ordinary resolution diagnostic.

        try {

            expected.tsym.complete();

        } catch(CompletionFailure e) {

            log.error(tree.pos(), "cant.resolve", Kinds.kindName(e.sym), e.sym);

            expected = syms.errType;

        }

        if (expected.hasTag(ARRAY)) {

            if (!tree.hasTag(NEWARRAY)) {

                tree = make.at(tree.pos).

                    NewArray(null, List.<JCExpression>nil(), List.of(tree));

            }

            JCNewArray na = (JCNewArray)tree;

            if (na.elemtype != null) {

                log.error(na.elemtype.pos(), "new.not.allowed.in.annotation");

            }

            ListBuffer<Attribute> buf = new ListBuffer<>();

            for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {

                buf.append(enterAttributeValue(types.elemtype(expected),

                                               l.head,

                                               env));

            }

            na.type = expected;

            return new Attribute.

                Array(expected, buf.toArray(new Attribute[buf.length()]));

        }

        if (tree.hasTag(NEWARRAY)) { //error recovery

            if (!expected.isErroneous())

                log.error(tree.pos(), "annotation.value.not.allowable.type");

            JCNewArray na = (JCNewArray)tree;

            if (na.elemtype != null) {

                log.error(na.elemtype.pos(), "new.not.allowed.in.annotation");

            }

            for (List<JCExpression> l = na.elems; l.nonEmpty(); l=l.tail) {

                enterAttributeValue(syms.errType,

                                    l.head,

                                    env);

            }

            return new Attribute.Error(syms.errType);

        }

        if ((expected.tsym.flags() & Flags.ANNOTATION) != 0) {

            if (tree.hasTag(ANNOTATION)) {

                return enterAnnotation((JCAnnotation)tree, expected, env);

            } else {

                log.error(tree.pos(), "annotation.value.must.be.annotation");

                expected = syms.errType;

            }

        }

        if (tree.hasTag(ANNOTATION)) { //error recovery

            if (!expected.isErroneous())

                log.error(tree.pos(), "annotation.not.valid.for.type", expected);

            enterAnnotation((JCAnnotation)tree, syms.errType, env);

            return new Attribute.Error(((JCAnnotation)tree).annotationType.type);

        }

        if (expected.isPrimitive() ||

            (types.isSameType(expected, syms.stringType) && !expected.hasTag(TypeTag.ERROR))) {

            Type result = attr.attribExpr(tree, env, expected);

            if (result.isErroneous())

                return new Attribute.Error(result.getOriginalType());

            if (result.constValue() == null) {

                log.error(tree.pos(), "attribute.value.must.be.constant");

                return new Attribute.Error(expected);

            }

            result = cfolder.coerce(result, expected);

            return new Attribute.Constant(expected, result.constValue());

        }

        if (expected.tsym == syms.classType.tsym) {

            Type result = attr.attribExpr(tree, env, expected);

            if (result.isErroneous()) {

                // Does it look like an unresolved class literal?

                if (TreeInfo.name(tree) == names._class &&

                    ((JCFieldAccess) tree).selected.type.isErroneous()) {

                    Name n = (((JCFieldAccess) tree).selected).type.tsym.flatName();

                    return new Attribute.UnresolvedClass(expected,

                            types.createErrorType(n,

                                    syms.unknownSymbol, syms.classType));

                } else {

                    return new Attribute.Error(result.getOriginalType());

                }

            }

            // Class literals look like field accesses of a field named class

            // at the tree level

            if (TreeInfo.name(tree) != names._class) {

                log.error(tree.pos(), "annotation.value.must.be.class.literal");

                return new Attribute.Error(syms.errType);

            }

            return new Attribute.Class(types,

                                       (((JCFieldAccess) tree).selected).type);

        }

        if (expected.hasTag(CLASS) &&

            (expected.tsym.flags() & Flags.ENUM) != 0) {

            Type result = attr.attribExpr(tree, env, expected);

            Symbol sym = TreeInfo.symbol(tree);

            if (sym == null ||

                TreeInfo.nonstaticSelect(tree) ||

                sym.kind != Kinds.VAR ||

                (sym.flags() & Flags.ENUM) == 0) {

                log.error(tree.pos(), "enum.annotation.must.be.enum.constant");

                return new Attribute.Error(result.getOriginalType());

            }

            VarSymbol enumerator = (VarSymbol) sym;

            return new Attribute.Enum(expected, enumerator);

        }

        //error recovery:

        if (!expected.isErroneous())

            log.error(tree.pos(), "annotation.value.not.allowable.type");

        return new Attribute.Error(attr.attribExpr(tree, env, expected));

    }

    /* *********************************

     * Support for repeating annotations

     ***********************************/

    /* Process repeated annotations. This method returns the

     * synthesized container annotation or null IFF all repeating

     * annotation are invalid.  This method reports errors/warnings.

     */

    private <T extends Attribute.Compound> T processRepeatedAnnotations(List<T> annotations,

            Symbol on) {

        T firstOccurrence = annotations.head;

        List<Attribute> repeated = List.nil();

        Type origAnnoType = null;

        Type arrayOfOrigAnnoType = null;

        Type targetContainerType = null;

        MethodSymbol containerValueSymbol = null;

        Assert.check(!annotations.isEmpty() &&

                     !annotations.tail.isEmpty()); // i.e. size() > 1

        int count = 0;

        for (List<T> al = annotations;

             !al.isEmpty();

             al = al.tail)