/***
    *     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.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.List;
  import java.util.concurrent.CopyOnWriteArrayList;
  
  import sk.baka.ambient.ActionsEnum;
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.R;
  import sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.stream.shoutcast.Radio;
  import sk.baka.ambient.stream.shoutcast.ShoutcastUtils;
  import sk.baka.ambient.views.gesturelist.GesturesListView;
  import android.view.View;
  import android.widget.TextView;
  
  /***
   * Controls the shoutcast server manager.
   * 
   * @author Martin Vysny
   */
  public final class ShoutcastController extends AbstractListController {
  
  	/***
  	 * Creates the shoutcast controller instance.
  	 * 
  	 * @param activity
  	 *            the activity instance.
  	 * @param playlistView
  	 *            the playlist view
  	 */
  	public ShoutcastController(final MainActivity activity,
  			final GesturesListView playlistView) {
  		super(R.id.shoutcastbrowser, R.id.shoutcastList, activity);
  		initButtonBar(R.id.shoutcastButtons, actions);
  		// register the drag'n'drop target.
  		listView.dragDropViews.clear();
  		listView.dragDropViews.add(playlistView);
  	}
  
  	@Override
  	public void destroy() {
  		listView.dragDropViews.clear();
  		super.destroy();
  	}
  
  	@Override
  	protected void onAction(ActionsEnum action) {
  		if (action == ActionsEnum.ShoutcastNameTrackSwitch) {
  			isRadioNames = !isRadioNames;
  			if (radioList != null) {
  				sortRadioList();
  				update(null);
  			}
  			return;
  		}
  		if (action == ActionsEnum.Back) {
  			goBack();
  			return;
  		}
  		super.onAction(action);
  	}
  
  	/***
  	 * The actions to display on the Task switcher.
  	 */
  	public static final List<ActionsEnum> actions = Collections
  			.unmodifiableList(Arrays.asList(ActionsEnum.Back,
  					ActionsEnum.ShoutcastNameTrackSwitch));
  
  	/***
  	 * If <code>true</code> then a genre list is final being shown. If
  	 * <code>false</code> then a radio list is being shown.
  	 */
  	private volatile boolean isShowingGenre = true;
  
  	/***
 	 * Used only when the radio list is shown. If <code>true</code> then the
 	 * radio name is shown. If <code>false</code> then the currently played
 	 * track name is shown.
 	 */
 	private boolean isRadioNames = true;
 
 	/***
 	 * Cached genres list.
 	 */
 	private volatile List<String> genres = null;
 
 	/***
 	 * Returns list of genres. If the genre list is not yet loaded then the
 	 * download starts in the background and an empty list is returned.
 	 * 
 	 * @return the genre list.
 	 */
 	private List<String> getGenres() {
 		if (genres != null) {
 			return genres;
 		}
 		app.getBackgroundTasks().schedule(new GenreDownloader(),
 				GenreDownloader.class, true,
 				app.getString(R.string.shoutcastDownloadGenres));
 		return Collections.emptyList();
 	}
 
 	private final class GenreDownloader implements Runnable {
 		public void run() {
 			try {
 				final List<String> genres = ShoutcastUtils.parseGenres();
 				ShoutcastController.this.genres = new CopyOnWriteArrayList<String>(
 						genres);
 				updateAsync();
 			} catch (final Exception e) {
 				throw new RuntimeException(e);
 			}
 		}
 	}
 
 	private void updateAsync() {
 		AmbientApplication.getHandler().post(new Runnable() {
 			public void run() {
 				update(null);
 			}
 		});
 	}
 
 	@Override
 	protected void visibilityChanged(boolean visible) {
 		if (visible) {
 			update(null);
 		}
 	}
 
 	@Override
 	protected void recomputeListItems() {
 		// handle offline mode
 		final boolean offline = !app.getStateHandler().getStartupState().online;
 		mainView.findViewById(R.id.shoutcastbrowserControls).setVisibility(
 				offline ? View.GONE : View.VISIBLE);
 		mainView.findViewById(R.id.shoutcastOffline).setVisibility(
 				offline ? View.VISIBLE : View.GONE);
 		if (offline) {
 			return;
 		}
 		listView.getModel().getModel().clear();
 		if (!isVisible()) {
 			return;
 		}
 		if (isShowingGenre) {
 			listView.getModel().getModel().addAll(getGenres());
 		} else {
 			if (radioList != null) {
 				listView.getModel().getModel().addAll(radioList);
 			}
 		}
 	}
 
 	@Override
 	public String getHint(Interval highlight) {
 		return highlight.length + " radio(s)";
 	}
 
 	@Override
 	public boolean isComputeTracksLong(Interval interval) {
 		return !interval.isEmpty();
 	}
 
 	@Override
 	public boolean isComputeTracksOnlineOp(Interval interval) {
 		return !interval.isEmpty();
 	}
 
 	@Override
 	public boolean canComputeItems() {
 		return !isShowingGenre;
 	}
 
 	@Override
 	public boolean canHighlight() {
 		return !isShowingGenre;
 	}
 
 	public void itemActivated(int index, Object model) {
 		if (isShowingGenre) {
 			showGenre((String) model);
 		} else {
 			final Radio r = (Radio) model;
 			app.getBackgroundTasks().schedule(new PlaylistDownloader(r),
 					PlaylistDownloader.class, true,
 					app.getString(R.string.shoutcastDownloadURLs));
 		}
 	}
 
 	private final class PlaylistDownloader implements Runnable {
 		private final Radio r;
 		private volatile boolean gettingPlaylist = true;
 		private volatile List<TrackMetadataBean> playlist = null;
 
 		/***
 		 * Creates new instance.
 		 * 
 		 * @param r
 		 *            the radio.
 		 */
 		public PlaylistDownloader(Radio r) {
 			this.r = r;
 		}
 
 		public void run() {
 			if (gettingPlaylist) {
 				playlist = getRadioStreams(r);
 				playlist = Collections.synchronizedList(playlist);
 				gettingPlaylist = false;
 				AmbientApplication.getHandler().post(this);
 			} else {
 				app.getPlaylist().add(app.getPlaylist().size(), playlist);
 			}
 		}
 	}
 
 	/***
 	 * Loads the radio list.
 	 * 
 	 * @author Martin Vysny
 	 */
 	private class RadioDownloader implements Runnable {
 		private final String genre;
 
 		/***
 		 * Creates new instance.
 		 * 
 		 * @param genre
 		 *            the genre.
 		 */
 		public RadioDownloader(final String genre) {
 			this.genre = genre;
 		}
 
 		public void run() {
 			List<Radio> list;
 			try {
 				list = ShoutcastUtils.getRadioList(genre);
 			} catch (final Exception e) {
 				throw new RuntimeException(e);
 			}
 			radioList = Collections.synchronizedList(list);
 			sortRadioList();
 			isShowingGenre = false;
 			updateAsync();
 		}
 	}
 
 	/***
 	 * The radio list.
 	 */
 	private volatile List<Radio> radioList = null;
 
 	@Override
 	public void removeItems(Interval remove) {
 		goBack();
 	}
 
 	private void goBack() {
 		if (isShowingGenre) {
 			// nowhere to go.
 			return;
 		}
 		isShowingGenre = true;
 		radioList = null;
 		update(null);
 	}
 
 	public void update(GesturesListView listView, View itemView, int index,
 			Object model) {
 		final TextView view = (TextView) itemView;
 		if (listView.getHighlight().contains(index)) {
 			view.setBackgroundColor(highlightColor);
 		} else {
 			view.setBackgroundColor(0);
 		}
 		if (model instanceof String) {
 			view.setText((String) model);
 		} else {
 			final Radio r = (Radio) model;
 			if (isRadioNames) {
 				view.setText(r.name + " (" + r.genre + ")");
 			} else {
 				view.setText(r.currentTrack + " (" + r.genre + ")");
 			}
 		}
 	}
 
 	private List<TrackMetadataBean> getRadioStreams(final Radio radio) {
 		try {
 			return radio.getRadioURLs();
 		} catch (final Exception ex) {
 			throw new RuntimeException(ex);
 		}
 	}
 
 	@Override
 	public List<TrackMetadataBean> computeTracks(Interval highlight) {
 		if (isShowingGenre)
 			throw new IllegalStateException();
 		final List<TrackMetadataBean> result = new ArrayList<TrackMetadataBean>();
 		for (int i = highlight.start; i <= highlight.end; i++) {
 			final Radio r = radioList.get(i);
 			result.addAll(getRadioStreams(r));
 		}
 		return new CopyOnWriteArrayList<TrackMetadataBean>(result);
 	}
 
 	private void sortRadioList() {
 		if (isRadioNames) {
 			ShoutcastUtils.sortByName(radioList);
 		} else {
 			Collections.sort(radioList, new Comparator<Radio>() {
 				public int compare(Radio object1, Radio object2) {
 					return object1.currentTrack
 							.compareToIgnoreCase(object2.currentTrack);
 				}
 			});
 		}
 	}
 
 	/***
 	 * Browse given genre.
 	 * 
 	 * @param genre
 	 *            the genre to browse.
 	 */
 	public void showGenre(final String genre) {
 		// read the radio list
 		app.getBackgroundTasks().schedule(new RadioDownloader(genre),
 				RadioDownloader.class, true,
 				app.getString(R.string.shoutcastDownloadStations));
 	}
 
 	@Override
 	protected void performZoom(boolean zoom) {
 		super.performZoom(zoom);
 		initButtonBar(R.id.shoutcastButtons, actions);
 	}
 }