/*
    * 
    * © Copyright 2005-2010, Mike Odling-Smee.  All rights reserved.
    * 	
    * 	Licensed under the Artistic License: 
    * 	http://www.opensource.org/licenses/artistic-license.php
    * 	
    * Preamble
    * 
   *         The intent of this document is to state the conditions under which a 
   *         Package may be copied, such that the Copyright Holder maintains some 
   *         semblance of artistic control over the development of the package, while 
   *         giving the users of the package the right to use and distribute the Package
   * 	       in a more-or-less customary fashion, plus the right to make reasonable 
   *         modifications.
   * 
   * Definitions:
   * 
   *         * "Package" refers to the collection of files distributed by the 
   *         Copyright Holder, and derivatives of that collection of files created 
   *         through textual modification. 
   * 
   *         * "Standard Version" refers to such a Package if it has not been modified, 
   *         or has been modified in accordance with the wishes of the Copyright Holder.
   * 
   *         * "Copyright Holder" is whoever is named in the copyright or copyrights for
   *         the package. 
   * 
   *         * "You" is you, if you're thinking about copying or distributing this Package.
   * 
   *         * "Reasonable copying fee" is whatever you can justify on the basis of 
   *         media cost, duplication charges, time of people involved, and so on. 
   *         (You will not be required to justify it to the Copyright Holder, but 
   *         only to the computing community at large as a market that must bear the 
   *         fee.) 
   * 
   *         * "Freely Available" means that no fee is charged for the item 
   *         itself, though there may be fees involved in handling the item. It also 
   *         means that recipients of the item may redistribute it under the same 
   *         conditions they received it.
   * 
   * 	1. You may make and give away verbatim copies of the source form of the Standard 
   * 	Version of this Package without restriction, provided that you duplicate all of 
   * 	the original copyright notices and associated disclaimers.
   * 	
   * 	2. You may apply bug fixes, portability fixes and other modifications derived 
   * 	from the Public Domain or from the Copyright Holder. A Package modified in such 
   * 	a way shall still be considered the Standard Version.
   * 	
   * 	3. You may otherwise modify your copy of this Package in any way, provided that 
   * 	you insert a prominent notice in each changed file stating how and when you 
   * 	changed that file, and provided that you do at least ONE of the following:
   * 	
   * 		a) place your modifications in the Public Domain or otherwise make them 
   * 		Freely Available, such as by posting said modifications to Usenet or an 
   * 		equivalent medium, or placing the modifications on a major archive site such 
   * 		as ftp.uu.net, or by allowing the Copyright Holder to include your modifications 
   * 		in the Standard Version of the Package.
   * 	
   * 		b) use the modified Package only within your corporation or organization.
   * 	
   * 		c) rename any non-standard executables so the names do not conflict with 
   * 		standard executables, which must also be provided, and provide a separate 
   * 		manual page for each non-standard executable that clearly documents how it 
   * 		differs from the Standard Version.
   * 	
   * 		d) make other distribution arrangements with the Copyright Holder.
   * 	
   * 	4. You may distribute the programs of this Package in object code or executable 
   * 	form, provided that you do at least ONE of the following:
   * 	
   * 		a) distribute a Standard Version of the executables and library files, 
   * 		together with instructions (in the manual page or equivalent) on where to 
   * 		get the Standard Version.
   * 	
   * 		b) accompany the distribution with the machine-readable source of the 
   * 		Package with your modifications.
   * 	
   * 		c) accompany any non-standard executables with their corresponding Standard 
   * 		Version executables, giving the non-standard executables non-standard names, 
   * 		and clearly documenting the differences in manual pages (or equivalent), 
   * 		together with instructions on where to get the Standard Version.
   * 	
   * 		d) make other distribution arrangements with the Copyright Holder.
   * 	
   * 	5. You may charge a reasonable copying fee for any distribution of this Package. 
   * 	You may charge any fee you choose for support of this Package. You may not 
   * 	charge a fee for this Package itself. However, you may distribute this Package 
   * 	in aggregate with other (possibly commercial) programs as part of a larger 
   * 	(possibly commercial) software distribution provided that you do not advertise 
   * 	this Package as a product of your own.
   * 	
   * 	6. The scripts and library files supplied as input to or produced as output from 
   * 	the programs of this Package do not automatically fall under the copyright of 
   * 	this Package, but belong to whomever generated them, and may be sold 
   * 	commercially, and may be aggregated with this Package.
   * 	
   * 	7. C or perl subroutines supplied by you and linked into this Package shall not 
   * 	be considered part of this Package.
  * 	
  * 	8. The name of the Copyright Holder may not be used to endorse or promote 
  * 	products derived from this software without specific prior written permission.
  * 	
  * 	9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED 
  * 	WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 
  * 	MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  * 
  * The End
  */
 package net.sourceforge.xuse.utils;
 
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
 import java.net.URL;
 import java.net.URLDecoder;
 import java.nio.channels.FileChannel;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Enumeration;
 import java.util.Iterator;
 import java.util.List;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 
 import net.sourceforge.xuse.build.BuildException;
 import net.sourceforge.xuse.build.XusePropertiesReader;
 import net.sourceforge.xuse.log.Logger;
 
 import com.xmlsolutions.annotation.Requirement; 
 
 
 public class FileUtils {
 	
 	private static final FileUtils LOG_INSTANCE = new FileUtils();
 
 	public static final File WORKING_DIR = new File(XusePropertiesReader.getXuseWorkingDir());
 
 	public static void copy(FileInputStream in, File destination) throws IOException {
 		FileChannel srcChannel = null;
 		FileChannel dstChannel = null;
     	try {
 			srcChannel = in.getChannel();
 			dstChannel = new FileOutputStream(destination).getChannel();
 			dstChannel.transferFrom(srcChannel, 0, srcChannel.size());
     	} finally {
     		if (srcChannel != null) {
     			srcChannel.close();
     		}
 			if (dstChannel != null) {
 				dstChannel.close();
 			}
     	}
     }
 	
 	public static final boolean fileExists(String path) {
 		if (path != null) {
 			String safePath = path;
 			try {
 				safePath = URLDecoder.decode(path, "UTF-8");
 			} catch (UnsupportedEncodingException uee) {
 				Logger.warn(LOG_INSTANCE, "Could not safely decode file path", uee);
 			}
 			File file = new File(safePath);
 			return file.exists();
 		}
 		return false;
 	}
 	
 	public static void copyFileToDir(String file, File destDir) throws IOException {
 		if (file != null) {
 			if (destDir != null) {
 				if (!destDir.exists()) {
 					destDir.mkdirs();
 				} else if (!destDir.isDirectory()) {
 					Logger.warn(LOG_INSTANCE, "Cannot copy file " + file + " to " + destDir.getAbsolutePath() + "; destination is not a directory");
 				}
 				Logger.debug(LOG_INSTANCE, "Copying " + file + " to " + destDir.getAbsolutePath());
 				//OK we are ok to try and copy
 				File input = new File(file);
 				String fileName = input.getName();
 				File destFile = new File(destDir, fileName);
 				copyFile(input, destFile);
 			} else {
 				Logger.warn(LOG_INSTANCE, "Cannot copy file " + file + "; destination was null");
 			}
 		} else {
 			Logger.warn(LOG_INSTANCE, "Cannot copy file as file was null");
 		}
 	}
 	
 	public static void copyFile(File input, File destination) throws IOException {
 		if (input != null) {
 			if (input.exists()) {
 				Logger.debug(LOG_INSTANCE, "Copying " + input.getAbsolutePath() + " to " + destination.getAbsolutePath());
 				copy(new FileInputStream(input), destination);
 			} else {
 				Logger.warn(LOG_INSTANCE, "Cannot copy " + input.getAbsolutePath() + " to " + destination.getAbsolutePath() + ", file does not exist");
 			}
 		} else {
 			Logger.warn(LOG_INSTANCE, "Cannot copy file to source or destination was null");
 		}
 	}
 	
 	public static void copy(InputStream in, File destination) throws IOException {
 		Logger.debug(LOG_INSTANCE, "Writing: " + destination.getAbsolutePath());
 		OutputStream out = new FileOutputStream(destination);
 		// Transfer bytes from in to out
         byte[] buf = new byte[1024];
         int len;
         int totalSize = 0;
         while ((len = in.read(buf)) > 0) {
             out.write(buf, 0, len);
             totalSize += len;
         }
         in.close();
         out.flush();
         out.close();
         Logger.debug(LOG_INSTANCE, "Wrote: " + totalSize + " bytes");
 	}
 	
 	public static void extractStyleSheets() throws IOException {
 		//if (!hasBeenExtracted()) {
 			File xslDir = new File(WORKING_DIR, XusePropertiesReader.getXslDirectory());
 			xslDir.mkdirs();
 			copyDirectory(XusePropertiesReader.getXslDirectory(), WORKING_DIR);
 		//}
 		
 	}
 
 	public static void extractResources() throws IOException {
 		File resourcesDir = new File(WORKING_DIR, XusePropertiesReader.getXuseResourcesDirectory());
 		resourcesDir.mkdirs();
 		copyDirectory(XusePropertiesReader.getXuseResourcesDirectory(), WORKING_DIR);
 	}
 	
 	public static void extractSchemas() throws IOException {
 		File dest = new File(System.getProperty("user.dir") + "/" + XusePropertiesReader.getXuseSchemaDir());
 		copyDirectory("xsd", dest, false);
 	}
 	
 	@Requirement(traceTo={"RQ40"})
 	public static void extractTemplateProject() throws IOException {
 		File dest = new File(System.getProperty("user.dir"));
 		Logger.debug(LOG_INSTANCE, "Extracting template project to " + dest.getCanonicalPath());
 		copyDirectory(XusePropertiesReader.getTemplateProjectPath(), dest, false);
 	}
 	
 	public static void extractResourceFromJar(String directoryInJar, String filename, File destination) throws IOException {
 		if (directoryInJar != null && destination != null) {
 			JarFile jarFile = getJarFile();		
 			Enumeration<JarEntry> enumeration = jarFile.entries();
 			destination.getParentFile().mkdirs();
 			while (enumeration.hasMoreElements()) {
 				JarEntry entry = (JarEntry)enumeration.nextElement();
 				String entryName = entry.getName();
 				if (entryName.startsWith(directoryInJar + "/" + filename) && !entryName.endsWith("/")) {
 					InputStream in = getInputStreamFromSystemOrClasspath(entry.getName());
 					copy(in, destination);
 				}
 			}
 		}
 	}
 	
 	public static boolean hasBeenExtracted() throws IOException {
 		File xslDir = new File(WORKING_DIR, XusePropertiesReader.getXslDirectory());
 		return xslDir.exists() && xslDir.isDirectory() && xslDir.list() != null && xslDir.list().length > 0;
 		
 	}
 	
 	public static JarFile getJarFile() throws BuildException {
 	    String path = "unknown";
 		try {
 		    URL jarPath = FileUtils.class.getResource("FileUtils.class");
 		    Logger.debug(LOG_INSTANCE, "Getting Jar file URL: " + jarPath.toString());
 			path = jarPath.toString().replaceAll("%20", " ");
 			String os = System.getProperty("os.name");
 			Logger.debug(LOG_INSTANCE, "OS: " + os);
 			if (os != null && os.contains("windows")) {
 				path = path.replaceAll("jar:file:/", "");
 			} else {
 				path = path.replaceAll("jar:file:", "");
 			}
 			path = path.substring(0, path.indexOf("!"));
 			Logger.debug(LOG_INSTANCE, "Jar file location: " + path);
 			return new JarFile(path);
 		} catch (Throwable t) {
 			throw new BuildException("Could not locate Xuse jar file: found path " + path, t);
 		}
 	}
 	
 	@Requirement(traceTo={"RQ19", "RQ60"})
 	public static void copyHTMLResources(String outputDir) throws IOException {
 		if (outputDir != null) {
 		    copyHTMLResources(new File(outputDir));
 		}
 	}
 	
 	public static void copyHTMLResources(File outputDir) throws IOException {
 		if (outputDir != null) {
 			copyDirectory("css", outputDir);
 			copyDirectory("images", outputDir);
 			copyDirectory("themes/" + XusePropertiesReader.getHTMLTheme(), outputDir);
 			copyDirectory("js", outputDir);
 			//Now we need to copy any custom resources
 			copyCustomResources(outputDir);
 		}
 	}
 	
 	public static void copyCustomResources(File outputDir) throws IOException {
 		//Copy CSS stylesheets
 		Logger.debug(LOG_INSTANCE, "in copyCustomResources()");
 		if (XusePropertiesReader.isCustomTheme()) {
 			String css = XusePropertiesReader.getHTMLTheme();
 			String fullCss = XusePropertiesReader.getResourcesDirectory() + "/" + css + ".css"; 
 			Logger.info(LOG_INSTANCE, "Got custom theme: " + css);
 			Logger.debug(LOG_INSTANCE, "CSS is: " + fullCss);
 			Logger.debug(LOG_INSTANCE, "before...");
 			copyFileToDir(fullCss, new File(outputDir, "css"));
 			Logger.debug(LOG_INSTANCE, "after...");
 		}
 		Logger.debug(LOG_INSTANCE, "here...");
 		//Copy any custom images
 		File imageDir = new File(outputDir, "images");
 		String customerLogo = XusePropertiesReader.getCustomerLogo();
 		Logger.debug(LOG_INSTANCE, "Customer logo: " + customerLogo);
 		copyFileToDir(customerLogo, imageDir);
 		String companyLogo = XusePropertiesReader.getCompanyLogo();
 		Logger.debug(LOG_INSTANCE, "Company logo: " + companyLogo);
 		copyFileToDir(companyLogo, imageDir);
 		String projectLogo = XusePropertiesReader.getProjectLogo();
 		Logger.debug(LOG_INSTANCE, "Project logo: " + projectLogo);
 		copyFileToDir(projectLogo, imageDir);
 	}
 	
 	public static void copyDirectory(File sourceDir, File destDir) throws IOException {
 		if (sourceDir != null && sourceDir.isDirectory() && destDir != null) {
 			if (destDir.exists() && destDir.isFile()) {
 				throw new IOException("Cannot write files to location " + destDir.getCanonicalPath());
 			} else if (!destDir.exists()) {
 				destDir.mkdir();
 			}
 			List<File> srcFiles = Arrays.asList(sourceDir.listFiles());
 			Iterator<File> iter = srcFiles.iterator();
 			File currentFile = null;
 			while (iter.hasNext()) {
 				currentFile = (File)iter.next();
 				if (currentFile.isDirectory()) {
 					copyDirectory(currentFile, new File(destDir, currentFile.getName()));
 				} else {
 					copy(new FileInputStream(currentFile), new File(destDir, currentFile.getName()));
 				}
 			}
 		}
 	}
 	
 	public static void copyDirectory(String directoryInJar, File destination, boolean mirrorDir) throws IOException {
 		Logger.debug(LOG_INSTANCE, "Copying directory from " + directoryInJar + " in jar file to " + destination.getCanonicalPath());
 		if (directoryInJar != null && destination != null) {
 			JarFile jarFile = getJarFile();		
 			Enumeration<JarEntry> enumeration = jarFile.entries();
 			File destDir = mirrorDir ? new File(destination, directoryInJar) : destination;
 			destDir.mkdirs();
 			while (enumeration.hasMoreElements()) {
 				JarEntry entry = (JarEntry)enumeration.nextElement();
 				String entryName = entry.getName();
 				if (entryName.startsWith(directoryInJar + "/") && !entryName.endsWith("/")) {
 					InputStream in = getInputStreamFromSystemOrClasspath(entry.getName());
 					String outputFileName = null;
 					if (mirrorDir) {
 						outputFileName = entry.getName(); 
 					} else {
 						int index = entry.getName().indexOf(directoryInJar) + directoryInJar.length();
 						outputFileName = entry.getName().substring(index);
 					}
 					
 					File dest = new File(destination, outputFileName);
 					File folder = dest.getParentFile();
 					if (!folder.exists()) {
 						if (!folder.mkdirs()) {
 							throw new BuildException("Could not create folder: " + folder.getAbsolutePath());
 						}
 					}
 					if (dest.exists() && dest.isFile()) {
 						Logger.debug(LOG_INSTANCE, "Destination " + dest.getAbsolutePath() + " already exists");
 						dest.delete();
 					}
 					copy(in, dest);
 				}
 			}
 		}
 	}
 	
 	public static void copyDirectory(String directoryInJar, File destination) throws IOException {
 		if (directoryInJar != null && destination != null) {
 			copyDirectory(directoryInJar, destination, true);	
 		}
 	}
 	
 	public static void copyResource(String file, String directory, File destDir) throws IOException {
 		
 		File destDirF = new File(destDir, directory);
 		if (!destDirF.exists()) {
 			destDirF.mkdirs();
 		}
 		File outfile = new File(destDirF, file);
 		InputStream in = getInputStreamFromSystemOrClasspath(directory + "/" + file);
 		copy(in, outfile);
 	}
 	
 
 	public static void archive(File file) throws Exception {
 		if (file != null && file.isFile() && file.canWrite() && file.exists()) {
 			File newFile = new File(file.getParent(), file.getName() + "." + System.currentTimeMillis() + ".old");
 			Logger.info(LOG_INSTANCE, "Archiving old file: " + file.getAbsolutePath() + " to " + newFile.getAbsolutePath());
 			if (!(file.renameTo(newFile))) {
 				throw new IOException("Could not rename: " + file.getAbsolutePath());
 			}
 		}
 	}
 	
 	public static void renameUpgraded(File file) throws Exception {
 		if (file != null && file.isFile() && file.canWrite()) {
 	Logger.info(LOG_INSTANCE, "Renaming upgraded file: " + file.getCanonicalPath());
 			String newName = Utils.substringBefore(file.getName(), "-upgrade.xml");
 			file.renameTo(new File(file.getParent(), newName + ".xml"));
 		}
 	}
 	
 	public static List<String> getFilesInDir(File dir, FileFilter filter) {
 		if (dir != null && dir.isDirectory()) {
 			Logger.debug(LOG_INSTANCE, "Looking for files in directory: " + dir.getAbsolutePath());
 			List<String> allFiles = new ArrayList<String>();
 			File[] children = dir.listFiles(filter);
 			Logger.debug(LOG_INSTANCE, "Found " + children.length + " children");
 			for (int i = 0; i < children.length; i++) {
 				if (children[i].isDirectory()) {
 					allFiles.addAll(getFilesInDir(children[i], filter));
 				} else {
 					Logger.debug(LOG_INSTANCE, "Adding child: " + children[i].getAbsolutePath());
 					allFiles.add(children[i].getAbsolutePath());
 				}
 			}
 			return allFiles;
 		} else {
 			Logger.warn(LOG_INSTANCE, "Could not find any files at " + dir);
 		}
 		return null;
 	}
 	
 	public static void writeFileContents(File output, String contents) throws BuildException {
 		if (output != null) {
 			try {
 				if (!output.exists()) {
 					output.createNewFile();
 				}
 				FileWriter fileWriter = new FileWriter(output);
 				fileWriter.append(contents);
 				fileWriter.close();
 			} catch (IOException ioe) {
 				throw new BuildException("COuld not write file contents", ioe);
 			}			
 		}
 	}
 	
 	private static InputStream getInputStreamFromSystemOrClasspath(String name) throws BuildException {
 		File file = new File(name);
 		try {
 			return new FileInputStream(file);
 		} catch (FileNotFoundException fnfe) {
 			try {
 				URL url = FileUtils.class.getClassLoader().getResource(name);
 				File in = new File(url.getPath());
 				if (!in.exists()) {
 					InputStream inStream = FileUtils.class.getClassLoader().getResourceAsStream(name);
 					if (inStream == null) {
 						throw new BuildException("Cannot find file " + name);
 					}
 					return inStream;
 				}
 				return new FileInputStream(in.getAbsolutePath());
 			} catch (Throwable t) {
 				throw new BuildException("Error finding the file - " + name + " - in the classpath.", t);
 			}
 		} catch (Throwable t) {
 			throw new BuildException("Error finding the file - " + name + " - in the classpath.", t);
 		}
 	}
 
 }