/***
    *     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.collection.local;
  
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  
  import sk.baka.ambient.collection.AbstractAudio;
  import sk.baka.ambient.collection.CollectionUtils;
  import sk.baka.ambient.collection.IDynamicPlaylistTrackProvider;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.playlist.Random;
  import android.database.Cursor;
  
  /***
   * <p>
   * Provides random mix of tracks from the entire library.
   * </p>
   * <p>
   * <i>Implementation note</i>: this object causes a database {@link Cursor} to
   * be opened for a long time - not probably a good strategy.
   * </p>
   * 
   * @author Martin Vysny
   */
  public abstract class AbstractTrackProvider implements IDynamicPlaylistTrackProvider {
  
  	private static final long serialVersionUID = 8828698373273796738L;
  
  	/***
  	 * Enumerates album names (or full tracks if the {@link Random#TRACK} is
  	 * selected) to be played.
  	 */
  	private transient Cursor cursor;
  
  	/***
  	 * The track ordering.
  	 */
  	private Random random = Random.TRACK;
  
  	/***
  	 * Returns current random value.
  	 * @return the value of the playback order.
  	 */
  	protected final Random getRandom() {
  		return random;
  	}
  	
  	/***
  	 * Creates a new provider. Gets all files from the library.
  	 * 
  	 * @param random
  	 *            The track ordering.
  	 */
  	protected AbstractTrackProvider(final Random random) {
  		super();
  		this.random = random;
  	}
  
  	public void reset() {
  		reinit();
  	}
  
  	public void removeFromHistory(int trackCount) {
  		// do nothing
  	}
  
  	public void setRandom(final Random random, final TrackMetadataBean track) {
  		if (this.random == random) {
  			return;
  		}
  		this.random = random;
  		reinit();
  		if (random.groupsByAlbum()) {
  			if (track != null) {
  				// try to fetch album containing given track
  				final List<TrackMetadataBean> list = getAlbumTracksInternal(track
  						.getAlbum());
  				final int index = list.indexOf(track);
  				list.subList(0, index + 1).clear();
  				cache = new LinkedList<TrackMetadataBean>(list);
  			}
  		}
 	}
 
 	private void reinit() {
 		cache = null;
 		invalidateCursor();
 	}
 
 	public boolean hasNext() {
 		fillCache();
 		return !cache.isEmpty();
 	}
 
 	public TrackMetadataBean next() {
 		fillCache();
 		final TrackMetadataBean result = cache.removeFirst();
 		return result;
 	}
 
 	public void remove() {
 		throw new UnsupportedOperationException("unsupported");
 	}
 
 	/***
 	 * Upcoming tracks cache.
 	 */
 	private transient LinkedList<TrackMetadataBean> cache;
 
 	/***
 	 * Manages upcoming track cache and fetches new tracks from the cursor
 	 * on-demand.
 	 */
 	private void fillCache() {
 		if (cache == null) {
 			cache = new LinkedList<TrackMetadataBean>();
 		}
 		if (cache.isEmpty()) {
 			// try to fetch some tracks
 			cache.addAll(fetchMoreTracks(true, true));
 		}
 	}
 
 	public void close() {
 		invalidateCursor();
 	}
 
 	private void invalidateCursor() {
 		if (cursor != null) {
 			cursor.close();
 			cursor = null;
 		}
 	}
 
 	/***
 	 * Fetches more tracks from the database.
 	 * 
 	 * @param rewindOnEnd
 	 *            if <code>true</code> and there are no more tracks to play in
 	 *            the {@link #cursor}, the cursor is closed and the DB is
 	 *            re-queried. Note that the DB is reqeried at most once.
 	 * @param rewindOnMissing
 	 *            if <code>true</code> and we have found an non-existant track
 	 *            (this can happen when SERIALIZABLE transaction isolation level
 	 *            is specified), the cursor is closed and the DB is re-queried.
 	 *            Note that the DB is reqeried at most once.
 	 * @return a list of tracks. May be <code>null</code> if there are no
 	 *         tracks left.
 	 */
 	private List<TrackMetadataBean> fetchMoreTracks(final boolean rewindOnEnd,
 			final boolean rewindOnMissing) {
 		boolean requeried = false;
 		getCursor();
 		if (!cursor.moveToNext()) {
 			if (!rewindOnEnd)
 				return null;
 			recreateCursor();
 			requeried = true;
 			if (!cursor.moveToNext())
 				return null;
 		}
 		final List<TrackMetadataBean> result;
 		if (random == Random.TRACK) {
 			// fetch a single track
 			final TrackMetadataBean track = getTrackFromCursor(cursor);
 			result = Collections.singletonList(track);
 		} else {
 			final String album = cursor.getString(0);
 			// fetch all tracks from given album
 			result = getAlbumTracksInternal(album);
 		}
 		// tracks fetched. check if they are present on the filesystem
 		for (final TrackMetadataBean track : result) {
 			final boolean isPresent = AbstractAudio
 					.fromUri(track.getLocation()).exists();
 			if (!isPresent) {
 				if (requeried || !rewindOnMissing) {
 					// probably an outdated collection. ignore it and bail out.
 					return result;
 				}
 				// try again
 				recreateCursor();
 				return fetchMoreTracks(false, false);
 			}
 		}
 		return result;
 	}
 
 	/***
 	 * Fetches all tracks for given album. The tracks are sorted depending on
 	 * the value of {@link #random}.
 	 * 
 	 * @param album
 	 *            the album name
 	 * @return track list, never <code>null</code>, may be empty if no such
 	 *         album exists.
 	 */
 	private List<TrackMetadataBean> getAlbumTracksInternal(final String album) {
 		final List<TrackMetadataBean> result = getAlbumTracks(album);
 		if ((random == Random.ALBUM_TRACK) || (random == Random.TRACK)) {
 			Collections.shuffle(result);
 		} else {
 			CollectionUtils.sortByAlbumOrder(result);
 		}
 		return result;
 	}
 
 	/***
 	 * Fetches all tracks for given album.
 	 * @param album the album to fetch.
 	 * @return track list, never <code>null</code>, may be empty if no such
 	 *         album exists. Not required to be sorted.
 	 */
 	protected abstract List<TrackMetadataBean> getAlbumTracks(final String album);
 	
 	/***
 	 * Re-creates the cursor.
 	 */
 	private void recreateCursor() {
 		invalidateCursor();
 		getCursor();
 	}
 
 	/***
 	 * Returns the cursor, creating it if necessary.
 	 * 
 	 * @return the cursor instance.
 	 */
 	private Cursor getCursor() {
 		if (cursor == null) {
 			cursor = newCursor(random != Random.TRACK);
 		}
 		return cursor;
 	}
 
 	/***
 	 * Creates new cursor, depending on the value of <code>albums</code>
 	 * argument.
 	 * 
 	 * @param albums
 	 *            if <code>true</code> then the cursor must provide string
 	 *            album names only, sorted by a random order. If
 	 *            <code>false</code> then the cursor must provide tracks
 	 *            sorted by random order.
 	 * @return cursor, not <code>null</code>.
 	 */
 	protected abstract Cursor newCursor(final boolean albums);
 
 	/***
 	 * Converts current row to a track bean. The cursor was provided by
 	 * {@link #newCursor(boolean)} invoked with <code>false</code>.
 	 * 
 	 * @param c
 	 *            the cursor, never <code>null</code>, always on a valid
 	 *            line.
 	 * @return non-<code>null</code> track instance.
 	 */
 	protected abstract TrackMetadataBean getTrackFromCursor(final Cursor c);
 }