/***
    *     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.io.InputStream;
  import java.lang.ref.Reference;
  import java.lang.ref.SoftReference;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  import sk.baka.ambient.activity.main.MainActivity;
  import sk.baka.ambient.collection.ICollection;
  import sk.baka.ambient.collection.TrackOriginEnum;
  import sk.baka.ambient.commons.IOUtils;
  import sk.baka.ambient.commons.MiscUtils;
  import sk.baka.ambient.commons.ObjectStorage;
  import sk.baka.ambient.commons.SimpleBus;
  import sk.baka.ambient.library.Library;
  import sk.baka.ambient.lrc.LRCStorage;
  import android.app.Application;
  import android.os.Handler;
  import android.util.Log;
  
  /***
   * Serves mainly for a primary access point to a singleton data structures and
   * services, such as {@link Library}, {@link PlaylistPlayer} etc.
   * 
   * @author Martin Vysny
   */
  public final class AmbientApplication extends Application {
  
  	/***
  	 * The cover cache manager.
  	 */
  	private CoverCache covers;
  
  	/***
  	 * The karaoke lyrics cache manager.
  	 */
  	private LRCStorage karaoke;
  
  	/***
  	 * Stored playlists.
  	 */
  	private ObjectStorage storedPlaylists;
  
  	/***
  	 * The music library.
  	 */
  	private Library library;
  
  	/***
  	 * The playlist player.
  	 */
  	private PlaylistPlayer playlist;
  
  	/***
  	 * The message bus.
  	 */
  	private SimpleBus bus;
  
  	/***
  	 * The main message handler.
  	 */
  	private static Handler handler;
  
  	/***
  	 * Returns the main message loop handler.
  	 * 
  	 * @return the handler.
  	 */
  	public static Handler getHandler() {
  		if (handler == null) {
  			throw new IllegalStateException("null handler");
  		}
  		return handler;
  	}
  
  	private BackgroundOpExecutor backgroundTasks;
  
  	private PlaybackNotificator playbackNotificator;
  
  	private NetworkHandler networkHandler;
  
 	/***
 	 * Returns the playback notificator instance.
 	 * 
 	 * @return the instance, never <code>null</code>.
 	 */
 	public PlaybackNotificator getNotificator() {
 		return playbackNotificator;
 	}
 
 	@Override
 	public void onCreate() {
 		super.onCreate();
 		if (instance != null) {
 			throw new IllegalStateException("Not a singleton");
 		}
 		instance = this;
 		handler = new Handler();
 		errorHandler = new ErrorHandler(this);
 		try {
 			stateHandler = new AppStateHandler(this);
 			final ConfigurationBean config = stateHandler.getConfig();
 			final AppState state = stateHandler.getStartupState();
 			bus = new SimpleBus();
 			backgroundTasks = new BackgroundOpExecutor();
 			library = new Library(this);
 			covers = new CoverCache();
 			covers.setMaxStorageSize(config.coverCache * 1024);
 			covers.setCacheOverflowBehavior(config.dontDownloadOnCacheFull);
 			bus.addHandler(covers);
 			karaoke = new LRCStorage();
 			storedPlaylists = new ObjectStorage(".playlist");
 			playlist = new PlaylistPlayer(this);
 			// start with an empty static playlist
 			playlist.staticPlaylist();
 			stateHandler.registerStateAware(playlist);
 			new PhoneStateHandler(this);
 			playbackNotificator = new PlaybackNotificator(this);
 			networkHandler = new NetworkHandler(this);
 			networkHandler.setForcedOffline(!state.online);
 		} catch (Exception e) {
 			instance = null;
 			Log.e(AmbientApplication.class.getSimpleName(),
 					"Failed to initialize", e);
 			throw new RuntimeException(e);
 		}
 	}
 
 	/***
 	 * Sets the online/offline state.
 	 * 
 	 * @param offline
 	 *            if <code>true</code> then the application switches into
 	 *            offline mode.
 	 */
 	public void setOffline(final boolean offline) {
 		networkHandler.setForcedOffline(offline);
 	}
 
 	/***
 	 * Retrieves current offline state.
 	 * 
 	 * @return if <code>true</code> then the application is in the offline mode.
 	 */
 	public boolean isOffline() {
 		return networkHandler.isOffline();
 	}
 
 	/***
 	 * The error handler.
 	 */
 	private ErrorHandler errorHandler;
 
 	/***
 	 * Returns the error handler instance.
 	 * 
 	 * @return the error handler instance, never <code>null</code>.
 	 */
 	public ErrorHandler getErrorHandler() {
 		return errorHandler;
 	}
 
 	/***
 	 * The application state and configuration handler instance.
 	 */
 	private AppStateHandler stateHandler;
 
 	/***
 	 * Returns the application state and configuration handler instance.
 	 * 
 	 * @return the application state and configuration handler instance, never
 	 *         <code>null</code>.
 	 */
 	public AppStateHandler getStateHandler() {
 		return stateHandler;
 	}
 
 	/***
 	 * Checks if {@link MainActivity} is visible.
 	 * 
 	 * @return <code>true</code> if the activity is visible, <code>false</code>
 	 *         otherwise.
 	 */
 	public boolean isMainActivityVisible() {
 		return stateHandler.containsStateAware(MainActivity.class);
 	}
 
 	/***
 	 * Returns the cover cache manager instance.
 	 * 
 	 * @return the cover cache manager.
 	 */
 	public CoverCache getCovers() {
 		return covers;
 	}
 
 	/***
 	 * Returns the karaoke lyrics manager instance.
 	 * 
 	 * @return the karaoke lyrics manager.
 	 */
 	public LRCStorage getKaraoke() {
 		return karaoke;
 	}
 
 	/***
 	 * Returns the cover cache manager instance.
 	 * 
 	 * @return the cover cache manager.
 	 */
 	public ObjectStorage getPlaylistStorage() {
 		return storedPlaylists;
 	}
 
 	private static AmbientApplication instance;
 
 	/***
 	 * Returns application instance.
 	 * 
 	 * @return the application instance.
 	 */
 	public static AmbientApplication getInstance() {
 		if (instance == null) {
 			throw new IllegalStateException("Not yet initialized");
 		}
 		return instance;
 	}
 
 	/***
 	 * Returns singleton instance of the library which stores Magnatune tracks.
 	 * 
 	 * @return never <code>null</code>
 	 */
 	public Library getLibrary() {
 		return library;
 	}
 
 	/***
 	 * Returns the background tasks executor.
 	 * 
 	 * @return non-<code>null</code> instance of executor.
 	 */
 	public BackgroundOpExecutor getBackgroundTasks() {
 		return backgroundTasks;
 	}
 
 	/***
 	 * Returns singleton instance of the playlist.
 	 * 
 	 * @return never <code>null</code>.
 	 */
 	public PlaylistPlayer getPlaylist() {
 		return playlist;
 	}
 
 	/***
 	 * Returns the message bus.
 	 * 
 	 * @return the message bus.
 	 */
 	public SimpleBus getBus() {
 		return bus;
 	}
 
 	@Override
 	public void onTerminate() {
 		try {
 			try {
 				bus.clear();
 				// terminate tasks after the bus is clear, to prevent events
 				// from popping up.
 				networkHandler.destroy();
 				playbackNotificator.destroy();
 				backgroundTasks.terminate();
 				playlist.close();
 				library.close();
 			} catch (final Exception ex) {
 				Log.e(AmbientApplication.class.getSimpleName(),
 						"Errors while shutting down: " + ex.getMessage(), ex);
 			}
 		} finally {
 			super.onTerminate();
 		}
 	}
 
 	/***
 	 * An error occurred. A notification will be shown to the user.
 	 * 
 	 * @param sender
 	 *            the sender.
 	 * @param error
 	 *            error if <code>true</code>, warning if <code>false</code>.
 	 * @param message
 	 *            the message to show. The message will be followed by a new
 	 *            line, the <code>Cause: </code> string and the
 	 *            {@link Throwable#getMessage()} if the cause is not
 	 *            <code>null</code>.
 	 * @param cause
 	 *            optional cause.
 	 */
 	public void error(final Class<?> sender, boolean error, String message,
 			Throwable cause) {
 		errorHandler.error(sender, error, message, cause);
 	}
 
 	private Reference<Object> clipboard = null;
 
 	/***
 	 * Sets clipboard contents.
 	 * 
 	 * @param obj
 	 *            the clipboard object to set.
 	 */
 	public void setClipboard(final Object obj) {
 		clipboard = new SoftReference<Object>(obj);
 		bus.getInvocator(IApplicationListener.class, true).clipboardChanged();
 	}
 
 	/***
 	 * Retrieves a clipboard object.
 	 * 
 	 * @return the clipboard object, may be <code>null</code> if the clipboard
 	 *         was cleared, either by client or by the garbage collector.
 	 */
 	public Object getClipboard() {
 		if (clipboard == null)
 			return null;
 		return clipboard.get();
 	}
 
 	/***
 	 * Checks if the application is shutting down.
 	 * 
 	 * @return <code>true</code> if we are shutting down, <code>false</code>
 	 *         otherwise.
 	 */
 	public boolean isShutdown() {
 		return isShutdown;
 	}
 
 	private boolean isShutdown = false;
 
 	/***
 	 * Shuts down the application.
 	 */
 	public void shutdown() {
 		isShutdown = true;
 		onTerminate();
 	}
 
 	private final ConcurrentMap<TrackOriginEnum, ICollection> providers = new ConcurrentHashMap<TrackOriginEnum, ICollection>();
 
 	/***
 	 * Registers new provider for given origin. The provider will be used only
 	 * for location fixing and must support
 	 * {@link ICollection#fixLocations(java.util.Collection)}.
 	 * 
 	 * @param origin
 	 *            the origin
 	 * @param provider
 	 *            the provider instance.
 	 */
 	public void registerProvider(final TrackOriginEnum origin,
 			final ICollection provider) {
 		if (!provider.supportsLocationFix()) {
 			throw new IllegalArgumentException("Does not support location fix");
 		}
 		providers.put(origin, provider);
 	}
 
 	/***
 	 * Returns the provider for given origin. May return <code>null</code> if no
 	 * such provider was registered.
 	 * 
 	 * @param origin
 	 *            the origin
 	 * @return the provider instance.
 	 */
 	public ICollection getProvider(final TrackOriginEnum origin) {
 		return providers.get(origin);
 	}
 
 	/***
 	 * The Ambient version.
 	 */
 	private String version;
 
 	/***
 	 * Returns the Ambient version.
 	 * 
 	 * @return the version string or "unknown" if the version is not available.
 	 */
 	public String getVersion() {
 		if (version != null) {
 			return version;
 		}
 		final InputStream in = getClassLoader().getResourceAsStream("version");
 		if (in != null) {
 			try {
 				version = IOUtils.readLine(in);
 			} catch (Exception ex) {
 				Log.e(getClass().getSimpleName(), "Failed to get version", ex);
 				version = "unknown";
 			} finally {
 				MiscUtils.closeQuietly(in);
 			}
 		}
 		return version;
 	}
 }