/*
    * 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
    *
   *   https://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 org.apache.commons.compress.harmony.unpack200.bytecode;
  
  import java.io.DataOutputStream;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.List;
  
  /**
   * Abstracts Annotations attributes.
   */
  public abstract class AnnotationsAttribute extends Attribute {
  
      /**
       * Represents the annotation structure for class file attributes.
       */
      public static class Annotation {
  
          private final int numPairs;
          private final CPUTF8[] elementNames;
          private final ElementValue[] elementValues;
          private final CPUTF8 type;
  
          // Resolved values
          private int typeIndex;
          private int[] nameIndexes;
  
          /**
           * Constructs a new instance.
           *
           * @param numPairs      Number of pairs, matches the lengths of {@code elementNames} and {@code elementValues}.
           * @param type          Type.
           * @param elementNames  Element names.
           * @param elementValues Element values.
           */
          public Annotation(final int numPairs, final CPUTF8 type, final CPUTF8[] elementNames, final ElementValue[] elementValues) {
              this.numPairs = numPairs;
              this.type = type;
              this.elementNames = elementNames;
              this.elementValues = elementValues;
          }
  
          /**
           * Gets a list of class file entries.
           *
           * @return a list of class file entries.
           */
          public List<Object> getClassFileEntries() {
              final List<Object> entries = new ArrayList<>();
              for (int i = 0; i < elementNames.length; i++) {
                  entries.add(elementNames[i]);
                  entries.addAll(elementValues[i].getClassFileEntries());
              }
              entries.add(type);
              return entries;
          }
  
          /**
           * Gets the cumulative length of all element values.
           *
           * @return the cumulative length of all element values.
           */
          public int getLength() {
              int length = 4;
              for (int i = 0; i < numPairs; i++) {
                  length += 2;
                  length += elementValues[i].getLength();
              }
              return length;
          }
  
          /**
           * Resolves this instance against a given pool.
           *
           * @param pool a class constant pool.
           */
          public void resolve(final ClassConstantPool pool) {
              type.resolve(pool);
              typeIndex = pool.indexOf(type);
              nameIndexes = new int[numPairs];
              for (int i = 0; i < elementNames.length; i++) {
                  elementNames[i].resolve(pool);
                 nameIndexes[i] = pool.indexOf(elementNames[i]);
                 elementValues[i].resolve(pool);
             }
         }
 
         /**
          * Writes this instance to the given output stream.
          *
          * @param dos the output stream.
          * @throws IOException if an I/O error occurs.
          */
         public void writeBody(final DataOutputStream dos) throws IOException {
             dos.writeShort(typeIndex);
             dos.writeShort(numPairs);
             for (int i = 0; i < numPairs; i++) {
                 dos.writeShort(nameIndexes[i]);
                 elementValues[i].writeBody(dos);
             }
         }
     }
 
     /**
      * Pairs a tag and value.
      */
     public static class ElementValue {
 
         private final Object value;
         private final int tag;
 
         // resolved value index if it's a constant
         private int constantValueIndex = -1;
 
         /**
          * Constructs a new instance.
          *
          * @param tag a tag.
          * @param value a value.
          */
         public ElementValue(final int tag, final Object value) {
             this.tag = tag;
             this.value = value;
         }
 
         /**
          * Gets a list of class file entries.
          *
          * @return a list of class file entries.
          */
         public List<Object> getClassFileEntries() {
             final List<Object> entries = new ArrayList<>(1);
             if (value instanceof CPNameAndType) {
                 // used to represent enum, so don't include the actual CPNameAndType
                 entries.add(((CPNameAndType) value).name);
                 entries.add(((CPNameAndType) value).descriptor);
             } else if (value instanceof ClassFileEntry) {
                 // TODO? ClassFileEntry is an Object
                 entries.add(value);
             } else if (value instanceof ElementValue[]) {
                 final ElementValue[] values = (ElementValue[]) value;
                 for (final ElementValue value2 : values) {
                     entries.addAll(value2.getClassFileEntries());
                 }
             } else if (value instanceof Annotation) {
                 entries.addAll(((Annotation) value).getClassFileEntries());
             }
             return entries;
         }
 
         /**
          * Gets the length.
          *
          * @return the length.
          */
         public int getLength() {
             switch (tag) {
             case 'B':
             case 'C':
             case 'D':
             case 'F':
             case 'I':
             case 'J':
             case 'S':
             case 'Z':
             case 'c':
             case 's':
                 return 3;
             case 'e':
                 return 5;
             case '[':
                 int length = 3;
                 final ElementValue[] nestedValues = (ElementValue[]) value;
                 for (final ElementValue nestedValue : nestedValues) {
                     length += nestedValue.getLength();
                 }
                 return length;
             case '@':
                 return 1 + ((Annotation) value).getLength();
             }
             return 0;
         }
 
         /**
          * Resolves this instance against a given pool.
          *
          * @param pool a class constant pool.
          */
         public void resolve(final ClassConstantPool pool) {
             if (value instanceof CPConstant) {
                 ((CPConstant) value).resolve(pool);
                 constantValueIndex = pool.indexOf((CPConstant) value);
             } else if (value instanceof CPClass) {
                 ((CPClass) value).resolve(pool);
                 constantValueIndex = pool.indexOf((CPClass) value);
             } else if (value instanceof CPUTF8) {
                 ((CPUTF8) value).resolve(pool);
                 constantValueIndex = pool.indexOf((CPUTF8) value);
             } else if (value instanceof CPNameAndType) {
                 ((CPNameAndType) value).resolve(pool);
             } else if (value instanceof Annotation) {
                 ((Annotation) value).resolve(pool);
             } else if (value instanceof ElementValue[]) {
                 final ElementValue[] nestedValues = (ElementValue[]) value;
                 for (final ElementValue nestedValue : nestedValues) {
                     nestedValue.resolve(pool);
                 }
             }
         }
 
         /**
          * Writes this instance to the given output stream.
          *
          * @param dos the output stream.
          * @throws IOException if an I/O error occurs.
          */
         public void writeBody(final DataOutputStream dos) throws IOException {
             dos.writeByte(tag);
             if (constantValueIndex != -1) {
                 dos.writeShort(constantValueIndex);
             } else if (value instanceof CPNameAndType) {
                 ((CPNameAndType) value).writeBody(dos);
             } else if (value instanceof Annotation) {
                 ((Annotation) value).writeBody(dos);
             } else if (value instanceof ElementValue[]) {
                 final ElementValue[] nestedValues = (ElementValue[]) value;
                 dos.writeShort(nestedValues.length);
                 for (final ElementValue nestedValue : nestedValues) {
                     nestedValue.writeBody(dos);
                 }
             } else {
                 throw new Error("");
             }
         }
     }
 
     /**
      * Constructs a new instance for an attribute name.
      *
      * @param attributeName an attribute name.
      */
     public AnnotationsAttribute(final CPUTF8 attributeName) {
         super(attributeName);
     }
 
 }