package de.matthias_burbach.mosaique.core.util;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   
   /***
    * @author Matthias Burbach
   */
  public final class FileUtils {
      /***
       * Private default constructor to enforce static usage of this utility
       * class.
       */
      private FileUtils() {
          //empty
      }
  
      /***
       * @param pathAndName The path and name of the file to get the path for.
       * @return The path of the file.
       */
      public static String getPathWithoutName(final String pathAndName) {
            if (pathAndName == null) {
                return null;
            }
            String name = (new File(pathAndName)).getName();
            return pathAndName.substring(0, pathAndName.length() - name.length());
        }
  
      /***
       * @param pathAndName The path and name of the file to get the name for.
       * @return The name of the file.
       */
      public static String getNameWithoutPath(final String pathAndName) {
          if (pathAndName == null) {
              return null;
            }
            String name = (new File(pathAndName)).getName();
            return name;
        }
  
        /***
         * @param filePathAndName The file to check for validity.
         * @return <code>true</code> iff the file exists and is readable
         */
      public static boolean isValidFile(final String filePathAndName) {
          if (filePathAndName == null) {
              return false;
          }
  
          File aFile = new File(filePathAndName);
          if (!aFile.exists() || !aFile.canRead() || !aFile.isFile()) {
           return false;
          }
  
          return true;
      }
  
      /***
       * @param file The file to delete.
       */
      public static void delete(final String file) {
          File aFile = new File(file);
          aFile.delete();
      }
  
      /***
       * Performs a file copy.
       * Before copying the file, however, it performs a lot of tests to make
       * sure everything is as it should be.
       *
       * @param fromName The path and name of the file to copy from.
       * @param toName The path and name of the file to copy to.
       *
       * @throws IOException if copying fails for any reason
       *
       * Copyright (c) 1997 by David Flanagan
       */
      public static void copy(
              final String fromName,
              final String toName)
              throws IOException {
          File fromFile = new File(fromName); // Get File objects from Strings
          File toFile = new File(toName);
  
          // First make sure the source file exists, is a file, and is readable.
          if (!fromFile.exists()) {
              abort("FileCopy: no such source file: " + fromName);
          }
          if (!fromFile.isFile()) {
              abort("FileCopy: can't copy directory: " + fromName);
          }
          if (!fromFile.canRead()) {
              abort("FileCopy: source file is unreadable: " + fromName);
          }
  
          // If the destination is a directory, use the source file name
         // as the destination file name
         if (toFile.isDirectory()) {
             toFile = new File(toFile, fromFile.getName());
         }
 
         // If the destination exists, make sure it is a writeable file.
         // If the destination doesn't
         // exist, make sure the directory exists and is writeable.
         if (toFile.exists()) {
             if (!toFile.canWrite()) {
                 abort("FileCopy: destination file is unwriteable: " + toName);
             }
         } else {
             // if file doesn't exist, check if directory exists and is
             // writeable.
             // If getParent() returns null, then the directory is the current
             // dir.
             // so look up the user.dir system property to find out what that is.
             String parent = toFile.getParent();
             // Get the destination directory
             if (parent == null) {
                 parent = System.getProperty("user.dir"); // or CWD
             }
             File dir = new File(parent); // Convert it to a file.
             if (!dir.exists()) {
                 abort(
                     "FileCopy: destination directory doesn't exist: " + parent);
             }
             if (dir.isFile()) {
                 abort("FileCopy: destination is not a directory: " + parent);
             }
             if (!dir.canWrite()) {
                 abort(
                     "FileCopy: destination directory is unwriteable: "
                         + parent);
             }
         }
 
         // If we've gotten this far, then everything is okay.
         // So we copy the file, a buffer of bytes at a time.
         FileInputStream from = null; // Stream to read from source
         FileOutputStream to = null; // Stream to write to destination
         try {
             from = new FileInputStream(fromFile); // Create input stream
             to = new FileOutputStream(toFile); // Create output stream
             final int bufferSize = 4096;
             byte[] buffer = new byte[bufferSize]; // to hold file contents
             int bytesRead; // How many bytes in buffer
             // Read a chunk of bytes into the buffer, then write them out,
             // looping until we reach the end of the file (when read() returns
             // -1).
             // Note the combination of assignment and comparison in this while
             // loop.  This is a common I/O programming idiom.
             while ((bytesRead = from.read(buffer)) != -1) {
                 // Read bytes until EOF
                 to.write(buffer, 0, bytesRead); //   write bytes
             }
         } finally { // Always close the streams, even if exceptions were thrown
             if (from != null) {
                 try {
                     from.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
             if (to != null) {
                 try {
                     to.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 
     /***
      * Is a convenience method to throw an exception.
      * @param msg The message to deliver on abort.
      * @throws IOException always
      */
     private static void abort(final String msg) throws IOException {
         throw new IOException(msg);
     }
 }