/***
    *     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.Serializable;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import sk.baka.ambient.collection.IDynamicPlaylistTrackProvider;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.Interval;
  
  /***
   * <p>
   * A dynamic playlist - items are added to the front of the playlist and removed
   * from the back of the playlist (if required). Does not support shuffle mode
   * itself - it configures the {@link IDynamicPlaylistTrackProvider} to provide
   * tracks in particular order instead.
   * </p>
   * <p>
   * Queued tracks are lined always in front of a currently playing track.
   * </p>
   * 
   * @author Martin Vysny
   */
  public final class DynamicPlaylistStrategy implements IPlaylistStrategy,
  		Serializable {
  	/***
  	 * 
  	 */
  	private static final long serialVersionUID = -8794527285381642344L;
  
  	/***
  	 * Provides tracks for playing.
  	 */
  	private final IDynamicPlaylistTrackProvider provider;
  
  	/***
  	 * The playlist. Always contains at most {@link #historyLength} + 1 +
  	 * {@link #upcomingTrackCount} tracks.
  	 */
  	private final LinkedList<PlaylistItem> playlist = new LinkedList<PlaylistItem>();
  
  	/***
  	 * Unmodifiable view on the {@link #playlist}.
  	 */
  	private transient List<PlaylistItem> unmodifiablePlaylist;
  
  	/***
  	 * Creates new dynamic playlist.
  	 * 
  	 * @param provider
  	 *            provides tracks for playing.
  	 * @param strategy
  	 *            if not <code>null</code> then clone this strategy.
  	 * @param historyLength
  	 *            Number of entries in the history.
  	 * @param upcomingTrackCount
  	 *            Number of upcoming tracks to show.
  	 */
  	public DynamicPlaylistStrategy(
  			final IDynamicPlaylistTrackProvider provider,
  			final IPlaylistStrategy strategy, final int historyLength,
  			final int upcomingTrackCount) {
  		super();
  		this.provider = provider;
  		this.historyLength = historyLength;
  		this.upcomingTrackCount = upcomingTrackCount;
  		if (strategy != null) {
  			playlist.addAll(strategy.getPlayItems());
  			currentTrack = strategy.getCurrentlyPlaying();
  			final List<Integer> queued = strategy.getQueue();
  			queueIndices(queued);
  			setRandom(strategy.getRandom());
  		}
  		populatePlaylist(true);
  	}
  
  	/***
  	 * Number of entries in the history.
  	 */
 	private transient int historyLength = 5;
 
 	/***
 	 * Number of upcoming tracks to show.
 	 */
 	private transient int upcomingTrackCount = 10;
 
 	/***
 	 * Sets the history length.
 	 * 
 	 * @param historyLength
 	 *            how many tracks are kept as a history after playback. Cannot
 	 *            be negative.
 	 */
 	public void setHistoryLength(final int historyLength) {
 		this.historyLength = historyLength;
 		populatePlaylist(true);
 	}
 
 	/***
 	 * Sets the upcoming track count.
 	 * 
 	 * @param upcomingTrackCount
 	 *            how many tracks will be shown before the playing track. Cannot
 	 *            be negative.
 	 */
 	public void setUpcomingTrackCount(final int upcomingTrackCount) {
 		this.upcomingTrackCount = upcomingTrackCount;
 		populatePlaylist(true);
 	}
 
 	/***
 	 * Currently played song. Index to the {@link #playlist} list.
 	 * <code>-1</code> if no song is currently being played.
 	 */
 	private int currentTrack = -1;
 
 	private Random random = Random.NONE;
 
 	/***
 	 * Polls the provider until the playlist is populated as required. Clears
 	 * the history as well, if required.
 	 * 
 	 * @param cleanHistory
 	 *            remove old tracks until there is no more than
 	 *            {@link #historyLength} tracks in the history.
 	 */
 	private void populatePlaylist(final boolean cleanHistory) {
 		// populate the playlist
 		while (size() - currentTrack - 1 < upcomingTrackCount) {
 			if (!provider.hasNext()) {
 				break;
 			}
 			final TrackMetadataBean track = provider.next();
 			final PlaylistItem item = new PlaylistItem(track, 0, 0);
 			playlist.add(item);
 		}
 		// clean the history
 		if (cleanHistory) {
 			final int currentHistoryLength = currentTrack;
 			if (currentHistoryLength > historyLength) {
 				playlist.subList(0, currentHistoryLength - historyLength)
 						.clear();
 				provider
 						.removeFromHistory(currentHistoryLength - historyLength);
 				currentTrack = historyLength;
 			}
 		}
 	}
 
 	public List<PlaylistItem> getPlayItems() {
 		if (unmodifiablePlaylist == null) {
 			unmodifiablePlaylist = Collections.unmodifiableList(playlist);
 		}
 		return unmodifiablePlaylist;
 	}
 
 	public int size() {
 		return playlist.size();
 	}
 
 	public void shuffle() {
 		playlist.subList(firstUpcomingTrackIndex(), playlist.size()).clear();
 		populatePlaylist(true);
 	}
 
 	public void sortByAlbumOrder() {
 		Utils.sortPlaylistByAlbumOrder(playlist.subList(
 				firstUpcomingTrackIndex(), playlist.size()));
 	}
 
 	public void add(int index, List<TrackMetadataBean> tracks) {
 		int i = index;
 		final int firstUpcomingTrackIndex = firstUpcomingTrackIndex();
 		if (i < firstUpcomingTrackIndex)
 			i = firstUpcomingTrackIndex;
 		for (final TrackMetadataBean track : tracks) {
 			playlist.add(i++, new PlaylistItem(track, 0, 0));
 		}
 	}
 
 	public void setRandom(Random random) {
 		final TrackMetadataBean current = currentTrack < 0 ? null : playlist
 				.get(currentTrack).getTrack();
 		provider.setRandom(random, current);
 		this.random = random;
 		// if Random.ALBUM, remove all upcoming tracks
 		if (random.groupsByAlbum()) {
 			playlist.subList(firstUpcomingTrackIndex(), playlist.size())
 					.clear();
 			populatePlaylist(true);
 		}
 	}
 
 	/***
 	 * Tracks &lt;{@link #currentTrack} + 1 .. {@link #currentTrack} +
 	 * {@link #queuedCount}&gt; are currently queued.
 	 */
 	private int queuedCount = 0;
 
 	public List<Integer> getQueue() {
 		final List<Integer> result = new ArrayList<Integer>(queuedCount);
 		final int firstUpcomingTrackIndex = firstUpcomingTrackIndex();
 		for (int i = currentTrack + 1; i < firstUpcomingTrackIndex; i++) {
 			result.add(i);
 		}
 		return result;
 	}
 
 	public void clearQueue() {
 		final int firstUpcomingTrackIndex = firstUpcomingTrackIndex();
 		for (int i = currentTrack + 1; i < firstUpcomingTrackIndex; i++) {
 			playlist.get(i).queueOrder = 0;
 		}
 		queuedCount = 0;
 	}
 
 	public int getCurrentlyPlaying() {
 		return currentTrack;
 	}
 
 	private int firstUpcomingTrackIndex() {
 		return currentTrack + 1 + queuedCount;
 	}
 
 	public void dequeue(int track) {
 		dequeue(track, false);
 	}
 
 	private void dequeue(int track, boolean remove) {
 		final PlaylistItem item = playlist.get(track);
 		if (item.queueOrder == 0)
 			return;
 		if (!remove) {
 			playlist.add(firstUpcomingTrackIndex(), item);
 		}
 		item.queueOrder = 0;
 		playlist.remove(track);
 		queuedCount--;
 		final int firstUpcomingTrackIndex = firstUpcomingTrackIndex();
 		for (int i = track; i < firstUpcomingTrackIndex; i++) {
 			playlist.get(i).queueOrder--;
 		}
 	}
 
 	/***
 	 * Queues tracks with given indices.
 	 * 
 	 * @param indices
 	 *            the tracks to queue.
 	 */
 	private void queueIndices(final Iterable<? extends Integer> indices) {
 		final List<PlaylistItem> queue = new ArrayList<PlaylistItem>();
 		final List<PlaylistItem> toRemove = new ArrayList<PlaylistItem>();
 		// remove the queued tracks from playlist - these tracks will be added
 		// after last queued track.
 		for (final Integer index : indices) {
 			PlaylistItem item = playlist.get(index);
 			if (item.queueOrder != 0)
 				continue;
 			if (index.intValue() == currentTrack)
 				item = new PlaylistItem(item.getTrack(), 0, 0);
 			queue.add(item);
 			if (index.intValue() != currentTrack) {
 				toRemove.add(item);
 				if (index < currentTrack)
 					currentTrack--;
 			}
 		}
 		playlist.removeAll(toRemove);
 		// append the tracks and assign them the correct queue number
 		playlist.addAll(firstUpcomingTrackIndex(), queue);
 		for (final PlaylistItem item : queue) {
 			queuedCount++;
 			item.queueOrder = queuedCount;
 		}
 	}
 
 	public void queue(final Interval interval) {
 		queueIndices(interval);
 	}
 
 	public void reinit() {
 		playlist.clear();
 		currentTrack = -1;
 		provider.removeFromHistory(Integer.MAX_VALUE);
 		populatePlaylist(true);
 	}
 
 	public int peekNext() {
 		final int result = currentTrack + 1;
 		if (result >= playlist.size()) {
 			return -1;
 		}
 		return result;
 	}
 
 	public int next() {
 		currentTrack++;
 		for (int i = currentTrack; i < currentTrack + queuedCount; i++) {
 			playlist.get(i).queueOrder--;
 		}
 		if (queuedCount > 0) {
 			queuedCount--;
 		}
 		populatePlaylist(true);
 		return currentTrack;
 	}
 
 	public int play(int track) {
 		if (track != -1) {
 			final PlaylistItem item = playlist.get(track);
 			item.playCount++;
 		}
 		if (track == currentTrack)
 			return track;
 		if (track == -1) {
 			playlist.subList(0, currentTrack).clear();
 			currentTrack = -1;
 		} else {
 			final PlaylistItem item = playlist.get(track);
 			remove(Interval.fromItem(track));
 			playlist.add(currentTrack + 1, item);
 			currentTrack++;
 		}
 		return currentTrack;
 	}
 
 	public int previous() {
 		if (currentTrack != -1) {
 			final PlaylistItem item = playlist.get(currentTrack);
 			item.playCount++;
 		}
 		return currentTrack;
 	}
 
 	public void remove(final Interval interval) {
 		if (interval.contains(currentTrack)) {
 			// set currentTrack to -1; we need to remove history to do that
 			currentTrack = -1;
 			remove(new Interval(0, interval.end));
 		} else {
 			for (int index = interval.end; index >= interval.start; index--) {
 				final PlaylistItem item = playlist.get(index);
 				if (item.getQueueOrder() != 0) {
 					dequeue(index, true);
 				} else {
 					playlist.remove(index);
 					if (index < currentTrack)
 						currentTrack--;
 				}
 			}
 		}
 		populatePlaylist(true);
 	}
 
 	public Random getRandom() {
 		return random;
 	}
 
 	public Interval move(final Interval i, final int ti) {
 		if (i.end >= playlist.size()) {
 			throw new IllegalArgumentException("Interval " + i
 					+ " exceeds playlist: " + playlist.size());
 		}
 		if ((ti < 0) || (ti > playlist.size()))
 			throw new IllegalArgumentException("Invalid targetIndex: " + ti);
 		Object result = i.subtract(getPlayedOrQueued());
 		final Interval[] ints;
 		if (result instanceof Interval) {
 			ints = new Interval[] { (Interval) result };
 			if (ints[0].isEmpty())
 				return i;
 		} else {
 			ints = (Interval[]) result;
 		}
 		int targetIndex = ti;
 		final List<PlaylistItem> movedTracks = new ArrayList<PlaylistItem>();
 		for (int intsIndex = ints.length - 1; intsIndex >= 0; intsIndex--) {
 			final Interval cut = ints[intsIndex];
 			final List<PlaylistItem> cutTracks = playlist.subList(cut.start,
 					cut.end + 1);
 			movedTracks.addAll(0, cutTracks);
 			if (currentTrack > cut.end) {
 				currentTrack -= cut.length;
 			}
 			if (targetIndex > cut.end) {
 				targetIndex -= cut.length;
 			}
 			cutTracks.clear();
 		}
 		playlist.addAll(targetIndex, movedTracks);
 		return new Interval(targetIndex, movedTracks.size());
 	}
 
 	private Interval getPlayedOrQueued() {
 		int first = currentTrack;
 		int length = 1 + queuedCount;
 		if (currentTrack < 0) {
 			first = 0;
 			length--;
 		}
 		return new Interval(first, length);
 	}
 
 	/***
 	 * Returns current history size.
 	 * 
 	 * @return number of items in the history.
 	 */
 	public int getCurrentHistoryLength() {
 		return currentTrack < 0 ? 0 : currentTrack;
 	}
 
 	public Interval moveBy(final Interval interval, final int delta) {
 		if (interval.end >= playlist.size()) {
 			throw new IllegalArgumentException("Interval " + interval
 					+ " exceeds playlist: " + playlist.size());
 		}
 		if (delta == 0)
 			return interval;
 		final boolean down = delta > 0;
 		int target = !down ? interval.start : interval.end + 1;
 		target += delta;
 		final Interval playedOrQueued = getPlayedOrQueued();
 		if (playedOrQueued.contains(target) && (target != playedOrQueued.start)) {
 			target = down ? playedOrQueued.end + 1 : playedOrQueued.start;
 		}
 		if ((target < 0) || (target > size()))
 			return interval;
 		return move(interval, target);
 	}
 
 	public void replaceLocations(Map<String, String> locationMap) {
 		Utils.replaceLocations(playlist, locationMap);
 	}
 }