/***
    *     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.io.IOException;
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.BitSet;
  import java.util.Collections;
  import java.util.List;
  import java.util.Map;
  
  import sk.baka.ambient.ActionsEnum;
  import sk.baka.ambient.AmbientApplication;
  import sk.baka.ambient.AppState;
  import sk.baka.ambient.R;
  import sk.baka.ambient.ZoomEnum;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.commons.ObjectStorage;
  import sk.baka.ambient.playlist.IPlaylistStrategy;
  import sk.baka.ambient.views.ButtonBar;
  import sk.baka.ambient.views.ViewUtils;
  import sk.baka.ambient.views.gesturelist.GesturesListView;
  import android.content.Context;
  import android.content.DialogInterface;
  import android.view.View;
  import android.widget.TextView;
  
  /***
   * Controls the playlist manager.
   * 
   * @author Martin Vysny
   */
  public final class PlaylistManagerController extends AbstractListController {
  	/***
  	 * Creates new playlist manager controller instance.
  	 * 
  	 * @param mainActivity
  	 */
  	public PlaylistManagerController(MainActivity mainActivity) {
  		super(R.id.playlistManager, R.id.playlistManagerPlaylists, mainActivity);
  		initButtonBar(R.id.playlistManagerButtons, actions);
  		update(null);
  	}
  
  	@Override
  	public void update(Interval target) {
  		super.update(target);
  		final boolean dynamic = app.getPlaylist().isDynamic();
  		updateDynamic(dynamic);
  	}
  
  	private final List<ActionsEnum> actions = Arrays.asList(
  			ActionsEnum.PlaylistStatic, ActionsEnum.PlaylistDynamic,
  			ActionsEnum.PlaylistClear, ActionsEnum.PlaylistSortByAlbums,
  			ActionsEnum.PlaylistShuffle, ActionsEnum.PlaylistSave);
  
  	@Override
  	protected void onAction(ActionsEnum action) {
  		if (action == ActionsEnum.PlaylistSave) {
  			savePlaylistWizard(mainActivity);
  		}
  		if (action == ActionsEnum.PlaylistStatic) {
  			updateDynamic(false);
  			actions.set(2, ActionsEnum.PlaylistClear);
  			initButtonBar(R.id.playlistManagerButtons, actions);
  		}
  		if (action == ActionsEnum.PlaylistDynamic) {
  			updateDynamic(true);
  			actions.set(2, ActionsEnum.RepopulatePlaylist);
  			initButtonBar(R.id.playlistManagerButtons, actions);
  		}
  		super.onAction(action);
  	}
  
  	/***
  	 * Navigates user through a 'save playlist' wizard.
  	 * 
  	 * @param context
  	 *            the context.
  	 */
  	public void savePlaylistWizard(final Context context) {
  		final ViewUtils.OnTextSubmit listener = new ViewUtils.OnTextSubmit() {
 			public void submit(String text) {
 				savePlaylistAs(context, text, true);
 				update(null);
 			}
 
 			public String validate(String text) {
 				return text.length() == 0 ? context
 						.getString(R.string.playlistNameEmpty) : null;
 			}
 
 			public void cancel() {
 				// do nothing, the window will disappear on its own.
 			}
 		};
 		ViewUtils.showTextEditor(context, context
 				.getString(R.string.lsplaylistSave), null, context
 				.getString(R.string.savePlaylist), context
 				.getString(R.string.savePlaylistAs), listener);
 	}
 
 	private void savePlaylistAs(final Context context, final String name,
 			final boolean askForOverwrite) {
 		final AmbientApplication app = AmbientApplication.getInstance();
 		try {
 			final ObjectStorage ps = app.getPlaylistStorage();
 			if (ps.contains(name) && askForOverwrite) {
 				final DialogInterface.OnClickListener listener = new DialogInterface.OnClickListener() {
 					public void onClick(DialogInterface dialog, int which) {
 						savePlaylistAs(context, name, false);
 					}
 				};
 				ViewUtils.showYesNoDialog(context, context
 						.getString(R.string.playlistOverwrite), listener);
 			}
 			final AppState state = new AppState();
 			app.getPlaylist().storeState(state);
 			ps.saveObject(name, (Serializable) state.playlist);
 		} catch (IOException e) {
 			app.error(PlaylistManagerController.class, true, app.getResources()
 					.getString(R.string.lsplaylistErrSave), e);
 		}
 	}
 
 	@Override
 	protected void recomputeListItems() {
 		final List<String> sortedNames = new ArrayList<String>(app
 				.getPlaylistStorage().getNames());
 		Collections.sort(sortedNames);
 		final List<Object> playlistNames = listView.getModel().getModel();
 		playlistNames.clear();
 		playlistNames.addAll(sortedNames);
 	}
 
 	@Override
 	public boolean isReadOnly() {
 		return false;
 	}
 
 	public void itemActivated(int index, Object model) {
 		loadPlaylist((String) model);
 	}
 
 	/***
 	 * Loads playlist with given name. Shows an error message when the playlist
 	 * failed to be loaded.
 	 * 
 	 * @param name
 	 *            the name of the playlist.
 	 */
 	public void loadPlaylist(final String name) {
 		try {
 			final ObjectStorage ps = app.getPlaylistStorage();
 			final IPlaylistStrategy state = (IPlaylistStrategy) ps
 					.loadObject(name);
 			app.getPlaylist().reinit(state);
 		} catch (final Exception ex) {
 			app.error(PlaylistManagerController.class, true, mainActivity
 					.getString(R.string.lsplaylistErrLoad), ex);
 		}
 	}
 
 	@Override
 	public void removeItems(final Interval remove) {
 		if (remove.isEmpty())
 			return;
 		final DialogInterface.OnClickListener listener = new DialogInterface.OnClickListener() {
 			public void onClick(DialogInterface dialog, int which) {
 				final List<Object> toDelete = listView.getModel().getModel()
 						.subList(remove.start, remove.end + 1);
 				final ObjectStorage storage = AmbientApplication.getInstance()
 						.getPlaylistStorage();
 				for (final Object pname : toDelete) {
 					storage.delete((String) pname);
 				}
 				update(null);
 			}
 		};
 		ViewUtils.showYesNoDialog(mainActivity, mainActivity
 				.getString(R.string.playlistDelete), listener);
 	}
 
 	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);
 		}
 		view.setText((String) model);
 	}
 
 	@Override
 	protected void performZoom(final Map<ZoomEnum, Integer> zoom) {
 		super.performZoom(zoom);
 		initButtonBar(R.id.playlistManagerButtons, actions);
 	}
 
 	public String toString(Object model) {
 		// shouldn't be called as strings are shown
 		throw new Error();
 	}
 
 	private void updateDynamic(final boolean dynamic) {
 		final BitSet bs = new BitSet();
 		bs.set(dynamic ? 1 : 0);
 		final ButtonBar b = ((ButtonBar) mainView
 				.findViewById(R.id.playlistManagerButtons));
 		b.highlight(null, bs);
 	}
 }