package org.varienaja.util;
   
   import java.io.BufferedInputStream;
   import java.io.BufferedOutputStream;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.zip.ZipEntry;
  
  import org.apache.log4j.Logger;
  
  /**
   * Some much-used operations on files.
   * TODO Add a logger, don't print stacktraces.
   * @author Varienaja
   */
  public class FileOperations {
  	private static final int BUFFER = 4096;
  	private static final Logger LOG = Logger.getLogger(FileOperations.class);
  	
  	/**
  	 * Finds a filename that is not already used. This method does not create the 
  	 * file for you, so it is theoretically possible that the returned available
  	 * filename is already taken.
  	 * @param dstdir The directory where the file should be created.
  	 * @param dst The desired filename
  	 * @return The desider filename, if still available. Or an alternative where needed.
  	 */
  	public static String createUniqueFilename(String dstdir,String dst) {
  		File file = new File(dstdir+dst);
  		if (!file.exists()) {
  			return dstdir+dst;
  		} else {
  			//Misuse of i:
  			String ext = "";
  			String fn = null;
  			int i = dst.lastIndexOf(".");
  			if (i<0) {
  				fn = dst;
  			} else {
  				fn = dst.substring(0,i);
  				ext = dst.substring(i);
  			}
  			String uniqueName = "";
  			i=0;
  			while (file.exists()) {
  				i++;
  				uniqueName = dstdir+fn+"("+i+")"+ext;
  				LOG.debug("Clash detected, trying: "+uniqueName);
  				file = new File(uniqueName);
  			}
  			LOG.debug("Unique filename: "+uniqueName);
  			return uniqueName;
  		}
  	}
  	
  	/**
  	 * Copies a file. If the destination-directory contains illegal characters, they
  	 * will be replaced by underscores. If the filename contains illegal characters,
  	 * they will be replaced by underscores. If the target file already exists, a new
  	 * filename will be generated.
  	 * @param src The location of the sourcefile.
  	 * @param dstdir The target directory.
  	 * @param dst The requested filename (without directory-part).
  	 * @return The filename, that the file was finally copied to.
  	 * @throws IOException
  	 */
  	public static String copyFile(String src,String dstdir,String dst) throws IOException {
  		dstdir = translateIllegalDirectoryChars(dstdir);
  		if (dstdir.charAt(dstdir.length()-1)!=File.separatorChar) {
  			dstdir = dstdir + File.separator;
  		}
  		dst = translateIllegalFileChars(dst);
  		try {
  			if (!new File(dstdir).mkdirs()) {
  				throw new IOException("Failed to create directory: "+dstdir);
  			}
  			String result = createUniqueFilename(dstdir,dst);
  			
  			FileInputStream source = new FileInputStream(src);
  			FileOutputStream dest = new FileOutputStream(result);
  	
  			copyStream(source,dest);
  			dest.close();
  			source.close();
  			return result;
  		} catch (IOException e) {
  			LOG.error("Error copying file: "+e);
  			throw e;
  		}
  	}
  	
  	/**
  	 * Moves a file. Behaves just like copyFile ( @see copyFile ).
  	 * @param src
  	 * @param dstdir
 	 * @param dst
 	 * @return
 	 * @throws IOException
 	 */
 	public static String moveFile(String src,String dstdir,String dst) throws IOException {
 		dstdir = translateIllegalDirectoryChars(dstdir);
 		if (dstdir.charAt(dstdir.length()-1)!=File.separatorChar) {
 			dstdir = dstdir + File.separator;
 		}
 		dst = translateIllegalFileChars(dst);
 		File destDir = new File(dstdir);
 		if(!destDir.exists()) {
 			if (!destDir.mkdirs()) {
 				throw new IOException("Failed to create directory: "+dstdir);
 			}
 		}
 		String result = createUniqueFilename(dstdir,dst);
 		
 		File source = new File (src);
 		if (source.renameTo(new File(result))) {
 			return result;
 		} else {
 			throw new IOException("Error moving from: "+src+" to "+result);
 		}
 	}
 	
 	public static void copyStream(InputStream in, OutputStream out) {
 		int count;
 		byte data[] = new byte[BUFFER];
 		
 		try {
 			BufferedInputStream source = new BufferedInputStream(in);
 			BufferedOutputStream dest = new BufferedOutputStream(out,BUFFER);
 			while ((count = source.read(data,0,BUFFER))!=-1) {
 				dest.write(data,0,count);
 			}
 			dest.flush();
 		} catch (IOException e) {
 			LOG.error("Error copying stream: "+e);
 		}
 	}
 	
 	/**
 	 * Creates a file in the temp-directory and returns the filename
 	 * @param in The InputStream
 	 * @param tmpname The filename to use (without path)
 	 * @return The fully qualified filename
 	 * @throws IOException
 	 */
 	public static String tmpFile(InputStream in,String tmpname) throws IOException {
 		File outFile = File.createTempFile(tmpname, null);
 		return streamToFile(in,outFile);
 	}
 
 	/**
 	 * Saves an InputStream to a file. If the file does not exist, it
 	 * is created. If the file already exists, it is overwritten!
 	 * @param in The InputStream
 	 * @param filename The file to save the Stream into.
 	 * @return The filename
 	 * @throws IOException
 	 */
 	public static String streamToFile(InputStream in,String filename) throws IOException {
 		FileOutputStream out = new FileOutputStream(filename);
 		copyStream(in,out);
 		out.close();
 		return filename;
 	}
 
 	/**
 	 * Saves an InputStream to a file. If the file does not exist, it
 	 * is created. If the file already exists, it is overwritten!
 	 * @param in The InputStream
 	 * @param filename The file to save the Stream into.
 	 * @return The file
 	 * @throws IOException
 	 */
 	public static String streamToFile(InputStream in,File file) throws IOException {
 		FileOutputStream out = new FileOutputStream(file);
 		copyStream(in,out);
 		out.close();
 		return file.getAbsolutePath();
 	}
 
 	/**
 	 * Deletes a file from the filesystem.
 	 * @param filename The file to delete
 	 * @return True, if succesfull; False otherwise.
 	 */
 	public static boolean deleteFile(String filename) {
 		File file = new File(filename);
 		return file.delete();
 	}
 	/**
 	 * Deletes a directory including all contents.
 	 * <p><em>WARNING</em>: This method will happily delete the contents of your entiry
 	 * hard drive. Use with <em>extreme care</em>.
 	 *  
 	 * @param dir The directory to delete.
 	 * @return True if the directory was deleted succesfully, false otherwise.
 	 */
 	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();  
 	}
 
 	/**
 	 * Returns the "from" string with all / \ : * ? " < > |
 	 * characters replaced with "_". In addition, points (.) and spaces
 	 * are not allowed as first or last character of the filename.
 	 * @param from The source string
 	 * @return The source string with every occurence of / \ : * ? " < > |
 	 *         replaced with "_".
 	 */
 	public static String translateIllegalFileChars(String from) {
 		//Forbidden characters:	/ \ : * ? " < > |
 		 if (from==null) return null;
 		 return from.replaceAll("\"|<|>|\\||:|\\*|\\?|/|\\\\|^\\.|\\.$|^ | $","_");
 	}
 	
 	/**
 	 * Returns the "from" string with all : * ? " < > |
 	 * characters replaced with "_". In addition, points (.) and spaces
 	 * are not allowed as first or last character of the directory name.
 	 * @param from The source string
 	 * @return The source string with every occurence of : * ? " < > |
 	 *         replaced with "_".
 	 */
 	public static String translateIllegalDirectoryChars(String from) {
 		//Forbidden characters:	: * ? " < > |
 		 if (from==null) return null;
 		 return from.replaceAll("\"|<|>|\\||\\*|\\?|^\\.|\\.$|^ | $","_");
 	}
 	
 	/**
 	 * Takes a zip-inputstream and extracts the contents to the specified directory.
 	 * If files in the zipstream are already present at the specifiek location, a new
 	 * name for the file will be created using the createUniqueFilename-method.
 	 * @param zis The Zip-inputstream
 	 * @param directory The location to unzip to
 	 * @return The number of files (excluding directories) exracted
 	 * @see createUniqueFilename
 	 */
 	public static int extractToDirectory(TolerantZipInputStream zis, String directory) {
 		int unpackedFiles = 0;
 		
 		ZipEntry entry;
 		try {
 			while ((entry = zis.getNextEntry()) != null) {
 				if (entry.isDirectory()) { //Directory-entry
 					String destFN = directory + File.separator + entry.getName();
 					LOG.debug("Creating directory: "+destFN);
 					if (!new File(destFN).mkdirs()) {
 						throw new IOException("Failed to create directoy: "+destFN);
 					}
 				} else { //File-entry
 					String destFN = createUniqueFilename(directory + File.separator,entry.getName());
 					LOG.debug("Extracting to: "+destFN);
 					streamToFile(zis, destFN);
 					unpackedFiles++;
 				}
 			}
 			zis.close();
 		} catch (IllegalArgumentException e) {
 			e.printStackTrace();
 			LOG.error("Error reading zipfile, does it contain non-ascii characters? " +e);
 			/* TODO Java doesn't seem to like zipfiles containing entries with non-ascii
 			 * characters in their filename. (&euml;, for instance) There probably is a
 			 * workaround to be found for this behaviour. 
 			 * 
 			 * The workaround is to treat the input as ISO-8859-1, and convert that to UTF8
 			 */
 		} catch (IOException e) {
 			LOG.error(e);
 		}
 		
 		return unpackedFiles;
 	}
 	
 }