package com.atlassian.core.util;
   
   
   
   import com.atlassian.core.util.zip.FolderArchiver;
   import com.opensymphony.util.TextUtils;
   import org.apache.log4j.Logger;
   
   import javax.servlet.http.HttpServletRequest;
  import java.io.*;
  import java.util.ArrayList;
  import java.util.List;
  
  /*
   * A series of utility methods for manipulating files.
   */
  public class FileUtils
  {
      private static final Logger log = Logger.getLogger(FileUtils.class);
      private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
  
      /**
       * Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>.
       * @param input the <code>InputStream</code> to read from
       * @param output the <code>OutputStream</code> to write to
       * @return the number of bytes copied
       * @throws IOException In case of an I/O problem
       */
      public static int copy(final InputStream input, final OutputStream output)
              throws IOException
      {
          return copy(input, output, DEFAULT_BUFFER_SIZE);
      }
  
      /**
       * Copy bytes from an <code>InputStream</code> to an <code>OutputStream</code>.
       * @param input the <code>InputStream</code> to read from
       * @param output the <code>OutputStream</code> to write to
       * @param bufferSize Size of internal buffer to use.
       * @return the number of bytes copied
       * @throws IOException In case of an I/O problem
       */
      public static int copy(final InputStream input,
                             final OutputStream output,
                             final int bufferSize)
              throws IOException
      {
          final byte[] buffer = new byte[bufferSize];
          int count = 0;
          int n = 0;
          while (-1 != (n = input.read(buffer)))
          {
              output.write(buffer, 0, n);
              count += n;
          }
          return count;
      }
  
      /**
       * Unconditionally close an <code>OutputStream</code>.
       * Equivalent to {@link OutputStream#close()}, except any exceptions will be ignored.
       * @param output A (possibly null) OutputStream
       */
      public static void shutdownStream(final OutputStream output)
      {
          if (output == null)
          {
              return;
          }
  
          try
          {
              output.close();
          }
          catch (final IOException ioe)
          {
          }
      }
  
      /**
       * Unconditionally close an <code>InputStream</code>.
       * Equivalent to {@link InputStream#close()}, except any exceptions will be ignored.
       * @param input A (possibly null) InputStream
       */
      public static void shutdownStream(final InputStream input)
      {
          if (input == null)
          {
              return;
          }
  
          try
          {
              input.close();
          }
          catch (final IOException ioe)
          {
          }
      }
 
 
     /**
      * safely performs a recursive delete on a directory
      *
      * @param dir
      */
     public static boolean deleteDir(File dir)
     {
         if (dir == null)
         {
             return false;
         }
 
         // to see if this directory is actually a symbolic link to a directory,
         // we want to get its canonical path - that is, we follow the link to
         // the file it's actually linked to
         File candir;
         try
         {
             candir = dir.getCanonicalFile();
         }
         catch (IOException e)
         {
             return false;
         }
 
         // a symbolic link has a different canonical path than its actual path,
         // unless it's a link to itself
         if (!candir.equals(dir.getAbsoluteFile()))
         {
             // this file is a symbolic link, and there's no reason for us to
             // follow it, because then we might be deleting something outside of
             // the directory we were told to delete
             return false;
         }
 
         // now we go through all of the files and subdirectories in the
         // directory and delete them one by one
         File[] files = candir.listFiles();
         if (files != null)
         {
             for (int i = 0; i < files.length; i++)
             {
                 File file = files[i];
 
                 // in case this directory is actually a symbolic link, or it's
                 // empty, we want to try to delete the link before we try
                 // anything
                 boolean deleted = !file.delete();
                 if (deleted)
                 {
                     // deleting the file failed, so maybe it's a non-empty
                     // directory
                     if (file.isDirectory()) deleteDir(file);
 
                     // otherwise, there's nothing else we can do
                 }
             }
         }
 
         // now that we tried to clear the directory out, we can try to delete it
         // again
         return dir.delete();
     }
 
 
     /**
      * Recursively delete everything beneath <param>file</param> then delete dir.
      */
     public static void recursiveDelete(File file)
     {
         File[] files = null;
 
         if (file.isDirectory())
             files = file.listFiles();
         else
         {
             file.delete();
             return;
         }
 
         for (int i = 0; i < files.length; i++)
         {
             File next = files[i];
             recursiveDelete(next);
         }
 
         file.delete();
     }
 
 
     /**
      * Get the contents of a classpath resource as a String.
      */
     public static String getResourceContent(String resource)
     {
         InputStream is = ClassLoaderUtils.getResourceAsStream(resource, FileUtils.class);
         return getInputStreamTextContent(is);
     }
 
     /**
      * Get the contents of a servlet context resource as a String.
      */
     public static String getResourceContent(HttpServletRequest req, String resource)
     {
         InputStream is = req.getSession().getServletContext().getResourceAsStream(resource);
         String result = getInputStreamTextContent(is);
 
         if (result == null)
         {
             result = "";
         }
 
         return result;
     }
 
     /**
      * Get the contents of an inputstream as a String.
      */
     public static String getInputStreamTextContent(InputStream is)
     {
         if (is == null)
         {
             return null;
         }
 
         String result = null;
 
         try
         {
             ByteArrayOutputStream baos = new ByteArrayOutputStream(is.available());
 
             copy(is, baos);
 
             result = new String(baos.toByteArray());
 
             is.close();
         }
         catch (IOException e)
         {
             log.error("IOException reading stream: " + e, e);
         }
 
         return result;
     }
 
     /**
      * Writes text to the nominated file.
      * If this file already exists, its content will be overwritten
      *
      * @param stringContent
      * @param destFile
      * @throws IOException
      */
     public static void saveTextFile(String stringContent, File destFile) throws IOException
     {
         ensureFileAndPathExist(destFile);
 
         FileWriter writer = new FileWriter(destFile);
         writer.write(stringContent);
         writer.close();
     }
 
     /**
      * Check that a given file and its parent directories exist - will create blank file and all directories if necessary.
      */
     public static void ensureFileAndPathExist(File file) throws IOException
     {
         file.getParentFile().mkdirs();
         file.createNewFile();
     }
 
     /**
      * move a directory with all it's children into another directory
      * if destination directory already exists, it will be deleted.
      *
      * e.g. rename c:/foo/bar to c:/fooz/bar
      *
      * @param dirName
      * @param destDir
      */
     public static boolean moveDir(File dirName, File destDir)
     {
         File destParent = new File(destDir.getParent());
 
         // if the destDir exists, we override
         if (destDir.exists())
         {
             destDir.delete();
         }
         // destParent is the new directory we're moving dirName to
         // we have to ensure all its directories are created before moving
         destParent.mkdirs();
         return dirName.renameTo(destDir);
     }
 
     /**
      * Create a zip file of a given directory.
      */
     public static void createZipFile(File baseDir, File zipFile) throws Exception
     {
         FolderArchiver compressor = new FolderArchiver(baseDir, zipFile);
         compressor.doArchive();
     }
 
     /**
      * Get the contents of a resource as a list, one line representing one list item.
      * <p />
      * Note: lines starting with # are deemed to be comments and not included.
      */
     public static List readResourcesAsList(String resource)
     {
         List result = new ArrayList();
 
         try
         {
             InputStream is = ClassLoaderUtils.getResourceAsStream(resource, FileUtils.class);
             BufferedReader in = new BufferedReader(new InputStreamReader(is));
             String s;
 
             while ((s = in.readLine()) != null)
             {
                 String niceS = TextUtils.noNull(s).trim();
 
                 if (TextUtils.stringSet(niceS) && !(niceS.charAt(0) == '#'))
                 {
                     result.add(s);
                 }
             }
 
             is.close();
         }
         catch (IOException e)
         {
             log.error("IOException reading stream: " + e, e);
         }
 
         return result;
     }
 
         /**
      * Copies all files from srcDir to destDir. Currently it just copies the files at te root, it's not recursive.
      */
     public static void copyDirectory(File srcDir, File destDir) throws IOException
     {
         copyDirectory(srcDir, destDir, false);
     }
 
     public static void copyDirectory(File srcDir, File destDir, boolean overwrite) throws IOException
     {
         File[] files = srcDir.listFiles();
 
         if (!destDir.exists())
             destDir.mkdirs();
         else
             log.debug(destDir.getAbsolutePath() + " already exists");
 
         if (files != null)
         {
             for (int i = 0; i < files.length; i++)
             {
                 File file = files[i];
                 File dest = new File(destDir, file.getName());
 
                 if (file.isFile())
                     copyFile(new FileInputStream(file), dest, overwrite);
                 else
                     copyDirectory(file, dest, overwrite);
             }
         }
     }
 
     /**
      * Copy file from source to destination. The directories up to <code>destination</code> will be
      * created if they don't already exist. <code>destination</code> will be overwritten if it
      * already exists.
      *
      * @param srcFile An existing non-directory <code>File</code> to copy bytes from.
      * @param destFile A non-directory <code>File</code> to write bytes to (possibly
      * overwriting).
      *
      * @throws java.io.IOException if <code>source</code> does not exist, <code>destination</code> cannot be
      * written to, or an IO error occurs during copying.
      *
      */
     public static void copyFile(File srcFile, File destFile) throws IOException
     {
         copyFile(srcFile, destFile, true);
     }
 
     public static void copyFile(File srcFile, File destFile, boolean overwrite) throws IOException
     {
         //check source exists
         if (!srcFile.exists())
         {
             final String message = "File " + srcFile + " does not exist";
             throw new IOException(message);
         }
 
         InputStream input = new FileInputStream(srcFile);
         copyFile(input, destFile, overwrite);
 
         if (srcFile.length() != srcFile.length())
         {
             final String message = "Failed to copy full contents from " + srcFile + " to " + destFile;
             throw new IOException(message);
         }
     }
 
     public static void copyFile(InputStream srcStream, File destFile) throws IOException
     {
         copyFile(srcStream, destFile, false);
     }
 
     public static void copyFile(InputStream srcStream, File destFile, boolean overwrite) throws IOException
     {
         File parentFile = destFile.getParentFile();
         if (!parentFile.isDirectory())
         {
             parentFile.mkdirs();
         }
 
         if (destFile.exists())
         {
             if (!destFile.canWrite())
             {
                 final String message = "Unable to open file " + destFile + " for writing.";
                 throw new IOException(message);
             }
 
             if (overwrite)
             {
                 log.debug("Overwriting file at: " + destFile.getAbsolutePath());
                 writeStreamToFile(srcStream, destFile);
             }
             else
             {
                 shutdownStream(srcStream);
                 log.warn(destFile.getAbsolutePath() + " already exists");
             }
         }
         else
         {
             destFile.createNewFile();
             writeStreamToFile(srcStream, destFile);
         }
     }
 
     private static void writeStreamToFile(InputStream srcStream, File destFile) throws IOException
     {
         InputStream input = null;
         OutputStream output = null;
 
         try
         {
             input = new BufferedInputStream(srcStream);
             output = new BufferedOutputStream(new FileOutputStream(destFile));
             int ch;
 
             while ((ch = input.read()) != -1)
                 output.write(ch);
         }
         catch (IOException e)
         {
             log.error("Error writing stream to file: " + destFile.getAbsolutePath());
             throw e;
         }
         finally
         {
             shutdownStream(input);
             shutdownStream(output);
         }
     }
 }