/*

 * 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 sun.reflect.annotation;

import java.lang.annotation.*;

import java.util.*;

import java.nio.ByteBuffer;

import java.nio.BufferUnderflowException;

import java.lang.reflect.*;

import sun.reflect.ConstantPool;

import sun.reflect.generics.parser.SignatureParser;

import sun.reflect.generics.tree.TypeSignature;

import sun.reflect.generics.factory.GenericsFactory;

import sun.reflect.generics.factory.CoreReflectionFactory;

import sun.reflect.generics.visitor.Reifier;

import sun.reflect.generics.scope.ClassScope;

/**

 * Parser for Java programming language annotations.  Translates

 * annotation byte streams emitted by compiler into annotation objects.

 *

 * @author  Josh Bloch

 * @since   1.5

 */

public class AnnotationParser {

    /**

     * Parses the annotations described by the specified byte array.

     * resolving constant references in the specified constant pool.

     * The array must contain an array of annotations as described

     * in the RuntimeVisibleAnnotations_attribute:

     *

     *   u2 num_annotations;

     *   annotation annotations[num_annotations];

     *

     * @throws AnnotationFormatError if an annotation is found to be

     *         malformed.

     */

    public static Map<Class<? extends Annotation>, Annotation> parseAnnotations(

                byte[] rawAnnotations,

                ConstantPool constPool,

                Class<?> container) {

        if (rawAnnotations == null)

            return Collections.emptyMap();

        try {

            return parseAnnotations2(rawAnnotations, constPool, container);

        } catch(BufferUnderflowException e) {

            throw new AnnotationFormatError("Unexpected end of annotations.");

        } catch(IllegalArgumentException e) {

            // Type mismatch in constant pool

            throw new AnnotationFormatError(e);

        }

    }

    private static Map<Class<? extends Annotation>, Annotation> parseAnnotations2(

                byte[] rawAnnotations,

                ConstantPool constPool,

                Class<?> container) {

        Map<Class<? extends Annotation>, Annotation> result =

            new LinkedHashMap<Class<? extends Annotation>, Annotation>();

        ByteBuffer buf = ByteBuffer.wrap(rawAnnotations);

        int numAnnotations = buf.getShort() & 0xFFFF;

        for (int i = 0; i < numAnnotations; i++) {

            Annotation a = parseAnnotation(buf, constPool, container, false);

            if (a != null) {

                Class<? extends Annotation> klass = a.annotationType();

                AnnotationType type = AnnotationType.getInstance(klass);

                if (type.retention() == RetentionPolicy.RUNTIME)

                    if (result.put(klass, a) != null)

                        throw new AnnotationFormatError(

                            "Duplicate annotation for class: "+klass+": " + a);

            }

        }

        return result;

    }

    /**

     * Parses the parameter annotations described by the specified byte array.

     * resolving constant references in the specified constant pool.

     * The array must contain an array of annotations as described

     * in the RuntimeVisibleParameterAnnotations_attribute:

     *

     *    u1 num_parameters;

     *    {

     *        u2 num_annotations;

     *        annotation annotations[num_annotations];

     *    } parameter_annotations[num_parameters];

     *

     * Unlike parseAnnotations, rawAnnotations must not be null!

     * A null value must be handled by the caller.  This is so because

     * we cannot determine the number of parameters if rawAnnotations

     * is null.  Also, the caller should check that the number

     * of parameters indicated by the return value of this method

     * matches the actual number of method parameters.  A mismatch

     * indicates that an AnnotationFormatError should be thrown.

     *

     * @throws AnnotationFormatError if an annotation is found to be

     *         malformed.

     */

    public static Annotation[][] parseParameterAnnotations(

                    byte[] rawAnnotations,

                    ConstantPool constPool,

                    Class<?> container) {

        try {

            return parseParameterAnnotations2(rawAnnotations, constPool, container);

        } catch(BufferUnderflowException e) {

            throw new AnnotationFormatError(

                "Unexpected end of parameter annotations.");

        } catch(IllegalArgumentException e) {

            // Type mismatch in constant pool

            throw new AnnotationFormatError(e);

        }

    }

