/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You under the Apache License, Version 2.0

 * (the "License"); you may not use this file except in compliance with

 * the License.  You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.sun.org.apache.bcel.internal.generic;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.DataInput;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import com.sun.org.apache.bcel.internal.classfile.AnnotationEntry;

import com.sun.org.apache.bcel.internal.classfile.Attribute;

import com.sun.org.apache.bcel.internal.classfile.ConstantUtf8;

import com.sun.org.apache.bcel.internal.classfile.ElementValuePair;

import com.sun.org.apache.bcel.internal.classfile.RuntimeInvisibleAnnotations;

import com.sun.org.apache.bcel.internal.classfile.RuntimeInvisibleParameterAnnotations;

import com.sun.org.apache.bcel.internal.classfile.RuntimeVisibleAnnotations;

import com.sun.org.apache.bcel.internal.classfile.RuntimeVisibleParameterAnnotations;

/**

 * @since 6.0

 */

public class AnnotationEntryGen {

    private int typeIndex;

    private List<ElementValuePairGen> evs;

    private final ConstantPoolGen cpool;

    private boolean isRuntimeVisible = false;

    /**

     * Here we are taking a fixed annotation of type Annotation and building a

     * modifiable AnnotationGen object. If the pool passed in is for a different

     * class file, then copyPoolEntries should have been passed as true as that

     * will force us to do a deep copy of the annotation and move the cpool

     * entries across. We need to copy the type and the element name value pairs

     * and the visibility.

     */

    public AnnotationEntryGen(final AnnotationEntry a, final ConstantPoolGen cpool,

                              final boolean copyPoolEntries) {

        this.cpool = cpool;

        if (copyPoolEntries) {

            typeIndex = cpool.addUtf8(a.getAnnotationType());

        } else {

            typeIndex = a.getAnnotationTypeIndex();

        }

        isRuntimeVisible = a.isRuntimeVisible();

        evs = copyValues(a.getElementValuePairs(), cpool, copyPoolEntries);

    }

    private List<ElementValuePairGen> copyValues(final ElementValuePair[] in, final ConstantPoolGen cpool,

                                                 final boolean copyPoolEntries) {

        final List<ElementValuePairGen> out = new ArrayList<>();

        for (final ElementValuePair nvp : in) {

            out.add(new ElementValuePairGen(nvp, cpool, copyPoolEntries));

        }

        return out;

    }

    private AnnotationEntryGen(final ConstantPoolGen cpool) {

        this.cpool = cpool;

    }

    /**

     * Retrieve an immutable version of this AnnotationGen

     */

    public AnnotationEntry getAnnotation() {

        final AnnotationEntry a = new AnnotationEntry(typeIndex, cpool.getConstantPool(),

                isRuntimeVisible);

        for (final ElementValuePairGen element : evs) {

            a.addElementNameValuePair(element.getElementNameValuePair());

        }

        return a;

    }

    public AnnotationEntryGen(final ObjectType type,

                              final List<ElementValuePairGen> elements, final boolean vis,

                              final ConstantPoolGen cpool) {

        this.cpool = cpool;

        this.typeIndex = cpool.addUtf8(type.getSignature());

        evs = elements;

        isRuntimeVisible = vis;

    }

    public static AnnotationEntryGen read(final DataInput dis,

                                          final ConstantPoolGen cpool, final boolean b) throws IOException {

        final AnnotationEntryGen a = new AnnotationEntryGen(cpool);

        a.typeIndex = dis.readUnsignedShort();

        final int elemValuePairCount = dis.readUnsignedShort();

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

            final int nidx = dis.readUnsignedShort();

            a.addElementNameValuePair(new ElementValuePairGen(nidx,

                    ElementValueGen.readElementValue(dis, cpool), cpool));

        }

        a.isRuntimeVisible(b);

