/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.myfaces.config.annotation;
  
  import java.io.DataInputStream;
  import java.io.IOException;
  import java.lang.annotation.Annotation;
  import java.net.JarURLConnection;
  import java.net.URL;
  import java.net.URLConnection;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.jar.JarEntry;
  import java.util.jar.JarFile;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.faces.FacesException;
  import javax.faces.bean.ManagedBean;
  import javax.faces.component.FacesComponent;
  import javax.faces.component.behavior.FacesBehavior;
  import javax.faces.context.ExternalContext;
  import javax.faces.convert.FacesConverter;
  import javax.faces.event.NamedEvent;
  import javax.faces.render.FacesBehaviorRenderer;
  import javax.faces.render.FacesRenderer;
  import javax.faces.validator.FacesValidator;
  
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFWebConfigParam;
  import org.apache.myfaces.shared.config.MyfacesConfig;
  import org.apache.myfaces.shared.util.ClassUtils;
  import org.apache.myfaces.spi.AnnotationProvider;
  import org.apache.myfaces.spi.AnnotationProviderFactory;
  import org.apache.myfaces.util.ContainerUtils;
  import org.apache.myfaces.config.util.GAEUtils;
  import org.apache.myfaces.config.util.JarUtils;
  import org.apache.myfaces.shared.util.StringUtils;
  import org.apache.myfaces.view.facelets.util.Classpath;
  
  /**
   * 
   * @since 2.0.2
   * @author Leonardo Uribe
   */
  public class DefaultAnnotationProvider extends AnnotationProvider
  {
      private static final Logger log = Logger.getLogger(DefaultAnnotationProvider.class.getName());
      
      /**
       * Servlet context init parameter which defines which packages to scan
       * for beans, separated by commas.
       */
      @JSFWebConfigParam(since="2.0")
      public static final String SCAN_PACKAGES = "org.apache.myfaces.annotation.SCAN_PACKAGES";
  
      /**
       * <p>Prefix path used to locate web application classes for this
       * web application.</p>
       */
      private static final String WEB_CLASSES_PREFIX = "/WEB-INF/classes/";
      
      /**
       * <p>Prefix path used to locate web application libraries for this
       * web application.</p>
       */
      private static final String WEB_LIB_PREFIX = "/WEB-INF/lib/";
      
      private static final String META_INF_PREFIX = "META-INF/";
  
      private static final String FACES_CONFIG_SUFFIX = ".faces-config.xml";
      
      private static final String STANDARD_FACES_CONFIG_RESOURCE = "META-INF/standard-faces-config.xml";
  
      /**
       * <p>Resource path used to acquire implicit resources buried
       * inside application JARs.</p>
      */
     private static final String FACES_CONFIG_IMPLICIT = "META-INF/faces-config.xml";
     
     private final _ClassByteCodeAnnotationFilter _filter;
 
     /**
      * This set contains the annotation names that this AnnotationConfigurator is able to scan
      * in the format that is read from .class file.
      */
     private static Set<String> byteCodeAnnotationsNames;
 
     static
     {
         Set<String> bcan = new HashSet<String>(10, 1f);
         bcan.add("Ljavax/faces/component/FacesComponent;");
         bcan.add("Ljavax/faces/component/behavior/FacesBehavior;");
         bcan.add("Ljavax/faces/convert/FacesConverter;");
         bcan.add("Ljavax/faces/validator/FacesValidator;");
         bcan.add("Ljavax/faces/render/FacesRenderer;");
         bcan.add("Ljavax/faces/bean/ManagedBean;");
         bcan.add("Ljavax/faces/event/NamedEvent;");
         //bcan.add("Ljavax/faces/event/ListenerFor;");
         //bcan.add("Ljavax/faces/event/ListenersFor;");
         bcan.add("Ljavax/faces/render/FacesBehaviorRenderer;");
 
         byteCodeAnnotationsNames = Collections.unmodifiableSet(bcan);
     }
     
     private static final Set<Class<? extends Annotation>> JSF_ANNOTATION_CLASSES;
     
     static
     {
         Set<Class<? extends Annotation>> bcan = new HashSet<Class<? extends Annotation>>(10, 1f);
         bcan.add(FacesComponent.class);
         bcan.add(FacesBehavior.class);
         bcan.add(FacesConverter.class);
         bcan.add(FacesValidator.class);
         bcan.add(FacesRenderer.class);
         bcan.add(ManagedBean.class);
         bcan.add(NamedEvent.class);
         bcan.add(FacesBehaviorRenderer.class);
         JSF_ANNOTATION_CLASSES = Collections.unmodifiableSet(bcan);
     }
     
     public DefaultAnnotationProvider()
     {
         super();
         _filter = new _ClassByteCodeAnnotationFilter();
     }
     
     @Override
     public Map<Class<? extends Annotation>, Set<Class<?>>> getAnnotatedClasses(ExternalContext ctx)
     {
         Map<Class<? extends Annotation>,Set<Class<?>>> map = new HashMap<Class<? extends Annotation>, Set<Class<?>>>();
         Collection<Class<?>> classes = null;
 
         //1. Scan for annotations on /WEB-INF/classes
         try
         {
             classes = getAnnotatedWebInfClasses(ctx);
         }
         catch (IOException e)
         {
             throw new FacesException(e);
         }
 
         for (Class<?> clazz : classes)
         {
             processClass(map, clazz);
         }
         
         //2. Scan for annotations on classpath
         String jarAnnotationFilesToScanParam = MyfacesConfig.getCurrentInstance(ctx).getGaeJsfAnnotationsJarFiles();
         jarAnnotationFilesToScanParam = jarAnnotationFilesToScanParam != null ? 
                 jarAnnotationFilesToScanParam.trim() : null;
         if (ContainerUtils.isRunningOnGoogleAppEngine(ctx) && 
             jarAnnotationFilesToScanParam != null &&
             jarAnnotationFilesToScanParam.length() > 0)
         {
             // Skip call AnnotationProvider.getBaseUrls(ctx), and instead use the value of the config parameter
             // to find which classes needs to be scanned for annotations
             classes = getGAEAnnotatedMetaInfClasses(ctx, jarAnnotationFilesToScanParam);
         }
         else
         {
             try
             {
                 AnnotationProvider provider
                         = AnnotationProviderFactory.getAnnotationProviderFactory(ctx).getAnnotationProvider(ctx);
                 classes = getAnnotatedMetaInfClasses(ctx, provider.getBaseUrls(ctx));
             }
             catch (IOException e)
             {
                 throw new FacesException(e);
             }
         }
         
         for (Class<?> clazz : classes)
         {
             processClass(map, clazz);
         }
         
         //3. Scan on myfaces-impl for annotations available on myfaces-impl.
         //Also scan jar including META-INF/standard-faces-config.xml
         //(myfaces-impl jar file)
         // -= Leonardo Uribe =- No annotations in MyFaces jars, code not
         // necessary, because all config is already in standard-faces-config.xml
         //URL url = getClassLoader().getResource(STANDARD_FACES_CONFIG_RESOURCE);
         //if (url == null)
         //{
         //    url = getClass().getClassLoader().getResource(STANDARD_FACES_CONFIG_RESOURCE);
         //}
         //classes = getAnnotatedMyfacesImplClasses(ctx, url);
         //for (Class<?> clazz : classes)
         //{
         //    processClass(map, clazz);
         //}
         
         return map;
     }
     
     @Override
     public Set<URL> getBaseUrls() throws IOException
     {
         Set<URL> urlSet = new HashSet<URL>();
         
         //This usually happens when maven-jetty-plugin is used
         //Scan jars looking for paths including META-INF/faces-config.xml
         Enumeration<URL> resources = getClassLoader().getResources(FACES_CONFIG_IMPLICIT);
         while (resources.hasMoreElements())
         {
             urlSet.add(resources.nextElement());
         }
 
         //Scan files inside META-INF ending with .faces-config.xml
         URL[] urls = Classpath.search(getClassLoader(), META_INF_PREFIX, FACES_CONFIG_SUFFIX);
         for (int i = 0; i < urls.length; i++)
         {
             urlSet.add(urls[i]);
         }
         
         return urlSet;
     }
     
     @Override
     public Set<URL> getBaseUrls(ExternalContext context) throws IOException
     {
         String jarFilesToScanParam = MyfacesConfig.getCurrentInstance(context).getGaeJsfJarFiles();
         jarFilesToScanParam = jarFilesToScanParam != null ? jarFilesToScanParam.trim() : null;
         if (ContainerUtils.isRunningOnGoogleAppEngine(context) && 
             jarFilesToScanParam != null &&
             jarFilesToScanParam.length() > 0)
         {
             Set<URL> urlSet = new HashSet<URL>();
             
             //This usually happens when maven-jetty-plugin is used
             //Scan jars looking for paths including META-INF/faces-config.xml
             Enumeration<URL> resources = getClassLoader().getResources(FACES_CONFIG_IMPLICIT);
             while (resources.hasMoreElements())
             {
                 urlSet.add(resources.nextElement());
             }
             
             Collection<URL> urlsGAE = GAEUtils.searchInWebLib(
                     context, getClassLoader(), jarFilesToScanParam, META_INF_PREFIX, FACES_CONFIG_SUFFIX);
             if (urlsGAE != null)
             {
                 urlSet.addAll(urlsGAE);
             }
             return urlSet;
         }
         else
         {
             return getBaseUrls();
         }
     }
 
     protected Collection<Class<?>> getAnnotatedMetaInfClasses(ExternalContext ctx, Set<URL> urls)
     {
         if (urls != null && !urls.isEmpty())
         {
             List<Class<?>> list = new ArrayList<Class<?>>();
             for (URL url : urls)
             {
                 try
                 {
                     JarFile jarFile = getJarFile(url);
                     if (jarFile != null)
                     {
                         archiveClasses(ctx, jarFile, list);
                     }
                 }
                 catch(IOException e)
                 {
                     log.log(Level.SEVERE, "cannot scan jar file for annotations:"+url, e);
                 }
             }
             return list;
         }
         return Collections.emptyList();
     }
     
     protected Collection<Class<?>> getGAEAnnotatedMetaInfClasses(ExternalContext context, String filter)
     {
         if (!filter.equals("none"))
         {
             String[] jarFilesToScan = StringUtils.trim(StringUtils.splitLongString(filter, ','));
             Set<String> paths = context.getResourcePaths(WEB_LIB_PREFIX);
             if (paths != null)
             {
                 List<Class<?>> list = new ArrayList<Class<?>>();
                 for (Object pathObject : paths)
                 {
                     String path = (String) pathObject;
                     if (path.endsWith(".jar") && GAEUtils.wildcardMatch(path, jarFilesToScan, GAEUtils.WEB_LIB_PREFIX))
                     {
                         // GAE does not use WAR format, so the app is just uncompressed in a directory
                         // What we need here is just take the path of the file, and open the file as a
                         // jar file. Then, if the jar should be scanned, try to find the required file.
                         try
                         {
                             URL jarUrl = new URL("jar:" + context.getResource(path).toExternalForm() + "!/"); 
                             JarFile jarFile = JarUtils.getJarFile(jarUrl);
                             if (jarFile != null)
                             {
                                 archiveClasses(context, jarFile, list);
                             }
                         }
                         catch(IOException e)
                         {
                             log.log(Level.SEVERE, 
                                     "IOException when reading jar file for annotations using filter: "+filter, e);
                         }
                     }
                 }
                 return list;
             }
         }
         return Collections.emptyList();
     }
 
     protected Collection<Class<?>> getAnnotatedMyfacesImplClasses(ExternalContext ctx, URL url)
     {
         return Collections.emptyList();
         /*
         try
         {
             List<Class<?>> list = new ArrayList<Class<?>>();
             JarFile jarFile = getJarFile(url);
             if (jarFile == null)
             {
                 return list;
             }
             else
             {
                 return archiveClasses(ctx, jarFile, list);
             }
         }
         catch(IOException e)
         {
             throw new FacesException("cannot scan jar file for annotations:"+url, e);
         }*/
     }
 
     protected Collection<Class<?>> getAnnotatedWebInfClasses(ExternalContext ctx) throws IOException
     {
         String scanPackages = ctx.getInitParameter(SCAN_PACKAGES);
         if (scanPackages != null)
         {
             try
             {
                 return packageClasses(ctx, scanPackages);
             }
             catch (ClassNotFoundException e)
             {
                 throw new FacesException(e);
             }
             catch (IOException e)
             {
                 throw new FacesException(e);
             }
         }
         else
         {
             return webClasses(ctx);
         }
     }
     
     /**
      * <p>Return a list of the classes defined within the given packages
      * If there are no such classes, a zero-length list will be returned.</p>
      *
      * @param scanPackages the package configuration
      *
      * @exception ClassNotFoundException if a located class cannot be loaded
      * @exception IOException if an input/output error occurs
      */
     private List<Class<?>> packageClasses(final ExternalContext externalContext,
             final String scanPackages) throws ClassNotFoundException, IOException
     {
 
         List<Class<?>> list = new ArrayList<Class<?>>();
 
         String[] scanPackageTokens = scanPackages.split(",");
         for (String scanPackageToken : scanPackageTokens)
         {
             if (scanPackageToken.toLowerCase().endsWith(".jar"))
             {
                 URL jarResource = externalContext.getResource(WEB_LIB_PREFIX
                         + scanPackageToken);
                 String jarURLString = "jar:" + jarResource.toString() + "!/";
                 URL url = new URL(jarURLString);
                 JarFile jarFile = ((JarURLConnection) url.openConnection())
                         .getJarFile();
 
                 archiveClasses(externalContext, jarFile, list);
             }
             else
             {
                 List<Class> list2 = new ArrayList<Class>();
                 _PackageInfo.getInstance().getClasses(list2, scanPackageToken);
                 for (Class c : list2)
                 {
                     list.add(c);                    
                 }
             }
         }
         return list;
     }    
     
     /**
      * <p>Return a list of classes to examine from the specified JAR archive.
      * If this archive has no classes in it, a zero-length list is returned.</p>
      *
      * @param context <code>ExternalContext</code> instance for
      *  this application
      * @param jar <code>JarFile</code> for the archive to be scanned
      *
      * @exception ClassNotFoundException if a located class cannot be loaded
      */
     private List<Class<?>> archiveClasses(ExternalContext context, JarFile jar, List<Class<?>> list)
     {
 
         // Accumulate and return a list of classes in this JAR file
         ClassLoader loader = ClassUtils.getContextClassLoader();
         if (loader == null)
         {
             loader = this.getClass().getClassLoader();
         }
         Enumeration<JarEntry> entries = jar.entries();
         while (entries.hasMoreElements())
         {
             JarEntry entry = entries.nextElement();
             if (entry.isDirectory())
             {
                 continue; // This is a directory
             }
             String name = entry.getName();
             if (name.startsWith("META-INF/"))
             {
                 continue; // Attribute files
             }
             if (!name.endsWith(".class"))
             {
                 continue; // This is not a class
             }
 
             DataInputStream in = null;
             boolean couldContainAnnotation = false;
             try
             {
                 in = new DataInputStream(jar.getInputStream(entry));
                 couldContainAnnotation = _filter
                         .couldContainAnnotationsOnClassDef(in,
                                 byteCodeAnnotationsNames);
             }
             catch (IOException e)
             {
                 // Include this class - we can't scan this class using
                 // the filter, but it could be valid, so we need to
                 // load it using the classLoader. Anyway, log a debug
                 // message.
                 couldContainAnnotation = true;
                 if (log.isLoggable(Level.FINE))
                 {
                     log.fine("IOException when filtering class " + name
                             + " for annotations");
                 }
             }
             finally
             {
                 if (in != null)
                 {
                     try
                     {
                         in.close();
                     }
                     catch (IOException e)
                     {
                         // No Op
                     }
                 }
             }
 
             if (couldContainAnnotation)
             {
                 name = name.substring(0, name.length() - 6); // Trim ".class"
                 Class<?> clazz = null;
                 try
                 {
                     clazz = loader.loadClass(name.replace('/', '.'));
                 }
                 catch (NoClassDefFoundError e)
                 {
                     // Skip this class - we cannot analyze classes we cannot load
                 }
                 catch (Exception e)
                 {
                     // Skip this class - we cannot analyze classes we cannot load
                 }
                 if (clazz != null)
                 {
                     list.add(clazz);
                 }
             }
         }
         return list;
 
     }
     
     /**
      * <p>Return a list of the classes defined under the
      * <code>/WEB-INF/classes</code> directory of this web
      * application.  If there are no such classes, a zero-length list
      * will be returned.</p>
      *
      * @param externalContext <code>ExternalContext</code> instance for
      *  this application
      *
      * @exception ClassNotFoundException if a located class cannot be loaded
      */
     private List<Class<?>> webClasses(ExternalContext externalContext)
     {
         List<Class<?>> list = new ArrayList<Class<?>>();
         webClasses(externalContext, WEB_CLASSES_PREFIX, list);
         return list;
     }
 
     /**
      * <p>Add classes found in the specified directory to the specified
      * list, recursively calling this method when a directory is encountered.</p>
      *
      * @param externalContext <code>ExternalContext</code> instance for
      *  this application
      * @param prefix Prefix specifying the "directory path" to be searched
      * @param list List to be appended to
      *
      * @exception ClassNotFoundException if a located class cannot be loaded
      */
     private void webClasses(ExternalContext externalContext, String prefix,
             List<Class<?>> list)
     {
 
         ClassLoader loader = getClassLoader();
 
         Set<String> paths = externalContext.getResourcePaths(prefix);
         if(paths == null)
         {
             return; //need this in case there is no WEB-INF/classes directory
         }
         if (log.isLoggable(Level.FINEST))
         {
             log.finest("webClasses(" + prefix + ") - Received " + paths.size()
                     + " paths to check");
         }
 
         String path = null;
 
         if (paths.isEmpty())
         {
             if (log.isLoggable(Level.WARNING))
             {
                 log
                         .warning("AnnotationConfigurator does not found classes "
                                 + "for annotations in "
                                 + prefix
                                 + " ."
                                 + " This could happen because maven jetty plugin is used"
                                 + " (goal jetty:run). Try configure "
                                 + SCAN_PACKAGES + " init parameter "
                                 + "or use jetty:run-exploded instead.");
             }
         }
         else
         {
             for (Object pathObject : paths)
             {
                 path = (String) pathObject;
                 if (path.endsWith("/"))
                 {
                     webClasses(externalContext, path, list);
                 }
                 else if (path.endsWith(".class"))
                 {
                     DataInputStream in = null;
                     boolean couldContainAnnotation = false;
                     try
                     {
                         in = new DataInputStream(externalContext
                                 .getResourceAsStream(path));
                         couldContainAnnotation = _filter
                                 .couldContainAnnotationsOnClassDef(in,
                                         byteCodeAnnotationsNames);
                     }
                     catch (IOException e)
                     {
                         // Include this class - we can't scan this class using
                         // the filter, but it could be valid, so we need to
                         // load it using the classLoader. Anyway, log a debug
                         // message.
                         couldContainAnnotation = true;
                         if (log.isLoggable(Level.FINE))
                         {
                             log.fine("IOException when filtering class " + path
                                     + " for annotations");
                         }
                     }
                     finally
                     {
                         if (in != null)
                         {
                             try
                             {
                                 in.close();
                             }
                             catch (IOException e)
                             {
                                 // No Op
                             }
                         }
                     }
 
                     if (couldContainAnnotation)
                     {
                         //Load it and add it to list for later processing
                         path = path.substring(WEB_CLASSES_PREFIX.length()); // Strip prefix
                         path = path.substring(0, path.length() - 6); // Strip suffix
                         path = path.replace('/', '.'); // Convert to FQCN
 
                         Class<?> clazz = null;
                         try
                         {
                             clazz = loader.loadClass(path);
                         }
                         catch (NoClassDefFoundError e)
                         {
                             // Skip this class - we cannot analyze classes we cannot load
                         }
                         catch (Exception e)
                         {
                             // Skip this class - we cannot analyze classes we cannot load
                         }
                         if (clazz != null)
                         {
                             list.add(clazz);
                         }
                     }
                 }
             }
         }
     }
     
     private JarFile getJarFile(URL url) throws IOException
     {
         URLConnection conn = url.openConnection();
         conn.setUseCaches(false);
         conn.setDefaultUseCaches(false);
 
         JarFile jarFile;
         if (conn instanceof JarURLConnection)
         {
             jarFile = ((JarURLConnection) conn).getJarFile();
         }
         else
         {
             jarFile = _getAlternativeJarFile(url);
         }
         return jarFile;
     }
     
 
     /**
      * taken from org.apache.myfaces.view.facelets.util.Classpath
      * 
      * For URLs to JARs that do not use JarURLConnection - allowed by the servlet spec - attempt to produce a JarFile
      * object all the same. Known servlet engines that function like this include Weblogic and OC4J. This is not a full
      * solution, since an unpacked WAR or EAR will not have JAR "files" as such.
      */
     private static JarFile _getAlternativeJarFile(URL url) throws IOException
     {
         String urlFile = url.getFile();
 
         // Trim off any suffix - which is prefixed by "!/" on Weblogic
         int separatorIndex = urlFile.indexOf("!/");
 
         // OK, didn't find that. Try the less safe "!", used on OC4J
         if (separatorIndex == -1)
         {
             separatorIndex = urlFile.indexOf('!');
         }
 
         if (separatorIndex != -1)
         {
             String jarFileUrl = urlFile.substring(0, separatorIndex);
             // And trim off any "file:" prefix.
             if (jarFileUrl.startsWith("file:"))
             {
                 jarFileUrl = jarFileUrl.substring("file:".length());
             }
 
             return new JarFile(jarFileUrl);
         }
 
         return null;
     }
         
     private ClassLoader getClassLoader()
     {
         ClassLoader loader = ClassUtils.getContextClassLoader();
         if (loader == null)
         {
             loader = this.getClass().getClassLoader();
         }
         return loader;
     }
     
     private void processClass(Map<Class<? extends Annotation>,Set<Class<?>>> map, Class<?> clazz)
     {
         Annotation[] annotations = clazz.getAnnotations();
         for (Annotation anno : annotations)
         {
             Class<? extends Annotation> annotationClass = anno.annotationType();
             if (JSF_ANNOTATION_CLASSES.contains(annotationClass))
             {
                 Set<Class<?>> set = map.get(annotationClass);
                 if (set == null)
                 {
                     set = new HashSet<Class<?>>();
                     set.add(clazz);
                     map.put(annotationClass, set);
                 }
                 else
                 {
                     set.add(clazz);
                 }
 
             }
         }
     }
 }