/*

  * 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.builtin;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.Iterator;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.MissingResourceException;

 import java.util.NoSuchElementException;

 import org.apache.commons.classscan.ClassPath;

 import org.apache.commons.classscan.ClassPathElement;

 import org.apache.commons.classscan.MetaClassLoader;

 import org.apache.commons.classscan.MetaClassPathElement;

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

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

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

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

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

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

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

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 public class UrlMetaClassLoader implements SpiMetaClassLoader {

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

     private final SpiMetaClassLoader parent;

     private Map<String, SpiMetaClassPathElement> locations;

         public UrlMetaClassLoader(SpiMetaRegistry registry, ClassLoader classLoader) {

                 parent= classLoader!= null ?(SpiMetaClassLoader)registry.getMetaClassLoader(classLoader.getParent()) :null;

                 // use LinkedHashMap to keep iteration over path elements in same order as definition

                 locations = new LinkedHashMap<String, SpiMetaClassPathElement>();

                 addLocations(registry, classLoader);

                 resolve();

                 locations = Collections.unmodifiableMap(locations);

     }

         void addLocations(SpiMetaRegistry registry, ClassLoader classLoader) {

             ClassPath classPath = registry.getClassPath(classLoader);

                 for(ClassPathElement pathElement : classPath.getClassPathElements()) {

                     addLocation(registry, pathElement);

             }

     }

     /**

      * Add a location

      * 

      * @param pathElement

      *            The URI of a jar or folder

      */

         private void addLocation(SpiMetaRegistry registry, ClassPathElement pathElement) {

             String baseLocation= pathElement.getLocation();

         if (!locations.containsKey(baseLocation)) {

             SpiMetaClassPathElement mcl = registry.createMetaClassPathElement(pathElement);

             if (mcl != null) {

                     locations.put(baseLocation, mcl);            

             }

                 Collection<SpiClassPathElement> additionalUrls= ((SpiClassPathElement)pathElement).getAdditionalLocations(registry);

                 if(additionalUrls!=null) {

                         for(SpiClassPathElement additionalUrl : additionalUrls) {

                                 addLocation(registry, additionalUrl);

                         }

                 }

         }

     }

     protected void addLocation(SpiMetaClassPathElement cpe) {

             locations.put(cpe.getName(), cpe);

         }

     // resolve string names into model entities instead of using resolution upon demand

     // memory used by multiple string copies weighs more heavily than time spent resolving meta-class

     // demand resolution would require clients to filter out classes which have un-resolvable dependencies

     private void resolve() {

             Iterator<SpiMetaClassPathElement> metaClassPathElements= locations.values().iterator();

             while(metaClassPathElements.hasNext()) {

                     SpiMetaClassPathElement metaClassPathElement= metaClassPathElements.next();

                     if(!metaClassPathElement.resolve(this)) {

                             metaClassPathElements.remove();

                     }

             }

         }

     @Override

     public MetaClassLoader getParent() {

         return parent;

     }

     @Override

     public Collection<? extends MetaClassPathElement> getClassLocations() {

         return locations.values();

     }

     @Override

     public MetaClassPathElement getClassLocation(String location) {

         return locations.get(location);

     }

     @Override

     public Iterator<? extends MetaClass> getMetaClasses() {             

             Collection<? extends MetaClassPathElement> classLocations = getClassLocations();

             if(classLocations.isEmpty()) {

                     List<? extends MetaClass> empty= Collections.emptyList();

                     return empty.iterator();

             }

                 final Iterator<? extends MetaClassPathElement> locations= classLocations.iterator();

             return new Iterator<MetaClass>() {

                 {

                         nextInnerIterator();

                 }

                 Iterator<? extends MetaClass> metaClasses;

                 private boolean nextInnerIterator() {

                         if(!locations.hasNext()) {

                                 return false;

                         }

                                 MetaClassPathElement mcpe= locations.next();

                                 metaClasses= mcpe.getMetaClasses().iterator();

                                 return true;

                         }

                         @Override

                         public boolean hasNext() {

                             while(!metaClasses.hasNext()) {                                        

                                 if(!nextInnerIterator()) {

                                         return false;

                                 }

                             }

                             return true;

                         }

                         @Override

                         public MetaClass next() {

                             while(!metaClasses.hasNext()) {                                        

                                 if(!locations.hasNext()) {

                                         throw new NoSuchElementException();

                                 }

                                     nextInnerIterator();

                             }

                             return metaClasses.next();

                         }

                         @Override

                         public void remove() {

                                 throw new UnsupportedOperationException();

                         }

             };

     }

     @Override

     public MetaClass getMetaClass(String className) {

             for(MetaClassPathElement location : locations.values()) {

                     MetaClass mc = location.getMetaClass(className);

                     if(mc != null) {

                             return mc;

                     }

             }

         return null;

     }

     @Override

     public MetaClass findMetaClass(String className) {

         MetaClass mc = parent.findMetaClass(className);

         if (mc != null) {

             return mc;

         }

         return getMetaClass(className);

     }

     @Override

     public MetaClass resolveMetaClass(String className) {

         MetaClass mc = parent.resolveMetaClass(className);

         if (mc != null) {

             return mc;

         }

             return resolveInPath(className);

     }

         MetaClass resolveInPath(String className) {

                 for(SpiMetaClassPathElement location : locations.values()) {

                         MetaClass mc = location.resolveMetaClass(this, className);

                     if(mc != null) {

                             return mc;

                     }

             }

         return null;

         }

     /**

      * Get metadata representing a type from its byte code signature

      * 

      * @param fieldDescriptor

      *            The field descriptor as defined in section 4.3.2 of The Java

      *            Virtual Machine Specification

      * @return The type metadata

      */

     /*

      * FieldType: BaseType ObjectType ArrayType

      * 

      * BaseType: // see PrimitiveClass

      * 

      * ObjectType: L <classname> ;

      * 

      * ArrayType: [ ComponentType

      */

     @Override

         public MetaType resolveTypeForDescriptor(String fieldDescriptor) {

             MetaType mt; 

         char typeCode = fieldDescriptor.charAt(0);

         switch (typeCode) {

         case 'L':

                         mt = resolveObjectType(fieldDescriptor);

                         break;

         case '[':

             mt = resolveArrayType(fieldDescriptor.substring(1));

             break;

         default:

                 mt = PrimitiveClass.valueOf(fieldDescriptor);

                 break;

         }

         if(mt == null) {

                 logger.info("Cannot resolve type "+fieldDescriptor);

         }

         return mt;

     }

         private MetaType resolveObjectType(String fieldDescriptor) {

                 String canonicalName = ClassNameHelper.internalToCanonicalName(fieldDescriptor);

                 return resolveMetaClass(canonicalName);

         }

     private MetaArray resolveArrayType(String fieldDescriptor) {

         MetaType arrayType = resolveTypeForDescriptor(fieldDescriptor);

         return new DefaultArrayType(arrayType);

     }

     @Override

     public Collection<? extends MetaClass> findAllImplementors(String interfaceToFind) {

         MetaClass mc = findMetaClass(interfaceToFind);

         Collection<MetaClass> implementations = new ArrayList<MetaClass>();

         MetaClassLoader classLoader = this;

         do {               

             Iterator<? extends MetaClass> metaClasses = classLoader.getMetaClasses(); 

             while(metaClasses.hasNext()) {

                     MetaClass potentialImplementation = metaClasses.next();

                 try {

                     if (!potentialImplementation.equals(mc) && mc.isAssignableFrom(potentialImplementation)) {

                         implementations.add(potentialImplementation);

                     }

                 }

                 catch (MissingResourceException mre) {

                     continue;

                 }

             }

             classLoader = classLoader.getParent();

         }

         while (classLoader != null);

         return implementations;

     }

 }