    private static Annotation[][] parseParameterAnnotations2(

                    byte[] rawAnnotations,

                    ConstantPool constPool,

                    Class<?> container) {

        ByteBuffer buf = ByteBuffer.wrap(rawAnnotations);

        int numParameters = buf.get() & 0xFF;

        Annotation[][] result = new Annotation[numParameters][];

        for (int i = 0; i < numParameters; i++) {

            int numAnnotations = buf.getShort() & 0xFFFF;

            List<Annotation> annotations =

                new ArrayList<Annotation>(numAnnotations);

            for (int j = 0; j < numAnnotations; j++) {

                Annotation a = parseAnnotation(buf, constPool, container, false);

                if (a != null) {

                    AnnotationType type = AnnotationType.getInstance(

                                              a.annotationType());

                    if (type.retention() == RetentionPolicy.RUNTIME)

                        annotations.add(a);

                }

            }

            result[i] = annotations.toArray(EMPTY_ANNOTATIONS_ARRAY);

        }

        return result;

    }

    private static final Annotation[] EMPTY_ANNOTATIONS_ARRAY =

                    new Annotation[0];

    /**

     * Parses the annotation at the current position in the specified

     * byte buffer, resolving constant references in the specified constant

     * pool.  The cursor of the byte buffer must point to an "annotation

     * structure" as described in the RuntimeVisibleAnnotations_attribute:

     *

     * annotation {

     *    u2    type_index;

     *       u2    num_member_value_pairs;

     *       {    u2    member_name_index;

     *             member_value value;

     *       }    member_value_pairs[num_member_value_pairs];

     *    }

     * }

     *

     * Returns the annotation, or null if the annotation's type cannot

     * be found by the VM, or is not a valid annotation type.

     *

     * @param exceptionOnMissingAnnotationClass if true, throw

     * TypeNotPresentException if a referenced annotation type is not

     * available at runtime

     */

    @SuppressWarnings("unchecked")

    private static Annotation parseAnnotation(ByteBuffer buf,

                                              ConstantPool constPool,

                                              Class<?> container,

                                              boolean exceptionOnMissingAnnotationClass) {

        int typeIndex = buf.getShort() & 0xFFFF;

        Class<? extends Annotation> annotationClass = null;

        String sig = "[unknown]";

        try {

            try {

                sig = constPool.getUTF8At(typeIndex);

                annotationClass = (Class<? extends Annotation>)parseSig(sig, container);

            } catch (IllegalArgumentException ex) {

                // support obsolete early jsr175 format class files

                annotationClass = (Class<? extends Annotation>)constPool.getClassAt(typeIndex);

            }

        } catch (NoClassDefFoundError e) {

            if (exceptionOnMissingAnnotationClass)

                // note: at this point sig is "[unknown]" or VM-style

                // name instead of a binary name

                throw new TypeNotPresentException(sig, e);

            skipAnnotation(buf, false);

            return null;

        }

        catch (TypeNotPresentException e) {

            if (exceptionOnMissingAnnotationClass)

                throw e;

            skipAnnotation(buf, false);

            return null;

        }

        AnnotationType type = null;

        try {

            type = AnnotationType.getInstance(annotationClass);

        } catch (IllegalArgumentException e) {

            skipAnnotation(buf, false);

            return null;

        }

        Map<String, Class<?>> memberTypes = type.memberTypes();

        Map<String, Object> memberValues =

            new LinkedHashMap<String, Object>(type.memberDefaults());

        int numMembers = buf.getShort() & 0xFFFF;

        for (int i = 0; i < numMembers; i++) {

            int memberNameIndex = buf.getShort() & 0xFFFF;

            String memberName = constPool.getUTF8At(memberNameIndex);

            Class<?> memberType = memberTypes.get(memberName);

            if (memberType == null) {

                // Member is no longer present in annotation type; ignore it

                skipMemberValue(buf);

            } else {

                Object value = parseMemberValue(memberType, buf, constPool, container);

                if (value instanceof AnnotationTypeMismatchExceptionProxy)

                    ((AnnotationTypeMismatchExceptionProxy) value).

                        setMember(type.members().get(memberName));

                memberValues.put(memberName, value);

            }

        }

        return annotationForMap(annotationClass, memberValues);

    }

    /**

     * Returns an annotation of the given type backed by the given

     * member -> value map.

     */

    public static Annotation annotationForMap(

        Class<? extends Annotation> type, Map<String, Object> memberValues)

    {

        return (Annotation) Proxy.newProxyInstance(

            type.getClassLoader(), new Class<?>[] { type },

            new AnnotationInvocationHandler(type, memberValues));

    }