        return a;

    }

    public void dump(final DataOutputStream dos) throws IOException {

        dos.writeShort(typeIndex); // u2 index of type name in cpool

        dos.writeShort(evs.size()); // u2 element_value pair count

        for (final ElementValuePairGen envp : evs) {

            envp.dump(dos);

        }

    }

    public void addElementNameValuePair(final ElementValuePairGen evp) {

        if (evs == null) {

            evs = new ArrayList<>();

        }

        evs.add(evp);

    }

    public int getTypeIndex() {

        return typeIndex;

    }

    public final String getTypeSignature() {

        // ConstantClass c = (ConstantClass)cpool.getConstant(typeIndex);

        final ConstantUtf8 utf8 = (ConstantUtf8) cpool

                .getConstant(typeIndex/* c.getNameIndex() */);

        return utf8.getBytes();

    }

    public final String getTypeName() {

        return getTypeSignature();// BCELBUG: Should I use this instead?

        // Utility.signatureToString(getTypeSignature());

    }

    /**

     * Returns list of ElementNameValuePair objects

     */

    public List<ElementValuePairGen> getValues() {

        return evs;

    }

    @Override

    public String toString() {

        final StringBuilder s = new StringBuilder(32); // CHECKSTYLE IGNORE MagicNumber

        s.append("AnnotationGen:[").append(getTypeName()).append(" #").append(evs.size()).append(" {");

        for (int i = 0; i < evs.size(); i++) {

            s.append(evs.get(i));

            if (i + 1 < evs.size()) {

                s.append(",");

            }

        }

        s.append("}]");

        return s.toString();

    }

    public String toShortString() {

        final StringBuilder s = new StringBuilder();

        s.append("@").append(getTypeName()).append("(");

        for (int i = 0; i < evs.size(); i++) {

            s.append(evs.get(i));

            if (i + 1 < evs.size()) {

                s.append(",");

            }

        }

        s.append(")");

        return s.toString();

    }

    private void isRuntimeVisible(final boolean b) {

        isRuntimeVisible = b;

    }

    public boolean isRuntimeVisible() {

        return isRuntimeVisible;

    }

    /**

     * Converts a list of AnnotationGen objects into a set of attributes

     * that can be attached to the class file.

     *

     * @param cp  The constant pool gen where we can create the necessary name refs

     * @param annotationEntryGens An array of AnnotationGen objects

     */

    static Attribute[] getAnnotationAttributes(final ConstantPoolGen cp, final AnnotationEntryGen[] annotationEntryGens) {

        if (annotationEntryGens.length == 0) {

            return new Attribute[0];

        }

        try {

            int countVisible = 0;

            int countInvisible = 0;

            //  put the annotations in the right output stream

            for (final AnnotationEntryGen a : annotationEntryGens) {

                if (a.isRuntimeVisible()) {

                    countVisible++;

                } else {

                    countInvisible++;

                }

            }

            final ByteArrayOutputStream rvaBytes = new ByteArrayOutputStream();

            final ByteArrayOutputStream riaBytes = new ByteArrayOutputStream();

            try (DataOutputStream rvaDos = new DataOutputStream(rvaBytes);

                    DataOutputStream riaDos = new DataOutputStream(riaBytes)) {

                rvaDos.writeShort(countVisible);

                riaDos.writeShort(countInvisible);

                // put the annotations in the right output stream

                for (final AnnotationEntryGen a : annotationEntryGens) {

                    if (a.isRuntimeVisible()) {

                        a.dump(rvaDos);

                    } else {

                        a.dump(riaDos);

                    }

                }

            }

            final byte[] rvaData = rvaBytes.toByteArray();

            final byte[] riaData = riaBytes.toByteArray();

            int rvaIndex = -1;

            int riaIndex = -1;

            if (rvaData.length > 2) {

                rvaIndex = cp.addUtf8("RuntimeVisibleAnnotations");

            }

            if (riaData.length > 2) {

                riaIndex = cp.addUtf8("RuntimeInvisibleAnnotations");

            }

            final List<Attribute> newAttributes = new ArrayList<>();

            if (rvaData.length > 2) {

                newAttributes.add(

                        new RuntimeVisibleAnnotations(rvaIndex, rvaData.length,

                            new DataInputStream(new ByteArrayInputStream(rvaData)), cp.getConstantPool()));

            }

            if (riaData.length > 2) {

                newAttributes.add(

                        new RuntimeInvisibleAnnotations(riaIndex, riaData.length,

                            new DataInputStream(new ByteArrayInputStream(riaData)), cp.getConstantPool()));

            }

            return newAttributes.toArray(new Attribute[newAttributes.size()]);

        } catch (final IOException e) {

            System.err.println("IOException whilst processing annotations. " +

                    e.getMessage());

        }

        return null;

    }

    /**

     * Annotations against a class are stored in one of four attribute kinds:

     * - RuntimeVisibleParameterAnnotations

     * - RuntimeInvisibleParameterAnnotations

     */

    static Attribute[] getParameterAnnotationAttributes(

            final ConstantPoolGen cp,

            final List<AnnotationEntryGen>[] /*Array of lists, array size depends on #params */vec) {

        final int[] visCount = new int[vec.length];

        int totalVisCount = 0;

        final int[] invisCount = new int[vec.length];

        int totalInvisCount = 0;

        try {

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

                if (vec[i] != null) {

                    for (final AnnotationEntryGen element : vec[i]) {

                        if (element.isRuntimeVisible()) {

                            visCount[i]++;

                            totalVisCount++;

                        } else {

                            invisCount[i]++;

                            totalInvisCount++;

                        }

                    }

                }

            }

            // Lets do the visible ones

            final ByteArrayOutputStream rvaBytes = new ByteArrayOutputStream();

            try (DataOutputStream rvaDos = new DataOutputStream(rvaBytes)) {

                rvaDos.writeByte(vec.length); // First goes number of parameters

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

                    rvaDos.writeShort(visCount[i]);

                    if (visCount[i] > 0) {

                        for (final AnnotationEntryGen element : vec[i]) {

                            if (element.isRuntimeVisible()) {

                                element.dump(rvaDos);

                            }

                        }

                    }

                }

            }

            // Lets do the invisible ones

            final ByteArrayOutputStream riaBytes = new ByteArrayOutputStream();

            try (DataOutputStream riaDos = new DataOutputStream(riaBytes)) {

                riaDos.writeByte(vec.length); // First goes number of parameters

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

                    riaDos.writeShort(invisCount[i]);

                    if (invisCount[i] > 0) {

                        for (final AnnotationEntryGen element : vec[i]) {

                            if (!element.isRuntimeVisible()) {

                                element.dump(riaDos);

                            }

                        }

                    }

                }

            }

            final byte[] rvaData = rvaBytes.toByteArray();

            final byte[] riaData = riaBytes.toByteArray();

            int rvaIndex = -1;

            int riaIndex = -1;

            if (totalVisCount > 0) {

                rvaIndex = cp.addUtf8("RuntimeVisibleParameterAnnotations");

            }

            if (totalInvisCount > 0) {

                riaIndex = cp.addUtf8("RuntimeInvisibleParameterAnnotations");

            }

            final List<Attribute> newAttributes = new ArrayList<>();

            if (totalVisCount > 0) {

                newAttributes

                        .add(new RuntimeVisibleParameterAnnotations(rvaIndex,

                                rvaData.length,

                                new DataInputStream(new ByteArrayInputStream(rvaData)),

                                    cp.getConstantPool()));

            }

            if (totalInvisCount > 0) {

                newAttributes

                        .add(new RuntimeInvisibleParameterAnnotations(riaIndex,

                                riaData.length,

                                new DataInputStream(new ByteArrayInputStream(riaData)),

                                    cp.getConstantPool()));

            }

            return newAttributes.toArray(new Attribute[newAttributes.size()]);

        } catch (final IOException e) {

            System.err.println("IOException whilst processing parameter annotations." +

                    e.getMessage());

        }

        return null;

    }

}