/***
    *     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.List;
  
  import sk.baka.ambient.ActionsEnum;
  import sk.baka.ambient.commons.SimpleBus;
  import android.util.Log;
  
  /***
   * Groups given controllers together and allows group operations over them.
   * 
   * @author Martin Vysny
   */
  public final class ControllerGroup {
  	/***
  	 * Creates new group controller.
  	 */
  	public ControllerGroup() {
  		super();
  	}
  
  	private final List<AbstractController> controllers = new ArrayList<AbstractController>();
  	private final List<ActionsEnum> actions = new ArrayList<ActionsEnum>();
  
  	/***
  	 * Registers a controller to this group.
  	 * 
  	 * @param controller
  	 *            the controller to register.
  	 * @param action
  	 *            action which triggers visibility of this controller.
  	 */
  	public void add(final AbstractController controller,
  			final ActionsEnum action) {
  		controllers.add(controller);
  		actions.add(action);
  	}
  
  	/***
  	 * Destroys all controllers. Exceptions are catched and logged.
  	 */
  	public void destroy() {
  		for (final AbstractController c : controllers) {
  			try {
  				c.destroy();
  			} catch (Exception ex) {
  				Log.e(ControllerGroup.class.getSimpleName(),
  						"Error destroying controller: " + ex.getMessage(), ex);
  			}
  		}
  		controllers.clear();
  		actions.clear();
  	}
  
  	/***
  	 * Hides all other controllers and flips the visibility of given controller.
  	 * 
  	 * @param controller
  	 *            the controller to show/hide. If <code>null</code> then all
  	 *            controllers are hidden.
  	 * @param visibility
  	 *            set this visibility for the controller. If <code>null</code>
  	 *            then the visibility is flipped.
  	 */
  	public void flipVisibility(final AbstractController controller,
  			final Boolean visibility) {
  		for (final AbstractController c : controllers) {
  			if (c != controller) {
  				c.hide();
  			} else {
  				if (visibility == null) {
  					c.flipVisibility();
  				} else {
  					c.setVisibility(visibility);
  				}
  			}
  		}
  	}
  
  	/***
 	 * Returns the visible controller.
 	 * 
 	 * @return index of the visible controller or <code>-1</code> if no such
 	 *         controller exists.
 	 */
 	public int getVisibleControllerIndex() {
 		for (int i = 0; i < controllers.size(); i++) {
 			if (controllers.get(i).isVisible())
 				return i;
 		}
 		return -1;
 	}
 
 	/***
 	 * Returns the visible controller.
 	 * 
 	 * @return index of the visible controller or <code>-1</code> if no such
 	 *         controller exists.
 	 */
 	public AbstractController getVisibleController() {
 		for (int i = 0; i < controllers.size(); i++) {
 			final AbstractController c = controllers.get(i);
 			if (c.isVisible()) {
 				return c;
 			}
 		}
 		return null;
 	}
 
 	/***
 	 * Returns action which triggers visibility of this controller.
 	 * 
 	 * @param controller
 	 *            the controller, may be <code>null</code>.
 	 * @return the action or <code>null</code> if no such controller exists or
 	 *         it has no action attached.
 	 */
 	public ActionsEnum getActionForController(
 			final AbstractController controller) {
 		final int index = controllers.indexOf(controller);
 		if (index < 0) {
 			return null;
 		}
 		return actions.get(index);
 	}
 
 	/***
 	 * Unregisters all controllers from given bus.
 	 * 
 	 * @param bus
 	 *            the bus to unregister controllers from.
 	 */
 	public void unregister(final SimpleBus bus) {
 		for (final AbstractController c : controllers) {
 			bus.removeHandler(c);
 		}
 	}
 
 	/***
 	 * Registers all controllers from given bus. Invokes
 	 * {@link AbstractController#update(sk.baka.ambient.commons.Interval)} on
 	 * all controllers.
 	 * 
 	 * @param bus
 	 *            the bus to unregister controllers from.
 	 */
 	public void registerAndUpdate(final SimpleBus bus) {
 		for (final AbstractController c : controllers) {
 			bus.addHandler(c);
 			c.update(null);
 		}
 	}
 
 	/***
 	 * Returns controller present at given index. Returns <code>null</code> if
 	 * the index is invalid.
 	 * 
 	 * @param index
 	 *            the index
 	 * @return controller instance or <code>null</code>.
 	 */
 	public AbstractController get(int index) {
 		return ((index < 0) || (index >= controllers.size())) ? null
 				: controllers.get(index);
 	}
 
 	/***
 	 * Returns first controller with given class (or subclass of given class).
 	 * 
 	 * @param <T>
 	 *            the controller type
 	 * @param clazz
 	 *            the controller class
 	 * @return non-<code>null</code> controller instance.
 	 * @throws IllegalArgumentException
 	 *             if no such controller exists.
 	 */
 	public <T extends AbstractController> T getController(final Class<T> clazz) {
 		for (final AbstractController c : controllers) {
 			if (clazz.isInstance(c)) {
 				return clazz.cast(c);
 			}
 		}
 		throw new IllegalArgumentException("No such controller: "
 				+ clazz.getName());
 	}
 
 	public void zoom(boolean zoom) {
 		for (final AbstractController c : controllers) {
 			c.zoom(zoom);
 		}
 	}
 }