/***
    *     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.stream.shoutcast;
  
  import java.io.BufferedInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.Socket;
  import java.net.URL;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.net.SocketFactory;
  
  import sk.baka.ambient.commons.IOUtils;
  
  /***
   * <p>
   * Polls a SHOUTcast server on given URL address. The stream itself will contain
   * mp3 data only - all shoutcast-related metadata are reported as events and
   * filtered out.
   * </p>
   * <p>
   * Throws {@link RadioStreamCorruptedException} when the stream corruption is
   * detected.
   * </p>
   * 
   * @author Martin Vysny
   */
  public class ShoutcastInputStream extends InputStream {
  
  	@Override
  	public int read(byte[] b, int offset, int length) throws IOException {
  		// make sure that the metaint was read correctly
  		getStreamedData();
  		if (metaint < 0) {
  			return getStreamedData().read(b, offset, length);
  		}
  		if (bytesToMetadata > 0) {
  			int toRead = Math.min(bytesToMetadata, length);
  			int result = getStreamedData().read(b, offset, toRead);
  			if (result >= 0) {
  				bytesToMetadata -= result;
  			}
  			return result;
  		}
  		readInstreamMetadata();
  		return read(b, offset, length);
  	}
  
  	private void readInstreamMetadata() throws IOException {
  		bytesToMetadata = metaint;
  		int chunkLength = getStreamedData().read();
  		if (chunkLength <= 0)
  			return;
  		chunkLength *= 16;
  		// read the metadata
  		final byte[] metadataBuffer = new byte[chunkLength];
  		int bufPointer = 0;
  		while (bufPointer < chunkLength) {
  			final int result = getStreamedData().read(metadataBuffer,
  					bufPointer, chunkLength - bufPointer);
  			if (result < 0)
  				return;
  			bufPointer += result;
  		}
  		while ((chunkLength > 0) && (metadataBuffer[chunkLength - 1] == 0)) {
  			chunkLength--;
  		}
  		String metadata = new String(metadataBuffer, 0, chunkLength, "UTF-8");
  		// parse the metadata
  		final Map<String, String> meta = new HashMap<String, String>();
  		while (metadata.length() > 0) {
  			int i = metadata.indexOf("='");
  			if (i < 0)
  				break;
  			final String mdName = metadata.substring(0, i);
  			metadata = metadata.substring(i + 2);
  			i = metadata.indexOf("';");
  			if (i < 0)
  				break;
  			final String mdValue = metadata.substring(0, i);
 			metadata = metadata.substring(i + 2);
 			meta.put(mdName, mdValue);
 		}
 		if (meta.isEmpty()) {
 			throw new RadioStreamCorruptedException("No tags in non-empty meta");
 		}
 		// invoke listener
 		final String title = meta.get("StreamTitle");
 		listener.metadataReceived(title, meta);
 	}
 
 	@Override
 	public int read() throws IOException {
 		if (metaint < 0) {
 			return getStreamedData().read();
 		}
 		if (bytesToMetadata > 0) {
 			int result = getStreamedData().read();
 			if (result >= 0) {
 				bytesToMetadata--;
 			}
 			return result;
 		}
 		readInstreamMetadata();
 		return read();
 	}
 
 	@Override
 	public int read(byte[] b) throws IOException {
 		return read(b, 0, b.length);
 	}
 
 	private final IShoutcastListener listener;
 
 	/***
 	 * Creates the object. The SHOUTcast server is polled on first invocation of
 	 * the <code>read</code> method.
 	 * 
 	 * @param url
 	 *            the server URL, must be a http (or file - for debugging
 	 *            purposes) protocol.
 	 * @param listener
 	 *            the listener.
 	 */
 	public ShoutcastInputStream(final URL url, final IShoutcastListener listener) {
 		super();
 		isFile = "file".equals(url.getProtocol());
 		final boolean isHttp = "http".equals(url.getProtocol());
 		if (!isHttp && !isFile) {
 			throw new IllegalArgumentException(url + " is not a http/file URL");
 		}
 		this.url = url;
 		this.listener = listener;
 	}
 
 	/***
 	 * Creates the object.
 	 * 
 	 * @param stream
 	 *            the SHOUTcast stream.
 	 * @param listener
 	 *            the listener.
 	 * @throws IOException
 	 */
 	ShoutcastInputStream(final InputStream stream,
 			final IShoutcastListener listener) throws IOException {
 		super();
 		isFile = false;
 		this.url = null;
 		this.listener = listener;
 		this.streamedData = stream;
 		readOpeningMetadata();
 	}
 
 	private InputStream getServerStream() throws IOException {
 		// build a request
 		final StringBuilder b = new StringBuilder();
 		b.append("GET ");
 		if (url.getPath().length() == 0) {
 			b.append('/');
 		} else {
 			b.append(url.getPath());
 		}
 		b.append(" HTTP/1.1\r\n");
 		b.append("User-Agent: Ambient\r\n");
 		b.append("icy-metadata:1\r\n");
 		b.append("\r\n");
 		final String request = b.toString();
 		final byte[] reqByte = request.getBytes("UTF-8");
 		// open communication socket
 		socket = SocketFactory.getDefault().createSocket(url.getHost(),
 				url.getPort() < 0 ? 80 : url.getPort());
 		// feed the request
 		final OutputStream out = socket.getOutputStream();
 		out.write(reqByte);
 		return new BufferedInputStream(socket.getInputStream());
 	}
 
 	private final boolean isFile;
 
 	/***
 	 * The SHOUTcast server URL.
 	 */
 	public final URL url;
 
 	/***
 	 * The underlying streamed data.
 	 */
 	private InputStream streamedData = null;
 
 	private InputStream getStreamedData() throws IOException {
 		if (streamedData == null) {
 			if (isFile) {
 				streamedData = url.openStream();
 			} else {
 				streamedData = getServerStream();
 			}
 			readOpeningMetadata();
 		}
 		return streamedData;
 	}
 
 	private String readLine() throws IOException {
 		return IOUtils.readLine(getStreamedData());
 	}
 
 	private void readOpeningMetadata() throws IOException {
 		// get the metadata
 		final String icyResponse = readLine();
 		if (icyResponse == null)
 			throw new IOException("Socked is closed");
 		if (!icyResponse.startsWith("ICY "))
 			throw new IOException("Not a SHOUTcast radio stream");
 		if (!icyResponse.equals("ICY 200 OK"))
 			throw new IOException("SHOUTcast error: " + icyResponse);
 		// seems ok. read the header and search for the mp3 data.
 		final Map<String, String> metadata = new HashMap<String, String>();
 		for (String metadataRow = readLine(); metadataRow.length() != 0; metadataRow = readLine()) {
 			int i = metadataRow.indexOf(':');
 			final String mdName = metadataRow.substring(0, i);
 			final String mdValue = metadataRow.substring(i + 1, metadataRow
 					.length());
 			metadata.put(mdName, mdValue);
 		}
 		final String name = metadata.get("icy-name");
 		final String genre = metadata.get("icy-genre");
 		String metaint = metadata.get("icy-metaint");
 		listener.opened(name, genre, metaint != null, metadata);
 		if (metaint != null) {
 			metaint = metaint.trim();
 			this.metaint = Integer.parseInt(metaint);
 			if (this.metaint < 1) {
 				this.metaint = -1;
 			}
 			bytesToMetadata = this.metaint;
 		}
 	}
 
 	/***
 	 * If greater than zero, a metadata chunk is repeated each
 	 * <code>metaint</code> bytes.
 	 */
 	private int metaint = -1;
 
 	/***
 	 * 
 	 */
 	private int bytesToMetadata = -1;
 
 	/***
 	 * If not <code>null</code> then this socket is used to get stream from the
 	 * server.
 	 */
 	private Socket socket = null;
 
 	@Override
 	public void close() throws IOException {
 		if (socket != null) {
 			socket.close();
 		} else {
 			if (streamedData != null) {
 				streamedData.close();
 			}
 		}
 	}
 }