/***
    *     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 sk.baka.ambient.collection.TrackMetadataBean;
  import sk.baka.ambient.commons.Interval;
  import sk.baka.ambient.commons.ThreadUnsafe;
  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.content.BroadcastReceiver;
  import android.content.Context;
  import android.content.Intent;
  import android.content.IntentFilter;
  import android.net.ConnectivityManager;
  import android.net.NetworkInfo;
  import android.net.wifi.WifiManager;
  import android.net.wifi.WifiManager.WifiLock;
  import android.util.Log;
  
  /***
   * Ensures that the WiFi is not turned off while playing an online content.
   * Moreover, monitors the network status info and fires online/offline events.
   * Initially, the handler expects the phone to be offline - if not, an event is
   * fired.
   * <p/>
   * Thread-unsafe, should be invoked from the main Handler instance only.
   * 
   * @author Martin Vysny
   */
  @ThreadUnsafe
  final class NetworkHandler extends BroadcastReceiver implements
  		IPlaylistPlayerListener {
  
  	private final AmbientApplication app;
  
  	/***
  	 * Creates new power handler.
  	 * 
  	 * @param app
  	 *            owner application.
  	 */
  	public NetworkHandler(final AmbientApplication app) {
  		this.app = app;
  		app.getBus().addHandler(this);
  		app.registerReceiver(this, new IntentFilter(
  				ConnectivityManager.CONNECTIVITY_ACTION));
  		onNetworkStateChanged(computeOffline());
  	}
  
  	public void playbackStateChanged(PlayerStateEnum state) {
  		if (state == PlayerStateEnum.Stopped) {
  			freeWifiLock();
  		} else if (state == PlayerStateEnum.Playing) {
  			lockWifiIfNecessary(null, false);
  		}
  	}
  
  	public void playlistChanged(Interval target) {
  		// do nothing
  	}
  
  	public void randomChanged(Random random) {
  		// do nothing
  	}
  
  	public void repeatChanged(Repeat repeat) {
  		// do nothing
  	}
  
  	public void trackChanged(PlaylistItem track, boolean play,
  			int positionMillis) {
  		if (play) {
  			if (track.getTrack().isLocal()) {
  				freeWifiLock();
  				return;
  			}
  			lockWifiIfNecessary(track.getTrack(), false);
  		}
  	}
  
  	private void lockWifiIfNecessary(final TrackMetadataBean track,
 			final boolean wifiConnected) {
 		if (wifiLock != null) {
 			// already locked. bail out
 			return;
 		}
 		if (track == null) {
 			final TrackMetadataBean t = app.getPlaylist()
 					.getCurrentlyPlayingTrack();
 			if (t != null) {
 				lockWifiIfNecessary(t, wifiConnected);
 			}
 			return;
 		}
 		if (track.isLocal()) {
 			return;
 		}
 		if (!wifiConnected && !isWifiConnected()) {
 			return;
 		}
 		// okay, might be using WiFi to access the server. Lock it
 		final WifiManager wifiMan = (WifiManager) app
 				.getSystemService(Context.WIFI_SERVICE);
 		wifiLock = wifiMan.createWifiLock(NetworkHandler.class.getName());
 		Log.i(NetworkHandler.class.getSimpleName(), "Acquiring WiFi lock");
 		wifiLock.acquire();
 	}
 
 	private boolean isWifiConnected() {
 		final ConnectivityManager manager = (ConnectivityManager) app
 				.getSystemService(Context.CONNECTIVITY_SERVICE);
 		final NetworkInfo info = manager
 				.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
 		return info != null && info.isConnected();
 	}
 
 	private WifiLock wifiLock = null;
 
 	public void trackPositionChanged(int position, boolean playing) {
 		// do nothing
 	}
 
 	/***
 	 * Destroys this handler and drops any power locks being held.
 	 */
 	void destroy() {
 		app.unregisterReceiver(this);
 		freeWifiLock();
 	}
 
 	private void freeWifiLock() {
 		if (wifiLock != null) {
 			Log.i(NetworkHandler.class.getSimpleName(), "Dropping WiFi lock");
 			wifiLock.release();
 			wifiLock = null;
 		}
 	}
 
 	@Override
 	public void onReceive(Context context, Intent intent) {
 		if (intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY,
 				false)) {
 			freeWifiLock();
 			onNetworkStateChanged(true);
 			return;
 		}
 		if (intent
 				.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER, false)) {
 			onNetworkStateChanged(!app.getStateHandler().getStartupState().online);
 			final boolean isPlaying = app.getPlaylist().getPlaybackState() == PlayerStateEnum.Playing;
 			if (!isPlaying) {
 				// do nothing
 				return;
 			}
 			final NetworkInfo newInfo = intent
 					.getParcelableExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO);
 			if (newInfo == null) {
 				// probably still reconnecting. Do nothing and wait
 				return;
 			}
 			if (newInfo.getType() == ConnectivityManager.TYPE_WIFI) {
 				lockWifiIfNecessary(null, true);
 				return;
 			}
 			// switching to a non-WIFI Internet provider. The playback might
 			// still be using WIFI access though: check this possibility
 			if (!isWifiConnected()) {
 				freeWifiLock();
 			}
 		}
 	}
 
 	private boolean getNetworkOffline() {
 		final ConnectivityManager manager = (ConnectivityManager) app
 				.getSystemService(Context.CONNECTIVITY_SERVICE);
 		final NetworkInfo[] infos = manager.getAllNetworkInfo();
 		if (infos == null) {
 			return true;
 		}
 		for (final NetworkInfo info : infos) {
 			if (info == null) {
 				continue;
 			}
 			if (info.isConnected()) {
 				return false;
 			}
 		}
 		return true;
 	}
 
 	/***
 	 * Computes the off-line status of the phone.
 	 * 
 	 * @return computed off-line state.
 	 */
 	private boolean computeOffline() {
 		if (!app.getStateHandler().getStartupState().online) {
 			return true;
 		}
 		return getNetworkOffline();
 	}
 
 	private boolean lastOfflineValue = true;
 
 	/***
 	 * Sets the offline status. Note that this method may be used to force the
 	 * offline state only - it cannot be used to force us being online.
 	 * 
 	 * @param offline
 	 *            <code>true</code> forces the offline status,
 	 *            <code>false</code> resumes the network status auto-detection.
 	 */
 	public void setForcedOffline(boolean offline) {
 		app.getStateHandler().getStartupState().online = !offline;
 		onNetworkStateChanged(computeOffline());
 	}
 
 	private void onNetworkStateChanged(final boolean networkOffline) {
 		if (networkOffline == lastOfflineValue) {
 			return;
 		}
 		lastOfflineValue = networkOffline;
 		app.getBackgroundTasks().setOffline(networkOffline);
 		app.getBus().getInvocator(IApplicationListener.class, true).offline(
 				networkOffline);
 	}
 
 	/***
 	 * Checks if the player is currently off-line.
 	 * 
 	 * @return <code>true</code> if the player is off-line, <code>false</code>
 	 *         if it is on-line.
 	 */
 	public boolean isOffline() {
 		return lastOfflineValue;
 	}
 }