/*

  * Licensed 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 org.apache.commons.classscan.bcel;

 import org.apache.bcel.classfile.AnnotationElementValue;

 import org.apache.bcel.classfile.AnnotationEntry;

 import org.apache.bcel.classfile.ArrayElementValue;

 import org.apache.bcel.classfile.ClassElementValue;

 import org.apache.bcel.classfile.ElementValue;

 import org.apache.bcel.classfile.ElementValuePair;

 import org.apache.bcel.classfile.EnumElementValue;

 import org.apache.bcel.classfile.SimpleElementValue;

 import org.apache.commons.classscan.builtin.ClassNameHelper;

 import org.apache.commons.classscan.model.MetaClass;

 import org.apache.commons.classscan.spi.model.SpiMetaAnnotation.SpiProperty;

 import org.apache.commons.classscan.spi.model.SpiMetaClassLoader;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 public class BcelProperty implements SpiProperty {

     private static final Logger logger = LoggerFactory.getLogger(BcelProperty.class);

     private final String propertyName;

     private Object value;

     public BcelProperty(ElementValuePair evPair) {

         propertyName = evPair.getNameString();

         value = evPair.getValue();

     }

         @Override

         public boolean resolve(SpiMetaClassLoader classLoader) {

                 value = createObject(classLoader, value);

                 return value!=null;

         }

     @Override

     public String getName() {

         return propertyName;

     }

     @Override

     public Object getValue() {

         return value;

     }

     private Object createObject(SpiMetaClassLoader classLoader, Object ev) {

         if (ev instanceof SimpleElementValue) {

             return createWrapper((SimpleElementValue) ev);

         }

         if (ev instanceof EnumElementValue) {

             return createEnum(classLoader, (EnumElementValue) ev);

         }

         if (ev instanceof ClassElementValue) {

             return createMetaClass(classLoader, (ClassElementValue) ev);

         }

         if (ev instanceof ArrayElementValue) {

             return createArray(classLoader, (ArrayElementValue) ev);

         }

         if (ev instanceof AnnotationElementValue) {

             return createAnnotation((AnnotationElementValue) ev);

         }

         logger.info("unknown annotation value type "+ev.getClass().getCanonicalName()+" for annotation property "+propertyName);

         return null;

     }

     private Object createWrapper(SimpleElementValue sev) {

         char primitiveTypeCode = (char) sev.getElementValueType();

         switch (primitiveTypeCode) {

         case 'B':

             return sev.getValueByte();

         case 'C':

             return sev.getValueChar();

         case 'D':

             return sev.getValueDouble();

         case 'F':

             return sev.getValueFloat();

         case 'I':

             return sev.getValueInt();

         case 'J':

             return sev.getValueLong();

         case 'S':

             return sev.getValueShort();

         case 'Z':

             return sev.getValueBoolean();

         case 's':

             return sev.getValueString();

         default:

             return null;

         }

     }

     private MetaClass createMetaClass(SpiMetaClassLoader classLoader, ClassElementValue ev) {

         String internalClassName = ev.getClassString();

         String canonicalName = ClassNameHelper.internalToCanonicalName(internalClassName);

         return classLoader.resolveMetaClass(canonicalName);

     }

     private Object createAnnotation(AnnotationElementValue aev) {

         AnnotationEntry ae = ((AnnotationElementValue) aev).getAnnotationEntry();

         return new BcelAnnotation(ae);

     }

     private Object createEnum(SpiMetaClassLoader classLoader, EnumElementValue eev) {

         String enumTypeString = ClassNameHelper.internalToCanonicalName(eev.getEnumTypeString());

         MetaClass dmc = classLoader.resolveMetaClass(enumTypeString);

         if(dmc==null) {

             logger.info("unknown enum type "+enumTypeString+" for annotation property "+propertyName);

             return null;

         }

         String enumInstanceName = eev.getEnumValueString();

         return new BcelEnumProperty(dmc, enumInstanceName);

     }

     private Object[] createArray(SpiMetaClassLoader classLoader, ArrayElementValue ev) {

         ArrayElementValue aev = (ArrayElementValue) ev;

         ElementValue[] elementValues = aev.getElementValuesArray();

         Object[] returnValues = new Object[elementValues.length];

         int i = 0;

         for (ElementValue elementValue : elementValues) {

             Object obj = createObject(classLoader, elementValue);

             if(obj==null) {

                     return null;

             }

                         returnValues[i++] = obj;

         }

         return returnValues;

     }

 }