/**************************************************************************
   Copyright 2005 Webstersmalley
   
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
   
       http://www.apache.org/licenses/LICENSE-2.0
   
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  *************************************************************************/
  /*
   * Created on 04-Jun-2005
   */
  package com.webstersmalley.picweb.utils;
  
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.nio.channels.FileChannel;
  import java.util.Date;
  
  import javax.xml.transform.Source;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.w3c.dom.Document;
  
  /***
   * Utility class for the basic file/IO related functions (eg 
   * write out an {@link org.w3c.dom.Document} as an XML file)
   * 
   * @author Matthew Smalley
   */
  public class IOUtils
  {
  	/*** Logger for the class. */
  	private static Log log = LogFactory.getLog(IOUtils.class);
  	
  	/***
  	 * Private constructor - should only used via static utilities methods
  	 *
  	 */
  	private IOUtils()
  	{
  		
  	}
  	
  	/***
  	 * Writes out a string as a file.
  	 * Will create parent directories in order to succeed.
  	 * 
  	 * @param filename the name of the new file
  	 * @param contents the contents of the new file
  	 * @throws FileNotFoundException File wasn't found
  	 */
  	public static void writeFile(String filename, String contents) throws FileNotFoundException
  	{
  		File output = new File(filename);
  		File parent = output.getParentFile();
  		parent.mkdirs();
  		PrintWriter out = new PrintWriter(new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(output))));
  		out.println(contents);
  		out.flush();
  		out.close();
  	}
  	
  	// This method writes a DOM document to a file
  
  	
  	/***
  	 * Writes out a {@link org.w3c.dom.Document} as an XML file.
  	 * 
  	 * @param filename the filename of the new XML file
  	 * @param doc the document to write
  	 * @throws Exception wraps up exceptions from the IO and the transformation
  	 */
  	public static void writeXmlFile(String filename, Document doc) throws Exception
  	{
  		try
  		{
  			// Prepare the DOM document for writing
  			Source source = new DOMSource(doc);
  
  			// Prepare the output file
  			File file = new File(filename);
 			FileOutputStream fos = new FileOutputStream(file);
 			StreamResult result = new StreamResult(fos);
 
 			// Write the DOM document to the file
 			Transformer xformer = TransformerFactory.newInstance().newTransformer();
 			xformer.transform(source, result);
 			fos.flush();
 			fos.close();
 		}
 		catch (Exception e)
 		{
 			throw new Exception("Error - unable to write XML File: " + e.toString(), e);
 		}
 	}
 	
 	/***
 	 * Copies the contents of one folder into another.
 	 * e.g. consider the following tree:
 	 * <code>
 	 * src\file1
 	 * src\dir1\file2
 	 * src\dir1\file3
 	 * </code>
 	 * If we called copyFolderContents("src", "dest") we'd end up with:
 	 * <code> 
 	 * dest\file1
 	 * dest\dir1\file2
 	 * dest\dir2\file3
 	 * </code>
 	 * 
 	 * @param src Source folder
 	 * @param dest Destination folder
 	 * @throws IOException
 	 */
 	public static void copyFolderContents(String src, String dest) throws IOException
 	{
 		log.debug("Copying contents of: '" + src + "' to '" + dest + "'");
 		File srcDir = new File(src);
 		File destDir = new File(dest);
 		destDir.mkdirs();
 		File[] children = srcDir.listFiles();
 		for (int i = 0; i < children.length; i++)
 		{
 			File child = children[i];
 			String destinationChild = destDir.getAbsolutePath() + File.separator + child.getName();
 			if (child.isDirectory())
 			{
 				copyFolderContents(child.getAbsolutePath(), destinationChild);
 			}
 			else
 			{
 				copyFile(child, new File(destinationChild));
 			}
 		}
 	}
 
 	/***
 	 * Copies the contents of a file to a new one, creating subdirectories
 	 * as necessary.
 	 * @param src Source file
 	 * @param dest Destination file
 	 * @throws IOException
 	 */
 	public static void copyFile(File src, File dest) throws IOException
 	{
 		log.debug("Copying file: '" + src + "' to '" + dest + "'");
 		// Create channel on the source
 		FileChannel srcChannel = new FileInputStream(src).getChannel();
 		
 		// Create channel on the destination
 		FileChannel dstChannel = new FileOutputStream(dest).getChannel();
 		
 		// Copy file contents from source to destination
 		dstChannel.transferFrom(srcChannel, 0, srcChannel.size());
 		
 		// Close the channels
 		srcChannel.close();
 		dstChannel.close();
 	}
 	
 	/***
 	 * Deletes the contents of a folder, leaving that folder intact.
 	 * 
 	 * @param folder the folder to purge
 	 * @throws IOException
 	 */
 	public static void purgeFolder(File folder) throws IOException
 	{
 		File[] children = folder.listFiles();
 		for (int i = 0; i < children.length; i++)
 		{
 			File child = children[i];
 			if (child.isDirectory())
 			{
 				purgeFolder(child);
 				log.debug("Deleting: " + child.getAbsolutePath());
 				if (!child.delete())
 				{
 					throw new IOException("Error - couldn't delete: " + child.getAbsolutePath());
 				}
 			}
 			else
 			{
 				log.debug("Deleting: " + child.getAbsolutePath());
 				if (!child.delete())
 				{
 					throw new IOException("Error - couldn't delete: " + child.getAbsolutePath());
 				}
 			}
 		}
 	}
 	
 	/***
 	 * Creates a blank (0-byte) file, creating folders as necessary.
 	 * If the file already exists, updates the lastModified time.
 	 * If the file exists but is not a regular file, throws an IOException. 
 	 * 
 	 * @param file the file to create
 	 * @throws IOException
 	 */
 	public static void touch(File file) throws IOException
 	{
 		if (file.exists())
 		{
 			if (file.isDirectory())
 			{
 				throw new IOException("Error touching file " + file.getAbsolutePath() + ". Already exists as a directory.");
 			}
 			else
 			{
 				file.setLastModified(new Date().getTime());
 			}
 		}
 		else
 		{
 			file.getParentFile().mkdirs();
 			file.createNewFile();
 		}
 	}
 }