    /**

     * Parses the annotation member value at the current position in the

     * specified byte buffer, resolving constant references in the specified

     * constant pool.  The cursor of the byte buffer must point to a

     * "member_value structure" as described in the

     * RuntimeVisibleAnnotations_attribute:

     *

     *  member_value {

     *    u1 tag;

     *    union {

     *       u2   const_value_index;

     *       {

     *           u2   type_name_index;

     *           u2   const_name_index;

     *       } enum_const_value;

     *       u2   class_info_index;

     *       annotation annotation_value;

     *       {

     *           u2    num_values;

     *           member_value values[num_values];

     *       } array_value;

     *    } value;

     * }

     *

     * The member must be of the indicated type. If it is not, this

     * method returns an AnnotationTypeMismatchExceptionProxy.

     */

    @SuppressWarnings("unchecked")

    public static Object parseMemberValue(Class<?> memberType,

                                          ByteBuffer buf,

                                          ConstantPool constPool,

                                          Class<?> container) {

        Object result = null;

        int tag = buf.get();

        switch(tag) {

          case 'e':

              return parseEnumValue((Class<? extends Enum<?>>)memberType, buf, constPool, container);

          case 'c':

              result = parseClassValue(buf, constPool, container);

              break;

          case '@':

              result = parseAnnotation(buf, constPool, container, true);

              break;

          case '[':

              return parseArray(memberType, buf, constPool, container);

          default:

              result = parseConst(tag, buf, constPool);

        }

        if (!(result instanceof ExceptionProxy) &&

            !memberType.isInstance(result))

            result = new AnnotationTypeMismatchExceptionProxy(

                result.getClass() + "[" + result + "]");

        return result;

    }

    /**

     * Parses the primitive or String annotation member value indicated by

     * the specified tag byte at the current position in the specified byte

     * buffer, resolving constant reference in the specified constant pool.

     * The cursor of the byte buffer must point to an annotation member value

     * of the type indicated by the specified tag, as described in the

     * RuntimeVisibleAnnotations_attribute:

     *

     *       u2   const_value_index;

     */

    private static Object parseConst(int tag,

                                     ByteBuffer buf, ConstantPool constPool) {

        int constIndex = buf.getShort() & 0xFFFF;

        switch(tag) {

          case 'B':

            return Byte.valueOf((byte) constPool.getIntAt(constIndex));

          case 'C':

            return Character.valueOf((char) constPool.getIntAt(constIndex));

          case 'D':

            return Double.valueOf(constPool.getDoubleAt(constIndex));

          case 'F':

            return Float.valueOf(constPool.getFloatAt(constIndex));

          case 'I':

            return Integer.valueOf(constPool.getIntAt(constIndex));

          case 'J':

            return Long.valueOf(constPool.getLongAt(constIndex));

          case 'S':

            return Short.valueOf((short) constPool.getIntAt(constIndex));

          case 'Z':

            return Boolean.valueOf(constPool.getIntAt(constIndex) != 0);

          case 's':

            return constPool.getUTF8At(constIndex);

          default:

            throw new AnnotationFormatError(

                "Invalid member-value tag in annotation: " + tag);

        }

    }

    /**

     * Parses the Class member value at the current position in the

     * specified byte buffer, resolving constant references in the specified

     * constant pool.  The cursor of the byte buffer must point to a "class

     * info index" as described in the RuntimeVisibleAnnotations_attribute:

     *

     *       u2   class_info_index;

     */

    private static Object parseClassValue(ByteBuffer buf,

                                          ConstantPool constPool,

                                          Class<?> container) {

        int classIndex = buf.getShort() & 0xFFFF;

        try {

            try {

                String sig = constPool.getUTF8At(classIndex);

                return parseSig(sig, container);

            } catch (IllegalArgumentException ex) {

                // support obsolete early jsr175 format class files

                return constPool.getClassAt(classIndex);

            }

        } catch (NoClassDefFoundError e) {

            return new TypeNotPresentExceptionProxy("[unknown]", e);

        }

        catch (TypeNotPresentException e) {

            return new TypeNotPresentExceptionProxy(e.typeName(), e.getCause());

        }

    }

    private static Class<?> parseSig(String sig, Class<?> container) {

        if (sig.equals("V")) return void.class;

        SignatureParser parser = SignatureParser.make();

        TypeSignature typeSig = parser.parseTypeSig(sig);

        GenericsFactory factory = CoreReflectionFactory.make(container, ClassScope.make(container));

        Reifier reify = Reifier.make(factory);

        typeSig.accept(reify);

        Type result = reify.getResult();

        return toClass(result);

    }

