/***
    *     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.text.CharacterIterator;
  import java.text.ParseException;
  import java.text.StringCharacterIterator;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Iterator;
  import java.util.List;
  import java.util.StringTokenizer;
  
  import sk.baka.ambient.collection.TrackMetadataBean;
  
  /***
   * <p>
   * Formats tags to a string. The following tags are supported:
   * </p>
   * <ul>
   * <li>
   * <li>%title - {@link TrackMetadataBean#getDisplayableName() the title}</li>
   * <li>%album - {@link TrackMetadataBean#getAlbum() album name}</li>
   * <li>%artist - {@link TrackMetadataBean#getArtist() the artist}</li>
   * <li>%genre - {@link TrackMetadataBean#getGenre() the genre}</li>
   * <li>%bitrate - {@link TrackMetadataBean#getBitrate() bitrate} in kbps
   * (without the "kbps" string)</li>
   * <li>%year - {@link TrackMetadataBean#getYearReleased() year}</li>
   * <li>%length - {@link TrackMetadataBean#getLength() length} in the h:mm:ss
   * format</li>
   * <li>%track - {@link TrackMetadataBean#getTrackNumber() track number}</li>
   * </ul>
   * <p>
   * If you surround a portion of text that contains a token (or a group) with
   * curly braces, that section will be hidden if all contained tokens and/or
   * groups are empty.
   * </p>
   * <p>
   * This object is not thread-safe.
   * </p>
   * 
   * @author Martin Vysny
   */
  public final class TagFormatter {
  
  	/***
  	 * The format string.
  	 */
  	public final String formatString;
  
  	/***
  	 * Creates new formatter and compiles the format string.
  	 * 
  	 * @param formatString
  	 *            the string
  	 * @throws ParseException
  	 *             if we failed to parse the format string.
  	 */
  	public TagFormatter(final String formatString) throws ParseException {
  		this(formatString, tokenizeString(formatString).iterator(), false,
  				null, -1);
  	}
  
  	/***
  	 * Child formatters.
  	 */
  	private final List<TagFormatter> childFormatters = new ArrayList<TagFormatter>();
  
  	/***
  	 * All supported tags.
  	 */
  	private static final List<String> tags = new ArrayList<String>(Arrays
  			.asList(new String[] { "%title", "%album", "%artist", "%genre",
  					"%bitrate", "%year", "%length", "%track" }));
  
  	/***
  	 * Returns the value of given tag for given track.
  	 * 
  	 * @param tagName
  	 *            the tag name, one of {@link #tags}.
  	 * @param track
  	 *            the track meta.
  	 * @return displayable value, never <code>null</code>
  	 */
 	private static String getTagValue(final String tagName,
 			final TrackMetadataBean track) {
 		if ("%title".equals(tagName)) {
 			return track.getDisplayableName();
 		}
 		if ("%album".equals(tagName)) {
 			return MiscUtils.emptyIfNull(track.getAlbum());
 		}
 		if ("%artist".equals(tagName)) {
 			return MiscUtils.emptyIfNull(track.getArtist());
 		}
 		if ("%genre".equals(tagName)) {
 			return MiscUtils.emptyIfNull(track.getGenre());
 		}
 		if ("%bitrate".equals(tagName)) {
 			return track.getBitrate() == 0 ? "" : String.valueOf(track
 					.getBitrate());
 		}
 		if ("%year".equals(tagName)) {
 			return MiscUtils.emptyIfNull(track.getYearReleased());
 		}
 		if ("%length".equals(tagName)) {
 			return TrackMetadataBean.getDisplayableLength(track.getLength());
 		}
 		if ("%track".equals(tagName)) {
 			return MiscUtils.emptyIfNull(track.getTrackNumber());
 		}
 		throw new RuntimeException("Unknown tag: " + tagName);
 	}
 
 	private TagFormatter(final String formatString,
 			final Iterator<String> tokens, final boolean parsingGroup,
 			final TagFormatter parent, final int index) throws ParseException {
 		super();
 		this.formatString = formatString;
 		this.parent = parent;
 		this.index = index;
 		for (; tokens.hasNext();) {
 			final String token = tokens.next();
 			if ("{".equals(token)) {
 				final TagFormatter innerGroup = new TagFormatter(formatString,
 						tokens, true, this, childFormatters.size());
 				childFormatters.add(innerGroup);
 				continue;
 			}
 			if ("}".equals(token)) {
 				if (!parsingGroup)
 					throw new ParseException("Unexpected }", -1);
 				// finish parsing.
 				return;
 			}
 			final int tagIndex = findTag(token);
 			final TagFormatter innerGroup = new TagFormatter(token,
 					tagIndex >= 0, this, childFormatters.size());
 			childFormatters.add(innerGroup);
 		}
 		if (parsingGroup)
 			throw new ParseException("Missing }", -1);
 	}
 
 	/***
 	 * Creates a tag formatter which simply returns a tag value or a string
 	 * literal.
 	 * 
 	 * @param value
 	 *            the value
 	 * @param isTagName
 	 *            if <code>true</code> then the <code>value</code> is a tag
 	 *            name to resolve. if <code>false</code> then the
 	 *            <code>value</code> is simply a string literal.
 	 * @param parent
 	 *            The parent, <code>null</code> if this is the root formatter.
 	 * @param index
 	 *            Index in the parent's list of children.
 	 */
 	private TagFormatter(final String value, final boolean isTagName,
 			final TagFormatter parent, final int index) {
 		super();
 		this.parent = parent;
 		this.index = index;
 		if (isTagName)
 			tag = value;
 		else
 			stringLiteral = value;
 		formatString = value;
 	}
 
 	/***
 	 * If not <code>null</code> then this formatter translates to a single tag
 	 * value.
 	 */
 	private String tag = null;
 
 	/***
 	 * If not <code>null</code> then this formatter translates into a string
 	 * literal.
 	 */
 	private String stringLiteral = null;
 
 	/***
 	 * The parent, <code>null</code> if this is the root formatter.
 	 */
 	private final TagFormatter parent;
 
 	/***
 	 * Index in the parent's list of children.
 	 */
 	private final int index;
 
 	/***
 	 * Returns <code>true</code> if contains one or more child formatters.
 	 * 
 	 * @return <code>true</code> if this formatter is a compound formatter (a
 	 *         group).
 	 */
 	private boolean isCompound() {
 		return (tag == null) && (stringLiteral == null)
 				&& !childFormatters.isEmpty();
 	}
 
 	/***
 	 * Returns <code>true</code> if this formatter behaves like a delimiter.
 	 * Delimiters separate visible elements which are not delimiters.
 	 * 
 	 * @return <code>true</code> if this formatter is a delimiter.
 	 */
 	private boolean isDelimiter() {
 		return isCompound() && (childFormatters.size() == 1)
 				&& (childFormatters.get(0).isStringLiteral());
 	}
 
 	/***
 	 * Formats given track and appends it into given string builder.
 	 * 
 	 * @param builder
 	 *            the builder to append the formatted track to.
 	 * @param bean
 	 *            the track to format
 	 * @param collapse
 	 *            if <code>true</code> then the formatter will collapse when
 	 *            all tags/groups are empty.
 	 */
 	public void format(final StringBuilder builder,
 			final TrackMetadataBean bean, final boolean collapse) {
 		// simple cases
 		if (isStringLiteral()) {
 			builder.append(stringLiteral);
 			return;
 		}
 		if (tag != null) {
 			builder.append(getTagValue(tag, bean));
 			return;
 		}
 		// regular case
 		if (collapse && isCollapsed(bean))
 			return;
 		for (final TagFormatter child : childFormatters) {
 			child.format(builder, bean, true);
 		}
 	}
 
 	/***
 	 * Serves for the cache validity verification. If current bean is not the
 	 * same instance as this bean then the cache is invalid.
 	 */
 	private TrackMetadataBean lastBean;
 
 	/***
 	 * Cache of the {@link #isCollapsed(TrackMetadataBean)} property.
 	 */
 	private boolean isCollapsedCached;
 
 	/***
 	 * Checks if this formatter produces collapsed output - if all tags and
 	 * groups contained in this formatter are collapsed or return an empty tag.
 	 * 
 	 * @param bean
 	 *            the data provider
 	 * @return <code>true</code> if all non-string formatters are collapsed.
 	 */
 	private boolean isCollapsed(final TrackMetadataBean bean) {
 		if (lastBean == bean)
 			return isCollapsedCached;
 		lastBean = bean;
 		// simple cases
 		if (isStringLiteral()) {
 			isCollapsedCached = false;
 			return false;
 		}
 		if (tag != null) {
 			isCollapsedCached = getTagValue(tag, bean).length() == 0;
 			return isCollapsedCached;
 		}
 		// delimiter?
 		if (isDelimiter()) {
 			// check if there is at least one non-delimiter uncollapsed item
 			if (parent == null) {
 				isCollapsedCached = true;
 				return true;
 			}
 			for (int i = index - 1; i >= 0; i--) {
 				final TagFormatter sibling = parent.childFormatters.get(i);
 				if (sibling.isDelimiter()) {
 					isCollapsedCached = true;
 					return true;
 				}
 				if (sibling.isCollapsed(bean))
 					continue;
 				// allright, we have found such item. Check if there is one at
 				// the other side of the delimiter.
 				final int size = parent.childFormatters.size();
 				for (int j = index + 1; j < size; j++) {
 					final TagFormatter nextSibling = parent.childFormatters
 							.get(j);
 					if (nextSibling.isDelimiter()) {
 						// this delimiter will be invisible. update its cache
 						sibling.lastBean = bean;
 						sibling.isCollapsedCached = true;
 						continue;
 					}
 					if (!nextSibling.isCollapsed(bean)) {
 						// visible items on both sides, we are visible
 						isCollapsedCached = false;
 						return false;
 					}
 				}
 			}
 			// no visible item, return true
 			isCollapsedCached = true;
 			return true;
 		}
 		// common compound formatter case
 		boolean wasNonLiteral = false;
 		for (final TagFormatter child : childFormatters) {
 			if (child.isStringLiteral())
 				continue;
 			wasNonLiteral = true;
 			if (!child.isCollapsed(bean)) {
 				isCollapsedCached = false;
 				return false;
 			}
 		}
 		isCollapsedCached = wasNonLiteral;
 		return wasNonLiteral;
 	}
 
 	private boolean isStringLiteral() {
 		return stringLiteral != null;
 	}
 
 	/***
 	 * Formats given track.
 	 * 
 	 * @param bean
 	 *            the track to format
 	 * @return never-<code>null</code> formatted string.
 	 */
 	public String format(final TrackMetadataBean bean) {
 		final StringBuilder b = new StringBuilder();
 		format(b, bean, false);
 		return b.toString();
 	}
 
 	private static List<String> tokenizeString(final String string) {
 		final StringTokenizer tokenizer = new StringTokenizer(string, "%{}",
 				true);
 		final List<String> result = new ArrayList<String>();
 		// first pass - tokenize
 		while (tokenizer.hasMoreTokens()) {
 			final String token = tokenizer.nextToken();
 			if ("%{}".indexOf(token.charAt(0)) >= 0) {
 				final CharacterIterator iter = new StringCharacterIterator(
 						token);
 				for (char c = iter.first(); c != CharacterIterator.DONE; c = iter
 						.next()) {
 					result.add(String.valueOf(c));
 				}
 			} else {
 				result.add(token);
 			}
 		}
 		// second pass - convert a % separator followed by a valid tag name to a
 		// tag.
 		for (int i = 0; i < result.size(); i++) {
 			if (!"%".equals(result.get(i)))
 				continue;
 			if (i + 1 >= result.size())
 				continue;
 			String nextToken = "%" + result.get(i + 1);
 			final int tagIndex = findTag(nextToken);
 			if (tagIndex < 0)
 				continue;
 			// we found a tag!
 			final String tag = tags.get(tagIndex);
 			result.set(i, tag);
 			nextToken = nextToken.substring(tag.length());
 			if (nextToken.length() == 0) {
 				result.remove(i + 1);
 				i--;
 			} else {
 				result.set(i + 1, nextToken);
 			}
 		}
 		return result;
 	}
 
 	private final static int findTag(final String tagName) {
 		for (int tagIndex = 0; tagIndex < tags.size(); tagIndex++) {
 			if (tagName.startsWith(tags.get(tagIndex))) {
 				return tagIndex;
 			}
 		}
 		return -1;
 	}
 
 	@Override
 	public String toString() {
 		if (isStringLiteral())
 			return "literal: " + stringLiteral;
 		if (tag != null)
 			return "tag: " + tag;
 		if (isDelimiter())
 			return "delimiter: '" + childFormatters.get(0).stringLiteral + "'";
 		return "compound formatter";
 	}
 
 }