/***
    *     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 java.util.Queue;
  
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.Interval;
  
  /***
   * A regular, old-school playlist. Manages the song ordering in playlist and
   * queues. Supports shuffle and track repeat. Based on a 'static' list of
   * tracks.
   * 
   * @author Martin Vysny
   */
  public final class StaticPlaylistStrategy implements IPlaylistStrategy,
  		Serializable {
  
  	/***
  	 * 
  	 */
  	private static final long serialVersionUID = -8220847953995138930L;
  
  	/***
  	 * Creates new static playlist strategy, optionally mimicking given
  	 * strategy.
  	 * 
  	 * @param strategy
  	 *            the strategy to mimic. If <code>null</code> then an empty
  	 *            playlist is created.
  	 */
  	public StaticPlaylistStrategy(final IPlaylistStrategy strategy) {
  		super();
  		if (strategy != null) {
  			// copy tracks
  			playlist.addAll(strategy.getPlayItems());
  			playOrder = new ArrayList<PlaylistItem>(playlist);
  			// copy currently played track
  			play(strategy.getCurrentlyPlaying());
  			// copy random mode
  			setRandom(strategy.getRandom());
  			// copy queued tracks
  			final List<Integer> queue = strategy.getQueue();
  			for (final Integer i : queue) {
  				queue(Interval.fromItem(i));
  			}
  		}
  	}
  
  	/***
  	 * The playlist, as shown on screen and defined by the user.
  	 */
  	private final List<PlaylistItem> playlist = new ArrayList<PlaylistItem>();
  
  	/***
  	 * The unmodifiable link to the playlist.
  	 */
  	private transient List<PlaylistItem> unmodifiablePlaylist;
  
  	/***
  	 * Songs queued manually by the user. Items {@link Queue#poll() polled} from
  	 * the queue are to be played first.
  	 */
  	private final LinkedList<PlaylistItem> queue = new LinkedList<PlaylistItem>();
  
  	/***
  	 * <p>
  	 * The expected play order. If shuffle is disabled then this is equal to
  	 * {@link #playlist}. If shuffle is enabled then this is a permutated
  	 * version of the {@link #playlist}.
  	 * </p>
  	 */
  	private List<PlaylistItem> playOrder = new ArrayList<PlaylistItem>();
  
  	/***
  	 * Currently played song. Index to the {@link #playOrder} list.
  	 * <code>-1</code> if no song is currently being played.
 	 */
 	private int currentTrack = -1;
 
 	/***
 	 * Play tracks in this order.
 	 */
 	private Random random = Random.NONE;
 
 	public int getCurrentlyPlaying() {
 		if (currentTrack == -1)
 			return -1;
 		return playlist.indexOf(playOrder.get(currentTrack));
 	}
 
 	public void shuffle() {
 		final PlaylistItem current = getCurrentlyPlayingItem();
 		Collections.shuffle(playlist);
 		if (current != null) {
 			currentTrack = playOrder.indexOf(current);
 		}
 		randomizeTracks();
 	}
 
 	public int size() {
 		return playlist.size();
 	}
 
 	public void sortByAlbumOrder() {
 		final PlaylistItem current = getCurrentlyPlayingItem();
 		Utils.sortPlaylistByAlbumOrder(playlist);
 		if (current != null) {
 			currentTrack = playOrder.indexOf(current);
 		}
 		randomizeTracks();
 	}
 
 	public List<PlaylistItem> getPlayItems() {
 		if (unmodifiablePlaylist == null) {
 			unmodifiablePlaylist = Collections.unmodifiableList(playlist);
 		}
 		return unmodifiablePlaylist;
 	}
 
 	public void clearQueue() {
 		for (PlaylistItem item : queue) {
 			item.queueOrder = 0;
 		}
 		queue.clear();
 	}
 
 	public List<Integer> getQueue() {
 		final List<Integer> result = new ArrayList<Integer>(queue.size());
 		result.addAll(Collections.nCopies(queue.size(), 0));
 		for (int i = 0; i < playlist.size(); i++) {
 			final PlaylistItem item = playlist.get(i);
 			if (item.queueOrder != 0) {
 				result.set(item.queueOrder - 1, i);
 			}
 		}
 		return result;
 	}
 
 	public void setRandom(Random random) {
 		if (this.random == random)
 			return;
 		this.random = random;
 		randomizeTracks();
 	}
 
 	private PlaylistItem getCurrentlyPlayingItem() {
 		return currentTrack < 0 ? null : playOrder.get(currentTrack);
 	}
 
 	private void randomizeTracks() {
 		final PlaylistItem current = getCurrentlyPlayingItem();
 		playOrder = Random.randomize(random, playlist,
 				currentTrack == -1 ? null : playOrder.get(currentTrack));
 		if (current != null) {
 			currentTrack = playOrder.indexOf(current);
 		}
 	}
 
 	public void remove(final Interval interval) {
 		remove(interval, true);
 	}
 
 	/***
 	 * Removes given tracks.
 	 * 
 	 * @param interval
 	 *            tracks to remove
 	 * @param deregister
 	 *            if <code>true</code> then the tracks are dequeued and
 	 *            current track pointer is reset if needed.
 	 */
 	private void remove(final Interval interval, final boolean deregister) {
 		for (int index = interval.end; index >= interval.start; index--) {
 			final PlaylistItem item = playlist.get(index);
 			if (deregister) {
 				dequeue(index);
 			}
 			final int playOrderIndex = playOrder.indexOf(item);
 			if (currentTrack == playOrderIndex) {
 				currentTrack = -1;
 			}
 			if (playOrderIndex < currentTrack)
 				currentTrack--;
 			playOrder.remove(playOrderIndex);
 			playlist.remove(index);
 		}
 	}
 
 	public void add(int i, List<TrackMetadataBean> tracks) {
 		final PlaylistItem current = getCurrentlyPlayingItem();
 		int index = i;
 		for (final TrackMetadataBean track : tracks) {
 			final PlaylistItem item = new PlaylistItem(track, 0, 0);
 			playlist.add(index++, item);
 		}
 		if (current != null) {
 			currentTrack = playOrder.indexOf(current);
 		}
 		randomizeTracks();
 	}
 
 	public void dequeue(int track) {
 		final PlaylistItem item = playlist.get(track);
 		dequeue(item);
 	}
 
 	private void dequeue(PlaylistItem item) {
 		final int queueIndex = queue.indexOf(item);
 		if (queueIndex < 0)
 			return;
 		queue.remove(queueIndex);
 		item.queueOrder = 0;
 		for (int i = queueIndex; i < queue.size(); i++) {
 			queue.get(i).queueOrder--;
 		}
 	}
 
 	public void queue(final Interval tracksToQueue) {
 		for (int track = tracksToQueue.start; track <= tracksToQueue.end; track++) {
 			final PlaylistItem item = playlist.get(track);
 			if (queue.contains(item))
 				continue;
 			queue.add(item);
 			item.queueOrder = queue.size();
 		}
 	}
 
 	public void reinit() {
 		currentTrack = -1;
 		playOrder = Random.randomize(random, playlist, null);
 		clearQueue();
 	}
 
 	public int peekNext() {
 		if (!queue.isEmpty()) {
 			final PlaylistItem item = queue.peek();
 			final int index = playlist.indexOf(item);
 			return index;
 		}
 		int result = currentTrack + 1;
 		if (result >= playOrder.size()) {
 			return -1;
 		}
 		final PlaylistItem item = playOrder.get(result);
 		return playlist.indexOf(item);
 	}
 
 	public int next() {
 		if (!queue.isEmpty()) {
 			final PlaylistItem item = queue.peek();
 			final int index = playOrder.indexOf(item);
 			dequeue(item);
 			item.playCount++;
 			currentTrack = index;
 			return playlist.indexOf(item);
 		}
 		currentTrack++;
 		if (currentTrack >= playOrder.size()) {
 			currentTrack = -1;
 			randomizeTracks();
 			return -1;
 		}
 		final PlaylistItem item = playOrder.get(currentTrack);
 		item.playCount++;
 		return playlist.indexOf(item);
 	}
 
 	public int play(int track) {
 		if (track == -1) {
 			currentTrack = -1;
 			randomizeTracks();
 		} else {
 			final PlaylistItem item = playlist.get(track);
 			currentTrack = playOrder.indexOf(item);
 			item.playCount++;
 		}
 		return track;
 	}
 
 	public int previous() {
 		if (currentTrack < 0) {
 			currentTrack = playOrder.size() - 1;
 		} else {
 			currentTrack--;
 		}
 		if (currentTrack < 0) {
 			randomizeTracks();
 			return currentTrack;
 		}
 		final PlaylistItem item = playOrder.get(currentTrack);
 		item.playCount++;
 		return playlist.indexOf(item);
 	}
 
 	public Random getRandom() {
 		return random;
 	}
 
 	public Interval move(Interval interval, int target) {
 		int targetIndex = target;
 		final PlaylistItem currentlyPlayedItem = getCurrentlyPlayingItem();
 		final List<PlaylistItem> movedTracks = new ArrayList<PlaylistItem>(
 				playlist.subList(interval.start, interval.end + 1));
 		remove(interval, false);
 		if (targetIndex > interval.end)
 			targetIndex -= interval.length;
 		final Interval result = new Interval(targetIndex, interval.length);
 		for (final PlaylistItem track : movedTracks) {
 			playlist.add(targetIndex++, track);
 		}
 		if (currentlyPlayedItem != null) {
 			currentTrack = playOrder.indexOf(currentlyPlayedItem);
 		}
 		randomizeTracks();
 		return result;
 	}
 
 	public Interval moveBy(final Interval interval, final int delta) {
 		if (delta == 0)
 			return interval;
 		final boolean down = delta > 0;
 		final int maxMove = !down ? interval.start : playlist.size()
 				- interval.end - 1;
 		if (maxMove <= 0)
 			return interval;
 		int absDelta = Math.abs(delta);
 		if (absDelta > maxMove)
 			absDelta = maxMove;
 		if (down) {
 			return move(interval, interval.end + absDelta + 1);
 		}
 		return move(interval, interval.start - absDelta);
 	}
 
 	public void replaceLocations(Map<String, String> locationMap) {
 		Utils.replaceLocations(playlist, locationMap);
 	}
 }