/*

  * 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 java.io.IOException;

 import java.util.Set;

 import org.apache.bcel.classfile.ClassFormatException;

 import org.apache.bcel.classfile.ClassParser;

 import org.apache.bcel.classfile.Field;

 import org.apache.bcel.classfile.JavaClass;

 import org.apache.bcel.classfile.Method;

 import org.apache.commons.classscan.MetaClassPathElement;

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

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

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

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

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

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

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

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

 import org.apache.commons.classscan.util.NameSet;

 import org.apache.commons.classscan.util.ReadOnlySet;

 import org.apache.commons.classscan.util.ResolveSet;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 public class BcelClass implements SpiMetaClass {

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

     private final MetaClassPathElement location;

     private final String canonicalName;

     private String parentName;

     private MetaClass parent;

     private String[] interfaceNames;

     private Set<MetaClass> interfaces;

     private final AnnotationMap annotations;

     private final ResolveSet<SpiMetaMethod> methods;

     private final ResolveSet<SpiMetaField> fields;

     private Boolean resolutionResult;

         public BcelClass(MetaClassPathElement location, ClassParser parser) throws ClassFormatException, IOException {

         this.location = location;

         JavaClass bcelClass = parser.parse();

         canonicalName = bcelClass.getClassName();

         parentName = getParentName(bcelClass);

         interfaceNames = bcelClass.getInterfaceNames();

         annotations = AnnotationMap.createAnnotations(bcelClass.getAnnotationEntries());

         methods = createMethods(bcelClass);

         fields = createFields(bcelClass);

     }

         @Override

         public boolean resolve(SpiMetaClassLoader classLoader) {

                 if(resolutionResult == null) {

                         // set result to true to prevent re-resolution of classes involved in cyclic graphs

                         resolutionResult = Boolean.TRUE;

                         resolutionResult= Boolean.valueOf(resolveParent(classLoader)

                                         && resolveInterfaces(classLoader)

                                         && annotations.resolve(classLoader)

                                         && methods.resolve(classLoader)

                                         && fields.resolve(classLoader));

                 }

                 return resolutionResult;

         }

         private boolean resolveParent(SpiMetaClassLoader classLoader) {

                 boolean success = true;

                 if(parentName == null) {

                         // this is java.lang.Object

                         // parent should remain null

                 }

                 else {

                         parent = classLoader.resolveMetaClass(parentName);

                         if(parent == null) {

                             logger.info("Cannot find parent "+parentName+" for class "+canonicalName);

                             success= false;

                         }

                         parentName = null;                        

                 }

                 return success;

         }

     private static final ReadOnlySet<MetaClass> EMPTY_INTERFACES = new ReadOnlySet<MetaClass>(new MetaClass[0]);

     private boolean resolveInterfaces(final SpiMetaClassLoader classLoader) {

             boolean success= true;

         if (interfaceNames==null || interfaceNames.length == 0) {

                 interfaces= EMPTY_INTERFACES;

         }

         else {

                 MetaClass[] metaClasses = new MetaClass[interfaceNames.length];

                 int i= 0;

                 for(String interfaceName : interfaceNames) {

                     MetaClass mc = classLoader.resolveMetaClass(interfaceName);

                     if(mc == null) {

                                     logger.info("Cannot find interface "+interfaceName+" for class "+canonicalName);

                                     success= false;

                     }

                     metaClasses[i++] = mc;

                 }

                 interfaces= new ReadOnlySet<MetaClass>(metaClasses);

         }

         interfaceNames= null;

         return success;

     }

     @Override

     public MetaClassPathElement getClassLocation() {

         return location;

     }

     @Override

     public String getName() {

         return canonicalName;

     }

     @Override

     public MetaClass getParent() {

         return parent;

     }

     private String getParentName(JavaClass bcelClass) {

         String superclassName = bcelClass.getSuperclassName();

         if (superclassName.equals(canonicalName)) { // bcel behaves

                                                     // unexpectedly, Object's

                                                     // super class is Object

             return null;

         }

         return superclassName;

     }

     @Override

     public Set<MetaClass> getInterfaces() {

         return interfaces;

     }

     @Override

     public Set<? extends MetaAnnotation> getAnnotations() {

         return annotations;

     }

     @Override

     public MetaAnnotation getAnnotation(String annotationName) {

         return annotations.getValue(annotationName);

     }

     @Override

     public Set<? extends MetaMethod> getMethods() {

         return methods;

     }

     private NameSet<SpiMetaMethod> createMethods(JavaClass bcelClass) {

         Method[] methods = bcelClass.getMethods();

         if (methods.length == 0) {

             return NameSet.emptyNameSet();

         }

         SpiMetaMethod[] metaMethods = new SpiMetaMethod[methods.length];

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

             metaMethods[i]= new BcelMethod(methods[i]);

         }

         return new NameSet<SpiMetaMethod>(metaMethods);

     }

     @Override

     public Set<? extends MetaField> getFields() {

         return fields;

     }

     private ResolveSet<SpiMetaField> createFields(JavaClass bcelClass) {

         Field[] fields = bcelClass.getFields();

         if (fields.length == 0) {

             return NameSet.emptyNameSet();

         }

         SpiMetaField[] metaFields = new SpiMetaField[fields.length];

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

                 metaFields[i]= new BcelField(fields[i]);

         }

         return new ResolveSet<SpiMetaField>(metaFields);

     }

     @Override

     public boolean isAssignableFrom(MetaClass assignor) {

         do {

             if (isAssignableFromAnyInterface(assignor)) {

                 return true;

             }

             assignor = assignor.getParent();

         }

         while (assignor != null);

         return false;

     }

     private boolean isAssignableFromAnyInterface(MetaClass assignor) {

         if (equals(assignor)) {

             return true;

         }

         for (MetaClass derived : assignor.getInterfaces()) {

             if (isAssignableFromAnyInterface(derived)) {

                 return true;

             }

         }

         return false;

     }

     @Override

     public boolean equals(Object obj) {

         if (!(obj instanceof MetaClass)) {

             return false;

         }

         MetaClass other = (MetaClass) obj;

         return canonicalName.equals(other.getName()) && location.equals(other.getClassLocation());

     }

     @Override

     public int hashCode() {

         final int prime = 33;

         int result = 1;

         result = prime * result + canonicalName.hashCode();

         result = prime * result + location.hashCode();

         return result;

     }

 }