/*

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

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.Map;

 import org.apache.commons.classscan.ClassPathElement;

 import org.apache.commons.classscan.ClassFile;

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

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

 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.apache.commons.classscan.util.NameSet;

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 public class DefaultMetaClassPathElement implements SpiMetaClassPathElement {

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

         private final String baseUrl;        

     private Map<String, SpiMetaClass> workClasses = new HashMap<String, SpiMetaClass>();

     private NameSet<SpiMetaClass> sealedClasses;

         public DefaultMetaClassPathElement(SpiMetaRegistry metaRegistry, ClassPathElement classPathElement) {

                 this.baseUrl = classPathElement.getLocation();

                 for(ClassFile classPathFile : classPathElement) {

                         addFile(metaRegistry, classPathFile);

                 }

     }

         private void addFile(SpiMetaRegistry metaRegistry, ClassFile classPathFile) {

                 String className = classPathFile.getClassName();

                 try {

                         InputStream byteStream = classPathFile.getBytes();

                         try {

                                 SpiMetaClass mc= metaRegistry.createMetaClass(this, className, byteStream);

                                 addMetaClass(mc);

                         }

                         finally {

                                 byteStream.close();

                         }

                 } catch (Exception e) {

                         logger.info("Exception while loading "+className, e);

                 }

         }

     void addMetaClass(SpiMetaClass mc) {

             String name= mc.getName();

         if (workClasses.containsKey(name)) {

             return;

         }

         workClasses.put(name, mc);

     }

         @Override

         public boolean resolve(SpiMetaClassLoader classLoader) {

         if( workClasses.isEmpty() ) {

                 sealedClasses = NameSet.emptyNameSet();

         }

         else {

                 Iterator<Map.Entry<String, SpiMetaClass>> metaClasses = workClasses.entrySet().iterator();

                 while(metaClasses.hasNext()) {

                         Map.Entry<String, SpiMetaClass> entry = metaClasses.next();

                             if(!entry.getValue().resolve(classLoader)) {

                                     logger.info("Could not resolve dependencies of "+entry.getKey());

                                     metaClasses.remove();

                             }

                     }

                 sealedClasses = new NameSet<SpiMetaClass>(SpiMetaClass.class, workClasses.values());

         }

         workClasses = null;

         if( sealedClasses.isEmpty() ) {

                 logger.info("No classes in "+baseUrl);

                 return false;

         }       

         return true;

         }

         @Override

         public MetaClass resolveMetaClass(SpiMetaClassLoader classLoader, String className) {

                 if(workClasses==null) {

                         return sealedClasses.getValue(className);

                 }

                 SpiMetaClass workClass = workClasses.get(className);

                 if( workClass != null && workClass.resolve(classLoader) ) {

                         return workClass;

                 }

                 return null;

         }

         @Override

         public Collection<? extends MetaClass> getMetaClasses() {

                 return sealedClasses;

         }

         @Override

         public MetaClass getMetaClass(String className) {

                 return sealedClasses.getValue(className);

         }

         @Override

         public String getName() {

                 return baseUrl;

         }

 }