/***
    *     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.playerservice;
  
  import java.io.IOException;
  import java.net.InetAddress;
  import java.net.URL;
  import java.util.Map;
  
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.AbstractAudio;
  import sk.baka.ambient.collection.TrackOriginEnum;
  import sk.baka.ambient.stream.shoutcast.IShoutcastListener;
  import android.app.Service;
  import android.content.Intent;
  import android.media.MediaPlayer;
  import android.media.MediaPlayer.OnBufferingUpdateListener;
  import android.media.MediaPlayer.OnCompletionListener;
  import android.media.MediaPlayer.OnErrorListener;
  import android.media.MediaPlayer.OnPreparedListener;
  import android.net.Uri;
  import android.os.IBinder;
  import android.util.Log;
  
  /***
   * <p>
   * Simply plays required audio files. Invokes {@link IPlayerListener} handler
   * when the playback is finished.
   * </p>
   * <p>
   * This service mainly prevents Android to kill the application when no
   * activities are shown on screen.
   * </p>
   * 
   * @author Martin Vysny
   */
  public final class PlayerService extends Service implements
  		OnCompletionListener, OnErrorListener, OnPreparedListener,
  		IShoutcastListener, OnBufferingUpdateListener {
  
  	/***
  	 * The player.
  	 */
  	private MediaPlayer player;
  
  	/***
  	 * The streamer server.
  	 */
  	private final StreamerServer streamerServer = new StreamerServer(this);
  
  	@Override
  	public void onCreate() {
  		super.onCreate();
  		setForeground(true);
  		newMediaPlayer();
  		try {
  			streamerServer.start(StreamerServer.PORT, InetAddress
  					.getLocalHost());
  		} catch (IOException e) {
  			throw new RuntimeException(e);
  		}
  	}
  
  	private void newMediaPlayer() {
  		if (player != null) {
  			try {
  				player.release();
  			} catch (Throwable e) {
  				// do nothing, we are going to throw this media player away
  				// anyway
  			}
  		}
  		player = new MediaPlayer();
  		player.setOnCompletionListener(this);
  		player.setOnErrorListener(this);
  		player.setOnPreparedListener(this);
  		player.setOnBufferingUpdateListener(this);
  	}
  
  	/***
  	 * The file being played.
  	 */
  	private String file;
 
 	/***
 	 * The track origin.
 	 */
 	private TrackOriginEnum origin;
 
 	/***
 	 * The playback state.
 	 */
 	volatile PlayerStateEnum playerState = PlayerStateEnum.Stopped;
 
 	/***
 	 * Log events with this tag.
 	 */
 	private final static String TAG = PlayerService.class.getSimpleName();
 
 	@Override
 	public void onDestroy() {
 		try {
 			// try to save the application state
 			AmbientApplication.getInstance().getStateHandler().saveState();
 			AmbientApplication.getInstance().getNotificator()
 					.cancelNotifications();
 			// free all resources
 			try {
 				stop(true);
 			} catch (Exception ex) {
 				Log.e(TAG, ex.getMessage(), ex);
 			}
 			streamerServer.stop();
 		} finally {
 			super.onDestroy();
 		}
 	}
 
 	private final IBinder binder = new IPlayer.Stub() {
 		public int getPlaybackState() {
 			return playerState.ordinal();
 		}
 
 		@SuppressWarnings("incomplete-switch")
 		public void pause() {
 			switch (playerState) {
 			case Paused: {
 				player.start();
 				playerState = PlayerStateEnum.Playing;
 			}
 				break;
 			case Playing: {
 				player.pause();
 				playerState = PlayerStateEnum.Paused;
 			}
 				break;
 			}
 		}
 
 		public void play(String file, int o, int startSeekMillis) {
 			PlayerService.this.file = file;
 			PlayerService.this.origin = TrackOriginEnum.values()[o];
 			if (!origin.online) {
 				// check if the file exists and is readable
 				final AbstractAudio audio = AbstractAudio.fromUri(file);
 				if (!audio.exists()) {
 					invokeError(getString(R.string.file_not_found) + ": "
 							+ file, null, true);
 					return;
 				}
 				if (!audio.isReadable()) {
 					invokeError(getString(R.string.file_not_readable) + ": "
 							+ file, null, true);
 					return;
 				}
 			}
 			getInvocator().buffered((byte) 0);
 			try {
 				String url = file;
 				if (origin == TrackOriginEnum.Shoutcast) {
 					url = StreamerServer.getShoutcastStream(new URL(url));
 				}
 				PlayerService.this.stop(false);
 				PlayerService.this.startSeekMillis = origin.seekable ? startSeekMillis
 						: 0;
 				if (origin == TrackOriginEnum.LocalFs
 						&& url.startsWith("content://")) {
 					player.setDataSource(PlayerService.this, Uri.parse(url));
 				} else {
 					player.setDataSource(url);
 				}
 				player.prepareAsync();
 			} catch (final Exception ex) {
 				invokeError(ex.getMessage(), ex, false);
 			}
 		}
 
 		public boolean seek(int position) {
 			if (playerState == PlayerStateEnum.Stopped) {
 				return false;
 			}
 			if (!origin.seekable) {
 				return false;
 			}
 			player.seekTo(position);
 			return true;
 		}
 
 		public void stop() {
 			PlayerService.this.stop(false);
 			getInvocator().buffered((byte) 0);
 		}
 
 		public int getPosition() {
 			if (playerState == PlayerStateEnum.Stopped)
 				return 0;
 			return player.getCurrentPosition();
 		}
 	};
 
 	/***
 	 * Used only in {@link #onPrepared(MediaPlayer)} - states the playback start
 	 * time.
 	 */
 	private int startSeekMillis = 0;
 
 	private void stop(boolean release) {
 		if (playerState != PlayerStateEnum.Stopped) {
 			player.stop();
 		}
 		if (release) {
 			player.release();
 		} else {
 			try {
 				player.reset();
 			} catch (IllegalStateException ex) {
 				// It seems that MediaPlayer randomly reports
 				// IllegalStateException. Throw this instance away.
 				Log.e(TAG, "MediaPlayer failed to complete the reset() "
 						+ "operation, throwing away", ex);
 				newMediaPlayer();
 			}
 		}
 		playerState = PlayerStateEnum.Stopped;
 	}
 
 	@Override
 	public IBinder onBind(Intent intent) {
 		return binder;
 	}
 
 	private final AmbientApplication getApp() {
 		return (AmbientApplication) getApplication();
 	}
 
 	/***
 	 * Returns a proxy which posts events using the <code>SimpleBus</code>
 	 * object.
 	 * 
 	 * @return the proxy instance.
 	 */
 	IPlayerListener getInvocator() {
 		return getApp().getBus().getInvocator(IPlayerListener.class, true);
 	}
 
 	public void onCompletion(MediaPlayer arg0) {
 		playerState = PlayerStateEnum.Stopped;
 		getInvocator().stopped(null, false, origin);
 	}
 
 	/***
 	 * An error occurred. The player is stopped and a stop event is generated.
 	 * 
 	 * @param message
 	 *            the error message.
 	 * @param ex
 	 *            the error cause, may be <code>null</code> if not known
 	 * @param missing
 	 *            if <code>true</code> then this error was caused by a file
 	 *            missing.
 	 */
 	void invokeError(final String message, final Throwable ex,
 			final boolean missing) {
 		if (ex == null) {
 			Log.e(TAG, message);
 		} else {
 			Log.e(TAG, message, ex);
 		}
 		Log.e(TAG, "File: " + file);
 		stop(false);
 		playerState = PlayerStateEnum.Stopped;
 		getInvocator().stopped(message, missing, origin);
 	}
 
 	public boolean onError(MediaPlayer player, int what, int extra) {
 		invokeError(MediaPlayerErrors.getMessage(what, extra, this), null,
 				false);
 		return true;
 	}
 
 	public void onPrepared(MediaPlayer p) {
 		try {
 			player.start();
 			if (startSeekMillis > 0) {
 				player.seekTo(startSeekMillis);
 			}
 			playerState = PlayerStateEnum.Playing;
 			getInvocator().started(file,
 					origin.endless ? 0 : player.getDuration(),
 					origin.endless ? 0 : player.getCurrentPosition());
 		} catch (final Exception ex) {
 			invokeError(ex.getMessage(), ex, false);
 		}
 	}
 
 	public void metadataReceived(String title, Map<String, String> metadata) {
 		getInvocator().radioNewTrack(title);
 	}
 
 	public void opened(String name, String genre, boolean hasMetaint,
 			Map<String, String> metadata) {
 		// ignore
 	}
 
 	public void onBufferingUpdate(MediaPlayer mp, int percent) {
 		getInvocator().buffered((byte) percent);
 	}
 }