/***
    *     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.activity.main;
  
  import java.text.ParseException;
  import java.util.Arrays;
  import java.util.List;
  
  import sk.baka.ambient.ActionsEnum;
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.AppState;
  import sk.baka.ambient.ConfigurationBean;
  import sk.baka.ambient.IApplicationListener;
  import sk.baka.ambient.IPlaylistPlayerListener;
  import sk.baka.ambient.PlaylistPlayer;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.collection.TrackOriginEnum;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.commons.MiscUtils;
  import sk.baka.ambient.commons.TagFormatter;
  import sk.baka.ambient.library.ILibraryListener;
  import sk.baka.ambient.lrc.lyrdb.LyrdbTrack;
  import sk.baka.ambient.playerservice.IPlayerListener;
  import sk.baka.ambient.playerservice.PlayerStateEnum;
  import sk.baka.ambient.playlist.PlaylistItem;
  import sk.baka.ambient.playlist.Random;
  import sk.baka.ambient.playlist.Repeat;
  import sk.baka.ambient.views.TextScroller;
  import android.graphics.Bitmap;
  import android.os.Handler;
  import android.view.View;
  import android.widget.ImageView;
  import android.widget.SeekBar;
  import android.widget.TextView;
  import android.widget.SeekBar.OnSeekBarChangeListener;
  
  /***
   * Controls the player view located on the {@link MainActivity} activity. This
   * class is thread unsafe and all methods must be called from the
   * {@link Handler message loop}.
   * 
   * @author Martin Vysny
   */
  public final class PlayerController extends AbstractController implements
  		IPlaylistPlayerListener, IPlayerListener, IApplicationListener,
  		ILibraryListener, OnSeekBarChangeListener {
  	/***
  	 * Handles events.
  	 */
  	private final Handler handler = AmbientApplication.getHandler();
  
  	private final List<ActionsEnum> actions;
  
  	/***
  	 * Creates the player controller.
  	 * 
  	 * @param app
  	 *            the application instance
  	 */
  	public PlayerController(final MainActivity app) {
  		super(R.id.playerWindow, app);
  		seekbar = (SeekBar) mainView.findViewById(R.id.playerSeekbar);
  		actions = Arrays.asList(ActionsEnum.PlaybackPrevious,
  				ActionsEnum.PlaybackPlay, ActionsEnum.PlaybackNext,
  				ActionsEnum.PlaybackStop, ActionsEnum.RepeatNothing,
  				ActionsEnum.RandomNo, ActionsEnum.QueueTracks,
  				ActionsEnum.QueueClear);
  		initButtonBar(R.id.playerButtons, actions);
  		try {
  			formatter = new TagFormatter(
  					this.app.getStateHandler().getConfig().playerTickerFormat);
  		} catch (ParseException e) {
  			throw new RuntimeException(e);
  		}
  		cycle = true;
  		scroller = (TextScroller) mainView.findViewById(R.id.playerTickerText);
  		update(Interval.EMPTY);
  		seekbar.setOnSeekBarChangeListener(this);
  	}
  
  	private TextScroller scroller;
  
  	private SeekBar seekbar;
 
 	/***
 	 * Current position in track, in milliseconds.
 	 */
 	private int position;
 
 	/***
 	 * Current track, may be <code>null</code> if no track is active.
 	 */
 	private TrackMetadataBean track;
 
 	/***
 	 * Redraws the position text ({@link R.id#playerTime}) and updates seekbar.
 	 */
 	private void redrawPosition() {
 		final StringBuilder builder = new StringBuilder(25);
 		if (track != null) {
 			TrackMetadataBean.appendDisplayableLength(position / 1000, builder,
 					false);
 			if (track.getLength() != 0) {
 				builder.append('/');
 				TrackMetadataBean.appendDisplayableLength(track.getLength(),
 						builder, true);
 			}
 			if (track.getBitrate() != 0) {
 				builder.append(' ');
 				builder.append(track.getBitrate());
 				builder.append("kbps");
 			}
 			if (track.getFrequency() != 0) {
 				builder.append(' ');
 				builder.append(track.getFrequency() / 1000);
 				builder.append("khz");
 			}
 			if (!ignoreProgress && (track.getLength() != 0)) {
 				seekbar.setProgress(position / 1000);
 			}
 		} else {
 			if (!ignoreProgress) {
 				seekbar.setProgress(0);
 			}
 		}
 		final TextView timeText = (TextView) mainView
 				.findViewById(R.id.playerTime);
 		timeText.setText(builder.toString());
 	}
 
 	/***
 	 * Reschedules the timer and starts ticking if a non-<code>null</code>
 	 * {@link #track} is selected and the playback is started. Disables the
 	 * timer otherwise.
 	 * 
 	 * @param playing
 	 *            if <code>true</code> then the playback is started.
 	 */
 	private void reschedulePositionTimer(final boolean playing) {
 		handler.removeCallbacks(incrementSongPosition);
 		if ((track == null) || !playing) {
 			return;
 		}
 		final int millisToSecond = 1000 - (position % 1000);
 		handler.postDelayed(incrementSongPosition, millisToSecond);
 	}
 
 	/***
 	 * Increments the song position by a second, updates the display and
 	 * auto-schedules itself.
 	 */
 	private final Runnable incrementSongPosition = new Runnable() {
 		public void run() {
 			final int newposition = app.getPlaylist().getPosition();
 			final int delta = newposition % 1000;
 			position = newposition;
 			// ideally, the delta will be around 0
 			int millisToSecond = 1000 - delta;
 			if (millisToSecond < 100) {
 				millisToSecond += 1000;
 				position += 1000;
 			}
 			handler.postDelayed(this, millisToSecond);
 			redrawPosition();
 		}
 	};
 
 	public void playbackStateChanged(PlayerStateEnum state) {
 		reschedulePositionTimer(state == PlayerStateEnum.Playing);
 		if (state == PlayerStateEnum.Playing) {
 			actions.set(1, ActionsEnum.PlaybackPause);
 			initButtonBar(R.id.playerButtons, actions);
 		} else {
 			actions.set(1, ActionsEnum.PlaybackPlay);
 			initButtonBar(R.id.playerButtons, actions);
 		}
 		if (state == PlayerStateEnum.Stopped) {
 			position = 0;
 			redrawPosition();
 		}
 	}
 
 	public void trackChanged(final PlaylistItem item, final boolean playing,
 			final int positionMillis) {
 		track = item == null ? null : item.getTrack();
 		if (item == null) {
 			position = 0;
 		} else {
 			position = positionMillis;
 		}
 		updateTrack();
 		reschedulePositionTimer(playing);
 	}
 
 	/***
 	 * Updates ticker, seekbar position and min/max values, cover image.
 	 */
 	private void updateTrack() {
 		updateTicker();
 		updateCover();
 		if (track != null) {
 			seekbar.setMax(track.getLength() == 0 ? 600 : track.getLength());
 		} else {
 			seekbar.setMax(600);
 		}
 		redrawPosition();
 	}
 
 	private TagFormatter formatter;
 
 	@Override
 	protected void visibilityChanged(boolean visible) {
 		super.visibilityChanged(visible);
 		if (visible) {
 			scroller.resume();
 		} else {
 			scroller.pause();
 		}
 	}
 
 	/***
 	 * Updates the song name ticker.
 	 */
 	private void updateTicker() {
 		final String format;
 		if (track != null) {
 			format = formatter.format(track);
 		} else {
 			format = "--";
 		}
 		scroller.setScrolledText(format);
 	}
 
 	public void trackPositionChanged(final int position, final boolean playing) {
 		if (track != null) {
 			this.position = position;
 		} else {
 			this.position = 0;
 		}
 		reschedulePositionTimer(playing);
 		redrawPosition();
 	}
 
 	public void randomChanged(Random random) {
 		actions.set(5, ActionsEnum.getAction(random));
 		initButtonBar(R.id.playerButtons, actions);
 	}
 
 	public void repeatChanged(Repeat repeat) {
 		actions.set(4, ActionsEnum.getAction(repeat));
 		initButtonBar(R.id.playerButtons, actions);
 	}
 
 	@Override
 	public void update(final Interval select) {
 		final PlaylistPlayer player = app.getPlaylist();
 		track = player.getCurrentlyPlayingTrack();
 		final PlayerStateEnum state = player.getPlaybackState();
 		if (state != PlayerStateEnum.Stopped) {
 			position = player.getPosition();
 		} else {
 			position = 0;
 		}
 		playbackStateChanged(state);
 		updateTrack();
 	}
 
 	public void playlistChanged(final Interval target) {
 		// do nothing
 	}
 
 	public void configChanged(ConfigurationBean config) {
 		try {
 			formatter = new TagFormatter(
 					app.getStateHandler().getConfig().playerTickerFormat);
 		} catch (ParseException e) {
 			throw new RuntimeException(e);
 		}
 		updateTicker();
 	}
 
 	public void coverLoaded(TrackMetadataBean track) {
 		if (!MiscUtils.nullEquals(this.track, track)) {
 			return;
 		}
 		updateCover();
 	}
 
 	public void libraryUpdate(boolean updateStarted, boolean interrupted,
 			boolean userNotified) {
 		// do nothing
 	}
 
 	public void clipboardChanged() {
 		// do nothing
 	}
 
 	public void radioNewTrack(String name) {
 		if ((track != null) && (name != null)) {
 			track = TrackMetadataBean.newBuilder().getData(track)
 					.setTitle(name).build(track.getTrackId());
 			updateTicker();
 		}
 	}
 
 	public void onProgressChanged(SeekBar seekBar, int progress,
 			boolean fromTouch) {
 		if (!fromTouch)
 			return;
 		final PlaylistPlayer p = AmbientApplication.getInstance().getPlaylist();
 		final TrackMetadataBean currentTrack = p.getCurrentlyPlayingTrack();
 		// is some track selected?
 		if (currentTrack == null) {
 			// nope, bail out
 			seekBar.setProgress(0);
 			return;
 		}
 		if (!currentTrack.getOrigin().seekable) {
 			// not seekable
 			seekBar.setProgress(0);
 			return;
 		}
 		if (p.getPlaybackState() == PlayerStateEnum.Stopped) {
 			p.playWithSeek(progress * 1000);
 		} else {
 			p.seek(progress * 1000);
 		}
 		return;
 	}
 
 	private boolean ignoreProgress = false;
 
 	public void onStartTrackingTouch(SeekBar seekBar) {
 		ignoreProgress = true;
 	}
 
 	public void onStopTrackingTouch(SeekBar seekBar) {
 		ignoreProgress = false;
 	}
 
 	public void buffered(byte percent) {
 		final int progress = seekbar.getMax() * percent / 100;
 		seekbar.setSecondaryProgress(progress);
 	}
 
 	public void started(String file, int duration, int currentPosition) {
 		// do nothing. this is a low-level player event which is handled by
 		// PlaylistPlayer
 	}
 
 	public void stopped(String error, boolean errorMissing,
 			TrackOriginEnum origin) {
 		// do nothing. this is a low-level player event which is handled by
 		// PlaylistPlayer - next track will be probably queued shortly.
 	}
 
 	public void lyricsLoaded(TrackMetadataBean track,
 			final List<LyrdbTrack> lyrics) {
 		// ignore
 	}
 
 	@Override
 	public void destroy() {
 		reschedulePositionTimer(false);
 		scroller.pause();
 		destroyCover();
 		scroller = null;
 		seekbar = null;
 		super.destroy();
 	}
 
 	public void offline(boolean offline) {
 		// the playlist player component will handle cases when an
 		// online content is being played.
 		// try to download cover if missing
 		if (!offline) {
 			updateCover();
 		}
 	}
 
 	public void stateChanged(AppState state) {
 		// do nothing
 	}
 
 	private Bitmap previousCover = null;
 
 	private void destroyCover() {
 		if (previousCover != null) {
 			final ImageView image = (ImageView) mainView
 					.findViewById(R.id.playlist_item_cover);
 			image.setImageResource(R.drawable.cover);
 			previousCover.recycle();
 			previousCover = null;
 		}
 	}
 	
 	private void updateCover() {
 		destroyCover();
 		final ImageView image = (ImageView) mainView
 				.findViewById(R.id.playlist_item_cover);
 		if (track != null) {
 			previousCover = app.getCovers().setCover(track, image);
 			image.setVisibility(View.VISIBLE);
 		} else {
 			image.setVisibility(View.INVISIBLE);
 		}
 	}
 
 	@Override
 	protected void performZoom(boolean zoom) {
 		initButtonBar(R.id.playerButtons, actions);
 	}
 }