/***
    *     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.util.ArrayList;
  import java.util.List;
  
  import junit.framework.TestCase;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.collection.TrackOriginEnum;
  import sk.baka.ambient.collection.TrackMetadataBean.Builder;
  import sk.baka.ambient.commons.Interval;
  
  /***
   * Common utility methods for testing a playlist strategy.
   * 
   * @author mvy
   */
  public abstract class AbstractPlaylistStrategyTest extends TestCase {
  	/***
  	 * Returns the strategy instance.
  	 * 
  	 * @return the strategy instance. The strategy playlist must be empty.
  	 */
  	protected abstract IPlaylistStrategy getStrategy();
  
  	/***
  	 * Contains 30 test tracks.
  	 */
  	protected List<TrackMetadataBean> tracks;
  
  	/***
  	 * The strategy instance being tested.
  	 */
  	protected IPlaylistStrategy strategy;
  
  	@Override
  	protected void setUp() throws Exception {
  		super.setUp();
  		tracks = new ArrayList<TrackMetadataBean>();
  		for (int i = 0; i < 30; i++) {
  			final Builder track = TrackMetadataBean.newBuilder();
  			track.setOrigin(TrackOriginEnum.LocalFs).setLocation(
  					"/sdcard/" + i + ".mp3");
  			track.setLength(100 * i).setFileSize(100 * i);
  			tracks.add(track.build(i));
  		}
  		strategy = getStrategy();
  	}
  
  	/***
  	 * @throws Exception
  	 */
  	public void testEmptyPlaylist() throws Exception {
  		assertEquals(0, strategy.size());
  		assertEquals(-1, strategy.previous());
  	}
  
  	/***
  	 * @throws Exception
  	 */
  	public void testAdding30Tracks() throws Exception {
  		strategy.add(0, tracks);
  		assertEquals(tracks, strategy.getPlayItems());
  	}
  
  	/***
  	 * @throws Exception
  	 */
  	public void testQueuingTracks() throws Exception {
  		for (final Random r : Random.values()) {
  			strategy = getStrategy();
  			strategy.setRandom(r);
  			strategy.add(0, tracks);
  			// queue 5 tracks
  			Interval queueInterval = new Interval(5, 5);
  			strategy.queue(queueInterval);
  			assertEquals(tracks.size(), strategy.size());
  			assertEqualsQueue(tracks.subList(5, 10));
  			verifyQueueProperties(5);
  			// queue another 5 tracks
  			queueInterval = new Interval(15, 5);
  			strategy.queue(queueInterval);
  			List<TrackMetadataBean> expectedQueue = new ArrayList<TrackMetadataBean>(
 					tracks.subList(5, 10));
 			expectedQueue.addAll(tracks.subList(15, 20));
 			assertEqualsQueue(expectedQueue);
 			verifyQueueProperties(10);
 		}
 	}
 
 	/***
 	 */
 	public void testPlayingQueuedTracks() {
 		for (final Random r : Random.values()) {
 			strategy = getStrategy();
 			strategy.setRandom(r);
 			strategy.add(0, tracks);
 			// queue 5 tracks
 			Interval queueInterval = new Interval(5, 5);
 			strategy.queue(queueInterval);
 			assertNextTracks(tracks.subList(5, 10), false);
 			verifyQueueProperties(0);
 			strategy.next();
 			verifyQueueProperties(0);
 		}
 	}
 
 	/***
 	 * Asserts that next x tracks will be in same ordering as in the
 	 * <code>tracks</code> list.
 	 * 
 	 * @param tracks
 	 *            expect this ordering when playing next tracks.
 	 * @param playlistEnd
 	 *            if <code>true</code> then the playlist must end after given
 	 *            tracks.
 	 */
 	protected void assertNextTracks(final List<TrackMetadataBean> tracks,
 			boolean playlistEnd) {
 		for (final TrackMetadataBean track : tracks) {
 			final int trackIndex = strategy.next();
 			assertEquals(trackIndex, strategy.getCurrentlyPlaying());
 			assertTrue("There should be more tracks to play", trackIndex >= 0);
 			assertEquals(track, strategy.getPlayItems().get(trackIndex).track);
 		}
 		if (playlistEnd) {
 			final int i = strategy.next();
 			if (i >= 0) {
 				fail("There are items left in the playlist; "
 						+ getCurrentlyPlaying());
 			}
 		}
 	}
 
 	/***
 	 * Compares current {@link #strategy}
 	 * {@link IPlaylistStrategy#getPlayItems()} to tracks in {@link #tracks}.
 	 * 
 	 * @param trackNumbers
 	 *            indexes to the {@link #tracks} list. <code>null</code>
 	 *            values are skipped.
 	 * @param startIndex
 	 *            where to start
 	 */
 	protected void assertTracks(final List<Integer> trackNumbers, int startIndex) {
 		int i = startIndex;
 		for (final Integer index : trackNumbers) {
 			if (index != null) {
 				final TrackMetadataBean expected = tracks.get(index);
 				final TrackMetadataBean got = strategy.getPlayItems().get(i).track;
 				assertEquals(expected, got);
 			}
 			i++;
 		}
 	}
 
 	/***
 	 * Asserts that next x tracks matches tracks in given <code>tracks</code>
 	 * list. The number of tracks must match, however the track ordering is
 	 * irrelevant (as opposed to {@link #assertNextTracks(List, boolean)}).
 	 * 
 	 * @param tracks
 	 *            expect these tracks when playing next tracks.
 	 * @param playlistEnd
 	 *            if <code>true</code> then the playlist must end after given
 	 *            tracks.
 	 */
 	protected void assertNextTracksUnordered(
 			final List<TrackMetadataBean> tracks, boolean playlistEnd) {
 		final List<TrackMetadataBean> tracks_ = new ArrayList<TrackMetadataBean>(
 				tracks);
 		while (!tracks_.isEmpty()) {
 			final int trackIndex = strategy.next();
 			assertTrue("No more tracks - tracks not present in the playlist: "
 					+ tracks_, trackIndex >= 0);
 			final TrackMetadataBean track = strategy.getPlayItems().get(
 					trackIndex).track;
 			assertTrue(
 					"Track "
 							+ track
 							+ " was provided by the playlist but not present in the track list",
 					tracks_.remove(track));
 		}
 		if (playlistEnd) {
 			assertEquals("There are items left in the playlist; "
 					+ getCurrentlyPlaying(), -1, strategy.next());
 		}
 	}
 
 	/***
 	 * Checks if the queue has correct queue count etc.
 	 * 
 	 * @param expectedQueueLength
 	 */
 	protected void verifyQueueProperties(final int expectedQueueLength) {
 		final List<Integer> queue = strategy.getQueue();
 		assertEquals(expectedQueueLength, queue.size());
 		// check queuedCount of queued items
 		for (int i = 0; i < queue.size(); i++) {
 			final PlaylistItem pi = strategy.getPlayItems().get(queue.get(i));
 			assertEquals(pi.toString() + " must be queued", i + 1,
 					pi.queueOrder);
 		}
 		// verify that unqueued tracks have queuedCount of zero
 		for (int i = 0; i < strategy.getPlayItems().size(); i++) {
 			if (queue.contains(i))
 				continue;
 			final PlaylistItem pi = strategy.getPlayItems().get(i);
 			assertEquals(pi.toString() + " must not be queued", 0,
 					pi.queueOrder);
 		}
 	}
 
 	/***
 	 * Compares given track list with a playlist.
 	 * 
 	 * @param expected
 	 *            the expected track list
 	 * @param actual
 	 *            the playlist
 	 */
 	public static void assertEquals(
 			final List<? extends TrackMetadataBean> expected,
 			final List<? extends PlaylistItem> actual) {
 		for (int i = 0; i < expected.size(); i++) {
 			assertEquals("At index i=" + i, expected.get(i), actual.get(i)
 					.getTrack());
 		}
 		assertEquals(expected.size(), actual.size());
 	}
 
 	/***
 	 * Compares given track list with a playlist.
 	 * 
 	 * @param expected
 	 *            the expected track list
 	 */
 	protected void assertEqualsQueue(
 			final List<? extends TrackMetadataBean> expected) {
 		final List<? extends Integer> actual = strategy.getQueue();
 		assertEquals(expected.size(), actual.size());
 		for (int i = 0; i < expected.size(); i++) {
 			assertEquals(expected.get(i), strategy.getPlayItems().get(
 					actual.get(i)).getTrack());
 		}
 	}
 
 	/***
 	 * Asserts that given list has given content.
 	 * 
 	 * @param expected
 	 * @param actual
 	 */
 	public static void assertEquals(final Object[] expected,
 			final List<?> actual) {
 		assertEquals(expected.length, actual.size());
 		for (int i = 0; i < expected.length; i++) {
 			assertEquals(expected[i], actual.get(i));
 		}
 	}
 
 	/***
 	 */
 	public void testPlaySameTrack() {
 		strategy.add(0, tracks);
 		strategy.play(6);
 		int i = strategy.getCurrentlyPlaying();
 		// the currently played track may not be the 6th track in case of the
 		// dynamic playlist
 		assertTrue(i >= 0);
 		strategy.play(i);
 		assertEquals(i, strategy.getCurrentlyPlaying());
 		strategy.play(-1);
 		assertEquals(-1, strategy.getCurrentlyPlaying());
 		strategy.play(-1);
 		assertEquals(-1, strategy.getCurrentlyPlaying());
 	}
 
 	/***
 	 * 
 	 */
 	public void testNormalOrder() {
 		strategy.add(0, tracks);
 		assertNextTracks(tracks, false);
 	}
 
 	/***
 	 */
 	public void testRemovingPlayedTrackRandom() {
 		strategy.setRandom(Random.TRACK);
 		strategy.add(0, tracks);
 		strategy.play(strategy.size() - 1);
 		strategy.remove(new Interval(0, strategy.size()));
 		assertEquals(-1, strategy.getCurrentlyPlaying());
 	}
 
 	/***
 	 */
 	public void testRemovingTracksPreservesCurrentlyPlayedTrack() {
 		strategy.add(0, tracks);
 		strategy.play(15);
 		TrackMetadataBean track = getCurrentlyPlaying();
 		strategy.remove(new Interval(20, 5));
 		assertEquals(track, getCurrentlyPlaying());
 		strategy.remove(new Interval(5, 5));
 		assertEquals(track, getCurrentlyPlaying());
 	}
 
 	/***
 	 * Returns {@link #strategy strategy} currently played track.
 	 * 
 	 * @return never <code>null</code>. Fails if no track is being played.
 	 */
 	protected TrackMetadataBean getCurrentlyPlaying() {
 		final int i = strategy.getCurrentlyPlaying();
 		assertTrue("No track is being played", i >= 0);
 		return strategy.getPlayItems().get(i).getTrack();
 	}
 
 	/***
 	 * 
 	 */
 	public void testSetRandomModePreservesCurrentTrack() {
 		strategy.add(0, tracks);
 		strategy.next();
 		strategy.next();
 		strategy.next();
 		TrackMetadataBean old = getCurrentlyPlaying();
 		strategy.setRandom(Random.TRACK);
 		assertEquals(old, getCurrentlyPlaying());
 		strategy.setRandom(Random.ALBUM);
 		assertEquals(old, getCurrentlyPlaying());
 		strategy.setRandom(Random.NONE);
 		assertEquals(old, getCurrentlyPlaying());
 	}
 }