package uk.ac.cam.spectra;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.OutputStream;
   import java.nio.channels.FileChannel;
   import java.text.DateFormat;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.regex.Pattern;
  
  import nu.xom.Attribute;
  import nu.xom.Document;
  import nu.xom.Nodes;
  import nu.xom.Serializer;
  import nu.xom.XPathContext;
  
  import org.apache.commons.io.IOUtils;
  import org.apache.log4j.Logger;
  
  /**
   * Usual grab bag of utility functions that don't fit anywhere else
   * conveniently.
   * 
   * @author Jim Downing
   */
  public class Util {
  	private static final int DEFAULT_LINE_LENGTH = 80;
  
  	private static final int DEFAULT_INDENT = 4;
  
  	private static final String DEFAULT_XML_ENCODING = "UTF-8";
  
  	private static final int PATH_SECTION_SIZE_EST = 20;
  
  	private static final Pattern PATHOLOGICAL_DATE_PATTERN = Pattern
  			.compile("\\d{2}-\\d{2}-\\d{4}");
  
  	private static final Logger LOG = Logger.getLogger(Util.class);
  
  	private static final DateFormat[] DATE_FORMATS = {
  			new SimpleDateFormat("dd/MM/yy"),
  			new SimpleDateFormat("dd/MM/yyyy"),
  			Constants.SIMPLE_ISO_DATE_FORMAT, DateFormat.getInstance() };
  
  	static {
  		for (DateFormat df : DATE_FORMATS) {
  			df.setLenient(false);
  		}
  	}
  
  	/**
  	 * Utility class, instantiation is not expected.
  	 */
  	private Util() {
  		;
  	}
  
  	/**
  	 * Builds a platform specific file path from the path name parts passed in.
  	 * An obvious thing to do now we have varargs - why hasn't java.io.File got
  	 * this?
  	 * 
  	 * @param parts
  	 *            directory names and an optional file name
  	 * @return platform specific path string.
  	 */
  	public static String buildPath(String... parts) {
  		StringBuilder sb = new StringBuilder(parts.length
  				* PATH_SECTION_SIZE_EST);
  		for (String part : parts) {
  			sb.append(part).append(File.separatorChar);
  		}
  		sb.deleteCharAt(sb.length() - 1);
  		return sb.toString();
  	}
  
  	/**
  	 * DEWISOTT.
  	 * 
  	 * @param from
  	 *            source file
  	 * @param to
  	 *            target file
  	 * @throws IOException
  	 * @throws IOException
  	 *             rethrown from java.io.
  	 */
  	public static void copy(File from, File to) throws IOException {
  		if (!to.exists()) {
  			to.createNewFile();
  		}
  		FileInputStream fileInputStream = null;
  		FileChannel srcChannel = null;
  		FileOutputStream fileOutputStream = null;
  		FileChannel dstChannel = null;
 		try {
 			fileInputStream = new FileInputStream(from);
 			srcChannel = fileInputStream.getChannel();
 			fileOutputStream = new FileOutputStream(to);
 			dstChannel = fileOutputStream.getChannel();
 			dstChannel.transferFrom(srcChannel, 0, srcChannel.size());
 		} finally {
 			if (srcChannel != null) {
 				try {
 					srcChannel.close();
 				} catch (IOException e) {
 					LOG.warn(e);
 				}
 			}
 			if (dstChannel != null) {
 				try {
 					dstChannel.close();
 				} catch (IOException e) {
 					LOG.warn(e);
 				}
 			}
 			IOUtils.closeQuietly(fileInputStream);
 			IOUtils.closeQuietly(fileOutputStream);
 		}
 	}
 
 	/**
 	 * Yet another method that java.io.File should possess, performs an atomic
 	 * move if possible, otherwise a non-atomic one.
 	 * 
 	 * @param from
 	 *            source file
 	 * @param to
 	 *            target file
 	 * @throws IOException
 	 *             rethrown from java.io
 	 */
 	public static void move(File from, File to) throws IOException {
 		if (!from.renameTo(to)) {
 			copy(from, to);
 			from.delete();
 		}
 	}
 
 	/**
 	 * Utility method to return the result of an xpath query you know is going
 	 * to return a single text node.
 	 * 
 	 * @param doc
 	 *            XOM document to query
 	 * @param query
 	 *            the XPath query
 	 * @param xpathContext
 	 *            the XPath context to resolve namespaces
 	 * @throws RuntimeException
 	 *             if the query doesn't return a single node, or if the node
 	 *             returned is not a text node.
 	 * @return String of Text node, untrimmed.
 	 */
 	public static Attribute queryUniqueAttribute(Document doc, String query,
 			XPathContext xpathContext) {
 		Nodes nds = doc.query(query, xpathContext);
 		if (nds.size() != 1) {
 			throw new RuntimeException("Query was not successful and unique. "
 					+ query + " returned " + nds.size());
 		}
 		Object obj = nds.get(0);
 		if (!(obj instanceof Attribute)) {
 			throw new RuntimeException(
 					"Query result was not an Attribute node: " + obj);
 		}
 		return (Attribute) obj;
 	}
 
 	/**
 	 * Prints a XOM document to an outputstream without having to remember the
 	 * serializer voodoo.
 	 * 
 	 * @param doc
 	 *            the XOM DOcument to print
 	 * @param out
 	 *            where to print to
 	 * @param pretty
 	 *            should it be pretty printed?
 	 * @throws IOException
 	 *             rethrown from the XOM serializer
 	 */
 	public static void print(Document doc, OutputStream out, boolean pretty) {
 		Serializer serializer;
 		try {
 			serializer = new Serializer(out, DEFAULT_XML_ENCODING);
 			if (pretty) {
 				serializer.setIndent(DEFAULT_INDENT);
 				serializer.setMaxLength(DEFAULT_LINE_LENGTH);
 			}
 			serializer.write(doc);
 		} catch (Exception e) {
 			LOG.error(e);
 			throw new RuntimeException(e);
 		}
 	}
 
 	/**
 	 * Parse a date according to a number of standard formats.
 	 * 
 	 * @param dateStr
 	 *            the date as a string
 	 * @return a parsed date object, or null if none of the standard formats can
 	 *         parse the string.
 	 */
 	public static Date parseDate(String dateStr) {
 		// Trap the peculiar dd-MM-yyyy
 		if (PATHOLOGICAL_DATE_PATTERN.matcher(dateStr).matches()) {
 			return null;
 		}
 		Date d = null;
 		for (DateFormat df : DATE_FORMATS) {
 			try {
 				d = df.parse(dateStr);
 			} catch (ParseException e) {
 				continue;
 			}
 			if (d != null) {
 				LOG
 						.debug("parsed "
 								+ dateStr
 								+ " using "
 								+ (df instanceof SimpleDateFormat ? ((SimpleDateFormat) df)
 										.toPattern()
 										: df.toString()));
 				break;
 			}
 		}
 		return d;
 	}
 
 	public static void rmr(File dir) {
 		for (File f : dir.listFiles()) {
 			if (f.isDirectory()) {
 				rmr(f);
 			} else {
 				f.delete();
 			}
 		}
 	}
 
 }