/***
    *     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.playlist;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.LineNumberReader;
  import java.text.ParseException;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.StringTokenizer;
  
  import org.xml.sax.Attributes;
  import org.xml.sax.SAXException;
  import org.xml.sax.helpers.DefaultHandler;
  
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.collection.TrackOriginEnum;
  import sk.baka.ambient.commons.IOUtils;
  import sk.baka.ambient.commons.MiscUtils;
  
  /***
   * Contains parsers for PLS, m3u, m3u8 and WPL playlists.
   * 
   * @author Martin Vysny
   */
  public final class Parsers {
  
  	private Parsers() {
  		throw new Error();
  	}
  
  	/***
  	 * Parses the PLS playlist and returns list of tracks contained in the
  	 * playlist.
  	 * 
  	 * @param in
  	 *            the playlist stream. the stream is always closed.
  	 * @param directory
  	 *            resolve all relative filenames against this directory. May be
  	 *            <code>null</code> if no resolving will be performed.
  	 * @return list of parsed tracks.
  	 * @throws IOException
  	 *             if i/o error occurs.
  	 * @throws ParseException
  	 *             on parse error
  	 */
  	public static List<TrackMetadataBean> parsePls(final InputStream in,
  			final String directory) throws IOException, ParseException {
  		try {
  			final String parent = directory == null ? null : IOUtils
  					.removeTrailingSlash(directory);
  			final List<String> buffer = new ArrayList<String>(3);
  			// read header
  			final LineNumberReader reader = new LineNumberReader(
  					new InputStreamReader(in, "UTF-8"));
  			readLines(reader, 1, buffer);
  			if (!"[playlist]".equals(buffer.get(0))) {
  				throw new ParseException("Missing the [playlist] header", 1);
  			}
  			readLines(reader, 1, buffer);
  			final String sEntryNumber = getValue(reader.getLineNumber(), buffer
  					.get(0), "NumberOfEntries");
  			final int entryNumber = parseInt(reader.getLineNumber(),
  					sEntryNumber, "NumberOfEntries") + 1;
  			// read tracks
  			final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>();
  			for (int i = 1; i < entryNumber; i++) {
  				readLines(reader, 3, buffer);
  				String url = getValue(reader.getLineNumber(), buffer.get(0),
  						"File" + i);
  				final TrackOriginEnum origin = TrackOriginEnum
  						.fromLocation(url);
  				url = resolve(origin, parent, url);
  				final String title = getValue(reader.getLineNumber(), buffer
  						.get(1), "Title" + i);
  				final String sLength = getValue(reader.getLineNumber(), buffer
  						.get(2), "Length" + i);
 				final int length = parseInt(reader.getLineNumber(), sLength,
 						"Length" + i);
 				final TrackMetadataBean.Builder b = TrackMetadataBean
 						.newBuilder();
 				b.setLocation(url).setOrigin(origin).setTitle(title).setLength(
 						length < 0 ? 0 : length);
 				final TrackMetadataBean track = b.build(-1);
 				result.add(track);
 			}
 			return result;
 		} finally {
 			MiscUtils.closeQuietly(in);
 		}
 	}
 
 	private static String resolve(final TrackOriginEnum origin,
 			final String parent, final String url) {
 		if ((origin == TrackOriginEnum.LocalFs) && (parent != null)
 				&& !new File(url).isAbsolute()) {
 			return parent + "/" + url;
 		}
 		return url;
 	}
 
 	private static int parseInt(final int lineNumber, final String num,
 			final String propName) throws ParseException {
 		try {
 			return Integer.parseInt(num);
 		} catch (NumberFormatException ex) {
 			throw new ParseException("Failed to parse " + propName + " value "
 					+ num, lineNumber);
 		}
 	}
 
 	/***
 	 * Reads exactly <code>lineCount</code> lines from given reader. Skips
 	 * {@link MiscUtils#isEmptyOrWhitespace(String)} lines.
 	 * 
 	 * @param reader
 	 *            the reader to poll
 	 * @param lineCount
 	 *            read this count of lines
 	 * @param target
 	 *            put the lines here.
 	 * @throws ParseException
 	 *             if there is not enough lines left in the stream.
 	 * @throws IOException
 	 *             if i/o error occurs.
 	 */
 	private static void readLines(final LineNumberReader reader,
 			final int lineCount, final List<String> target)
 			throws ParseException, IOException {
 		target.clear();
 		int linesToRead = lineCount;
 		while (linesToRead > 0) {
 			final String line = reader.readLine();
 			if (line == null) {
 				throw new ParseException("Expected " + lineCount + " lines; "
 						+ linesToRead + " missing", reader.getLineNumber());
 			}
 			if (!MiscUtils.isEmptyOrWhitespace(line)) {
 				target.add(line.trim());
 				linesToRead--;
 			}
 		}
 	}
 
 	private static String getValue(final int lineNumber, final String line,
 			final String propertyName) throws ParseException {
 		if (!line.toLowerCase().startsWith(propertyName.toLowerCase() + "=")) {
 			throw new ParseException("Expected property '" + propertyName
 					+ "' but got " + line, lineNumber);
 		}
 		final String result = line.substring(propertyName.length() + 1);
 		return result.trim();
 	}
 
 	/***
 	 * Parses the M3U playlist and returns list of tracks contained in the
 	 * playlist.
 	 * 
 	 * @param in
 	 *            the playlist stream. the stream is always closed.
 	 * @param directory
 	 *            resolve all relative filenames against this directory. May be
 	 *            <code>null</code> if no resolving will be performed.
 	 * @param unicode
 	 *            if <code>true</code> then the M3U8 UTF-8 encoding is used.
 	 *            If <code>false</code> then the M3U ISO8859_1 encoding is
 	 *            used.
 	 * @return list of tracks
 	 * @throws IOException
 	 *             if i/o error occurs.
 	 */
 	public static List<TrackMetadataBean> parseM3u(final InputStream in,
 			final String directory, final boolean unicode) throws IOException {
 		try {
 			final String parent = directory == null ? null : IOUtils
 					.removeTrailingSlash(directory);
 			final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>();
 			final LineNumberReader reader = new LineNumberReader(
 					new InputStreamReader(in, unicode ? "UTF-8" : "ISO8859_1"));
 			String nextTitle = null;
 			Integer nextDuration = null;
 			for (String line = reader.readLine(); line != null; line = reader
 					.readLine()) {
 				line = line.trim();
 				if (MiscUtils.isEmptyOrWhitespace(line)) {
 					continue;
 				}
 				if (line.startsWith("#")) {
 					if (!line.startsWith("#EXTINF")) {
 						continue;
 					}
 					try {
 						final StringTokenizer t = new StringTokenizer(line,
 								":,");
 						t.nextToken();
 						nextDuration = Integer.valueOf(t.nextToken().trim());
 						nextTitle = t.nextToken().trim();
 					} catch (final Exception ex) {
 						// ignore.
 					}
 					continue;
 				}
 				final TrackMetadataBean.Builder b = new TrackMetadataBean.Builder();
 				final TrackOriginEnum origin = TrackOriginEnum
 						.fromLocation(line);
 				final String url = resolve(origin, parent, line);
 				b.setLocation(url).setOrigin(origin);
 				if (nextTitle != null) {
 					b.setTitle(nextTitle);
 					nextTitle = null;
 				}
 				if (nextDuration != null) {
 					b.setLength(nextDuration < 0 ? 0 : nextDuration);
 					nextDuration = null;
 				}
 				result.add(b.build(-1));
 			}
 			return result;
 		} finally {
 			MiscUtils.closeQuietly(in);
 		}
 	}
 
 	/***
 	 * Parses the XSPF playlist and returns list of tracks contained in the
 	 * playlist.
 	 * 
 	 * @param in
 	 *            the playlist stream. the stream is always closed.
 	 * @param directory
 	 *            resolve all relative filenames against this directory. May be
 	 *            <code>null</code> if no resolving will be performed.
 	 * @return list of tracks
 	 * @throws IOException
 	 *             if i/o error occurs.
 	 * @throws ParseException
 	 *             if parse exception occurs.
 	 */
 	public static List<TrackMetadataBean> parseXspf(final InputStream in,
 			final String directory) throws IOException, ParseException {
 		try {
 			final String parent = directory == null ? null : IOUtils
 					.removeTrailingSlash(directory);
 			final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>();
 			IOUtils.parseXML(in, new XspfParser(result, parent));
 			return result;
 		} catch (SAXException e) {
 			final ParseException ex = new ParseException(e.getMessage(), 0);
 			ex.initCause(e);
 			throw ex;
 		} finally {
 			MiscUtils.closeQuietly(in);
 		}
 	}
 
 	private static final class XspfParser extends DefaultHandler {
 		private final List<TrackMetadataBean> result;
 		private final String parent;
 		private boolean inTrack = false;
 		private final static String XSPF_NS = "http://xspf.org/ns/0/";
 		private String inElement = null;
 		private final Map<String, StringBuilder> metatags = new HashMap<String, StringBuilder>();
 
 		/***
 		 * Creates new parser instance.
 		 * 
 		 * @param result
 		 *            put all records here.
 		 * @param parent
 		 *            the directory where the playlist is located.
 		 */
 		public XspfParser(final List<TrackMetadataBean> result,
 				final String parent) {
 			this.result = result;
 			this.parent = parent;
 		}
 
 		@Override
 		public void characters(char[] ch, int start, int length) {
 			if (inElement == null || !inTrack) {
 				return;
 			}
 			StringBuilder tagBuilder = metatags.get(inElement);
 			if (tagBuilder == null) {
 				tagBuilder = new StringBuilder();
 				metatags.put(inElement, tagBuilder);
 			}
 			tagBuilder.append(ch, start, length);
 		}
 
 		@Override
 		public void endElement(String uri, String localName, String name)
 				throws SAXException {
 			inElement = null;
 			if ("track".equals(localName)) {
 				inTrack = false;
 				// create track and register it.
 				if (!metatags.containsKey("location")) {
 					throw new SAXException("Missing <location> element");
 				}
 				String location = metatags.get("location").toString().trim();
 				if (location.startsWith("file://")) {
 					location = location.substring(7);
 				}
 				if (location.startsWith("file:")) {
 					location = location.substring(5);
 				}
 				final TrackMetadataBean.Builder b = new TrackMetadataBean.Builder();
 				final TrackOriginEnum origin = TrackOriginEnum
 						.fromLocation(location);
 				final String url = resolve(origin, parent, location);
 				b.setLocation(url).setOrigin(origin);
 				if (metatags.containsKey("creator")) {
 					b.setArtist(metatags.get("creator").toString().trim());
 				}
 				if (metatags.containsKey("album")) {
 					b.setAlbum(metatags.get("album").toString().trim());
 				}
 				if (metatags.containsKey("title")) {
 					b.setTitle(metatags.get("title").toString().trim());
 				}
 				if (metatags.containsKey("duration")) {
 					try {
 						b.setLength(Integer.parseInt(metatags.get("duration")
 								.toString().trim()) / 1000);
 					} catch (NumberFormatException ex) {
 						// ignore.
 					}
 				}
 				result.add(b.build(-1));
 				metatags.clear();
 			}
 		}
 
 		@Override
 		public void startElement(String uri, String localName, String name,
 				Attributes attributes) throws SAXException {
 			inElement = localName;
 			if (!XSPF_NS.equals(uri)) {
 				throw new SAXException("Unsupported playlist type: expected "
 						+ XSPF_NS + " but got " + uri);
 			}
 			if ("track".equals(localName)) {
 				inTrack = true;
 			}
 		}
 	}
 
 	/***
 	 * Parses the WPL playlist and returns list of tracks contained in the
 	 * playlist.
 	 * 
 	 * @param in
 	 *            the playlist stream. the stream is always closed.
 	 * @param directory
 	 *            resolve all relative filenames against this directory. May be
 	 *            <code>null</code> if no resolving will be performed.
 	 * @return list of tracks
 	 * @throws IOException
 	 *             if i/o error occurs.
 	 * @throws ParseException
 	 *             if parse exception occurs.
 	 */
 	public static List<TrackMetadataBean> parseWpl(final InputStream in,
 			final String directory) throws IOException, ParseException {
 		try {
 			final String parent = directory == null ? null : IOUtils
 					.removeTrailingSlash(directory);
 			final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>();
 			IOUtils.parseXML(in, new WplParser(result, parent));
 			return result;
 		} catch (SAXException e) {
 			final ParseException ex = new ParseException(e.getMessage(), 0);
 			ex.initCause(e);
 			throw ex;
 		} finally {
 			MiscUtils.closeQuietly(in);
 		}
 	}
 
 	private static final class WplParser extends DefaultHandler {
 		private final List<TrackMetadataBean> result;
 		private final String parent;
 
 		/***
 		 * Creates new parser instance.
 		 * 
 		 * @param result
 		 *            put tracks here.
 		 * @param parent
 		 *            resolve relative paths against this directory.
 		 */
 		public WplParser(final List<TrackMetadataBean> result,
 				final String parent) {
 			this.result = result;
 			this.parent = parent;
 		}
 
 		@Override
 		public void startElement(String uri, String localName, String name,
 				Attributes attributes) throws SAXException {
 			if ("media".equals(localName)) {
 				final String src = attributes.getValue("src");
 				if (MiscUtils.isEmptyOrWhitespace(src)) {
 					throw new SAXException("Attribute src missing or invalid");
 				}
 				final TrackMetadataBean.Builder b = new TrackMetadataBean.Builder();
 				final TrackOriginEnum origin = TrackOriginEnum
 						.fromLocation(src);
 				final String url = resolve(origin, parent, src);
 				b.setLocation(url).setOrigin(origin);
 				result.add(b.build(-1));
 			}
 		}
 	}
 
 	/***
 	 * Parses given playlist.
 	 * 
 	 * @param playlist
 	 *            the playlist to parse.
 	 * @return list of tracks contained in the playlist
 	 * @throws IOException
 	 *             if i/o error occurs
 	 * @throws ParseException
 	 *             if the playlist is not well formed or is of unknown type.
 	 */
 	public static List<TrackMetadataBean> parse(final File playlist)
 			throws IOException, ParseException {
 		final String name = playlist.getName().toLowerCase();
 		final String parent = playlist.getAbsoluteFile().getParentFile()
 				.getAbsolutePath();
 		if (name.endsWith(".m3u")) {
 			return parseM3u(new FileInputStream(playlist), parent, false);
 		}
 		if (name.endsWith(".m3u8")) {
 			return parseM3u(new FileInputStream(playlist), parent, true);
 		}
 		if (name.endsWith(".pls")) {
 			return parsePls(new FileInputStream(playlist), parent);
 		}
 		if (name.endsWith(".xspf")) {
 			return parseXspf(new FileInputStream(playlist), parent);
 		}
 		if (name.endsWith(".wpl")) {
 			return parseWpl(new FileInputStream(playlist), parent);
 		}
 		throw new ParseException("Unknown/unsupported playlist type: " + name,
 				0);
 	}
 
 	/***
 	 * Checks if given playlist contains metadata. Currently only XSPF playlists
 	 * contain metadata.
 	 * 
 	 * @param filename
 	 *            the file to check.
 	 * @return <code>true</code> if the playlist contains track metadata,
 	 *         <code>false</code> otherwise.
 	 */
 	public static boolean hasMetadata(final String filename) {
 		return filename.toLowerCase().endsWith(".xspf");
 	}
 }