/***
    *     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.library;
  
  import java.io.File;
  import java.io.FileFilter;
  import java.io.FilenameFilter;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.List;
  import java.util.regex.Pattern;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.collection.TrackOriginEnum;
  import sk.baka.ambient.collection.TrackMetadataBean.Builder;
  import sk.baka.ambient.commons.MiscUtils;
  import android.content.ContentValues;
  import android.database.Cursor;
  
  import com.es.skreemr.SkreemRSong;
  
  import entagged.audioformats.AudioFile;
  import entagged.audioformats.AudioFileIO;
  import entagged.audioformats.Tag;
  import entagged.audioformats.exceptions.CannotReadException;
  
  /***
   * Library utility methods.
   * 
   * @author Martin Vysny
   */
  public final class LibraryUtils {
  	private LibraryUtils() {
  		// prevent instantiation
  	}
  
  	/***
  	 * All column names in the <code>tracks</code> table.
  	 */
  	public static final String[] COLUMN_NAMES = new String[] { "id", "origin",
  			"title", "artist", "composer", "album", "genre", "trackNumber",
  			"location", "length", "bitrate", "fileSize", "yearReleased",
  			"frequency", "buy_url", "license", "artist_url", "artist_desc" };
  
  	/***
  	 * All {@link #COLUMN_NAMES columns} separated by commas.
  	 */
  	public static final String COLUMNS;
  
  	static {
  		final StringBuilder b = new StringBuilder();
  		boolean first = true;
  		for (final String column : COLUMN_NAMES) {
  			if (first) {
  				first = false;
  			} else {
  				b.append(',');
  			}
  			b.append("tracks.");
  			b.append(column);
  		}
  		COLUMNS = b.toString();
  	}
  
  	/***
  	 * Converts the sqlite3 {@link ContentValues} to the tag bean.
  	 * 
  	 * @param cursor
  	 *            the content values object, must not be <code>null</code>.
  	 *            Expects columns in {@link #COLUMN_NAMES} ordering.
  	 * @return the bean instance, never <code>null</code>
  	 */
  	public static TrackMetadataBean cursorToTrackBean(final Cursor cursor) {
  		final long id = cursor.getInt(0);
  		final Builder track = TrackMetadataBean.newBuilder();
  		track.setOrigin(TrackOriginEnum.fromDb(cursor.getInt(1))).setTitle(
  				cursor.getString(2)).setArtist(cursor.getString(3));
  		track.composer = cursor.getString(4);
  		track.album = cursor.getString(5);
  		track.genre = cursor.getString(6);
  		track.trackNumber = cursor.getString(7);
 		track.location = cursor.getString(8);
 		track.length = cursor.getInt(9);
 		track.bitrate = cursor.getInt(10);
 		track.fileSize = cursor.getLong(11);
 		track.yearReleased = cursor.getString(12);
 		track.frequency = cursor.getInt(13);
 		track.buyURL = cursor.getString(14);
 		track.license = cursor.getString(15);
 		track.artistURL = cursor.getString(16);
 		track.artistDesc = cursor.getString(17);
 		return track.build(id);
 	}
 
 	private static final Pattern time = Pattern
 			.compile("[0-9]{2}:[0-9]{2}:[0-9]{2}");
 
 	/***
 	 * Converts the {@link SkreemRSong} to the tag bean.
 	 * 
 	 * @param song
 	 *            the song.
 	 * @return the bean instance, never <code>null</code>
 	 */
 	public static TrackMetadataBean toTrackBean(final SkreemRSong song) {
 		final Builder track = TrackMetadataBean.newBuilder();
 		if (time.matcher(song.getDuration()).matches()) {
 			try {
 				track.length = Integer.valueOf(song.getDuration().substring(0,
 						2))
 						* 3600
 						+ Integer.valueOf(song.getDuration().substring(3, 5))
 						* 60
 						+ Integer.valueOf(song.getDuration().substring(6, 8));
 			} catch (NumberFormatException ex) {
 				track.length = 0;
 			}
 		}
 		track.genre = fixId3Genre(MiscUtils.nullIfEmptyOrWhitespace(song
 				.getGenre()));
 		try {
 			track.bitrate = Integer.parseInt(song.getBitrate()) / 1000;
 		} catch (NumberFormatException ex) {
 			track.bitrate = 0;
 		}
 		try {
 			track.frequency = Integer.parseInt(song.getFrequency());
 		} catch (NumberFormatException ex) {
 			track.frequency = 0;
 		}
 		track.origin = TrackOriginEnum.SkreemR;
 		track.title = song.getSong();
 		track.artist = song.getArtist();
 		track.album = song.getAlbum();
 		track.location = song.getUrl();
 		track.yearReleased = song.getYear();
 		track.fileSize = -1;
 		final TrackMetadataBean result = track.build(-1);
 		return result;
 	}
 
 	/***
 	 * Converts a list of {@link SkreemRSong} to a list of tag bean.
 	 * 
 	 * @param songs
 	 *            the song list.
 	 * @return the bean instance, never <code>null</code>
 	 */
 	public static List<TrackMetadataBean> toTrackBean(
 			final List<SkreemRSong> songs) {
 		final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>(
 				songs.size());
 		for (final SkreemRSong song : songs) {
 			result.add(toTrackBean(song));
 		}
 		return result;
 	}
 
 	/***
 	 * Converts the track to {@link ContentValues} suitable for database insert.
 	 * 
 	 * @param track
 	 *            the track to convert.
 	 * @return values
 	 */
 	public static ContentValues trackBeanToValues(final TrackMetadataBean track) {
 		final ContentValues values = new ContentValues();
 		values.put("title", track.getTitle());
 		values.put("origin", track.getOrigin().ordinal());
 		values.put("artist", track.getArtist());
 		values.put("composer", track.getComposer());
 		values.put("album", track.getAlbum());
 		values.put("genre", track.getGenre());
 		values.put("trackNumber", track.getTrackNumber());
 		values.put("location", track.getLocation());
 		values.put("length", track.getLength());
 		values.put("bitrate", track.getBitrate());
 		values.put("fileSize", track.getFileSize());
 		values.put("yearReleased", track.getYearReleased());
 		values.put("frequency", track.getFrequency());
 		values.put("buy_url", track.getBuyURL());
 		values.put("license", track.getLicense());
 		values.put("artist_url", track.getArtistURL());
 		values.put("artist_desc", track.getArtistDesc());
 		return values;
 	}
 
 	/***
 	 * Retrieves a music file tag from given file name.
 	 * 
 	 * @param filename
 	 *            the file to retrieve tags from.
 	 * @return bean instance, never <code>null</code>.
 	 */
 	public static TrackMetadataBean getTag(final String filename) {
 		if (TRACK_META_NAME_FILTER.accept(null, filename)) {
 			// try to read the tag
 			try {
 				final AudioFile f = AudioFileIO.read(new File(filename));
 				final Tag tag = f.getTag();
 				final Builder track = TrackMetadataBean.newBuilder();
 				track.trackNumber = MiscUtils.nullIfEmptyOrWhitespace(tag
 						.getFirstTrack());
 				if (track.trackNumber != null) {
 					// strip anything after slash, including the slash
 					final int slash = track.trackNumber.indexOf('/');
 					if (slash >= 0)
 						track.trackNumber = track.trackNumber.substring(0,
 								slash);
 				}
 				track.title = MiscUtils.nullIfEmptyOrWhitespace(tag
 						.getFirstTitle());
 				track.artist = MiscUtils.fixArtistAlbumName(MiscUtils
 						.nullIfEmptyOrWhitespace(tag.getFirstArtist()));
 				track.album = MiscUtils.fixArtistAlbumName(MiscUtils
 						.nullIfEmptyOrWhitespace(tag.getFirstAlbum()));
 				track.genre = fixId3Genre(MiscUtils.nullIfEmptyOrWhitespace(tag
 						.getFirstGenre()));
 				track.yearReleased = MiscUtils.nullIfEmptyOrWhitespace(tag
 						.getFirstYear());
 				track.frequency = f.getSamplingRate();
 				track.origin = TrackOriginEnum.LocalFs;
 				track.length = f.getLength();
 				track.bitrate = f.getBitrate();
 				track.fileSize = new File(filename).length();
 				track.location = filename;
 				return track.build(-1);
 			} catch (final CannotReadException e) {
 				final String text = MiscUtils.format(R.string.errTagRead,
 						filename);
 				AmbientApplication.getInstance().error(LibraryUtils.class,
 						true, text, e);
 			}
 		}
 		// not a known file, construct a simple tag bean
 		final Builder track = TrackMetadataBean.newBuilder();
 		track.origin = TrackOriginEnum.LocalFs;
 		track.location = filename;
 		track.fileSize = new File(filename).length();
 		return track.build(-1);
 	}
 
 	/***
 	 * If the genre is in the form of <code>(number)</code>, the string is
 	 * replaced by appropriate genre name.
 	 * 
 	 * @param genre
 	 *            the genre to check
 	 * @return fixed genre string representation.
 	 */
 	public static String fixId3Genre(final String genre) {
 		if (genre == null)
 			return null;
 		if (!genre.startsWith("(") || !genre.endsWith(")"))
 			return genre;
 		try {
 			final int genreIndex = Integer.parseInt(genre.substring(1, genre
 					.length() - 1));
 			if ((genreIndex < 0) || (genreIndex >= Tag.DEFAULT_GENRES.length))
 				return genre;
 			return Tag.DEFAULT_GENRES[genreIndex];
 		} catch (NumberFormatException ex) {
 			return genre;
 		}
 	}
 
 	/***
 	 * Polls all tracks from given cursor. The cursor is closed afterwards.
 	 * Usable for example on the
 	 * {@link DBStrategy#findByCriteria(java.util.Map, boolean, String)}
 	 * method output.
 	 * 
 	 * @param c
 	 *            the cursor
 	 * @return list of track meta beans, never <code>null</code>, may be empty.
 	 */
 	@SuppressWarnings("unchecked")
 	public static List<TrackMetadataBean> pollTracks(final Cursor c) {
 		if (!c.moveToFirst()) {
 			c.close();
 			return Collections.EMPTY_LIST;
 		}
 		final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>();
 		try {
 			do {
 				if (Thread.currentThread().isInterrupted()) {
 					throw new RuntimeException("interrupted");
 				}
 				final TrackMetadataBean track = cursorToTrackBean(c);
 				result.add(track);
 			} while (c.moveToNext());
 		} finally {
 			c.close();
 		}
 		return result;
 	}
 
 	/***
 	 * Polls all tracks from given cursor. The cursor is closed afterwards.
 	 * Usable for example on the
 	 * {@link DBStrategy#getCriteriaList(sk.baka.ambient.collection.CategoryEnum[], java.util.EnumMap)}
 	 * method result.
 	 * 
 	 * @param c
 	 *            the cursor
 	 * @param separator
 	 *            if multiple columns are required, this character separates
 	 *            them. In case of a single column, this parameter is ignored.
 	 * @param column
 	 *            put values of this column into the <code>columnValues</code>
 	 *            list. Ignored when <code>columnValues</code> is
 	 *            <code>null</code>.
 	 * @param columnValues
 	 *            put values from <code>column</code> here.
 	 * @param useAsNull
 	 *            if not <code>null</code> then this value is used instead of
 	 *            <code>null</code> value.
 	 * @return values of first selected column, never <code>null</code>, may be
 	 *         empty.
 	 */
 	@SuppressWarnings("unchecked")
 	public static List<String> pollStrings(final Cursor c,
 			final char separator, final int column,
 			final List<String> columnValues, final String... useAsNull) {
 		if (!c.moveToFirst()) {
 			c.close();
 			return Collections.EMPTY_LIST;
 		}
 		final List<String> result = new ArrayList<String>();
 		final StringBuilder b = new StringBuilder();
 		do {
 			b.delete(0, b.length());
 			for (int i = 0; i < useAsNull.length; i++) {
 				if (i != 0) {
 					b.append(separator);
 				}
 				String val = c.getString(i);
 				if ((columnValues != null) && (i == column)) {
 					columnValues.add(val);
 				}
 				if (val == null)
 					val = useAsNull[i];
 				b.append(val);
 			}
 			result.add(b.toString());
 		} while (c.moveToNext());
 		c.close();
 		return result;
 	}
 
 	/***
 	 * Set of supported extensions of track files, lower-case.
 	 */
 	public static final List<String> trackExtensions = Collections
 			.unmodifiableList(Arrays.asList(new String[] { ".mp3", ".m4a",
 					".amr", ".wma", ".mid", ".smf", ".wav", ".ogg" }));
 
 	/***
 	 * MIME types for {@link #trackExtensions}.
 	 */
 	public static final List<String> trackMime = Collections
 			.unmodifiableList(Arrays.asList(new String[] { "audio/mpeg",
 					"audio/mp4", "audio/AMR", "audio/x-ms-wma", "audio/mid",
 					"audio/mid", "audio/wav", "application/ogg" }));
 
 	/***
 	 * Returns MIME type for given file. Detects only audio file types.
 	 * 
 	 * @param fileName
 	 *            the file name.
 	 * @return the MIME type or "application/octet-stream" if unknown.
 	 */
 	public static String getMime(final String fileName) {
 		for (int i = 0; i < trackExtensions.size(); i++) {
 			if (fileName.toLowerCase().endsWith(trackExtensions.get(i))) {
 				return trackMime.get(i);
 			}
 		}
 		return "application/octet-stream";
 	}
 
 	/***
 	 * Set of supported extensions of track files, lower-case, which is the
 	 * Entagged library able to process.
 	 */
 	public static final List<String> trackMetaExtensions = Collections
 			.unmodifiableList(Arrays.asList(new String[] { ".mp3", ".ogg",
 					".flac", ".wav", ".mpc", ".mp+", ".ape", ".wma" }));
 
 	/***
 	 * Set of supported extensions of playlist files, lower-case.
 	 */
 	public static final List<String> playlistExtensions = Collections
 			.unmodifiableList(Arrays.asList(new String[] { ".m3u", ".m3u8",
 					".pls", ".wpl", ".xspf" }));
 
 	/***
 	 * Set of supported extensions of music (track and playlist) files,
 	 * lower-case.
 	 */
 	public static final List<String> musicExtensions = new ArrayList<String>(
 			trackExtensions);
 	static {
 		musicExtensions.addAll(playlistExtensions);
 	}
 
 	private final static class ExtensionFilter implements FilenameFilter {
 		private final List<String> extensions;
 
 		/***
 		 * Creates new filter.
 		 * @param extensions extends to accept.
 		 */
 		public ExtensionFilter(final List<String> extensions) {
 			this.extensions = extensions;
 		}
 
 		public boolean accept(File dir, String filename) {
 			final String name = filename.toLowerCase();
 			for (final String ext : extensions) {
 				if (name.toLowerCase().endsWith(ext))
 					return true;
 			}
 			return false;
 		}
 	}
 
 	private final static class FilenameFilterWrapper implements FileFilter {
 		private final ExtensionFilter extensions;
 
 		/***
 		 * Creates new wrapper.
 		 * @param extensions wrap this filter.
 		 */
 		public FilenameFilterWrapper(final ExtensionFilter extensions) {
 			this.extensions = extensions;
 		}
 
 		public boolean accept(File pathname) {
 			if (pathname.isDirectory()) {
 				return true;
 			}
 			return extensions.accept(null, pathname.getName());
 		}
 	}
 
 	/***
 	 * Filters out all files except track files.
 	 */
 	public final static FilenameFilter TRACK_NAME_FILTER = new ExtensionFilter(
 			trackExtensions);
 
 	/***
 	 * Filters out all files except track files which the Entagged library
 	 * supports.
 	 */
 	public final static FilenameFilter TRACK_META_NAME_FILTER = new ExtensionFilter(
 			trackMetaExtensions);
 
 	/***
 	 * Filters out all files except directories and track files.
 	 */
 	public final static FileFilter TRACK_FILTER = new FilenameFilterWrapper(
 			new ExtensionFilter(trackExtensions));
 
 	/***
 	 * Filters out all files except playlist files.
 	 */
 	public final static FilenameFilter PLAYLIST_NAME_FILTER = new ExtensionFilter(
 			playlistExtensions);
 
 	/***
 	 * Filters out all files except directories and playlist files.
 	 */
 	public final static FileFilter PLAYLIST_FILTER = new FilenameFilterWrapper(
 			new ExtensionFilter(playlistExtensions));
 
 	/***
 	 * Filters out all files except playlist and track files.
 	 */
 	public final static FilenameFilter MUSIC_NAME_FILTER = new ExtensionFilter(
 			musicExtensions);
 
 	/***
 	 * Filters out all files except directories, playlist and track files.
 	 */
 	public final static FileFilter MUSIC_FILTER = new FilenameFilterWrapper(
 			new ExtensionFilter(musicExtensions));
 }