/***
    *     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.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.
   * Thread-unsafe, should be invoked from the main Handler instance only.
   * 
   * @author Martin Vysny
   */
  final class PowerHandler extends BroadcastReceiver implements
  		IPlaylistPlayerListener {
  
  	private final AmbientApplication app;
  
  	/***
  	 * Creates new power handler.
  	 * 
  	 * @param app
  	 *            owner application.
  	 */
  	public PowerHandler(final AmbientApplication app) {
  		this.app = app;
  		app.getBus().addHandler(this);
  		app.registerReceiver(this, new IntentFilter(
  				ConnectivityManager.CONNECTIVITY_ACTION));
  	}
  
  	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(PowerHandler.class.getName());
 		Log.i(PowerHandler.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(PowerHandler.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();
 			return;
 		}
 		if (intent
 				.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER, false)) {
 			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();
 			}
 		}
 	}
 }