    static Class<?> toClass(Type o) {

        if (o instanceof GenericArrayType)

            return Array.newInstance(toClass(((GenericArrayType)o).getGenericComponentType()),

                                     0)

                .getClass();

        return (Class)o;

    }

    /**

     * Parses the enum constant member value at the current position in the

     * specified byte buffer, resolving constant references in the specified

     * constant pool.  The cursor of the byte buffer must point to a

     * "enum_const_value structure" as described in the

     * RuntimeVisibleAnnotations_attribute:

     *

     *       {

     *           u2   type_name_index;

     *           u2   const_name_index;

     *       } enum_const_value;

     */

    @SuppressWarnings({"rawtypes", "unchecked"})

    private static Object parseEnumValue(Class<? extends Enum> enumType, ByteBuffer buf,

                                         ConstantPool constPool,

                                         Class<?> container) {

        int typeNameIndex = buf.getShort() & 0xFFFF;

        String typeName  = constPool.getUTF8At(typeNameIndex);

        int constNameIndex = buf.getShort() & 0xFFFF;

        String constName = constPool.getUTF8At(constNameIndex);

        if (!typeName.endsWith(";")) {

            // support now-obsolete early jsr175-format class files.

            if (!enumType.getName().equals(typeName))

            return new AnnotationTypeMismatchExceptionProxy(

                typeName + "." + constName);

        } else if (enumType != parseSig(typeName, container)) {

            return new AnnotationTypeMismatchExceptionProxy(

                typeName + "." + constName);

        }

        try {

            return  Enum.valueOf(enumType, constName);

        } catch(IllegalArgumentException e) {

            return new EnumConstantNotPresentExceptionProxy(

                (Class<? extends Enum<?>>)enumType, constName);

        }

    }

    /**

     * Parses the array value at the current position in the specified byte

     * buffer, resolving constant references in the specified constant pool.

     * The cursor of the byte buffer must point to an array value struct

     * as specified in the RuntimeVisibleAnnotations_attribute:

     *

     *       {

     *           u2    num_values;

     *           member_value values[num_values];

     *       } array_value;

     *

     * If the array values do not match arrayType, an

     * AnnotationTypeMismatchExceptionProxy will be returned.

     */

    @SuppressWarnings("unchecked")

    private static Object parseArray(Class<?> arrayType,

                                     ByteBuffer buf,

                                     ConstantPool constPool,

                                     Class<?> container) {

        int length = buf.getShort() & 0xFFFF;  // Number of array components

        Class<?> componentType = arrayType.getComponentType();

        if (componentType == byte.class) {

            return parseByteArray(length, buf, constPool);

        } else if (componentType == char.class) {

            return parseCharArray(length, buf, constPool);

        } else if (componentType == double.class) {

            return parseDoubleArray(length, buf, constPool);

        } else if (componentType == float.class) {

            return parseFloatArray(length, buf, constPool);

        } else if (componentType == int.class) {

            return parseIntArray(length, buf, constPool);

        } else if (componentType == long.class) {

            return parseLongArray(length, buf, constPool);

        } else if (componentType == short.class) {

            return parseShortArray(length, buf, constPool);

        } else if (componentType == boolean.class) {

            return parseBooleanArray(length, buf, constPool);

        } else if (componentType == String.class) {

            return parseStringArray(length, buf, constPool);

        } else if (componentType == Class.class) {

            return parseClassArray(length, buf, constPool, container);

        } else if (componentType.isEnum()) {

            return parseEnumArray(length, (Class<? extends Enum<?>>)componentType, buf,

                                  constPool, container);

        } else {

            assert componentType.isAnnotation();

            return parseAnnotationArray(length, (Class <? extends Annotation>)componentType, buf,

                                        constPool, container);

        }

    }

    private static Object parseByteArray(int length,

                                  ByteBuffer buf, ConstantPool constPool) {

        byte[] result = new byte[length];

        boolean typeMismatch = false;

        int tag = 0;

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

            tag = buf.get();

            if (tag == 'B') {

                int index = buf.getShort() & 0xFFFF;

                result[i] = (byte) constPool.getIntAt(index);

            } else {

                skipMemberValue(tag, buf);

                typeMismatch = true;

            }

        }

        return typeMismatch ? exceptionProxy(tag) : result;

    }

    private static Object parseCharArray(int length,

                                  ByteBuffer buf, ConstantPool constPool) {

        char[] result = new char[length];

        boolean typeMismatch = false;

        byte tag = 0;

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

            tag = buf.get();