package org.andromda.core.common;
   
   import java.io.BufferedInputStream;
   import java.io.BufferedOutputStream;
   import java.io.BufferedReader;
   import java.io.File;
   import java.io.FileOutputStream;
   import java.io.InputStream;
   import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.Reader;
  import java.io.IOException;
  
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLConnection;
  import java.net.URLDecoder;
  
  import java.util.ArrayList;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipFile;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  
  
  /***
   * Provides utilities for loading resources.
   *
   * @author Chad Brandon
   */
  public class ResourceUtils
  {
      private final static Logger logger = Logger.getLogger(ResourceUtils.class);
      
      /***
       * All archive files start with this prefix.
       */
      private static final String ARCHIVE_PREFIX = "jar:";
      
      /***
       * The prefix for URL file resources.
       */
      private static final String FILE_PREFIX = "file:";
      
      /***
       * The prefix to use for searching the classpath for a resource.
       */
      private static final String CLASSPATH_PREFIX = "classpath:";
  
      /***
       * Retrieves a resource from the current classpath.
       *
       * @param resourceName the name of the resource
       * @return the resource url
       */
      public static URL getResource(final String resourceName)
      {
          ExceptionUtils.checkEmpty(
              "resourceName",
              resourceName);
          final ClassLoader loader = ClassUtils.getClassLoader();
          return loader != null ? loader.getResource(resourceName) : null;
      }
  
      /***
       * Loads the resource and returns the contents as a String.
       *
       * @param resource the name of the resource.
       * @return String
       */
      public static String getContents(final URL resource)
      {
          try
          {
              return getContents(resource != null ? new InputStreamReader(resource.openStream()) : null);
          }
          catch (final Throwable throwable)
          {
              throw new RuntimeException(throwable);
          }
      }
  
      /***
       * The line separator.
       */
      private static final char LINE_SEPARATOR = '\n';
  
      /***
       * Loads the resource and returns the contents as a String.
       *
       * @param resource the name of the resource.
       * @return the contents of the resource as a string.
       */
      public static String getContents(final Reader resource)
     {
         final StringBuffer contents = new StringBuffer();
         try
         {
             if (resource != null)
             {
                 BufferedReader resourceInput = new BufferedReader(resource);
                 for (String line = resourceInput.readLine(); line != null; line = resourceInput.readLine())
                 {
                     contents.append(line).append(LINE_SEPARATOR);
                 }
                 resourceInput.close();
                 resourceInput = null;
             }
         }
         catch (final Throwable throwable)
         {
             throw new RuntimeException(throwable);
         }
         return contents.toString().trim();
     }
 
     /***
      * If the <code>resource</code> represents a classpath archive (i.e. jar, zip, etc), this method will retrieve all
      * contents from that resource as a List of relative paths (relative to the archive base). Otherwise an empty List
      * will be returned.
      *
      * @param resource the resource from which to retrieve the contents
      * @return a list of Strings containing the names of every nested resource found in this resource.
      */
     public static List getClassPathArchiveContents(final URL resource)
     {
         final List contents = new ArrayList();
         if (isArchive(resource))
         {
             final ZipFile archive = getArchive(resource);
             if (archive != null)
             {
                 for (final Enumeration entries = archive.entries(); entries.hasMoreElements();)
                 {
                     final ZipEntry entry = (ZipEntry)entries.nextElement();
                     contents.add(entry.getName());
                 }
             }
         }
         return contents;
     }
 
     /***
      * If this <code>resource</code> happens to be a directory, it will load the contents of that directory into a
      * List and return the list of names relative to the given <code>resource</code> (otherwise it will return an empty
      * List).
      *
      * @param resource the resource from which to retrieve the contents
      * @param levels the number of levels to step down if the resource ends up being a directory (if its an artifact,
      *               levels will be ignored).
      * @return a list of Strings containing the names of every nested resource found in this resource.
      */
     public static List getDirectoryContents(
         final URL resource,
         final int levels)
     {
         return getDirectoryContents(
             resource,
             levels,
             true);
     }
 
     /***
      * The character used for substituing whitespace in paths.
      */
     private static final String PATH_WHITESPACE_CHARACTER = "%20";
 
     /***
      * Replaces any escape characters in the given file path with their
      * counterparts.
      *
      * @param filePath the path of the file to unescape.
      * @return the unescaped path.
      */
     public static String unescapeFilePath(String filePath)
     {
         if (filePath != null && filePath.length() > 0)
         {
             filePath = filePath.replaceAll(
                     PATH_WHITESPACE_CHARACTER,
                     " ");
         }
         return filePath;
     }
 
     /***
      * If this <code>resource</code> happens to be a directory, it will load the contents of that directory into a
      * List and return the list of names relative to the given <code>resource</code> (otherwise it will return an empty
      * List).
      *
      * @param resource the resource from which to retrieve the contents
      * @param levels the number of levels to step down if the resource ends up being a directory (if its an artifact,
      *               levels will be ignored).
      * @param includeSubdirectories whether or not to include subdirectories in the contents.
      * @return a list of Strings containing the names of every nested resource found in this resource.
      */
     public static List getDirectoryContents(
         final URL resource,
         final int levels,
         boolean includeSubdirectories)
     {
         final List contents = new ArrayList();
         if (resource != null)
         {
             // - create the file and make sure we remove any path white space characters
             final File fileResource = new File(unescapeFilePath(resource.getFile()));
             if (fileResource.isDirectory())
             {
                 File rootDirectory = fileResource;
                 for (int ctr = 0; ctr < levels; ctr++)
                 {
                     rootDirectory = rootDirectory.getParentFile();
                 }
                 final File pluginDirectory = rootDirectory;
                 loadFiles(
                     pluginDirectory,
                     contents,
                     includeSubdirectories);
 
                 // - remove the root path from each file
                 for (final ListIterator iterator = contents.listIterator(); iterator.hasNext();)
                 {
                     iterator.set(
                         StringUtils.replace(
                             ((File)iterator.next()).getPath().replace(
                                 '//',
                                 '/'),
                             pluginDirectory.getPath().replace(
                                 '//',
                                 '/') + '/',
                             ""));
                 }
             }
         }
         return contents;
     }
 
     /***
      * Loads all files find in the <code>directory</code> and adds them to the <code>fileList</code>.
      *
      * @param directory the directory from which to load all files.
      * @param fileList  the List of files to which we'll add the found files.
      * @param includeSubdirectories whether or not to include sub directories when loading the files.
      */
     private static void loadFiles(
         final File directory,
         final List fileList,
         boolean includeSubdirectories)
     {
         if (directory != null)
         {
             final File[] files = directory.listFiles();
             if (files != null)
             {
                 for (int ctr = 0; ctr < files.length; ctr++)
                 {
                     File file = files[ctr];
                     if (!file.isDirectory())
                     {
                         fileList.add(file);
                     }
                     else if (includeSubdirectories)
                     {
                         loadFiles(
                             file,
                             fileList,
                             includeSubdirectories);
                     }
                 }
             }
         }
     }
 
     /***
      * Returns true/false on whether or not this <code>resource</code> represents an archive or not (i.e. jar, or zip,
      * etc).
      *
      * @return true if its an archive, false otherwise.
      */
     public static boolean isArchive(final URL resource)
     {
         return resource != null && resource.toString().startsWith(ARCHIVE_PREFIX);
     }
     
     private static final String URL_DECODE_ENCODING = "UTF-8";
 
     /***
      * If this <code>resource</code> is an archive file, it will return the resource as an archive.
      *
      * @return the archive as a ZipFile
      */
     public static ZipFile getArchive(final URL resource)
     {
         try
         {
             ZipFile archive = null;
             if (resource != null)
             {
                 String resourceUrl = resource.toString();
                 resourceUrl = resourceUrl.replaceFirst(
                         ARCHIVE_PREFIX,
                         "");
                 final int entryPrefixIndex = resourceUrl.indexOf('!');
                 if (entryPrefixIndex != -1)
                 {
                     resourceUrl = resourceUrl.substring(
                             0,
                             entryPrefixIndex);
                 }
                 resourceUrl = URLDecoder.decode(new URL(resourceUrl).getFile(), URL_DECODE_ENCODING); 
                 archive = new ZipFile(resourceUrl);
             }
             return archive;
         }
         catch (final Throwable throwable)
         {
             throw new RuntimeException(throwable);
         }
     }
 
     /***
      * Loads the file resource and returns the contents as a String.
      *
      * @param resourceName the name of the resource.
      * @return String
      */
     public static String getContents(final String resourceName)
     {
         return getContents(getResource(resourceName));
     }
 
     /***
      * Takes a className as an argument and returns the URL for the class.
      *
      * @param className
      * @return java.net.URL
      */
     public static URL getClassResource(final String className)
     {
         ExceptionUtils.checkEmpty(
             "className",
             className);
         return getResource(getClassNameAsResource(className));
     }
 
     /***
      * Gets the class name as a resource.
      *
      * @param className the name of the class.
      * @return the class name as a resource path.
      */
     private static String getClassNameAsResource(final String className)
     {
         return className.replace(
             '.',
             '/') + ".class";
     }
 
     /***
      * <p/>
      * Retrieves a resource from an optionally given <code>directory</code> or from the package on the classpath. </p>
      * <p/>
      * If the directory is specified and is a valid directory then an attempt at finding the resource by appending the
      * <code>resourceName</code> to the given <code>directory</code> will be made, otherwise an attempt to find the
      * <code>resourceName</code> directly on the classpath will be initiated. </p>
      *
      * @param resourceName the name of a resource
      * @param directory the directory location
      * @return the resource url
      */
     public static URL getResource(
         final String resourceName,
         final String directory)
     {
         ExceptionUtils.checkEmpty(
             "resourceName",
             resourceName);
 
         if (directory != null)
         {
             final File file = new File(directory, resourceName);
             if (file.exists())
             {
                 try
                 {
                     return file.toURL();
                 }
                 catch (final MalformedURLException exception)
                 {
                     // - ignore, we just try to find the resource on the classpath
                 }
             }
         }
         return getResource(resourceName);
     }
 
     /***
      * Makes the directory for the given location if it doesn't exist.
      *
      * @param location the location to make the directory.
      */
     public static void makeDirectories(final String location)
     {
         final File file = new File(location);
         final File parent = file.getParentFile();
         if (parent != null)
         {
             parent.mkdirs();
         }
     }
 
     /***
      * Gets the time as a <code>long</code> when this <code>resource</code> was last modified.
      * If it can not be determined <code>0</code> is returned.
      *
      * @param resource the resource from which to retrieve
      *        the last modified time.
      * @return the last modified time or 0 if it couldn't be retrieved.
      */
     public static long getLastModifiedTime(final URL resource)
     {
         long lastModified;
         try
         {
             final File file = new File(resource.getFile());
             if (file.exists())
             {
                 lastModified = file.lastModified();
             }
             else
             {
                 URLConnection uriConnection = resource.openConnection();
                 lastModified = uriConnection.getLastModified();
 
                 // - we need to set the urlConnection to null and explicity
                 //   call garbage collection, otherwise the JVM won't let go
                 //   of the URL resource
                 uriConnection = null;
                 System.gc();
             }
         }
         catch (final Exception exception)
         {
             lastModified = 0;
         }
         return lastModified;
     }
 
     /***
      * <p>
      * Retrieves a resource from an optionally given <code>directory</code> or from the package on the classpath.
      * </p>
      * If the directory is specified and is a valid directory then an attempt at finding the resource by appending the
      * <code>resourceName</code> to the given <code>directory</code> will be made, otherwise an attempt to find the
      * <code>resourceName</code> directly on the classpath will be initiated. </p>
      *
      * @param resourceName the name of a resource
      * @param directory the directory location
      * @return the resource url
      */
     public static URL getResource(
         final String resourceName,
         final URL directory)
     {
         String directoryLocation = null;
         if (directory != null)
         {
             directoryLocation = directory.getFile();
         }
         return getResource(
             resourceName,
             directoryLocation);
     }
 
     /***
      * Attempts to construct the given <code>path</code>
      * to a URL instance. If the argument cannot be resolved as a resource
      * on the file system this method will attempt to locate it on the
      * classpath.
      *
      * @param path the path from which to construct the URL.
      * @return the constructed URL or null if one couldn't be constructed.
      */
     public static URL toURL(String path)
     {
         URL url = null;
         if (path != null)
         {
             path = ResourceUtils.normalizePath(path);
 
             try
             {
                 if (path.startsWith(CLASSPATH_PREFIX))
                 {
                     url = ResourceUtils.resolveClasspathResource(path);
                 }
                 else
                 {
                     final File file = new File(path);
                     url = file.exists() ? file.toURL() : new URL(path);
                 }
             }
             catch (MalformedURLException exception)
             {
                 // ignore means no protocol was specified
             }
         }
         return url;
     }
 
     /***
      * Resolves a URL to a classpath resource, this method will treat occurrences of the exclamation mark
      * similar to what {@link URL} does with the <code>jar:file</code> protocol.
      * <p/>
      * Example: <code>my/path/to/some.zip!/file.xml</code> represents a resource <code>file.xml</code>
      * that is located in a ZIP file on the classpath called <code>my/path/to/some.zip</code>
      * <p/>
      * It is possible to have nested ZIP files, example:
      * <code>my/path/to/first.zip!/subdir/second.zip!/file.xml</code>.
      * <p/>
      * <i>Please note that the extension of the ZIP file can be anything,
      * but in the case the extension is <code>.jar</code> the JVM will automatically unpack resources
      * one level deep and put them all on the classpath</i>
      *
      * @param path the name of the resource to resolve to a URL, potentially nested in ZIP archives
      * @return a URL pointing the resource resolved from the argument path
      *      or <code>null</code> if the argument is <code>null</code> or impossible to resolve
      */
     public static URL resolveClasspathResource(String path)
     {
         URL urlResource = null;
         if (path.startsWith(CLASSPATH_PREFIX))
         {        
             path = path.substring(CLASSPATH_PREFIX.length(), path.length());
             
             // - the value of the following constant is -1 of no nested resources were specified,
             //   otherwise it points to the location of the first occurrence
             final int nestedPathOffset = path.indexOf("!/");
     
             // - take the part of the path that is not nested (may be all of it)
             final String resourcePath = nestedPathOffset == -1 ? path : path.substring(0, nestedPathOffset);
             final String nestingPath = nestedPathOffset == -1 ? "" : path.substring(nestedPathOffset);
     
             // - use the new path to load a URL from the classpath using the context class loader for this thread
             urlResource = Thread.currentThread().getContextClassLoader().getResource(resourcePath);
     
             // - at this point the URL might be null in case the resource was not found
             if (urlResource == null)
             {
                 if (logger.isDebugEnabled())
                 {
                     logger.debug("Resource could not be located on the classpath: " + resourcePath);
                 }
             }
             else
             {
                 try
                 {
                     // - extract the filename from the entire resource path
                     final int fileNameOffset = resourcePath.lastIndexOf('/');
                     final String resourceFileName =
                         fileNameOffset == -1 ? resourcePath : resourcePath.substring(fileNameOffset + 1);
     
                     if (logger.isDebugEnabled())
                     {
                         logger.debug("Creating temporary copy on the file system of the classpath resource");
                     }
                     final File fileSystemResource = File.createTempFile(resourceFileName, null);
                     if (logger.isDebugEnabled())
                     {
                         logger.debug("Temporary file will be deleted on VM exit: " + fileSystemResource.getAbsolutePath());
                     }
                     fileSystemResource.deleteOnExit();
                     if (logger.isDebugEnabled())
                     {
                         logger.debug("Copying classpath resource contents into temporary file");
                     }
                     writeUrlToFile(urlResource, fileSystemResource.toString(), null);
     
                     // - count the times the actual resource to resolve has been nested
                     final int nestingCount = StringUtils.countMatches(path, "!/");
                     // - this buffer is used to construct the URL spec to that specific resource
                     final StringBuffer buffer = new StringBuffer();
                     for (int ctr = 0; ctr < nestingCount; ctr++)
                     {
                         buffer.append(ARCHIVE_PREFIX);
                     }
                     buffer.append(FILE_PREFIX).append(fileSystemResource.getAbsolutePath()).append(nestingPath);
                     if (logger.isDebugEnabled())
                     {
                         logger.debug("Constructing URL to " +
                             (nestingCount > 0 ? "nested" : "") + " resource in temporary file");
                     }
     
                     urlResource = new URL(buffer.toString());
                 }
                 catch (final IOException exception)
                 {
                     logger.warn("Unable to resolve classpath resource", exception);
                     // - impossible to properly resolve the path into a URL
                     urlResource = null;
                 }
             }
         }
         return urlResource;
     }
     
     /***
      * Writes the URL contents to a file specified by the fileLocation argument.
      *
      * @param url the URL to read
      * @param fileLocation the location which to write.
      * @param encoding the optional encoding
      */
     public static void writeUrlToFile(
         final URL url,
         final String fileLocation,
         final String encoding)
         throws IOException
     {
         ExceptionUtils.checkNull(
             "url",
             url);
         ExceptionUtils.checkEmpty(
             "fileLocation",
             fileLocation);
         final File file = new File(fileLocation);
         final File parent = file.getParentFile();
         if (parent != null)
         {
             parent.mkdirs();
         }
         OutputStream stream = new BufferedOutputStream(new FileOutputStream(file));
         if (StringUtils.isNotBlank(encoding))
         {
             BufferedReader inputReader = new BufferedReader(new InputStreamReader(
                         url.openStream(),
                         encoding));
             for (int ctr = inputReader.read(); ctr != -1; ctr = inputReader.read())
             {
                 stream.write(ctr);
             }
             inputReader.close();
             inputReader = null;
         }
         else
         {
             InputStream inputStream = new BufferedInputStream(url.openStream());
             for (int ctr = inputStream.read(); ctr != -1; ctr = inputStream.read())
             {
                 stream.write(ctr);
             }
             inputStream.close();
             inputStream = null;
         }
         stream.flush();
         stream.close();
         stream = null;
     }
 
 
     /***
      * Indicates whether or not the given <code>url</code> is a file.
      *
      * @param url the URL to check.
      * @return true/false
      */
     public static boolean isFile(final URL url)
     {
         return url != null && new File(url.getFile()).isFile();
     }
 
     /***
      * Recursively deletes a directory and its contents.
      *
      * @param directory the directory to delete.
      */
     public static void deleteDirectory(final File directory)
     {
         if (directory != null && directory.exists() && directory.isDirectory())
         {
             final File[] files = directory.listFiles();
             if (files != null && files.length > 0)
             {
                 final int mergedTemplatesCount = files.length;
                 for (int ctr = 0; ctr < mergedTemplatesCount; ctr++)
                 {
                     final File file = files[ctr];
                     if (file.isDirectory())
                     {
                         deleteDirectory(file);
                         file.delete();
                     }
                     else
                     {
                         file.delete();
                     }
                 }
             }
         }
     }
 
     /***
      * The forward slash character.
      */
     private static final String FORWARD_SLASH = "/";
 
     /***
      * Gets the contents of this directory and any of its sub directories based on the given <code>patterns</code>.
      * And returns absolute or relative paths depending on the value of <code>absolute</code>.
      *
      * @param url the URL of the directory.
      * @param absolute whether or not the returned content paths should be absoluate (if
      *        false paths will be relative to URL).
      * @return a collection of paths.
      */
     public static List getDirectoryContents(
         final URL url,
         boolean absolute,
         final String[] patterns)
     {
         List contents = ResourceUtils.getDirectoryContents(
                 url,
                 0,
                 true);
 
         // - first see if its a directory
         if (!contents.isEmpty())
         {
             for (final ListIterator iterator = contents.listIterator(); iterator.hasNext();)
             {
                 String path = (String)iterator.next();
                 if (!matchesAtLeastOnePattern(
                         path,
                         patterns))
                 {
                     iterator.remove();
                 }
                 else if (absolute)
                 {
                     path = url.toString().endsWith(FORWARD_SLASH) ? path : FORWARD_SLASH + path;
                     final URL resource = ResourceUtils.toURL(url + path);
                     if (resource != null)
                     {
                         iterator.set(resource.toString());
                     }
                 }
             }
         }
         else // - otherwise handle archives (i.e. jars, etc).
         {
             final String urlAsString = url.toString();
             final String delimiter = "!/";
             final String archivePath = urlAsString.replaceAll(
                     delimiter + ".*",
                     delimiter);
             contents = ResourceUtils.getClassPathArchiveContents(url);
             for (final ListIterator iterator = contents.listIterator(); iterator.hasNext();)
             {
                 final String relativePath = (String)iterator.next();
                 final String fullPath = archivePath + relativePath;
                 if (!fullPath.startsWith(urlAsString) || fullPath.equals(urlAsString + FORWARD_SLASH))
                 {
                     iterator.remove();
                 }
                 else if (!matchesAtLeastOnePattern(
                         relativePath,
                         patterns))
                 {
                     iterator.remove();
                 }
                 else if (absolute)
                 {
                     iterator.set(fullPath);
                 }
             }
         }
         return contents;
     }
 
     /***
      * Indicates whether or not the given <code>path</code> matches on
      * one or more of the patterns defined within this class
      * returns true if no patterns are defined.
      *
      * @param path the path to match on.
      * @return true/false
      */
     public static boolean matchesAtLeastOnePattern(
         final String path,
         final String[] patterns)
     {
         boolean matches = patterns == null || patterns.length == 0;
         if (!matches)
         {
             if (patterns.length > 0)
             {
                 final int patternNumber = patterns.length;
                 for (int ctr = 0; ctr < patternNumber; ctr++)
                 {
                     final String pattern = patterns[ctr];
                     if (PathMatcher.wildcardMatch(
                             path,
                             pattern))
                     {
                         matches = true;
                         break;
                     }
                 }
             }
         }
         return matches;
     }
 
     /***
      * Indicates whether or not the contents of the given <code>directory</code>
      * and any of its sub directories have been modified after the given <code>time</code>.
      *
      * @param directory the directory to check
      * @param time the time to check against
      * @return true/false
      */
     public static boolean modifiedAfter(
         long time,
         final File directory)
     {
         final List files = new ArrayList();
         ResourceUtils.loadFiles(
             directory,
             files,
             true);
         boolean changed = files.isEmpty();
         for (final Iterator iterator = files.iterator(); iterator.hasNext();)
         {
             final File file = (File)iterator.next();
             changed = file.lastModified() < time;
             if (changed)
             {
                 break;
             }
         }
         return changed;
     }
 
     /***
      * The pattern used for normalizing paths paths with more than one back slash.
      */
     private static final String BACK_SLASH_NORMALIZATION_PATTERN = "////+";
 
     /***
      * The pattern used for normalizing paths with more than one forward slash.
      */
     private static final String FORWARD_SLASH_NORMALIZATION_PATTERN = FORWARD_SLASH + "+";
 
     /***
      * Removes any extra path separators and converts all from back slashes
      * to forward slashes.
      *
      * @param path the path to normalize.
      * @return the normalizd path
      */
     public static String normalizePath(final String path)
     {
         return path != null
         ? path.replaceAll(
             BACK_SLASH_NORMALIZATION_PATTERN,
             FORWARD_SLASH).replaceAll(
             FORWARD_SLASH_NORMALIZATION_PATTERN,
             FORWARD_SLASH) : null;
     }
 
     /***
      * Takes a path and replaces the oldException with the newExtension.
      *
      * @param path the path to rename.
      * @param oldExtension the extension to rename from.
      * @param newExtension the extension to rename to.
      * @return the path with the new extension.
      */
     public static String renameExtension(
         final String path,
         final String oldExtension,
         final String newExtension)
     {
         ExceptionUtils.checkEmpty(
             "path",
             path);
         ExceptionUtils.checkNull(
             "oldExtension",
             oldExtension);
         ExceptionUtils.checkNull(
             "newExtension",
             newExtension);
         String newPath = path;
         final int oldExtensionIndex = path.lastIndexOf(oldExtension);
         if (oldExtensionIndex != -1)
         {
             newPath = path.substring(
                     0,
                     oldExtensionIndex) + newExtension;
         }
         return newPath;
     }
 }