/***
    *     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.BufferedInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.LineNumberReader;
  import java.io.OutputStream;
  import java.io.Reader;
  import java.io.UnsupportedEncodingException;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLDecoder;
  import java.net.URLEncoder;
  import java.util.Collections;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.StringTokenizer;
  
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.parsers.SAXParserFactory;
  
  import org.xml.sax.ContentHandler;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  import org.xml.sax.XMLReader;
  
  import android.util.Log;
  
  /***
   * Contains IO and HTTP utility methods.
   * 
   * @author Martin Vysny
   */
  public final class IOUtils {
  	private IOUtils() {
  		throw new Error();
  	}
  
  	/***
  	 * Encodes given URL as per {@link URLEncoder#encode(String, String)}. Uses
  	 * UTF-8 encoding. Spaces are correctly represented as <code>%20</code>.
  	 * 
  	 * @param url
  	 *            the URL to encode
  	 * @return URL-friendly string.
  	 */
  	public static String encodeURL(final String url) {
  		try {
  			final String result = URLEncoder.encode(url, "UTF-8");
  			return result.replace("+", "%20");
  		} catch (UnsupportedEncodingException e) {
  			throw new Error(e);
  		}
  	}
  
  	/***
  	 * Parses XML readable from given stream. Note that the parser is configured
  	 * to be namespace-aware - Android bug prevents us to use
  	 * non-namespace-aware parser.
  	 * 
  	 * @param in
  	 *            the stream, always closed.
  	 * @param handler
  	 *            handles XML events.
  	 * @throws SAXException
  	 *             if parsing fails
  	 * @throws IOException
  	 *             if i/o error occurs
  	 */
  	public static void parseXML(final InputStream in,
  			final ContentHandler handler) throws IOException, SAXException {
  		final SAXParserFactory parser = SAXParserFactory.newInstance();
  		parser.setValidating(false);
  		parser.setNamespaceAware(true);
  		final XMLReader reader;
  		try {
  			reader = parser.newSAXParser().getXMLReader();
  		} catch (ParserConfigurationException e) {
  			throw new RuntimeException(e);
  		}
 		reader.setContentHandler(handler);
 		try {
 			final InputSource source = new InputSource(in);
 			reader.parse(source);
 		} finally {
 			MiscUtils.closeQuietly(in);
 		}
 	}
 
 	/***
 	 * Reads a line from given stream. No charset decoding is performed - only
 	 * ASCII characters are expected. The line is expected to be terminated by
 	 * the \n character. All \r characters are ignored.
 	 * 
 	 * @param in
 	 *            the stream to read from. This should be an
 	 *            {@link BufferedInputStream} implementation for performance
 	 *            reasons.
 	 * @return the line. May return <code>null</code> on end-of-stream.
 	 * @throws IOException
 	 *             if i/o error occurs.
 	 */
 	public static String readLine(final InputStream in) throws IOException {
 		final StringBuilder result = new StringBuilder();
 		int charsRead = 0;
 		while (true) {
 			final int c = in.read();
 			if (c < 0) {
 				if (charsRead == 0) {
 					// Log.e("READLINE", "EOF");
 					return null;
 				}
 				break;
 			}
 			charsRead++;
 			if (c > 127) {
 				throw new IOException("Invalid character " + (char) c
 						+ ": ordinal " + c);
 			}
 			if (c == '\n') {
 				break;
 			}
 			if (c == '\r') {
 				continue;
 			}
 			result.append((char) c);
 		}
 		// Log.e("READLINE", "Line: '" + result.toString() + "'");
 		return result.toString();
 	}
 
 	/***
 	 * Writes a line to given stream. No charset encoding is performed - only
 	 * ASCII characters are expected. An additional \r\n characters will be
 	 * written.
 	 * 
 	 * @param string
 	 *            the string to write. It must consist of ASCII characters only.
 	 * @param out
 	 *            the stream to write to.
 	 * @throws IOException
 	 *             if i/o error occurs.
 	 */
 	public static void writeLine(final String string, final OutputStream out)
 			throws IOException {
 		// Log.e("WRITELINE", "Line: '" + string + "'");
 		for (int i = 0; i < string.length(); i++) {
 			final char c = string.charAt(i);
 			if ((c < 0) || (c > 127)) {
 				throw new IllegalArgumentException(
 						"Non ascii characters found in " + string);
 			}
 			out.write(c);
 		}
 		out.write('\r');
 		out.write('\n');
 	}
 
 	/***
 	 * Writes an empty line to given stream. An additional \r\n characters will
 	 * be written.
 	 * 
 	 * @param out
 	 *            the stream to write to.
 	 * @throws IOException
 	 *             if i/o error occurs.
 	 */
 	public static void writeLine(final OutputStream out) throws IOException {
 		writeLine("", out);
 	}
 
 	/***
 	 * Strips extension from given name. Does nothing if the file name does not
 	 * have an extension.
 	 * 
 	 * @param name
 	 *            the name to strip extension from
 	 * @return stripped name.
 	 */
 	public static String stripExt(final String name) {
 		final int lastDot = name.lastIndexOf('.');
 		if (lastDot < 0)
 			return name;
 		final int lastSlash = name.lastIndexOf('/');
 		if ((lastSlash >= 0) && (lastDot < lastSlash)) {
 			// no dot in base name.
 			return name;
 		}
 		return name.substring(0, lastDot);
 	}
 
 	/***
 	 * Copies input stream to the output stream.
 	 * 
 	 * @param in
 	 *            the input stream. Always closed.
 	 * @param out
 	 *            the output stream. Always closed.
 	 * @param bufferSize
 	 *            the buffer size in bytes
 	 * @throws IOException
 	 *             thrown when i/o error occurs or when interrupted.
 	 */
 	public static void copy(final InputStream in, final OutputStream out,
 			final int bufferSize) throws IOException {
 		try {
 			final byte[] buf = new byte[bufferSize];
 			while (true) {
 				final int read = in.read(buf);
 				if (read < 0) {
 					break;
 				}
 				if (read > 0) {
 					out.write(buf, 0, read);
 				}
 				if (Thread.currentThread().isInterrupted()) {
 					throw new IOException("Interrupted");
 				}
 			}
 		} finally {
 			MiscUtils.closeQuietly(in);
 			MiscUtils.closeQuietly(out);
 		}
 	}
 
 	/***
 	 * Removes trailing slash from given file name.
 	 * 
 	 * @param name
 	 *            the file name.
 	 * @return file name without the trailing slash.
 	 */
 	public static String removeTrailingSlash(final String name) {
 		if (name.endsWith("/") || name.endsWith("//")) {
 			return name.substring(0, name.length() - 1);
 		}
 		return name;
 	}
 
 	/***
 	 * Reads the request until an empty string is encountered.
 	 * 
 	 * @param in
 	 *            the stream to read from.
 	 * @throws IOException
 	 *             if i/o error occurs.
 	 */
 	public static void readRequest(final InputStream in) throws IOException {
 		while (true) {
 			final String line = IOUtils.readLine(in);
 			if (MiscUtils.isEmpty(line)) {
 				break;
 			}
 		}
 	}
 
 	/***
 	 * The http request
 	 * 
 	 * @author Martin Vysny
 	 */
 	public static final class HttpRequest {
 		/***
 		 * The request string: GET, POST etc.
 		 */
 		public String method;
 		/***
 		 * The original request path.
 		 */
 		public String requestPath;
 		/***
 		 * The path without the query/anchor part.
 		 */
 		public String path;
 		/***
 		 * The query parameter values.
 		 */
 		public Map<String, String> query;
 		/***
 		 * 0 for HTTP/1.0, 1 for HTTP/1.1
 		 */
 		public byte version;
 	}
 
 	/***
 	 * Parses given HTTP request.
 	 * 
 	 * @param request
 	 *            the request
 	 * @return parsed request or <code>null</code> if the request is malformed.
 	 * @throws ServerHttpException
 	 *             on HTTP error.
 	 */
 	public static HttpRequest parseRequest(final String request)
 			throws ServerHttpException {
 		final String[] parts = request.split("//s+");
 		if (parts.length != 3) {
 			throw new ServerHttpException(400, "Invalid request: " + request);
 		}
 		final HttpRequest result = new HttpRequest();
 		result.method = parts[0];
 		result.requestPath = parts[1];
 		final URL path;
 		try {
 			path = new URL("file://" + parts[1]);
 		} catch (MalformedURLException e) {
 			throw new ServerHttpException(400, e);
 		}
 		result.query = parseParams(path.getQuery());
 		result.path = URLDecoder.decode(path.getPath());
 		if (!parts[2].startsWith("HTTP/1.")) {
 			throw new ServerHttpException(400, "Invalid HTTP: " + parts[2]);
 		}
 		result.version = (byte) (parts[2].charAt(7) - '0');
 		return result;
 	}
 
 	private static Map<String, String> parseParams(final String get)
 			throws ServerHttpException {
 		if (get == null) {
 			return Collections.emptyMap();
 		}
 		final StringTokenizer st = new StringTokenizer(get, "&");
 		final Map<String, String> result = new HashMap<String, String>();
 		while (st.hasMoreTokens()) {
 			final String token = st.nextToken();
 			int equals = token.indexOf('=');
 			if (equals < 0) {
 				throw new ServerHttpException(400);
 			}
 			final String paramName = token.substring(0, equals);
 			final String paramValue = URLDecoder.decode(token.substring(
 					equals + 1, token.length()));
 			result.put(paramName, paramValue);
 		}
 		return result;
 	}
 
 	/***
 	 * Writes HTTP response. The response is not terminated by an empty line.
 	 * 
 	 * @param httpVer
 	 *            the HTTP version, 0 or 1.
 	 * @param httpCode
 	 *            the HTTP code.
 	 * @param keepAlive
 	 *            if <code>true</code> then "keep-alive" is written. If
 	 *            <code>false</code> then "close" is written.
 	 * @param size
 	 *            the size of the content. -1 if not known.
 	 * @param resultMime
 	 *            response MIME type.
 	 * @param out
 	 *            write the response here.
 	 * @throws IOException
 	 *             if i/o error occurs
 	 */
 	public static void writeHttpResponse(final byte httpVer,
 			final int httpCode, final boolean keepAlive, final long size,
 			final String resultMime, final OutputStream out) throws IOException {
 		IOUtils.writeLine(ServerHttpException
 				.getResponseLine(httpVer, httpCode), out);
 		IOUtils.writeLine("Date: " + MiscUtils.getRFC2822Date(new Date()), out);
 		IOUtils.writeLine(
 				"Connection: " + (keepAlive ? "keep-alive" : "close"), out);
 		IOUtils.writeLine("Cache-Control: max-age=31104000", out);
 		IOUtils.writeLine("Content-Type: " + resultMime, out);
 		IOUtils.writeLine("Accept-Ranges: bytes", out);
 		if (size >= 0) {
 			IOUtils.writeLine("Content-Length: " + size, out);
 		}
 		IOUtils.writeLine("Server: Ambient", out);
 		// if (keepAlive) {
 		// IOUtils.writeLine("Keep-Alive: timeout=15, max=100", out);
 		// }
 	}
 
 	/***
 	 * Cat given reader to log.
 	 * 
 	 * @param r
 	 *            the reader to cat.
 	 */
 	public static void cat(final Reader r) {
 		try {
 			final LineNumberReader reader = new LineNumberReader(r);
 			while (true) {
 				final String line = reader.readLine();
 				if (line == null) {
 					break;
 				}
 				MiscUtils.sysout(line);
 			}
 		} catch (Exception ex) {
 			Log.e("IOUtils", "Error: " + ex.getMessage(), ex);
 		} finally {
 			MiscUtils.closeQuietly(r);
 		}
 	}
 
 	/***
 	 * Formats IP address contained in an integer and returns it as a string.
 	 * 
 	 * @param address
 	 *            the IP to decode
 	 * @return decoded IP.
 	 */
 	public static String formatIP(final int address) {
 		byte[] addr = new byte[4];
 		addr[3] = (byte) ((address >>> 24) & 0xFF);
 		addr[2] = (byte) ((address >>> 16) & 0xFF);
 		addr[1] = (byte) ((address >>> 8) & 0xFF);
 		addr[0] = (byte) (address & 0xFF);
 		return (addr[0] & 0xff) + "." + (addr[1] & 0xff) + "."
 				+ (addr[2] & 0xff) + "." + (addr[3] & 0xff);
 	}
 
 	/***
 	 * Returns the extension of the file, starting with dot character.
 	 * 
 	 * @param name
 	 *            the file name to get the extension from.
 	 * @return extension or empty string if the file does not have an extension.
 	 */
 	public static String getExt(final String name) {
 		final int lastDot = name.lastIndexOf('.');
 		if (lastDot < 0) {
 			return "";
 		}
 		final int lastSlash = name.lastIndexOf('/');
 		if ((lastSlash >= 0) && (lastDot < lastSlash)) {
 			// no dot in base name.
 			return "";
 		}
 		return name.substring(lastDot);
 	}
 }