/***
    *     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.text.ParseException;
  
  import sk.baka.ambient.activity.ErrorActivity;
  import sk.baka.ambient.activity.main.MainActivity;
  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.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 android.app.Notification;
  import android.app.NotificationManager;
  import android.app.PendingIntent;
  import android.content.Context;
  import android.content.Intent;
  import android.graphics.Typeface;
  import android.text.SpannableStringBuilder;
  import android.text.Spanned;
  import android.text.style.StyleSpan;
  import android.widget.Toast;
  
  /***
   * Controls the notification shown when a track is being played.
   * 
   * @author Martin Vysny
   */
  public final class PlaybackNotificator {
  	/***
  	 * The ID of the notification.
  	 */
  	public static final int NOTIFICATION_ID = 23847;
  
  	/***
  	 * The ID of the error notification.
  	 */
  	public static final int ERROR_NOTIFICATION_ID = 23848;
  
  	private final AmbientApplication app;
  
  	/***
  	 * Creates new notification controller.
  	 * 
  	 * @param app
  	 *            the application instance.
  	 */
  	PlaybackNotificator(final AmbientApplication app) {
  		super();
  		this.app = app;
  		app.getBus().addHandler(listener);
  		final boolean isPlaying = AmbientApplication.getInstance()
  				.getPlaylist().getPlaybackState() == PlayerStateEnum.Playing;
  		final TrackMetadataBean track = AmbientApplication.getInstance()
  				.getPlaylist().getCurrentlyPlayingTrack();
  		if ((track != null) && isPlaying) {
  			createNotification(track);
  		}
  	}
  
  	private final Listener listener = new Listener();
  
  	private void createNotification(final TrackMetadataBean track) {
  		if (app.isShutdown()) {
  			cancelNotifications();
  			return;
  		}
  		final NotificationManager nm = (NotificationManager) app
  				.getSystemService(Context.NOTIFICATION_SERVICE);
  		final SpannableStringBuilder text = new SpannableStringBuilder();
  		if (!MiscUtils.isEmptyOrWhitespace(track.getAlbum())) {
  			text.append(track.getAlbum());
  		}
  		if (!MiscUtils.isEmptyOrWhitespace(track.getArtist())) {
  			if (text.length() != 0) {
  				text.append(" ");
  				final String by = app.getString(R.string.trackBy);
 				text.append(by);
 				text.setSpan(new StyleSpan(Typeface.ITALIC), text.length()
 						- by.length(), text.length(),
 						Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
 				text.append(" ");
 				text.append(track.getArtist());
 			}
 		}
 		final Notification notification = new Notification(R.drawable.icon,
 				null, System.currentTimeMillis());
 		final PendingIntent contentIntent = PendingIntent.getActivity(app, 0,
 				new Intent(app, MainActivity.class), 0);
 		notification.setLatestEventInfo(app, track.getDisplayableName(), text,
 				contentIntent);
 		notification.flags = Notification.FLAG_NO_CLEAR
 				| Notification.FLAG_ONGOING_EVENT;
 		nm.notify(NOTIFICATION_ID, notification);
 	}
 
 	/***
 	 * Cancels all notifications.
 	 */
 	public void cancelNotifications() {
 		final NotificationManager nm = (NotificationManager) app
 				.getSystemService(Context.NOTIFICATION_SERVICE);
 		nm.cancel(NOTIFICATION_ID);
 		nm.cancel(ERROR_NOTIFICATION_ID);
 	}
 
 	/***
 	 * Cancels the playback notification.
 	 */
 	public void cancelPlaybackNotification() {
 		final NotificationManager nm = (NotificationManager) app
 				.getSystemService(Context.NOTIFICATION_SERVICE);
 		nm.cancel(NOTIFICATION_ID);
 	}
 
 	private final class Listener implements IPlaylistPlayerListener,
 			IPlayerListener {
 
 		public void playbackStateChanged(PlayerStateEnum state) {
 			// handle the Android Notification
 			if (state != PlayerStateEnum.Playing) {
 				cancelPlaybackNotification();
 			} else {
 				final TrackMetadataBean track = AmbientApplication
 						.getInstance().getPlaylist().getCurrentlyPlayingTrack();
 				if (track != null) {
 					createNotification(track);
 				}
 			}
 		}
 
 		public void playlistChanged(Interval target) {
 			// ignore
 		}
 
 		public void randomChanged(Random random) {
 			// ignore
 		}
 
 		public void repeatChanged(Repeat repeat) {
 			// ignore
 		}
 
 		public void trackChanged(PlaylistItem track, boolean play,
 				int positionMillis) {
 			// update the Android Notification
 			final boolean isPlaying = AmbientApplication.getInstance()
 					.getPlaylist().getPlaybackState() == PlayerStateEnum.Playing;
 			if ((track != null) && isPlaying) {
 				createNotification(track.getTrack());
 			}
 			// notify the user with the Toast
 			if (track == null) {
 				return;
 			}
 			if (!play) {
 				return;
 			}
 			if (app.getStateHandler().getConfig().notifyWhenMinimizedOnly
 					&& app.isMainActivityVisible()) {
 				return;
 			}
 			notifyOnNextTrack(track.getTrack());
 		}
 
 		public void trackPositionChanged(int position, boolean playing) {
 			// ignore
 		}
 
 		public void buffered(byte percent) {
 			// ignore
 		}
 
 		public void radioNewTrack(String name) {
 			// update the Android Notification
 			final TrackMetadataBean.Builder b = new TrackMetadataBean.Builder();
 			createNotification(b.setOrigin(TrackOriginEnum.Shoutcast)
 					.setLocation("Shoutcast radio").setTitle(name).build(-1));
 			// notify the user with the Toast
 			final TrackMetadataBean bean = TrackMetadataBean.newBuilder()
 					.setLocation(name).setTitle(name).setOrigin(
 							TrackOriginEnum.Shoutcast).build(-1);
 			notifyOnNextTrack(bean);
 
 		}
 
 		public void started(String file, int duration, int currentPosition) {
 			// ignore this low-level event, we are primarily capturing
 			// higher-level
 			// events
 		}
 
 		public void stopped(String error, boolean errorMissing,
 				TrackOriginEnum origin) {
 			// ignore this low-level event, we are primarily capturing
 			// higher-level
 			// events
 		}
 	}
 
 	/***
 	 * Shows a notification that
 	 * 
 	 * @param bean
 	 *            the bean to format
 	 */
 	private synchronized void notifyOnNextTrack(final TrackMetadataBean bean) {
 		notifyOnNextTrack(bean, app.getStateHandler().getConfig());
 	}
 
 	/***
 	 * Forces the application to show a notification based on given
 	 * configuration.
 	 * 
 	 * @param bean
 	 *            the bean to format
 	 * @param config
 	 *            the configuration to use
 	 */
 	public synchronized void notifyOnNextTrack(final TrackMetadataBean bean,
 			final ConfigurationBean config) {
 		if (config.notificationType == ConfigurationBean.TrackChangeNotifEnum.None) {
 			return;
 		}
 		// format the notification message
 		final boolean shortNotif = config.notificationType == ConfigurationBean.TrackChangeNotifEnum.Short;
 		final String format = shortNotif ? config.shortNotificationFormat
 				: config.longNotificationFormat;
 		try {
 			if ((notificationFormatter == null)
 					|| !notificationFormatter.formatString.equals(format)) {
 				notificationFormatter = new TagFormatter(format);
 			}
 		} catch (ParseException e) {
 			throw new RuntimeException(e);
 		}
 		final String formatted = notificationFormatter.format(bean);
 		// notify
 		final Toast toast = Toast.makeText(app, formatted,
 				config.notificationType.viewDuration);
 		toast.setGravity(config.notificationLocation.gravity, 0, 0);
 		toast.show();
 	}
 
 	/***
 	 * Cached notification formatter instance.
 	 */
 	private TagFormatter notificationFormatter;
 
 	/***
 	 * Destroys the notificator, removing it from the bus.
 	 */
 	void destroy() {
 		app.getBus().removeHandler(listener);
 	}
 
 	/***
 	 * Updates the error notification.
 	 * 
 	 * @param errorCount
 	 *            the error/warning count. If zero the notification is hidden.
 	 * @param last
 	 *            last error/warning or <code>null</code> if no errors are
 	 *            present.
 	 */
 	void updateErrorNotification(final int errorCount,
 			final ErrorHandler.ErrorInfo last) {
 		final NotificationManager nm = (NotificationManager) app
 				.getSystemService(Context.NOTIFICATION_SERVICE);
 		if (errorCount <= 0) {
 			nm.cancel(ERROR_NOTIFICATION_ID);
 			return;
 		}
 		final Notification notification = new Notification(R.drawable.quit, null,
 				last.timestamp);
 		final PendingIntent contentIntent = PendingIntent.getActivity(app, 0,
 				new Intent(app, ErrorActivity.class), 0);
 		notification.setLatestEventInfo(app, app
 				.getString(R.string.ambientError), last.message, contentIntent);
 		notification.number = errorCount;
 		nm.notify(ERROR_NOTIFICATION_ID, notification);
 	}
 }