/***
    *     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;
  
  import java.util.Collections;
  import java.util.List;
  import java.util.Map;
  
  import sk.baka.ambient.AppState.IAppStateAware;
  import sk.baka.ambient.collection.IDynamicPlaylistTrackProvider;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.collection.TrackOriginEnum;
  import sk.baka.ambient.collection.local.MediaStoreTrackProvider;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.playerservice.IPlayer;
  import sk.baka.ambient.playerservice.IPlayerListener;
  import sk.baka.ambient.playerservice.PlayerService;
  import sk.baka.ambient.playerservice.PlayerStateEnum;
  import sk.baka.ambient.playlist.DynamicPlaylistStrategy;
  import sk.baka.ambient.playlist.IPlaylistStrategy;
  import sk.baka.ambient.playlist.PlaylistItem;
  import sk.baka.ambient.playlist.Random;
  import sk.baka.ambient.playlist.Repeat;
  import sk.baka.ambient.playlist.StaticPlaylistStrategy;
  import sk.baka.ambient.playlist.Utils;
  import android.content.ComponentName;
  import android.content.Context;
  import android.content.Intent;
  import android.content.ServiceConnection;
  import android.os.Handler;
  import android.os.IBinder;
  
  /***
   * This is THE component :) Combines player and playlist. Emits
   * {@link IPlaylistPlayerListener} messages.
   * 
   * @author Martin Vysny
   */
  public final class PlaylistPlayer implements IPlaylistStrategy, IAppStateAware {
  	/***
  	 * The player service invocator.
  	 */
  	IPlayer playerService;
  
  	/***
  	 * Receives value of {@link #playerService}.
  	 */
  	private final ServiceConnection serviceConnection = new ServiceConnection() {
  		public void onServiceConnected(ComponentName name, IBinder service) {
  			playerService = IPlayer.Stub.asInterface(service);
  			// okay, player connected. we can now restore the state if needed
  			final AppState state = app.getStateHandler().getStartupState();
  			reinit(state);
  		}
  
  		public void onServiceDisconnected(ComponentName arg0) {
  			// do nothing, we will never be disconnected from a local service
  		}
  	};
  
  	/***
  	 * Creates new player instance.
  	 * 
  	 * @param app
  	 *            the application instance.
  	 */
  	PlaylistPlayer(final AmbientApplication app) {
  		app.bindService(new Intent(app, PlayerService.class),
  				serviceConnection, Context.BIND_AUTO_CREATE);
  		app.getBus().addHandler(listener);
  		this.app = app;
  		errHandler = new PlaylistPlayerErrorHandler(this);
  	}
  
  	private final AmbientApplication app;
  	
  	private final PlaylistPlayerErrorHandler errHandler;
  
  	/***
  	 * Stops the playback. Does nothing if the player is inactive.
  	 */
  	public void stop() {
  		try {
  			playerService.stop();
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 		errHandler.cancelLocationResolving();
 		invokePlaybackStateChanged();
 	}
 
 	/***
 	 * Returns the playback state.
 	 * 
 	 * @return the playback state.
 	 */
 	public PlayerStateEnum getPlaybackState() {
 		if (playerService == null) {
 			// this is only possible when the application is starting. The
 			// playback will be stopped.
 			return PlayerStateEnum.Stopped;
 		}
 		try {
 			return PlayerStateEnum.values()[playerService.getPlaybackState()];
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	/***
 	 * Pauses the player, or resumes playback if the player was paused. Does
 	 * nothing if the player is stopped.
 	 */
 	public void pause() {
 		try {
 			playerService.pause();
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 		invokePlaybackStateChanged();
 	}
 
 	/***
 	 * Seeks to given position. If the position is invalid then the result is
 	 * undefined. Does nothing if the playback is stopped.
 	 * 
 	 * @param position
 	 *            Seek to this position in milliseconds.
 	 */
 	public void seek(int position) {
 		try {
 			final boolean seekChanged = playerService.seek(position);
 			if (seekChanged) {
 				getBusInvocator().trackPositionChanged(position,
 						getPlaybackState() == PlayerStateEnum.Playing);
 			}
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	/***
 	 * The playlist backend.
 	 */
 	private IPlaylistStrategy playlist;
 
 	/***
 	 * Adds track to the playlist after given track
 	 * 
 	 * @param index
 	 *            insert given track after track with this index.
 	 * 
 	 * @param track
 	 *            the track to add.
 	 */
 	public void add(int index, TrackMetadataBean track) {
 		add(index, Collections.singletonList(track));
 	}
 
 	public void add(int index, List<TrackMetadataBean> tracks) {
 		playlist.add(index, tracks);
 		// TODO vyzivus: compute the interval of added tracks correctly
 		getBusInvocator().playlistChanged(null);
 	}
 
 	private IPlaylistPlayerListener getBusInvocator() {
 		return app.getBus().getInvocator(IPlaylistPlayerListener.class, true);
 	}
 
 	/***
 	 * Adds track to the end of the playlist.
 	 * 
 	 * @param track
 	 *            the track to add.
 	 */
 	public void add(TrackMetadataBean track) {
 		add(playlist.size(), track);
 	}
 
 	public void clearQueue() {
 		playlist.clearQueue();
 		getBusInvocator().playlistChanged(null);
 	}
 
 	public void dequeue(int track) {
 		playlist.dequeue(track);
 	}
 
 	public int getCurrentlyPlaying() {
 		return playlist.getCurrentlyPlaying();
 	}
 
 	/***
 	 * Returns currently playing track.
 	 * 
 	 * @return current track or <code>null</code> if no track is being played (
 	 *         {@link #getCurrentlyPlaying()} returns <code>-1</code>).
 	 */
 	public TrackMetadataBean getCurrentlyPlayingTrack() {
 		if (playlist == null)
 			return null;
 		final int current = playlist.getCurrentlyPlaying();
 		return current < 0 ? null : playlist.getPlayItems().get(current)
 				.getTrack();
 	}
 
 	/***
 	 * Returns currently playing track.
 	 * 
 	 * @return current track or <code>null</code> if no track is being played (
 	 *         {@link #getCurrentlyPlaying()} returns <code>-1</code>).
 	 */
 	public PlaylistItem getCurrentlyPlayingItem() {
 		final int current = playlist.getCurrentlyPlaying();
 		return current < 0 ? null : playlist.getPlayItems().get(current);
 	}
 
 	public List<PlaylistItem> getPlayItems() {
 		return playlist.getPlayItems();
 	}
 
 	public int next() {
 		final int track = playlist.next();
 		final boolean playing = getPlaybackState() != PlayerStateEnum.Stopped;
 		if (playing) {
 			psPlay(track, 0);
 		}
 		invokeTrackChanged(playing, 0);
 		return track;
 	}
 
 	public int play(int trackToPlay) {
 		return playWithSeek(trackToPlay, 0);
 	}
 
 	/***
 	 * Plays given track. The playback continues from this track forward, unless
 	 * random play is activated.
 	 * 
 	 * @param trackToPlay
 	 *            the track to play. Index to the {@link #getPlayItems()} list.
 	 *            If <code>-1</code> then the current track pointer is moved
 	 *            before first track and the playback is stopped.
 	 * @param startSeekMillis
 	 *            start playback here. Ignored when the stream is not seekable.
 	 * @return the track that is being played.
 	 */
 	public int playWithSeek(final int trackToPlay, final int startSeekMillis) {
 		final int track = playlist.play(trackToPlay);
 		psPlay(track, startSeekMillis);
 		invokeTrackChanged(true, startSeekMillis);
 		return track;
 	}
 
 	/***
 	 * Plays current track from the beginning.
 	 */
 	public void play() {
 		playWithSeek(0);
 	}
 
 	/***
 	 * Plays current track from the beginning.
 	 * 
 	 * @param startSeekMillis
 	 *            start playback here. Ignored when the stream is not seekable.
 	 */
 	public void playWithSeek(final int startSeekMillis) {
 		playWithSeek(getCurrentlyPlaying(), startSeekMillis);
 	}
 
 	public int previous() {
 		final int track = playlist.previous();
 		final boolean playing = getPlaybackState() != PlayerStateEnum.Stopped;
 		if (playing) {
 			psPlay(track, 0);
 		}
 		invokeTrackChanged(playing, 0);
 		return track;
 	}
 
 	/***
 	 * Requests the player service to play given track. The {@link #playlist} is not updated.
 	 * @param track the track to play.
 	 * @param startSeekMillis start seek time, in milliseconds.
 	 */
 	void psPlay(int track, int startSeekMillis) {
 		if (track < 0) {
 			stop();
 			return;
 		}
 		final TrackMetadataBean bean = playlist.getPlayItems().get(track)
 				.getTrack();
 		try {
 			playerService.play(bean.getLocation(), bean.getOrigin().ordinal(),
 					startSeekMillis);
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	/***
 	 * Queues given track, after all other queued tracks. Does nothing if the
 	 * track is already queued.
 	 * 
 	 * @param track
 	 *            the track to queue, index to the {@link #getPlayItems()} list.
 	 */
 	public void queue(int track) {
 		queue(Interval.fromItem(track));
 	}
 
 	public void queue(final Interval tracks) {
 		if (tracks.isEmpty())
 			return;
 		playlist.queue(tracks);
 		getBusInvocator().playlistChanged(null);
 	}
 
 	public void reinit() {
 		playlist.reinit();
 	}
 
 	/***
 	 * Removes a track with given index from the playlist.
 	 * 
 	 * @param index
 	 *            the index.
 	 * @return the removed track. If currently played track is removed then the
 	 *         playlist should move to play a next song.
 	 */
 	public PlaylistItem remove(final int index) {
 		final PlaylistItem result = playlist.getPlayItems().get(index);
 		playlist.remove(Interval.fromItem(index));
 		getBusInvocator().playlistChanged(Interval.EMPTY);
 		return result;
 	}
 
 	/***
 	 * Returns <code>true</code> if the playlist is a dynamic playlist.
 	 * 
 	 * @return <code>true</code> if current playlist is dynamic.
 	 */
 	public boolean isDynamic() {
 		return playlist instanceof DynamicPlaylistStrategy;
 	}
 
 	public void remove(Interval interval) {
 		if (interval.isEmpty())
 			return;
 		playlist.remove(interval);
 		getBusInvocator().playlistChanged(Interval.EMPTY);
 	}
 
 	public void setRandom(Random random) {
 		setRandomRepeat(random, repeat);
 	}
 
 	public Random getRandom() {
 		return random;
 	}
 
 	public void shuffle() {
 		playlist.shuffle();
 		getBusInvocator().playlistChanged(null);
 	}
 
 	public int size() {
 		return playlist.size();
 	}
 
 	public void sortByAlbumOrder() {
 		playlist.sortByAlbumOrder();
 		getBusInvocator().playlistChanged(null);
 	}
 
 	/***
 	 * Changes the playlist backend to be a dynamic playlist. The playlist is
 	 * populated automatically.
 	 */
 	public void dynamicPlaylist() {
 		if (playlist instanceof DynamicPlaylistStrategy) {
 			return;
 		}
 		// TODO vyzivus maybe make this configurable?
 		final IDynamicPlaylistTrackProvider provider = new MediaStoreTrackProvider(
 				Random.ALBUM);
 		playlist = new DynamicPlaylistStrategy(provider, playlist, app
 				.getStateHandler().getConfig().dynamicHistorySize, app
 				.getStateHandler().getConfig().dynamicUpcomingSize);
 		getBusInvocator().playlistChanged(null);
 	}
 
 	/***
 	 * Changes the playlist backend to be an empty static playlist.
 	 */
 	public void staticPlaylist() {
 		if (playlist instanceof StaticPlaylistStrategy)
 			return;
 		playlist = new StaticPlaylistStrategy(playlist);
 	}
 
 	/***
 	 * Closes and deactivates the player. The instance is no more usable.
 	 */
 	public void close() {
 		errHandler.close();
 		app.unbindService(serviceConnection);
 		app.getBus().removeHandler(listener);
 	}
 
 	private final Listener listener = new Listener();
 
 	private final Handler handler = AmbientApplication.getHandler();
 
 	private final class Listener implements IPlayerListener,
 			IApplicationListener, Runnable {
 
 		public void stateChanged(AppState state) {
 			// do nothing
 		}
 
 		public void started(String file, int duration, int currentPosition) {
 			errHandler.handleSuccess();
 			getBusInvocator().playbackStateChanged(PlayerStateEnum.Playing);
 		}
 
 		private boolean isQueued(int track) {
 			if (track < 0) {
 				return false;
 			}
 			return playlist.getPlayItems().get(track).getQueueOrder() > 0;
 		}
 
 		public void stopped(String error, boolean missing,
 				TrackOriginEnum origin) {
 			// on error show notification
 			if (error != null) {
 				errHandler.handleError(error, missing, origin);
 				return;
 			}
 			// tell the player to play next song from the playlist.
 			if (repeat == Repeat.TRACK) {
 				playWithGap();
 				return;
 			}
 			final TrackMetadataBean prevTrack = getCurrentlyPlayingTrack();
 			int track = playlist.peekNext();
 			final boolean isNextQueued = isQueued(track);
 			if ((repeat == Repeat.ALBUM) && (prevTrack != null)
 					&& !isNextQueued) {
 				if (isDynamic()) {
 					// TODO vyzivus
 				} else {
 					// the album is going to be switched?
 					final TrackMetadataBean newTrack = track == -1 ? null
 							: playlist.getPlayItems().get(track).getTrack();
 					if ((newTrack == null)
 							|| (!newTrack.getAlbum().equals(
 									prevTrack.getAlbum()))) {
 						// find first song of given album.
 						final List<PlaylistItem> tracks = Utils.filterOnAlbum(
 								playlist.getPlayItems(), prevTrack.getAlbum());
 						if (!tracks.isEmpty()) {
 							Utils.sortPlaylistByAlbumOrder(tracks);
 							final PlaylistItem first = tracks.get(0);
 							final int firstIndex = playlist.getPlayItems()
 									.indexOf(first);
 							playWithGap(firstIndex);
 							return;
 						}
 					}
 				}
 				// continue normally with the next track.
 			}
 			track = playlist.next();
 			if (track != -1) {
 				playWithGap();
 				return;
 			}
 			// end of the playlist.
 			if ((repeat == Repeat.NO) || (playlist.size() == 0)) {
 				// nothing more to play
 				invokePlaybackStateChanged();
 				return;
 			}
 			// try playing first track.
 			if (next() != -1) {
 				playWithGap();
 			}
 		}
 
 		public void configChanged(ConfigurationBean config) {
 			if (isDynamic()) {
 				final DynamicPlaylistStrategy p = (DynamicPlaylistStrategy) playlist;
 				p.setHistoryLength(config.dynamicHistorySize);
 				p.setUpcomingTrackCount(config.dynamicUpcomingSize);
 				getBusInvocator().playlistChanged(null);
 			}
 		}
 
 		private void playWithGap() {
 			playWithGap(null);
 		}
 
 		private volatile Integer desiredTrack;
 
 		private void playWithGap(final Integer track) {
 			desiredTrack = track;
 			final long gap = app.getStateHandler().getConfig().playerGap;
 			if (gap == 0) {
 				run();
 				return;
 			}
 			handler.removeCallbacks(this);
 			handler.postDelayed(this, gap);
 		}
 
 		public void run() {
 			if (desiredTrack == null) {
 				play();
 			} else {
 				play(desiredTrack);
 			}
 		}
 
 		public void clipboardChanged() {
 			// do nothing
 		}
 
 		public void radioNewTrack(String name) {
 			// do nothing
 		}
 
 		public void buffered(byte percent) {
 			// do nothing
 		}
 
 		public void offline(boolean offline) {
 			if (offline) {
 				final TrackMetadataBean track = getCurrentlyPlayingTrack();
 				if ((track != null) && !track.isLocal()) {
 					stop();
 				}
 			}
 		}
 	}
 
 	/***
 	 * The repeat mode.
 	 */
 	private Repeat repeat = Repeat.NO;
 
 	/***
 	 * Random mode as selected by user.
 	 */
 	private Random random = Random.NONE;
 
 	private void setRandomRepeat(final Random random, final Repeat repeat) {
 		if (random == null)
 			throw new IllegalArgumentException("null random");
 		if (repeat == null)
 			throw new IllegalArgumentException("null repeat");
 		// static playlist: if repeat album is selected, a special processing
 		// needs to be employed, to ensure that the entire disc is played
 		// correctly.
 		Random strategyRandom = random;
 		if (!isDynamic() && (repeat == Repeat.ALBUM)) {
 			// we need to group the playorder by albums, to make sure that the
 			// entire disc is played correctly.
 			if (random == Random.NONE) {
 				strategyRandom = Random.ALBUM_PLAYLIST;
 			} else if (random == Random.TRACK) {
 				strategyRandom = Random.ALBUM_TRACK;
 			}
 		}
 		playlist.setRandom(strategyRandom);
 		if (this.random != random) {
 			this.random = random;
 			getBusInvocator().randomChanged(random);
 			if (isDynamic()) {
 				// the playlist may have been changed as well
 				getBusInvocator().playlistChanged(null);
 			}
 		}
 		if (this.repeat != repeat) {
 			this.repeat = repeat;
 			getBusInvocator().repeatChanged(repeat);
 		}
 	}
 
 	/***
 	 * Sets the repeat mode.
 	 * 
 	 * @param repeat
 	 *            repeat mode, must not be <code>null</code>.
 	 */
 	public void setRepeat(final Repeat repeat) {
 		setRandomRepeat(random, repeat);
 	}
 
 	/***
 	 * Returns the repeat mode.
 	 * 
 	 * @return repeat mode, must not be <code>null</code>.
 	 */
 	public Repeat getRepeat() {
 		return repeat;
 	}
 
 	private void invokePlaybackStateChanged() {
 		final PlayerStateEnum state = getPlaybackState();
 		getBusInvocator().playbackStateChanged(state);
 	}
 
 	private void invokeTrackChanged(final boolean play, final int positionMillis) {
 		final PlaylistItem item = getCurrentlyPlayingItem();
 		getBusInvocator().trackChanged(item, play, positionMillis);
 		if (isDynamic()) {
 			getBusInvocator().playlistChanged(null);
 		}
 	}
 
 	/***
 	 * Returns current position in millis of the playback. Returns 0 if the
 	 * playback is stopped.
 	 * 
 	 * @return current player position in millis.
 	 */
 	public int getPosition() {
 		try {
 			return playerService.getPosition();
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	public List<Integer> getQueue() {
 		return playlist.getQueue();
 	}
 
 	public Interval move(Interval interval, int targetIndex) {
 		if (interval.isEmpty() || interval.contains(targetIndex))
 			return interval;
 		final Interval result = playlist.move(interval, targetIndex);
 		getBusInvocator().playlistChanged(result);
 		return result;
 	}
 
 	/***
 	 * Finds given track in the playlist and activates it. If the track is not
 	 * found then track is deselected.
 	 * 
 	 * @param track
 	 *            the track to activate, may be <code>null</code>.
 	 */
 	private void setActive(final TrackMetadataBean track) {
 		if ((track == null) || isDynamic()) {
 			playlist.play(-1);
 		} else {
 			final List<PlaylistItem> items = playlist.getPlayItems();
 			for (int i = 0; i < items.size(); i++) {
 				final PlaylistItem item = items.get(i);
 				if (item.getTrack().equals(track)) {
 					playlist.play(i);
 					invokeTrackChanged(false, 0);
 					return;
 				}
 			}
 			playlist.play(-1);
 		}
 		invokeTrackChanged(false, 0);
 	}
 
 	/***
 	 * Reinits the player with given playlist strategy.
 	 * 
 	 * @param strategy
 	 *            the deserialized strategy
 	 */
 	public void reinit(final IPlaylistStrategy strategy) {
 		TrackMetadataBean track = getCurrentlyPlayingTrack();
 		final Random prevRandom = getRandom();
 		playlist = strategy;
 		playlist.clearQueue();
 		playlist.setRandom(prevRandom);
 		setActive(track);
 		postReinit();
 	}
 
 	private void postReinit() {
 		// init the dynamic playlist if needed
 		if (isDynamic()) {
 			final DynamicPlaylistStrategy s = (DynamicPlaylistStrategy) playlist;
 			s
 					.setHistoryLength(app.getStateHandler().getConfig().dynamicHistorySize);
 			s
 					.setUpcomingTrackCount(app.getStateHandler().getConfig().dynamicUpcomingSize);
 		}
 		getBusInvocator().playlistChanged(null);
 	}
 
 	public void reinit(AppState state) {
 		playlist = state.playlist;
 		if (playlist == null) {
 			staticPlaylist();
 		}
 		setRandomRepeat(state.random != null ? state.random : Random.NONE,
 				state.repeat != null ? state.repeat : Repeat.NO);
 		// configure the player
 		stop();
 		if (state.state != PlayerStateEnum.Stopped) {
 			playWithSeek(state.position);
 			if (state.state == PlayerStateEnum.Paused) {
 				pause();
 			}
 		} else {
 			invokeTrackChanged(false, 0);
 		}
 		postReinit();
 	}
 
 	public void storeState(AppState result) {
 		final boolean store = app.getStateHandler().getConfig().rememberPlaylist;
 		result.playlist = store ? playlist : null;
 		result.position = store ? getPosition() : 0;
 		result.repeat = getRepeat();
 		result.random = getRandom();
 		result.state = store ? getPlaybackState() : PlayerStateEnum.Stopped;
 	}
 
 	public Interval moveBy(Interval interval, int delta) {
 		if (delta == 0)
 			return interval;
 		final Interval result = playlist.moveBy(interval, delta);
 		getBusInvocator().playlistChanged(result);
 		return result;
 	}
 
 	public int peekNext() {
 		return playlist.peekNext();
 	}
 
 	public void replaceLocations(Map<String, String> locationMap) {
 		playlist.replaceLocations(locationMap);
 	}
 }