/*
    *  Copyright 2012 Chris Pheby
    *
    *  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.jadira.scanner.file.locator;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.UnsupportedEncodingException;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLDecoder;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.jadira.scanner.core.api.Locator;
  import org.jadira.scanner.core.exception.FileAccessException;
  import org.jadira.scanner.core.utils.lang.IterableEnumeration;
  import org.jadira.scanner.core.utils.reflection.ClassLoaderUtils;
  
  /**
   * Matches any Jars with a marker file indicated
   */
  public class ContainedClassClasspathUrlLocator implements Locator<URL> {
  
  	private final List<String> paths;
  	
  	private final ClassLoader[] classLoaders;
  
  	public ContainedClassClasspathUrlLocator(Class<?> clazz, ClassLoader... classLoaders) {
  		this.paths = new ArrayList<String>(1);
  		paths.add(asNormalizedName(clazz));
  		
  		this.classLoaders = ClassLoaderUtils.getClassLoaders(classLoaders);
  	}
  	
  	public ContainedClassClasspathUrlLocator(List<Class<?>> classes, ClassLoader... classLoaders) {
          this.paths = new ArrayList<String>(classes.size());
          for (Class<?> next : classes) {
              paths.add(asNormalizedName(next));
          }
          
          this.classLoaders = ClassLoaderUtils.getClassLoaders(classLoaders);
  	}
  	
  	@Override
  	public List<URL> locate() {
  
          List<URL> list = new ArrayList<URL>();
          
          for (ClassLoader classLoader : classLoaders) {
              try {
              	for (String nextPath : paths) {
      	            for (URL nextResourceMatchedUrl : new IterableEnumeration<URL>(classLoader.getResources(nextPath))) {
      	
      	                String deploymentArchiveRoot = determineClasspathRootForResource(nextPath, nextResourceMatchedUrl);
      	                
                          File fp = new File(deploymentArchiveRoot);
                          
                          if (!fp.exists()) {
                              throw new FileAccessException("File unexpectedly does not exist: " + fp);
                          }
                          
                          try {
                              list.add(fp.toURI().toURL());
                          } catch (MalformedURLException e) {
                          	throw new FileAccessException("Filepath unexpectedly malformed: " + fp.getPath(), e);
                          }
      	            }
              	}
              } catch (IOException e) {
              	throw new FileAccessException("Problem resolving deployment archives: " + e.getMessage(), e);
              }
          }
  		
          return list;
      }
  	
      private String determineClasspathRootForResource(String nextResource, URL nextResourceMatchedUrl) {
  
          String nextResourceMatchedPathName = nextResourceMatchedUrl.getFile();
          try {
              nextResourceMatchedPathName = URLDecoder.decode(nextResourceMatchedPathName, "UTF-8");
          } catch (UnsupportedEncodingException e) {
              // Never thrown for UTF-8
              throw new FileAccessException("Exception thrown for Encoding when not expected: " + e.getMessage(), e);
          }
  
         // Reformat file urls to remove file: prefix
         if (nextResourceMatchedPathName.startsWith("file:")) {
             nextResourceMatchedPathName = nextResourceMatchedPathName.substring(5);
         }
 
         // Chomp archive name if an archive
         if (nextResourceMatchedPathName.indexOf('!') > 0) {
             nextResourceMatchedPathName = nextResourceMatchedPathName.substring(0, nextResourceMatchedPathName.indexOf('!'));
         } else {
             File indicatedResource = new File(nextResourceMatchedPathName);
 
             // Traverse to classpath root relative to the original matching resource
             int pathDepth = nextResource.replaceAll("[^/]", "").length();
             for (int i = 0; i < pathDepth; i++) {
                 indicatedResource = indicatedResource.getParentFile();
             }
             nextResourceMatchedPathName = indicatedResource.getParent();
         }
 
         return nextResourceMatchedPathName;
     }
     
     
     private static String asNormalizedName(Class<?> clazz) {
      
         String result = clazz.getName().replace(".", "/") + ".class";
         return result;
     }
 }