/***
    *     Ambient - A music player for the Android platform
    Copyright (C) 2007 Martin Vysny
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  package sk.baka.ambient.commons;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.Closeable;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.ObjectStreamClass;
  import java.io.OutputStream;
  import java.io.PrintWriter;
  import java.io.Serializable;
  import java.io.StringWriter;
  import java.net.ServerSocket;
  import java.net.Socket;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Date;
  import java.util.Formatter;
  import java.util.List;
  import java.util.Locale;
  import java.util.concurrent.Callable;
  
  import sk.baka.ambient.AmbientApplication;
  import android.util.Log;
  
  /***
   * Miscellaneous utility methods.
   * 
   * @author Martin Vysny
   */
  public final class MiscUtils {
  	private MiscUtils() {
  		throw new Error();
  	}
  
  	/***
  	 * Compares two objects. Handles <code>null</code>s correctly. For return
  	 * value please see the {@link Comparable#compareTo(Object)} contract.
  	 * 
  	 * @param <T>
  	 *            the object type
  	 * @param o1
  	 *            first object
  	 * @param o2
  	 *            second object
  	 * @param nullFirst
  	 *            if <code>true</code> then <code>null</code> is less than any
  	 *            non-<code>null</code> object. If <code>false</code> then
  	 *            <code>null</code> is greater than any non-null object.
  	 * @return see {@link Comparable#compareTo(Object)} for details.
  	 */
  	public static <T extends Comparable<? super T>> int nullCompare(final T o1,
  			final T o2, final boolean nullFirst) {
  		final int nullCompareToObject = nullFirst ? -1 : 1;
  		return o1 == null ? (o2 == null ? 0 : nullCompareToObject)
  				: (o2 == null ? -nullCompareToObject : o1.compareTo(o2));
  	}
  
  	/***
  	 * Returns next enum constant. If there is no next constant then returns the
  	 * first one.
  	 * 
  	 * @param <T>
  	 *            the enum type
  	 * @param constant
  	 *            the constant, must not be <code>null</code>.
  	 * @param next
  	 *            if <code>true</code> then next constant is returned, if
  	 *            <code>false</code> then simply given constant is returned.
  	 * @return the next constant.
  	 */
  	public static <T extends Enum<T>> T nextOrThis(final T constant,
  			final boolean next) {
  		if (!next)
  			return constant;
  		final Class<T> clazz = constant.getDeclaringClass();
 		final T[] values = clazz.getEnumConstants();
 		int ordinal = constant.ordinal() + 1;
 		if (ordinal >= values.length)
 			ordinal = 0;
 		return values[ordinal];
 	}
 
 	/***
 	 * Returns all interfaces that given class and all superclasses implements.
 	 * 
 	 * @param clazz
 	 *            the class to analyze
 	 * @return interface list that the class is castable to.
 	 */
 	public static List<Class<?>> getInterfaces(final Class<?> clazz) {
 		Class<?> cl = clazz;
 		final List<Class<?>> result = new ArrayList<Class<?>>();
 		for (; cl != Object.class; cl = cl.getSuperclass()) {
 			final List<Class<?>> interfaces = Arrays.<Class<?>> asList(cl
 					.getInterfaces());
 			result.addAll(interfaces);
 		}
 		return result;
 	}
 
 	/***
 	 * If given string is empty, contains spaces only or is <code>null</code>
 	 * then <code>null</code> is returned.
 	 * 
 	 * @param str
 	 *            the string.
 	 * @return string or <code>null</code> if one of the above applies.
 	 */
 	public static String nullIfEmptyOrWhitespace(final String str) {
 		if (str == null)
 			return null;
 		if (str.trim().length() == 0)
 			return null;
 		return str;
 	}
 
 	/***
 	 * Returns given string. If given string is <code>null</code> then an empty
 	 * string is returned.
 	 * 
 	 * @param str
 	 *            the string.
 	 * @return non-<code>null</code> string.
 	 */
 	public static String emptyIfNull(final String str) {
 		return str == null ? "" : str;
 	}
 
 	/***
 	 * Checks if given string is empty or consists of whitespace characters
 	 * only.
 	 * 
 	 * @param str
 	 *            the string to check.
 	 * @return <code>true</code> if the string is empty, <code>false</code>
 	 *         otherwise.
 	 */
 	public static boolean isEmptyOrWhitespace(final String str) {
 		return null == nullIfEmptyOrWhitespace(str);
 	}
 
 	/***
 	 * Checks if given string is empty (<code>null</code> or zero-sized).
 	 * 
 	 * @param str
 	 *            the string to check.
 	 * @return <code>true</code> if the string is empty, <code>false</code>
 	 *         otherwise.
 	 */
 	public static boolean isEmpty(final String str) {
 		return (str == null) || (str.length() == 0);
 	}
 
 	/***
 	 * Formats given string. Uses {@link Formatter}.
 	 * 
 	 * @param resId
 	 *            formatting string id
 	 * @param args
 	 *            parameters
 	 * @return formatted string
 	 */
 	public static String format(final int resId, Object... args) {
 		final String formatStr = AmbientApplication.getInstance().getString(
 				resId);
 		return new Formatter().format(formatStr, args).toString();
 	}
 
 	/***
 	 * Similar to {@link #nullCompare(Comparable, Comparable, boolean)}, but
 	 * uses {@link #equals(Object)} instead.
 	 * 
 	 * @param <T>
 	 *            the object type
 	 * @param o1
 	 *            first object
 	 * @param o2
 	 *            second object
 	 * @return <code>true</code> if either o1 is equal to o2, or both are
 	 *         <code>null</code>s; <code>false</code> otherwise.
 	 */
 	public static <T> boolean nullEquals(final T o1, final T o2) {
 		return o1 == null ? o2 == null : o1.equals(o2);
 	}
 
 	/***
 	 * Deserializes an object from contents of given file.
 	 * 
 	 * @param file
 	 *            the file to read
 	 * @return deserialized object.
 	 * @throws IOException
 	 */
 	public static Serializable deserializeFromFile(final File file)
 			throws IOException {
 		return deserialize(new FileInputStream(file));
 	}
 
 	/***
 	 * Deserializes an object from an input stream. The stream is closed.
 	 * 
 	 * @param stream
 	 *            the stream to read
 	 * @return deserialized object.
 	 * @throws IOException
 	 */
 	public static Serializable deserialize(final InputStream stream)
 			throws IOException {
 		if (stream == null)
 			return null;
 		try {
 			final ObjectInputStream in = new ObjectInputStream(stream) {
 				@Override
 				protected Class<?> resolveClass(
 						ObjectStreamClass objectStreamClass)
 						throws ClassNotFoundException {
 					return Class.forName(objectStreamClass.getName(), true,
 							MiscUtils.class.getClassLoader());
 				}
 			};
 			try {
 				return (Serializable) in.readObject();
 			} catch (ClassNotFoundException e) {
 				throw new RuntimeException(e);
 			}
 		} finally {
 			closeQuietly(stream);
 		}
 	}
 
 	/***
 	 * Serializes given object to the output stream. The stream is closed.
 	 * 
 	 * @param object
 	 *            the object to serialize
 	 * @param out
 	 *            serialize here
 	 * @throws IOException
 	 */
 	public static void serialize(final Serializable object,
 			final OutputStream out) throws IOException {
 		try {
 			final ObjectOutputStream oout = new ObjectOutputStream(out);
 			oout.writeObject(object);
 			closeQuietly(oout);
 		} finally {
 			closeQuietly(out);
 		}
 	}
 
 	/***
 	 * Serializes given object to the output stream. The stream is closed.
 	 * 
 	 * @param object
 	 *            the object to serialize
 	 * @return serialized form
 	 */
 	public static byte[] serializeToBytes(final Serializable object) {
 		if (object == null)
 			return null;
 		final ByteArrayOutputStream out = new ByteArrayOutputStream();
 		try {
 			serialize(object, out);
 		} catch (IOException e) {
 			throw new RuntimeException(e);
 		}
 		return out.toByteArray();
 	}
 
 	/***
 	 * Deserializes an object from a byte array.
 	 * 
 	 * @param serialized
 	 *            the serialized object form
 	 * @return deserialized object.
 	 */
 	public static Serializable deserialize(final byte[] serialized) {
 		if (serialized == null)
 			return null;
 		try {
 			return deserialize(new ByteArrayInputStream(serialized));
 		} catch (IOException e) {
 			// shouldn't happen unless the stream is corrupted
 			throw new RuntimeException(e);
 		}
 	}
 
 	/***
 	 * Closes the closeable object. Catches any exception.
 	 * 
 	 * @param c
 	 *            close this closeable. Does nothing if the stream is
 	 *            <code>null</code>.
 	 */
 	public static void closeQuietly(final Closeable c) {
 		if (c == null) {
 			return;
 		}
 		try {
 			c.close();
 		} catch (Exception e) {
 			Log.w(MiscUtils.class.getSimpleName(), "Failed to close object", e);
 		}
 	}
 
 	/***
 	 * Closes a socket quietly.
 	 * 
 	 * @param socket
 	 *            the socket to close.
 	 */
 	public static void closeQuietly(final Socket socket) {
 		closeQuietly(new Closeable() {
 			public void close() throws IOException {
 				socket.close();
 			}
 		});
 	}
 
 	/***
 	 * Closes a server socket quietly.
 	 * 
 	 * @param socket
 	 *            the socket to close.
 	 */
 	public static void closeQuietly(final ServerSocket socket) {
 		closeQuietly(new Closeable() {
 			public void close() throws IOException {
 				socket.close();
 			}
 		});
 	}
 
 	/***
 	 * Iterates over given iterable and returns its items as a list.
 	 * 
 	 * @param <T>
 	 *            the item type
 	 * @param i
 	 *            the iterable
 	 * @return list, never <code>null</code>.
 	 */
 	public static <T> List<T> iterableToList(final Iterable<? extends T> i) {
 		final List<T> result = new ArrayList<T>();
 		for (final T t : i) {
 			result.add(t);
 		}
 		return result;
 	}
 
 	/***
 	 * SI prefixes.
 	 */
 	private static final char[] PREFIXES = new char[] { 'k', 'M', 'G', 'T', 'P' };
 
 	/***
 	 * Formats the length and returns it.
 	 * 
 	 * @param length
 	 *            in bytes
 	 * @return xxKb/xxMb/etc
 	 */
 	public static String formatByteLength(final long length) {
 		long len = length * 10; // show a single-digit decimal fraction
 		int prefix = -1;
 		while ((len > 10240) && (prefix < PREFIXES.length)) {
 			len /= 1024;
 			prefix++;
 		}
 		final StringBuilder result = new StringBuilder();
 		if (prefix < 0) {
 			result.append(length);
 			result.append('b');
 			return result.toString();
 		}
 		result.append(len);
 		result.insert(result.length() - 1, '.');
 		if (result.charAt(result.length() - 1) == '0') {
 			result.delete(result.length() - 2, result.length());
 		}
 		result.append(PREFIXES[prefix]);
 		result.append('b');
 		return result.toString();
 	}
 
 	/***
 	 * Moves the leading "the" word to the end of given name.
 	 * 
 	 * @param artistAlbum
 	 *            an artist/album name
 	 * @return fixed name
 	 */
 	public static String fixArtistAlbumName(final String artistAlbum) {
 		if (artistAlbum == null) {
 			return null;
 		}
 		final String name = artistAlbum.trim();
 		if (name.length() < 5) {
 			return name;
 		}
 		if (!name.substring(0, 3).equalsIgnoreCase("the")
 				|| !Character.isWhitespace(name.charAt(3))) {
 			return name;
 		}
 		int i = 4;
 		for (; (i < name.length()) && Character.isWhitespace(name.charAt(i)); i++) {
 		}
 		return name.substring(i) + ", " + name.substring(0, 3);
 	}
 
 	/***
 	 * May be used in maps and/or sets which does not support <code>null</code>.
 	 */
 	public static final Object NULL = new Object();
 
 	/***
 	 * Wraps given object to a reference. The purpose of this reference is to
 	 * enforce reference-equality in place of object-equality. In other words,
 	 * two references returned by this method are considered equal if and only
 	 * if <code>r1.get() == r2.get()</code>.
 	 * 
 	 * @param <T>
 	 *            the object type.
 	 * @param object
 	 *            the object instance. <code>null</code>s are handled correctly,
 	 *            i.e. <code>null</code> is only equal to <code>null</code>.
 	 * @return a reference to given object.
 	 */
 	public static <T> Ref<T> getIdentity(final T object) {
 		return new Ref<T>() {
 			public T get() {
 				return object;
 			}
 
 			@Override
 			public boolean equals(Object o) {
 				if (o == null)
 					return false;
 				if (o == this)
 					return true;
 				if (o.getClass() != getClass())
 					return false;
 				return ((Ref<?>) o).get() == object;
 			}
 
 			@Override
 			public int hashCode() {
 				return object == null ? 0 : System.identityHashCode(object);
 			}
 		};
 	}
 
 	/***
 	 * Returns object hash code. Returns 0 if <code>null</code> was given.
 	 * 
 	 * @param o
 	 *            the object to compute hash code for.
 	 * @return the hash code.
 	 */
 	public static int hashCode(final Object o) {
 		return o == null ? 0 : o.hashCode();
 	}
 
 	/***
 	 * Parses RFC 2822 date.
 	 * 
 	 * @param date
 	 *            the date to parse.
 	 * @return parsed date.
 	 * @throws ParseException
 	 *             if parse fails.
 	 */
 	public static Date parseRFC2822Date(final String date)
 			throws ParseException {
 		final String pattern = "EEE, d MMM yyyy HH:mm:ss Z";
 		final SimpleDateFormat sdf = new SimpleDateFormat(pattern,
 				Locale.ENGLISH);
 		return sdf.parse(date);
 	}
 
 	/***
 	 * Formats given date as a RFC 2822 date.
 	 * 
 	 * @param date
 	 *            the date to format.
 	 * @return formatted date.
 	 */
 	public static String getRFC2822Date(final Date date) {
 		final String pattern = "EEE, d MMM yyyy HH:mm:ss Z";
 		final SimpleDateFormat sdf = new SimpleDateFormat(pattern,
 				Locale.ENGLISH);
 		return sdf.format(date);
 	}
 
 	private static final char[] HEX = new char[] { '0', '1', '2', '3', '4',
 			'5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
 
 	/***
 	 * Formats each byte in the array in its hexadecimal form and returns it.
 	 * 
 	 * @param array
 	 *            the array to print
 	 * @return hexadecimal format
 	 */
 	public static String toHexa(final byte[] array) {
 		if (array == null) {
 			return "null";
 		}
 		final StringBuilder b = new StringBuilder(array.length * 2);
 		for (final byte by : array) {
 			int bval = by;
 			if (bval < 0) {
 				bval += 256;
 			}
 			b.append(HEX[bval >> 4]);
 			b.append(HEX[bval & 15]);
 		}
 		return b.toString();
 	}
 
 	/***
 	 * Converts hexadecimal string returned by {@link #toHexa(byte[])} back to
 	 * the original array.
 	 * 
 	 * @param hexaArray
 	 *            the array returned by {@link #toHexa(byte[])}.
 	 * @return the array.
 	 */
 	public static byte[] fromHexa(final String hexaArray) {
 		if (hexaArray == null || hexaArray.equals("null")) {
 			return null;
 		}
 		final int length = hexaArray.length() / 2;
 		final byte[] result = new byte[length];
 		for (int i = 0; i < length; i++) {
 			final int pos = i * 2;
 			result[i] = (byte) (getHexa(hexaArray.charAt(pos)) * 16 + getHexa(hexaArray
 					.charAt(pos + 1)));
 		}
 		return result;
 	}
 
 	private static byte getHexa(final char hexa) {
 		final int result = Arrays.binarySearch(HEX, hexa);
 		if (result < 0) {
 			throw new IllegalArgumentException("Not a hexa character: " + hexa);
 		}
 		return (byte) result;
 	}
 
 	/***
 	 * Returns given exception (including its stack trace) as a string.
 	 * 
 	 * @param throwable
 	 *            the throwable.
 	 * @return string representation of the throwable.
 	 */
 	public static String getStackTrace(final Throwable throwable) {
 		final StringWriter writer = new StringWriter();
 		final PrintWriter pw = new PrintWriter(writer);
 		throwable.printStackTrace(pw);
 		pw.flush();
 		return writer.toString();
 	}
 
 	/***
 	 * Sysout for the fucking Android.
 	 * 
 	 * @param string
 	 *            the fucking string.
 	 */
 	public static void sysout(Object string) {
 		Log.e("Sysout", "sysout: " + string);
 	}
 
 	/***
 	 * Converts a {@link Callable} to a {@link Runnable}.
 	 * 
 	 * @param callable
 	 *            the callable to convert, must not be <code>null</code>.
 	 * @return runnable instance.
 	 */
 	public static Runnable toRunnable(final Callable<?> callable) {
 		if (callable == null) {
 			throw new NullArgumentException("callable");
 		}
 		return new Runnable() {
 			public void run() {
 				try {
 					callable.call();
 				} catch (Exception e) {
 					throw new RuntimeException(e);
 				}
 			}
 		};
 	}
 }