/*
 * Southampton University Map App
 * Copyright (C) 2011  Christopher Baines
 * 
 * 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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

package net.cbaines.suma;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;

import org.osmdroid.DefaultResourceProxyImpl;
import org.osmdroid.ResourceProxy;
import org.osmdroid.tileprovider.tilesource.TileSourceFactory;
import org.osmdroid.util.GeoPoint;
import org.osmdroid.views.MapController;
import org.osmdroid.views.MapView;
import org.osmdroid.views.overlay.MyLocationOverlay;
import org.osmdroid.views.overlay.Overlay;
import org.osmdroid.views.overlay.PathOverlay;
import org.osmdroid.views.overlay.ScaleBarOverlay;
import org.osmdroid.views.util.constants.MapViewConstants;

import android.app.AlertDialog;
import android.app.Dialog;
import android.app.SearchManager;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Color;
import android.graphics.DashPathEffect;
import android.graphics.Paint;
import android.net.Uri;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AdapterView.OnItemLongClickListener;

import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.stmt.PreparedQuery;
import com.j256.ormlite.stmt.QueryBuilder;

/**
 * 
 * @author Christopher Baines <cbaines8@gmail.com>
 * 
 */
public class MapActivity extends ToastHelperActivity implements MapViewConstants, RouteColorConstants, OnItemClickListener,
		OnItemLongClickListener, OnSharedPreferenceChangeListener, Preferences {

	private MapView mapView;
	private MapController mapController;
	private ResourceProxy mResourceProxy;

	private long startTime;

	static final int VIEW_DIALOG_ID = 0;
	static final int FAVOURITE_DIALOG_ID = 1;
	static final int WELCOME_DIALOG_ID = 2;
	static final int SEARCH_RESULTS_DIALOG_ID = 3;

	private ArrayList<POI> searchResults = null;

	private FavouritesDialog favDialog;

	private HashMap<String, Overlay> overlays = new HashMap<String, Overlay>();
	private HashMap<String, Overlay> pastOverlays;

	// Overlays

	// -- Building Overlays
	static final String BUILDING_OVERLAYS = "buildingOverlays:";

	// ---- Residential Building Overlay
	private static final String RESIDENTIAL_BUILDING_OVERLAY = "residentialBuildingOverlay";
	private BuildingNumOverlay residentialBuildingOverlay;
	static final boolean RESIDENTIAL_BUILDING_OVERLAY_ENABLED_BY_DEFAULT = true;
	private static final int RESIDENTIAL_BUILDING_OVERLAY_RANK = 6;

	// ---- Non-Residential Building Overlay
	private static final String NON_RESIDENTIAL_BUILDING_OVERLAY = "nonResidentialBuildingOverlay";
	private BuildingNumOverlay nonResidentialBuildingOverlay;
	static final boolean NON_RESIDENTIAL_BUILDING_OVERLAY_ENABLED_BY_DEFAULT = true;
	private static final int NON_RESIDENTIAL_BUILDING_OVERLAY_RANK = 5;

	static final String[] BUILDING_TYPES = { RESIDENTIAL_BUILDING_OVERLAY, NON_RESIDENTIAL_BUILDING_OVERLAY };

	// -- Bus Stop Overlays
	static final String BUS_STOP_OVERLAYS = "busStopOverlays:";

	// ---- Uni-Link Bus Stop Overlay
	private static final String UNI_LINK_BUS_STOP_OVERLAY = "uniLinkBusStopOverlay";
	private BusStopOverlay uniLinkBusStopOverlay;
	static final boolean UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT = true;
	private static final int UNI_LINK_BUS_STOP_OVERLAY_RANK = 3;

	// ---- Non Uni-Link Bus Stop Overlay
	private BusStopOverlay nonUniLinkBusStopOverlay;
	private static final int NON_UNI_LINK_BUS_STOP_OVERLAY_RANK = 4;

	// -- Site Overlays
	static final String[] SITE_NAMES = { "Highfield Campus", "Boldrewood Campus", "Avenue Campus", "Winchester School of Art",
			"The University of Southampton Science Park", "National Oceanography Centre Campus", "Boat House",
			"Southampton General Hospital", "Royal South Hants Hospital", "Belgrave Industrial Site", "Highfield Hall",
			"Glen Eyre Hall", "South Hill Hall", "Chamberlain Hall", "Hartley Grove", "Bencraft Hall", "Connaught Hall",
			"Montefiore Hall", "Stoneham Hall", "Erasmus Park" };

	private static final String SITE_OVERLAYS = "siteOverlays:";
	private HashMap<Site, PathOverlay> siteOverlays = new HashMap<Site, PathOverlay>(21);
	static final boolean SITE_OVERLAYS_ENABLED_BY_DEFAULT = false;
	private static final int SITE_OVERLAYS_RANK = 8;

	// -- Route Overlays
	private static final String BUS_ROUTE_OVERLAYS = "routeOverlays:";
	private HashMap<BusRoute, PathOverlay> busRouteOverlays = new HashMap<BusRoute, PathOverlay>(5);
	static final boolean BUS_ROUTE_OVERLAYS_ENABLED_BY_DEFAULT = true;
	private static final int BUS_ROUTE_OVERLAYS_RANK = 7;

	// -- Other
	static final String OTHER_OVERLAYS = "otherOverlay:";

	// ---- Scale Bar Overlay
	private static final String SCALE_BAR_OVERLAY = "scaleBarOverlay";
	private ScaleBarOverlay scaleBarOverlay;
	static final boolean SCALE_BAR_OVERLAY_ENABLED_BY_DEFAULT = true;
	private static final int SCALE_BAR_OVERLAY_RANK = 1;

	// ---- My Location Overlay
	private static final String MY_LOCATION_OVERLAY = "myLocationOverlay";
	private static final String MY_LOCATION_OVERLAY_COMPASS = "myLocationOverlayCompass";
	private MyLocationOverlay myLocationOverlay;
	static final boolean MY_LOCATION_OVERLAY_ENABLED_BY_DEFAULT = true;
	static final boolean MY_LOCATION_OVERLAY_COMPASS_ENABLED_BY_DEFAULT = true;
	private static final int MY_LOCATION_OVERLAY_RANK = 2;

	static final String[] OTHER_OVERLAY_NAMES = { SCALE_BAR_OVERLAY, MY_LOCATION_OVERLAY_COMPASS, MY_LOCATION_OVERLAY };

	// Other bits

	// Uni-Link routes
	static final String[] UNI_LINK_ROUTES = { "U1", "U1N", "U2", "U6", "U9" };

	static final String[] PREFERENCES_GROUPS = { BUS_STOP_OVERLAYS, BUS_ROUTE_OVERLAYS, BUILDING_OVERLAYS, SITE_OVERLAYS,
			OTHER_OVERLAYS };

	static final String[][] PREFERENCES_CHILDREN = { UNI_LINK_ROUTES, UNI_LINK_ROUTES, BUILDING_TYPES, SITE_NAMES,
			OTHER_OVERLAY_NAMES };

	private MapActivity instance;

	private SearchResultsDialog searchResultsDialog;

	private static final String TAG = "MapActivity";

	@SuppressWarnings("unchecked")
	public void onCreate(Bundle savedInstanceState) {
		startTime = System.currentTimeMillis();

		super.onCreate(savedInstanceState);

		instance = this;

		try {
			File dbFile = new File(DATABASE_PATH + DATABASE_NAME);
			if (dbFile.exists()) {
				Log.i(TAG, "Database exists");

				SQLiteDatabase checkDB = SQLiteDatabase.openDatabase(DATABASE_PATH + DATABASE_NAME, null,
						SQLiteDatabase.OPEN_READONLY);
				int version = checkDB.getVersion();
				checkDB.close();

				if (version != DATABASE_VERSION) {
					Log.i(TAG, "Not the right version");

					copyDatabase();
				}
			} else {
				Log.i(TAG, "Database does not exist");

				SQLiteDatabase db = getHelper().getWritableDatabase();

				if (USE_BUNDLED_DATABASE) {
					db.close();

					copyDatabase();
				} else {
					Log.i(TAG, "Creating database");

					try {
						DataManager.createDatabase(instance);
					} catch (SQLException e) {
						e.printStackTrace();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}

		setContentView(R.layout.map_activity);

		Log.i(TAG, "Finished setting content view " + (System.currentTimeMillis() - startTime));

		mapView = (MapView) this.findViewById(R.id.mapview);
		mapView.setTileSource(TileSourceFactory.MAPQUESTOSM);
		mapView.setBuiltInZoomControls(true);
		mapView.setMultiTouchControls(true);

		pastOverlays = (HashMap<String, Overlay>) getLastNonConfigurationInstance();

		/*
		 * SensorManager mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); This code in the following
		 * constructor causes problems in some emulators, disable sensors to fix.
		 */
		Log.i(TAG, "Starting creating myLocationOverlay");
		myLocationOverlay = new MyLocationOverlay(instance, mapView);
		myLocationOverlay.setEnabled(true);
		Log.i(TAG, "Finished creating myLocationOverlay");

		new Thread(new Runnable() {
			public void run() {
				try {
					showOverlays();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		}).start();

		Log.i(TAG, "Started loading thread " + (System.currentTimeMillis() - startTime));

		mapController = mapView.getController();
		mResourceProxy = new DefaultResourceProxyImpl(getApplicationContext());

		GeoPoint startLocation = null;

		Intent intent = getIntent();
		Bundle extras = intent.getExtras();

		if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
			String query = intent.getStringExtra(SearchManager.QUERY);

			searchResults = new ArrayList<POI>();

			try {
				Dao<Building, String> buildingDao = getHelper().getBuildingDao();

				QueryBuilder<Building, String> buildingQueryBuilder = buildingDao.queryBuilder();
				buildingQueryBuilder.where().like(Building.ID_FIELD_NAME, "%" + query + "%").or()
						.like(Building.NAME_FIELD_NAME, "%" + query + "%");
				PreparedQuery<Building> buildingPreparedQuery = buildingQueryBuilder.prepare();
				List<Building> buildings = buildingDao.query(buildingPreparedQuery);
				searchResults.addAll(buildings);
				buildings = null;

				Dao<BusStop, String> busStopDao = getHelper().getBusStopDao();

				QueryBuilder<BusStop, String> busStopQueryBuilder = busStopDao.queryBuilder();
				busStopQueryBuilder.where().like(BusStop.ID_FIELD_NAME, "%" + query + "%").or()
						.like(BusStop.DESCRIPTION_FIELD_NAME, "%" + query + "%");
				PreparedQuery<BusStop> busStopPreparedQuery = busStopQueryBuilder.prepare();
				List<BusStop> busStops = busStopDao.query(busStopPreparedQuery);
				searchResults.addAll(busStops);
				busStops = null;

				Dao<Site, String> siteDao = getHelper().getSiteDao();

				QueryBuilder<Site, String> siteQueryBuilder = siteDao.queryBuilder();
				siteQueryBuilder.where().like(Site.NAME_FIELD_NAME, "%" + query + "%").or()
						.like(Site.ID_FIELD_NAME, "%" + query + "%");
				PreparedQuery<Site> sitePreparedQuery = siteQueryBuilder.prepare();
				List<Site> sites = siteDao.query(sitePreparedQuery);
				searchResults.addAll(sites);
				sites = null;

				Collections.sort(searchResults, new StringPOIDistanceComparator(query));

				startLocation = new GeoPoint(50935551, -1393488);
				mapController.setZoom(15);

				showDialog(SEARCH_RESULTS_DIALOG_ID);

				searchResultsDialog.setTitle(getResources().getString(R.string.search_results_dialog_title) + query);
				if (searchResults.size() == 0) {
					searchResultsDialog.setMessage("No results found");
				} else {
					searchResultsDialog.setItems(searchResults);
				}

			} catch (SQLException e) {
				e.printStackTrace();
			}

		} else if (intent.getDataString() != null) {
			String dataString = getIntent().getDataString();

			Log.i(TAG, "getIntent().getDataString() " + dataString);

			if (dataString.startsWith("content")) {

				Uri data = intent.getData();

				Log.i("Data: ", data.toString());

				startLocation = new GeoPoint(50935551, -1393488);
			} else {

				String str = getIntent().getDataString().substring(4, getIntent().getDataString().length());
				String[] strParts = str.split(",");

				int lat = Util.doubleToIntE6(Double.valueOf(strParts[0]));
				int lng;

				if (strParts[1].contains("?")) {
					String zoom = strParts[1].substring(strParts[1].indexOf("?") + 3, strParts[1].length());
					String strLng = strParts[1].substring(0, strParts[1].indexOf("?") - 1);
					lng = Util.doubleToIntE6(Double.valueOf(strLng));

					mapController.setZoom(Integer.valueOf(zoom));
				} else {
					lng = Util.doubleToIntE6(Double.valueOf(strParts[1]));
					mapController.setZoom(15);
				}

				startLocation = new GeoPoint(lat, lng);
			}
		} else if (extras != null && extras.containsKey("poiPoint")) {
			String poiPoint = getIntent().getExtras().getString("poiPoint");
			Log.i(TAG, "poiPoint " + poiPoint);

			String[] bits = poiPoint.split(",");

			startLocation = new GeoPoint(Double.valueOf(bits[0]), Double.valueOf(bits[1]));
			mapController.setZoom(20);

		} else {
			startLocation = myLocationOverlay.getMyLocation();
			if (startLocation == null) {
				startLocation = new GeoPoint(50935551, -1393488); // ECS
			}
			mapController.setZoom(15);
		}

		mapController.setCenter(startLocation);

		final SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
		String appVersion = sharedPrefs.getString(APP_VERSION, APP_NOT_INSTALLED);

		if (appVersion.equals(APP_NOT_INSTALLED) || !appVersion.equals(CURRENT_APP_VERSION)) {
			showDialog(WELCOME_DIALOG_ID);
		}

		Log.i(TAG, "Finished onCreate " + (System.currentTimeMillis() - startTime));
	}

	private void copyDatabase() throws IOException {
		Log.i(TAG, "Begining copy database");

		InputStream myInput = getAssets().open(DATABASE_NAME);

		// Path to the just created empty db
		String outFileName = DATABASE_PATH + DATABASE_NAME;

		File database = new File(outFileName);
		if (database.exists()) {
			database.delete();
		}

		// Open the empty db as the output stream
		OutputStream myOutput = new FileOutputStream(outFileName);

		// transfer bytes from the inputfile to the outputfile
		byte[] buffer = new byte[1024];
		int length;
		while ((length = myInput.read(buffer)) > 0) {
			myOutput.write(buffer, 0, length);
		}

		// Close the streams

		myOutput.flush();

		myOutput.close();
		myInput.close();

		Log.i(TAG, "Finished copying db");
	}

	public void onResume() {
		super.onResume();
		Log.i(TAG, "OnResume " + (System.currentTimeMillis() - startTime));
		if (myLocationOverlay != null) {
			final SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
			final SharedPreferences activityPrefs = getPreferences(0);

			if (activityPrefs.getBoolean(OTHER_OVERLAYS + MY_LOCATION_OVERLAY_COMPASS,
					MY_LOCATION_OVERLAY_COMPASS_ENABLED_BY_DEFAULT)) {
				myLocationOverlay.enableCompass();
			} else {
				myLocationOverlay.disableCompass();
			}

			if (activityPrefs.getBoolean(OTHER_OVERLAYS + MY_LOCATION_OVERLAY, MY_LOCATION_OVERLAY_ENABLED_BY_DEFAULT)
					&& sharedPrefs.getBoolean(GPS_ENABLED, GPS_ENABLED_BY_DEFAULT)) {
				// The following can cause problems in some emulators,
				myLocationOverlay.enableMyLocation();
			} else {
				myLocationOverlay.disableMyLocation();
			}

			sharedPrefs.registerOnSharedPreferenceChangeListener(this);
			activityPrefs.registerOnSharedPreferenceChangeListener(this);
		}
		Log.i(TAG, "Finished OnResume " + (System.currentTimeMillis() - startTime));
	}

	public void onPause() {
		super.onResume();
		Log.i(TAG, "OnPause");
		if (myLocationOverlay != null) {
			myLocationOverlay.disableMyLocation();
			myLocationOverlay.disableCompass();
		}
	}

	public void finish() {
		super.finish();
	}

	@Override
	public Object onRetainNonConfigurationInstance() {
		return overlays;
	}

	private void showOverlays() throws SQLException {
		Log.i(TAG, "Began showing overlays at " + (System.currentTimeMillis() - startTime));

		if (pastOverlays != null) {
			Log.i(TAG, "Able to recover some/all of the overlays from a previous activity");
		} else {
			Log.i(TAG, "Unable to recover overlays");
		}

		final SharedPreferences activityPrefs = getPreferences(0);

		showUtilityOverlays();

		showUniLinkBusStopOverlay();

		showNonUniLinkBusStopOverlay();

		if (activityPrefs.getBoolean(BUILDING_OVERLAYS + RESIDENTIAL_BUILDING_OVERLAY,
				RESIDENTIAL_BUILDING_OVERLAY_ENABLED_BY_DEFAULT)
				|| activityPrefs.getBoolean(BUILDING_OVERLAYS + NON_RESIDENTIAL_BUILDING_OVERLAY,
						NON_RESIDENTIAL_BUILDING_OVERLAY_ENABLED_BY_DEFAULT)) {
			showBuildingOverlays();
		}

		Log.v(TAG, "Begining to show the route overlays at " + (System.currentTimeMillis() - startTime));
		for (BusRoute busRoute : getHelper().getBusRouteDao()) {
			if (!busRoute.uniLink) {
				// Log.v(TAG, "Bus route " + busRoute.code + "(" + busRoute.id +
				// ") is not unilink");
				continue;
			}
			Log.v(TAG, "Looking at showing " + busRoute.code + " route overlay");
			if (activityPrefs.getBoolean(BUS_ROUTE_OVERLAYS + busRoute.code, BUS_ROUTE_OVERLAYS_ENABLED_BY_DEFAULT)) {
				showRouteOverlay(busRoute);
			}
		}
		Log.v(TAG, "Finished loading routes " + (System.currentTimeMillis() - startTime));

		Log.v(TAG, "Begining to show the site overlays at " + (System.currentTimeMillis() - startTime));
		try {
			for (Site site : getHelper().getSiteDao()) {
				// Log.v(TAG, "Looking at  showing " + site.name +
				// " site overlay");
				if (activityPrefs.getBoolean(SITE_OVERLAYS + site.name, SITE_OVERLAYS_ENABLED_BY_DEFAULT)) {
					showSiteOverlay(site);
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		Log.v(TAG, "Finished showing the site overlays " + (System.currentTimeMillis() - startTime));

		Log.v(TAG, "Finished showing all the overlays " + (System.currentTimeMillis() - startTime));
	}

	private void showUtilityOverlays() {
		new Thread(new Runnable() {
			public void run() {
				Log.i(TAG, "Begining showing the utility overlays " + (System.currentTimeMillis() - startTime));

				final SharedPreferences activityPrefs = getPreferences(0);
				final OverlayRankComparator comparator = new OverlayRankComparator(getPreferences(0));

				if (scaleBarOverlay != null) {
					Log.v(TAG, "ScaleBarOverlay is already created");
				} else {
					if (pastOverlays != null && (scaleBarOverlay = (ScaleBarOverlay) pastOverlays.get(SCALE_BAR_OVERLAY)) != null) {
						Log.i(TAG, "Finished restoring utility overlays " + (System.currentTimeMillis() - startTime));
					} else {
						scaleBarOverlay = new ScaleBarOverlay(instance);
					}

					overlays.put(SCALE_BAR_OVERLAY, scaleBarOverlay);

					synchronized (mapView.getOverlays()) {
						mapView.getOverlays().add(scaleBarOverlay);
						mapView.getOverlays().add(myLocationOverlay);
						Collections.sort(mapView.getOverlays(), comparator);
					}

				}

				scaleBarOverlay.setEnabled(activityPrefs.getBoolean(OTHER_OVERLAYS + SCALE_BAR_OVERLAY,
						SCALE_BAR_OVERLAY_ENABLED_BY_DEFAULT));

				mapView.postInvalidate();

				Log.i(TAG, "Finished showing utility overlays " + (System.currentTimeMillis() - startTime));
			}
		}).start();
	}

	private void showRouteOverlay(final BusRoute route) {
		new Thread(new Runnable() {
			public void run() {
				Log.i(TAG, "Begining showing route " + route.code + " overlay at " + (System.currentTimeMillis() - startTime));

				final SharedPreferences activityPrefs = getPreferences(0);
				final OverlayRankComparator comparator = new OverlayRankComparator(getPreferences(0));

				PathOverlay routeOverlay;
				if ((routeOverlay = busRouteOverlays.get(route)) != null) {
					Log.v(TAG, route.code + " route overlay already existed");
				} else {
					if (pastOverlays != null
							&& (routeOverlay = (PathOverlay) pastOverlays.get(BUS_ROUTE_OVERLAYS + route.code)) != null) {
						Log.v(TAG, "Restored " + route.code + " route overlay");
						if (route.code.equals("U1")) {
							PathOverlay routeOverlayU1E = (PathOverlay) pastOverlays.get(BUS_ROUTE_OVERLAYS + "U1E");
							overlays.put(BUS_ROUTE_OVERLAYS + "U1E", routeOverlayU1E);
						}
					} else {
						InputStream resource = null;
						int colour = 0;
						if (route.code.equals("U1")) {
							resource = getResources().openRawResource(R.raw.u1);
							colour = U1;

							// TODO Is this a route like U1N or, something else,
							// this hack works somewhat for now?
							PathOverlay routeOverlayU1E = DataManager.getRoutePath(getResources().openRawResource(R.raw.u1e),
									colour, mResourceProxy);
							routeOverlayU1E.getPaint().setAntiAlias(true);
							routeOverlayU1E.getPaint().setAlpha(145);
							routeOverlayU1E.getPaint().setStrokeWidth(12);
							routeOverlayU1E.getPaint().setPathEffect(new DashPathEffect(new float[] { 20, 16 }, 0));

							busRouteOverlays.put(new BusRoute(1000, "U1E", "U1E Route Label", true), routeOverlayU1E);
							overlays.put(BUS_ROUTE_OVERLAYS + "U1E", routeOverlayU1E);
							synchronized (mapView.getOverlays()) {
								mapView.getOverlays().add(routeOverlayU1E);
							}
						} else if (route.code.equals("U1N")) {
							resource = getResources().openRawResource(R.raw.u1n);
							colour = U1N;
						} else if (route.code.equals("U2")) {
							resource = getResources().openRawResource(R.raw.u2);
							colour = U2;
						} else if (route.code.equals("U6")) {
							resource = getResources().openRawResource(R.raw.u6);
							colour = U6;
						} else if (route.code.equals("U9")) {
							resource = getResources().openRawResource(R.raw.u9);
							colour = U9;
						} else {
							Log.w(TAG, "Wierd route " + route);
						}

						routeOverlay = DataManager.getRoutePath(resource, colour, mResourceProxy);

						Log.v(TAG, "Path overlay has " + routeOverlay.getNumberOfPoints() + " points");

						routeOverlay.getPaint().setAntiAlias(true);
						routeOverlay.getPaint().setAlpha(145);
						routeOverlay.getPaint().setStrokeWidth(12);
					}

					busRouteOverlays.put(route, routeOverlay);
					overlays.put(BUS_ROUTE_OVERLAYS + route.code, routeOverlay);

					synchronized (mapView.getOverlays()) {
						mapView.getOverlays().add(routeOverlay);
						Collections.sort(mapView.getOverlays(), comparator);
					}

				}

				routeOverlay.setEnabled(activityPrefs.getBoolean(BUS_ROUTE_OVERLAYS + route.code,
						BUS_ROUTE_OVERLAYS_ENABLED_BY_DEFAULT));
				if (route.code.equals("U1")) {
					overlays.get(BUS_ROUTE_OVERLAYS + "U1E").setEnabled(
							activityPrefs.getBoolean(BUS_ROUTE_OVERLAYS + "U1", BUS_ROUTE_OVERLAYS_ENABLED_BY_DEFAULT));
				}

				mapView.postInvalidate();

				Log.i(TAG, "Finished showing route " + route.code + " overlay at " + (System.currentTimeMillis() - startTime));
			}
		}).start();
	}

	private void showSiteOverlay(final Site site) {

		new Thread(new Runnable() {
			public void run() {
				Log.i(TAG, "Begining showing site " + site.name + " overlay at " + (System.currentTimeMillis() - startTime));

				final SharedPreferences activityPrefs = getPreferences(0);
				final OverlayRankComparator comparator = new OverlayRankComparator(getPreferences(0));

				PathOverlay siteOverlay;
				if ((siteOverlay = siteOverlays.get(site)) != null) {

				} else {
					if (pastOverlays != null && (siteOverlay = (PathOverlay) pastOverlays.get(SITE_OVERLAYS + site.name)) != null) {
						Log.i(TAG, "Restored " + site.name + " site overlay");
					} else {

						siteOverlay = new PathOverlay(Color.BLUE, instance);
						Paint paint = siteOverlay.getPaint();
						paint.setAntiAlias(true);
						paint.setStrokeWidth(1.5f);
						for (int i = 0; i < site.outline.points.length; i++) {
							siteOverlay.addPoint(site.outline.points[i]);
						}
						siteOverlay.addPoint(site.outline.points[0]);

					}

					siteOverlays.put(site, siteOverlay);
					overlays.put(SITE_OVERLAYS + site.name, siteOverlay);

					Log.v(TAG, "Applyed the site overlay, now sorting them");

					synchronized (mapView.getOverlays()) {
						mapView.getOverlays().add(siteOverlay);
						Collections.sort(mapView.getOverlays(), comparator);
					}
				}

				siteOverlay.setEnabled(activityPrefs.getBoolean(SITE_OVERLAYS + site.name, SITE_OVERLAYS_ENABLED_BY_DEFAULT));

				mapView.postInvalidate();

				Log.i(TAG, "Finished showing site " + site.name + " overlay at " + (System.currentTimeMillis() - startTime));
			}
		}).start();
	}

	private void showBuildingOverlays() {
		new Thread(new Runnable() {
			public void run() {
				Log.i(TAG, "Begining showing building overlays at " + (System.currentTimeMillis() - startTime));

				final SharedPreferences activityPrefs = getPreferences(0);
				final OverlayRankComparator comparator = new OverlayRankComparator(getPreferences(0));

				if (residentialBuildingOverlay != null) {

				} else {
					if (pastOverlays != null
							&& (residentialBuildingOverlay = (BuildingNumOverlay) pastOverlays.get(RESIDENTIAL_BUILDING_OVERLAY)) != null) {
						nonResidentialBuildingOverlay = (BuildingNumOverlay) pastOverlays.get(NON_RESIDENTIAL_BUILDING_OVERLAY);

						Log.i(TAG, "Restored building overlays");
					} else {
						try {

							Log.v(TAG, "Begining the creation of the building overlays");

							ArrayList<Building> residentialBuildings = new ArrayList<Building>();
							ArrayList<Building> nonResidentialBuildings = new ArrayList<Building>();

							Dao<Building, String> buildingDao;

							buildingDao = getHelper().getBuildingDao();

							final SharedPreferences favouritesPrefs = getSharedPreferences(FAVOURITES_PREFERENCES, MODE_PRIVATE);

							for (Building building : buildingDao) {
								if (building.residential == true) {
									if (favouritesPrefs.getBoolean(building.id, false)) {
										residentialBuildings.add(building);
									} else {
										residentialBuildings.add(0, building);
									}
								} else {
									if (favouritesPrefs.getBoolean(building.id, false)) {
										nonResidentialBuildings.add(building);
									} else {
										nonResidentialBuildings.add(0, building);
									}
								}
							}

							residentialBuildingOverlay = new BuildingNumOverlay(instance, residentialBuildings);
							nonResidentialBuildingOverlay = new BuildingNumOverlay(instance, nonResidentialBuildings);

							Log.v(TAG, "Applyed the site overlay, now sorting them");

						} catch (SQLException e) {
							e.printStackTrace();
						}
					}

					overlays.put(RESIDENTIAL_BUILDING_OVERLAY, residentialBuildingOverlay);
					overlays.put(NON_RESIDENTIAL_BUILDING_OVERLAY, nonResidentialBuildingOverlay);

					synchronized (mapView.getOverlays()) {
						mapView.getOverlays().add(residentialBuildingOverlay);
						mapView.getOverlays().add(nonResidentialBuildingOverlay);
						Collections.sort(mapView.getOverlays(), comparator);
					}
				}

				residentialBuildingOverlay.setEnabled(activityPrefs.getBoolean(BUILDING_OVERLAYS + RESIDENTIAL_BUILDING_OVERLAY,
						RESIDENTIAL_BUILDING_OVERLAY_ENABLED_BY_DEFAULT));
				nonResidentialBuildingOverlay.setEnabled(activityPrefs.getBoolean(BUILDING_OVERLAYS
						+ NON_RESIDENTIAL_BUILDING_OVERLAY, NON_RESIDENTIAL_BUILDING_OVERLAY_ENABLED_BY_DEFAULT));

				mapView.postInvalidate();

				Log.i(TAG, "Finished showing building overlays at " + (System.currentTimeMillis() - startTime));
			}
		}).start();
	}

	private void showUniLinkBusStopOverlay() {
		new Thread(new Runnable() {
			public void run() {
				Log.i(TAG, "Begining showing bus stop overlays at " + (System.currentTimeMillis() - startTime));

				final SharedPreferences activityPrefs = getPreferences(0);
				final OverlayRankComparator comparator = new OverlayRankComparator(getPreferences(0));

				if (uniLinkBusStopOverlay != null) {
					if (!activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U1", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)
							&& !activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U1N", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)
							&& !activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U2", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)
							&& !activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U6", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)
							&& !activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U9", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)) {
						Log.i(TAG, "Uni-Link bus stop overlay not needed");
						overlays.remove(UNI_LINK_BUS_STOP_OVERLAY);

						synchronized (mapView.getOverlays()) {
							mapView.getOverlays().remove(uniLinkBusStopOverlay);
							Collections.sort(mapView.getOverlays(), comparator);
						}

						uniLinkBusStopOverlay = null;
					} else {
						uniLinkBusStopOverlay.setRoutes(0,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U1", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
						uniLinkBusStopOverlay.setRoutes(1,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U1N", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
						uniLinkBusStopOverlay.setRoutes(2,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U2", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
						uniLinkBusStopOverlay.setRoutes(3,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U6", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
						uniLinkBusStopOverlay.setRoutes(4,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U9", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
					}
				} else {
					if (activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U1", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)
							|| activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U1N", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)
							|| activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U2", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)
							|| activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U6", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)
							|| activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U9", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)) {
						if (pastOverlays != null
								&& (uniLinkBusStopOverlay = (BusStopOverlay) pastOverlays.get(UNI_LINK_BUS_STOP_OVERLAY)) != null) {
							Log.i(TAG, "Restored Uni-Link bus stop overlay");
						} else {

							try {
								List<BusStop> busStops;
								Log.v(TAG, "Begin fetching BusStops at " + (System.currentTimeMillis() - startTime));

								busStops = getHelper().getBusStopDao().queryForEq(BusStop.UNI_LINK_FIELD_NAME, true);

								Log.v(TAG, "Finished fetching BusStops at " + (System.currentTimeMillis() - startTime));

								uniLinkBusStopOverlay = new BusStopOverlay(instance, busStops);
							} catch (SQLException e) {
								e.printStackTrace();
							}
						}

						uniLinkBusStopOverlay.setRoutes(0,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U1", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
						uniLinkBusStopOverlay.setRoutes(1,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U1N", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
						uniLinkBusStopOverlay.setRoutes(2,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U2", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
						uniLinkBusStopOverlay.setRoutes(3,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U6", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
						uniLinkBusStopOverlay.setRoutes(4,
								activityPrefs.getBoolean(BUS_STOP_OVERLAYS + "U9", UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));

						overlays.put(UNI_LINK_BUS_STOP_OVERLAY, uniLinkBusStopOverlay);

						Log.v(TAG, "Applyed the site overlay, now sorting them");

						synchronized (mapView.getOverlays()) {
							mapView.getOverlays().add(uniLinkBusStopOverlay);
							Collections.sort(mapView.getOverlays(), comparator);
						}
					}
				}

				mapView.postInvalidate();

				Log.i(TAG, "Finished showing bus stop overlays at " + (System.currentTimeMillis() - startTime));
			}
		}).start();
	}

	private void showNonUniLinkBusStopOverlay() {
		new Thread(new Runnable() {
			public void run() {
				Log.i(TAG, "Begining showing non uni link bus stop overlays at " + (System.currentTimeMillis() - startTime));

				// final SharedPreferences activityPrefs = getPreferences(0);
				final SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(instance);
				final OverlayRankComparator comparator = new OverlayRankComparator(getPreferences(0));

				if (nonUniLinkBusStopOverlay != null) {
					nonUniLinkBusStopOverlay.setEnabled(sharedPrefs.getBoolean(NON_UNI_LINK_BUS_STOPS_OVERLAY,
							NON_UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));

					Log.i(TAG,
							"nonUniLinkBusStopOverlay enabled ? "
									+ sharedPrefs.getBoolean(NON_UNI_LINK_BUS_STOPS_OVERLAY,
											NON_UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT));
				} else if (sharedPrefs.getBoolean(NON_UNI_LINK_BUS_STOPS_OVERLAY,
						NON_UNI_LINK_BUS_STOP_OVERLAY_ENABLED_BY_DEFAULT)) {
					if (pastOverlays != null
							&& (nonUniLinkBusStopOverlay = (BusStopOverlay) pastOverlays.get(NON_UNI_LINK_BUS_STOPS_OVERLAY)) != null) {
						Log.i(TAG, "Restored non Uni-Link bus stop overlays");
					} else {
						try {
							List<BusStop> busStops;
							Log.v(TAG, "Begin fetching non Uni-Link BusStops at " + (System.currentTimeMillis() - startTime));

							busStops = getHelper().getBusStopDao().queryForEq(BusStop.UNI_LINK_FIELD_NAME, false);

							Log.v(TAG,
									"Finished fetching " + busStops.size() + " non Uni-Link BusStops at "
											+ (System.currentTimeMillis() - startTime));

							nonUniLinkBusStopOverlay = new BusStopOverlay(instance, busStops);
						} catch (SQLException e) {
							e.printStackTrace();
						}
					}

					overlays.put(NON_UNI_LINK_BUS_STOPS_OVERLAY, nonUniLinkBusStopOverlay);

					Log.v(TAG, "Applyed the site overlay, now sorting them");

					synchronized (mapView.getOverlays()) {
						mapView.getOverlays().add(nonUniLinkBusStopOverlay);
						Collections.sort(mapView.getOverlays(), comparator);
					}
				}

				if (nonUniLinkBusStopOverlay != null) {

				}

				mapView.postInvalidate();

				Log.i(TAG, "Finished showing non Uni-Link bus stop overlays at " + (System.currentTimeMillis() - startTime));
			}
		}).start();
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		MenuInflater inflater = getMenuInflater();
		inflater.inflate(R.menu.map_menu, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		// Handle item selection
		switch (item.getItemId()) {
		case R.id.menu_find:
			onSearchRequested();
			return true;
		case R.id.menu_preferences:
			Intent settingsActivity = new Intent(getBaseContext(), PreferencesActivity.class);
			startActivity(settingsActivity);
			return true;
		case R.id.menu_find_my_location:
			final SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);
			final SharedPreferences activityPrefs = getPreferences(0);
			if (sharedPrefs.getBoolean(GPS_ENABLED, GPS_ENABLED_BY_DEFAULT)) {
				activityPrefs.edit().putBoolean(OTHER_OVERLAYS + MY_LOCATION_OVERLAY, true).commit();
				myLocationOverlay.enableFollowLocation();
				mapController.setZoom(18);
			} else {
				DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() {
					public void onClick(DialogInterface dialog, int which) {
						switch (which) {
						case DialogInterface.BUTTON_POSITIVE:
							Editor editor = sharedPrefs.edit();
							editor.putBoolean(GPS_ENABLED, true);
							editor.commit();

							activityPrefs.edit().putBoolean(OTHER_OVERLAYS + MY_LOCATION_OVERLAY, true).commit();
							myLocationOverlay.enableFollowLocation();
							mapController.setZoom(18);

						case DialogInterface.BUTTON_NEGATIVE:
							// No button clicked
							break;
						}
					}
				};

				AlertDialog.Builder builder = new AlertDialog.Builder(this);
				builder.setMessage("GPS is not enabled, do you wish to enable it?").setPositiveButton("Yes", dialogClickListener)
						.setNegativeButton("No", dialogClickListener).show();
			}

			return true;
		case R.id.menu_view:
			Log.i(TAG, "Showing view dialog");
			showDialog(VIEW_DIALOG_ID);
			return false;
		case R.id.menu_favourites:
			Log.i(TAG, "Showing favourite dialog");

			showDialog(FAVOURITE_DIALOG_ID);
			if (favDialog == null) {
				Log.e(TAG, "Very wierd, just tried to launch the favourite's dialog, but its null?");
				return false;
			}

			return false;
		case R.id.menu_about:
			Intent aboutIntent = new Intent(MapActivity.this, AboutActivity.class);
			startActivityForResult(aboutIntent, 0);
			return true;
		default:
			Log.e(TAG, "No known menu option selected");
			return super.onOptionsItemSelected(item);
		}
	}

	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		Log.i(TAG, "Got activity result");
		if (resultCode == RESULT_OK) {

			POI poi = null;
			Bundle bundle = data.getExtras();
			if (bundle == null) {
				Log.i(TAG, "Bundle is null");
			} else {
				String poiId = (String) bundle.get("poi");
				if (poiId != null) {
					Log.i(TAG, "Got id " + poiId);
					try {
						poi = getHelper().getBuildingDao().queryForId(poiId);
						if (poi == null) {
							poi = getHelper().getBusStopDao().queryForId(poiId);
						}
					} catch (SQLException e) {
						e.printStackTrace();
					}

					if (poi == null) {
						Log.e(TAG, "Could not find poi " + poiId + " in onActivityResult");
					} else {
						if (myLocationOverlay != null) {
							// It could be null if it has not been enabled
							myLocationOverlay.disableFollowLocation();
						}
						mapController.setZoom(20);
						mapController.setCenter(poi.point);

					}
				} else {
					Log.i(TAG, "Got null poi id");
				}

				mapView.invalidate();
			}
		}

	}

	protected Dialog onCreateDialog(int id) {
		switch (id) {
		case VIEW_DIALOG_ID:
			ViewDialog viewDialog = new ViewDialog(instance);
			return viewDialog;
		case FAVOURITE_DIALOG_ID:
			favDialog = new FavouritesDialog(instance);
			favDialog.setOnItemClickListener(this);
			favDialog.setOnItemLongClickListener(this);
			favDialog.setTitle(R.string.favourites_dialog_title);
			return favDialog;
		case SEARCH_RESULTS_DIALOG_ID:
			searchResultsDialog = new SearchResultsDialog(instance);
			searchResultsDialog.setOnItemClickListener(this);
			searchResultsDialog.setOnItemLongClickListener(this);
			return searchResultsDialog;
		case WELCOME_DIALOG_ID:
			WelcomeDialog welcomeDialog = new WelcomeDialog(instance);
			return welcomeDialog;
		}
		return null;
	}

	protected void onPrepareDialog(int id, Dialog dialog) {
		if (dialog instanceof FavouritesDialog) {
			favDialog = (FavouritesDialog) dialog;

			ArrayList<POI> newFavouriteItems = new ArrayList<POI>();

			try {
				Dao<Building, String> buildingDao = getHelper().getBuildingDao();
				Dao<BusStop, String> busStopDao = getHelper().getBusStopDao();

				final SharedPreferences favouritesPrefs = getSharedPreferences(FAVOURITES_PREFERENCES, 0);
				for (String idStr : favouritesPrefs.getAll().keySet()) {
					Building building;
					BusStop busStop;
					if ((building = buildingDao.queryForId(idStr)) != null) {
						newFavouriteItems.add(building);
					} else if ((busStop = busStopDao.queryForId(idStr)) != null) {
						newFavouriteItems.add(busStop);
					} else {
						Log.e(TAG, "Item in favourites " + idStr + " cannot be found");
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}

			Log.i(TAG, "There are " + newFavouriteItems.size() + " favourites");
			if (newFavouriteItems.size() == 0) {
				Log.i(TAG, "Favourite dialog has no favourites, displaying message");
				favDialog.setMessage(getResources().getString(R.string.favourites_dialog_message));
				favDialog.setItems(null);
			} else {
				favDialog.setMessage("");
				favDialog.setItems(newFavouriteItems);
			}
		} else if (dialog instanceof SearchResultsDialog) {
			searchResultsDialog = (SearchResultsDialog) dialog;
		}
	}

	public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
		Log.i(TAG, "OnItemClick pos " + position + " id " + id);

		POI poi = null;
		if (favDialog != null) {
			poi = favDialog.adapter.getPOIItem(position);
		} else if (searchResultsDialog != null) {
			poi = searchResultsDialog.adapter.getPOIItem(position);
		}

		if (poi != null) {
			Log.i(TAG, "Got id " + poi.id);

			if (myLocationOverlay != null) {
				myLocationOverlay.disableFollowLocation();
			}
			mapController.setZoom(20);
			mapController.setCenter(poi.point);

			if (favDialog != null) {
				favDialog.dismiss();
				favDialog = null;
			} else if (searchResultsDialog != null) {
				searchResultsDialog.dismiss();
				searchResultsDialog = null;
			}

		} else {
			Log.i(TAG, "Got null poi id");
		}

	}

	/**
	 * Long click on a item in the favourites menu
	 */
	public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {

		Log.i(TAG, "OnItemClick pos " + position + " id " + id);

		POI poi = null;
		if (favDialog != null) {
			poi = favDialog.adapter.getPOIItem(position);
		} else if (searchResultsDialog != null) {
			poi = searchResultsDialog.adapter.getPOIItem(position);
		}

		if (poi != null) {
			Log.i(TAG, "Got id " + poi.id);

			if (poi.type == POI.BUS_STOP) {
				BusStop busStop = (BusStop) poi;

				Log.i(TAG, "Pressed " + busStop.id);

				Uri uri = Uri.parse("http://id.southampton.ac.uk/bus-stop/" + busStop.id);

				Log.i(TAG, "Starting a activity for " + uri + " path " + uri.getPath());

				Intent busStopIntent = new Intent(Intent.ACTION_VIEW, uri);
				startActivity(busStopIntent);

				return true;

			} else if (poi.type == POI.BUILDING) {
				Building building = (Building) poi;

				Log.i(TAG, "Pressed " + building.id);

				Uri uri = Uri.parse("http://id.southampton.ac.uk/building/" + building.id);

				Log.i(TAG, "Starting a activity for " + uri + " path " + uri.getPath());

				Intent buildingIntent = new Intent(Intent.ACTION_VIEW, uri);
				startActivity(buildingIntent);

				return true;

			} else if (poi.type == POI.SITE) {
				Site site = (Site) poi;

				Log.i(TAG, "Pressed " + site.id);

				Uri uri = Uri.parse("http://id.southampton.ac.uk/site/" + site.id);

				Log.i(TAG, "Starting a activity for " + uri + " path " + uri.getPath());

				Intent siteIntent = new Intent(Intent.ACTION_VIEW, uri);
				startActivity(siteIntent);

				return true;

			} else {

				myLocationOverlay.disableFollowLocation();
				mapController.setZoom(20);
				mapController.setCenter(poi.point);

				if (favDialog != null) {
					favDialog.dismiss();
					favDialog = null;
				} else if (searchResultsDialog != null) {
					searchResultsDialog.dismiss();
					searchResultsDialog = null;
				}

			}

		} else {
			Log.i(TAG, "Got null poi");

			// mapController.setZoom(15);
			// mapController.setCenter(new GeoPoint(50935551, -1393488));
		}

		return true;
	}

	private class OverlayRankComparator implements Comparator<Overlay> {
		// private final SharedPreferences prefs;

		OverlayRankComparator(SharedPreferences prefs) {
			// this.prefs = prefs;
		}

		public int compare(Overlay arg0, Overlay arg1) {
			return getRank(arg1) - getRank(arg0);
		}

		private final int getRank(Overlay overlay) { // TODO: Dont hardcode the
														// rank values
			if (overlay == scaleBarOverlay) {
				return SCALE_BAR_OVERLAY_RANK;
			} else if (overlay == myLocationOverlay) {
				return MY_LOCATION_OVERLAY_RANK;
			} else if (overlay == uniLinkBusStopOverlay) {
				return UNI_LINK_BUS_STOP_OVERLAY_RANK;
			} else if (overlay == nonUniLinkBusStopOverlay) {
				return NON_UNI_LINK_BUS_STOP_OVERLAY_RANK;
			} else if (overlay.equals(residentialBuildingOverlay)) {
				return RESIDENTIAL_BUILDING_OVERLAY_RANK;
			} else if (overlay.equals(nonResidentialBuildingOverlay)) {
				return NON_RESIDENTIAL_BUILDING_OVERLAY_RANK;
			} else if (siteOverlays != null && siteOverlays.values().contains(overlay)) {
				return SITE_OVERLAYS_RANK;
			} else if (busRouteOverlays != null && busRouteOverlays.values().contains(overlay)) {
				return BUS_ROUTE_OVERLAYS_RANK;
			} else {
				Log.e(TAG, "Trying to rank unknown overlay " + overlay);
				return -1;
			}
		}
	}

	/**
	 * Handles all changes in preferences
	 */
	public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
		Log.v(TAG, "Got shared prefs changed event for key " + key);

		// Shared Preferences
		if (key.equals(GPS_ENABLED)) {
			final SharedPreferences activityPrefs = getPreferences(0);

			if (activityPrefs.getBoolean("Other:Compass", false) && prefs.getBoolean("GPSEnabled", false)) {
				myLocationOverlay.enableMyLocation();
			} else {
				myLocationOverlay.disableMyLocation();
			}
		} else if (key.equals(NON_UNI_LINK_BUS_TIMES)) {
			// Noting to do here atm
		} else if (key.equals(UNI_LINK_BUS_TIMES)) {
			// Noting to do here atm
		} else if (key.startsWith(BUS_STOP_OVERLAYS)) {
			showUniLinkBusStopOverlay();
		} else if (key.equals(NON_UNI_LINK_BUS_STOPS_OVERLAY)) {
			showNonUniLinkBusStopOverlay();
		} else if (key.startsWith(BUS_ROUTE_OVERLAYS)) {
			try {
				String routeName = key.substring(BUS_ROUTE_OVERLAYS.length(), key.length());
				for (BusRoute route : getHelper().getBusRouteDao()) {
					Log.v(TAG, route.code + " " + routeName);
					if (route.code.equals(routeName)) {
						showRouteOverlay(route);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		} else if (key.startsWith(BUILDING_OVERLAYS)) {
			showBuildingOverlays();
		} else if (key.startsWith(SITE_OVERLAYS)) {
			String siteName = key.substring(SITE_OVERLAYS.length(), key.length());
			try {
				for (Site site : getHelper().getSiteDao()) {
					if (site.name.equals(siteName)) {
						showSiteOverlay(site);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		} else if (key.startsWith(OTHER_OVERLAYS)) {
			if (key.substring(OTHER_OVERLAYS.length(), key.length()).equals(SCALE_BAR_OVERLAY)) {
				showUtilityOverlays();
			} else if (key.substring(OTHER_OVERLAYS.length(), key.length()).equals(MY_LOCATION_OVERLAY_COMPASS)) {
				if (prefs.getBoolean(key, MY_LOCATION_OVERLAY_COMPASS_ENABLED_BY_DEFAULT)) {
					myLocationOverlay.enableCompass();
				} else {
					myLocationOverlay.disableCompass();
				}
				mapView.invalidate();
			} else if (key.substring(OTHER_OVERLAYS.length(), key.length()).equals(MY_LOCATION_OVERLAY)) {
				final SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);

				if (prefs.getBoolean(key, MY_LOCATION_OVERLAY_ENABLED_BY_DEFAULT)
						&& sharedPrefs.getBoolean(GPS_ENABLED, GPS_ENABLED_BY_DEFAULT)) {
					myLocationOverlay.enableMyLocation();
					myLocationOverlay.setDrawAccuracyEnabled(true);
				} else {
					myLocationOverlay.disableMyLocation();
					myLocationOverlay.setDrawAccuracyEnabled(false);
				}
			} else {
				Log.e(TAG, "Unhandled preference key " + key);
			}
		} else {
			Log.e(TAG, "Unhandled preference key " + key);
		}
	}
}