/*

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

 import java.net.JarURLConnection;

 import java.net.MalformedURLException;

 import java.net.URI;

 import java.net.URISyntaxException;

 import java.net.URL;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Enumeration;

 import java.util.Iterator;

 import java.util.List;

 import java.util.jar.Attributes;

 import java.util.jar.JarEntry;

 import java.util.jar.JarFile;

 import java.util.jar.Manifest;

 import java.util.regex.Pattern;

 import org.apache.commons.classscan.ClassFile;

 import org.apache.commons.classscan.ResourceFile;

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

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

 import org.slf4j.Logger;

 import org.slf4j.LoggerFactory;

 public class JarClassPathElement implements SpiClassPathElement {

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

     final private URL location;

     private URL[] classPathLocations;

         public JarClassPathElement(URL location) {

                 this.location = location;

         }

         @Override

         public Iterator<ClassFile> iterator() {                

                 final JarFile jarFile= getJarFile();                

         final Enumeration<JarEntry> jarEntries = jarFile.entries();

                 return new ClassFileIterator() {                        

                         ClassFile getNext() {

                                 while(jarEntries.hasMoreElements()) {

                                         JarClassFile jcf= new JarClassFile(jarFile, jarEntries.nextElement());

                                         if(jcf.getClassName()!=null) {

                                                 return jcf;

                                         }

                                 }

                                 try {

                                         jarFile.close();

                                 } catch (IOException ex) {

                             logger.warn("Failed to close " + location, ex);

                                 }

                                 return null;

                         }

                 };

         }

         private JarFile getJarFile() {                

         try {

             JarURLConnection conn = (JarURLConnection) location.openConnection();

             JarFile jf= conn.getJarFile();

             extractClasspath(jf);

             return jf;

         }

         catch (IOException ex) {

             logger.warn("Failed to open " + location, ex);

             return null;

         }

         }

         private void extractClasspath(JarFile jf) throws IOException {

                 Manifest manifest = jf.getManifest();

                 if(manifest == null) {

                         return;

                 }

                 URI resolveLocation;

                 try {

                         resolveLocation = location.toURI();

                 } catch (URISyntaxException e) {

                 logger.warn("Could not create URI out of {}", location);

                 return;

                 }

         Attributes attributes = manifest.getMainAttributes();

         String classPath = attributes.getValue(Attributes.Name.CLASS_PATH);

         if (classPath == null) {

             return;

         }

         List<URL> newLocations = new ArrayList<URL>();

                 for (String pathElement : PATH_SPLITTER.split(classPath)) {

             URI resolvedLocation = resolveLocation.resolve(pathElement);

             try {

                                 URL newLocation = resolvedLocation.toURL();

                     newLocations.add(newLocation);

             } catch (MalformedURLException e) {

                     logger.warn("Could not resolve Class-Path element {} relative to {}", pathElement, resolveLocation);

                         }

         }

         classPathLocations = newLocations.toArray(new URL[newLocations.size()]);

         }

     private static Pattern PATH_SPLITTER = Pattern.compile("\\s+");

         @Override

         public String getLocation() {

                 return location.toExternalForm();

         }

         @Override

         public Collection<SpiClassPathElement> getAdditionalLocations(SpiMetaRegistry registry) {

                 if(classPathLocations==null) {

                         return null;

                 }

                 return UrlClassPath.getClassPathElements(registry, classPathLocations);

         }

         @Override

         public ResourceFile getResource(String fileName) {

                 JarFile jarFile= getJarFile();

                 JarEntry jarEntry = jarFile.getJarEntry(fileName);

                 if(jarEntry==null) {

                         try {

                                 jarFile.close();

                         } catch (IOException e) {

                     logger.info("ignoring exception on close", e);

                         }

                         return null;

                 }

                 return new JarResourceFile(jarFile, jarEntry);

         }

 }