/*
   Bookmark editing activity

   Copyright 2013 Thincast Technologies GmbH, Author: Martin Fleisz

   This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
   If a copy of the MPL was not distributed with this file, You can obtain one at
   http://mozilla.org/MPL/2.0/.
 */

package com.freerdp.freerdpcore.presentation;

import android.app.AlertDialog;
import android.content.ComponentName;
import android.content.DialogInterface;
import android.content.SharedPreferences;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.os.Bundle;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceManager;
import android.preference.PreferenceScreen;
import android.util.Log;
import android.view.View;

import com.freerdp.freerdpcore.R;
import com.freerdp.freerdpcore.application.GlobalApp;
import com.freerdp.freerdpcore.domain.BookmarkBase;
import com.freerdp.freerdpcore.domain.ConnectionReference;
import com.freerdp.freerdpcore.domain.ManualBookmark;
import com.freerdp.freerdpcore.services.BookmarkBaseGateway;
import com.freerdp.freerdpcore.services.LibFreeRDP;
import com.freerdp.freerdpcore.utils.RDPFileParser;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;

public class BookmarkActivity extends PreferenceActivity implements OnSharedPreferenceChangeListener
{
	public static final String PARAM_CONNECTION_REFERENCE = "conRef";

	private static final String TAG = "BookmarkActivity";
	private static final int PREFERENCES_BOOKMARK = 1;
	private static final int PREFERENCES_CREDENTIALS = 2;
	private static final int PREFERENCES_SCREEN = 3;
	private static final int PREFERENCES_PERFORMANCE = 4;
	private static final int PREFERENCES_ADVANCED = 5;
	private static final int PREFERENCES_SCREEN3G = 6;
	private static final int PREFERENCES_PERFORMANCE3G = 7;
	private static final int PREFERENCES_GATEWAY = 8;
	private static final int PREFERENCES_DEBUG = 9;
	// bookmark needs to be static because the activity is started for each
	// subview
	// (we have to do this because Android has a bug where the style for
	// Preferences
	// is only applied to the first PreferenceScreen but not to subsequent ones)
	private static BookmarkBase bookmark = null;
	private static boolean settings_changed = false;
	private static boolean new_bookmark = false;
	private int current_preferences;

	@Override public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);

		PreferenceManager mgr = getPreferenceManager();
		// init shared preferences for activity
		mgr.setSharedPreferencesName("TEMP");
		mgr.setSharedPreferencesMode(MODE_PRIVATE);

		if (bookmark == null)
		{
			// if we have a bookmark id set in the extras we are in edit mode
			Bundle bundle = getIntent().getExtras();
			if (bundle != null)
			{
				// See if we got a connection reference to a bookmark
				if (bundle.containsKey(PARAM_CONNECTION_REFERENCE))
				{
					String refStr = bundle.getString(PARAM_CONNECTION_REFERENCE);
					if (ConnectionReference.isManualBookmarkReference(refStr))
					{
						bookmark = GlobalApp.getManualBookmarkGateway().findById(
						    ConnectionReference.getManualBookmarkId(refStr));
						new_bookmark = false;
					}
					else if (ConnectionReference.isHostnameReference(refStr))
					{
						bookmark = new ManualBookmark();
						bookmark.<ManualBookmark>get().setLabel(
						    ConnectionReference.getHostname(refStr));
						bookmark.<ManualBookmark>get().setHostname(
						    ConnectionReference.getHostname(refStr));
						new_bookmark = true;
					}
					else if (ConnectionReference.isFileReference(refStr))
					{
						String file = ConnectionReference.getFile(refStr);

						bookmark = new ManualBookmark();
						bookmark.setLabel(file);

						try
						{
							RDPFileParser rdpFile = new RDPFileParser(file);
							updateBookmarkFromFile((ManualBookmark)bookmark, rdpFile);

							bookmark.setLabel(new File(file).getName());
							new_bookmark = true;
						}
						catch (IOException e)
						{
							Log.e(TAG, "Failed reading RDP file", e);
						}
					}
				}
			}

			// last chance - ensure we really have a valid bookmark
			if (bookmark == null)
				bookmark = new ManualBookmark();

			// hide gateway settings if we edit a non-manual bookmark
			if (current_preferences == PREFERENCES_ADVANCED &&
			    bookmark.getType() != ManualBookmark.TYPE_MANUAL)
			{
				PreferenceScreen screen = getPreferenceScreen();
				screen.removePreference(findPreference("bookmark.enable_gateway"));
				screen.removePreference(findPreference("bookmark.gateway"));
			}

			updateH264Preferences();

			// update preferences from bookmark
			bookmark.writeToSharedPreferences(mgr.getSharedPreferences());

			// no settings changed yet
			settings_changed = false;
		}

		// load the requested settings resource
		if (getIntent() == null || getIntent().getData() == null)
		{
			addPreferencesFromResource(R.xml.bookmark_settings);
			current_preferences = PREFERENCES_BOOKMARK;
		}
		else if (getIntent().getData().toString().equals("preferences://screen_settings"))
		{
			addPreferencesFromResource(R.xml.screen_settings);
			current_preferences = PREFERENCES_SCREEN;
		}
		else if (getIntent().getData().toString().equals("preferences://performance_flags"))
		{
			addPreferencesFromResource(R.xml.performance_flags);
			current_preferences = PREFERENCES_PERFORMANCE;
		}
		else if (getIntent().getData().toString().equals("preferences://screen_settings_3g"))
		{
			addPreferencesFromResource(R.xml.screen_settings_3g);
			current_preferences = PREFERENCES_SCREEN3G;
		}
		else if (getIntent().getData().toString().equals("preferences://performance_flags_3g"))
		{
			addPreferencesFromResource(R.xml.performance_flags_3g);
			current_preferences = PREFERENCES_PERFORMANCE3G;
		}
		else if (getIntent().getData().toString().equals("preferences://advanced_settings"))
		{
			addPreferencesFromResource(R.xml.advanced_settings);
			current_preferences = PREFERENCES_ADVANCED;
		}
		else if (getIntent().getData().toString().equals("preferences://credentials_settings"))
		{
			addPreferencesFromResource(R.xml.credentials_settings);
			current_preferences = PREFERENCES_CREDENTIALS;
		}
		else if (getIntent().getData().toString().equals("preferences://gateway_settings"))
		{
			addPreferencesFromResource(R.xml.gateway_settings);
			current_preferences = PREFERENCES_GATEWAY;
		}
		else if (getIntent().getData().toString().equals("preferences://debug_settings"))
		{
			addPreferencesFromResource(R.xml.debug_settings);
			current_preferences = PREFERENCES_DEBUG;
		}
		else
		{
			addPreferencesFromResource(R.xml.bookmark_settings);
			current_preferences = PREFERENCES_BOOKMARK;
		}

		// update UI with bookmark data
		SharedPreferences spref = mgr.getSharedPreferences();
		initSettings(spref);

		// register for preferences changed notification
		mgr.getSharedPreferences().registerOnSharedPreferenceChangeListener(this);

		// set the correct component names in our preferencescreen settings
		setIntentComponentNames();

		updateH264Preferences();
	}

	private void updateH264Preferences()
	{
		if (!LibFreeRDP.hasH264Support())
		{
			final int preferenceIdList[] = { R.string.preference_key_h264,
				                             R.string.preference_key_h264_3g };

			PreferenceManager mgr = getPreferenceManager();
			for (int id : preferenceIdList)
			{
				final String key = getString(id);
				Preference preference = mgr.findPreference(key);
				if (preference != null)
				{
					preference.setEnabled(false);
				}
			}
		}
	}

	private void updateBookmarkFromFile(ManualBookmark bookmark, RDPFileParser rdpFile)
	{
		String s;
		Integer i;

		s = rdpFile.getString("full address");
		if (s != null)
		{
			// this gets complicated as it can include port
			if (s.lastIndexOf(":") > s.lastIndexOf("]"))
			{
				try
				{
					String port = s.substring(s.lastIndexOf(":") + 1);
					bookmark.setPort(Integer.parseInt(port));
				}
				catch (NumberFormatException e)
				{
					Log.e(TAG, "Malformed address");
				}

				s = s.substring(0, s.lastIndexOf(":"));
			}

			// or even be an ipv6 address
			if (s.startsWith("[") && s.endsWith("]"))
				s = s.substring(1, s.length() - 1);

			bookmark.setHostname(s);
		}

		i = rdpFile.getInteger("server port");
		if (i != null)
			bookmark.setPort(i);

		s = rdpFile.getString("username");
		if (s != null)
			bookmark.setUsername(s);

		s = rdpFile.getString("domain");
		if (s != null)
			bookmark.setDomain(s);

		i = rdpFile.getInteger("connect to console");
		if (i != null)
			bookmark.getAdvancedSettings().setConsoleMode(i == 1);
	}

	private void setIntentComponentNames()
	{
		// we set the component name for our sub-activity calls here because we
		// don't know the package
		// name of the main app in our library project.
		ComponentName compName =
		    new ComponentName(getPackageName(), BookmarkActivity.class.getName());
		ArrayList<String> prefKeys = new ArrayList<String>();

		prefKeys.add("bookmark.credentials");
		prefKeys.add("bookmark.screen");
		prefKeys.add("bookmark.performance");
		prefKeys.add("bookmark.advanced");
		prefKeys.add("bookmark.screen_3g");
		prefKeys.add("bookmark.performance_3g");
		prefKeys.add("bookmark.gateway_settings");
		prefKeys.add("bookmark.debug");

		for (String p : prefKeys)
		{
			Preference pref = findPreference(p);
			if (pref != null)
				pref.getIntent().setComponent(compName);
		}
	}

	@Override public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key)
	{
		settings_changed = true;
		switch (current_preferences)
		{
			case PREFERENCES_DEBUG:
				debugSettingsChanged(sharedPreferences, key);
				break;

			case PREFERENCES_BOOKMARK:
				bookmarkSettingsChanged(sharedPreferences, key);
				break;

			case PREFERENCES_ADVANCED:
				advancedSettingsChanged(sharedPreferences, key);
				break;

			case PREFERENCES_CREDENTIALS:
				credentialsSettingsChanged(sharedPreferences, key);
				break;

			case PREFERENCES_SCREEN:
			case PREFERENCES_SCREEN3G:
				screenSettingsChanged(sharedPreferences, key);
				break;

			case PREFERENCES_GATEWAY:
				gatewaySettingsChanged(sharedPreferences, key);
				break;

			default:
				break;
		}
	}

	private void initSettings(SharedPreferences sharedPreferences)
	{
		switch (current_preferences)
		{
			case PREFERENCES_BOOKMARK:
				initBookmarkSettings(sharedPreferences);
				break;

			case PREFERENCES_ADVANCED:
				initAdvancedSettings(sharedPreferences);
				break;

			case PREFERENCES_CREDENTIALS:
				initCredentialsSettings(sharedPreferences);
				break;

			case PREFERENCES_SCREEN:
				initScreenSettings(sharedPreferences);
				break;

			case PREFERENCES_SCREEN3G:
				initScreenSettings3G(sharedPreferences);
				break;

			case PREFERENCES_GATEWAY:
				initGatewaySettings(sharedPreferences);
				break;

			case PREFERENCES_DEBUG:
				initDebugSettings(sharedPreferences);
				break;

			default:
				break;
		}
	}

	private void initBookmarkSettings(SharedPreferences sharedPreferences)
	{
		bookmarkSettingsChanged(sharedPreferences, "bookmark.label");
		bookmarkSettingsChanged(sharedPreferences, "bookmark.hostname");
		bookmarkSettingsChanged(sharedPreferences, "bookmark.port");
		bookmarkSettingsChanged(sharedPreferences, "bookmark.username");
		bookmarkSettingsChanged(sharedPreferences, "bookmark.resolution");
	}

	private void bookmarkSettingsChanged(SharedPreferences sharedPreferences, String key)
	{
		if (key.equals("bookmark.label") && findPreference(key) != null)
			findPreference(key).setSummary(sharedPreferences.getString(key, ""));
		else if (key.equals("bookmark.hostname") && findPreference(key) != null)
			findPreference(key).setSummary(sharedPreferences.getString(key, ""));
		else if (key.equals("bookmark.port") && findPreference(key) != null)
			findPreference(key).setSummary(String.valueOf(sharedPreferences.getInt(key, -1)));
		else if (key.equals("bookmark.username"))
		{
			String username = sharedPreferences.getString(key, "<none>");
			if (username.length() == 0)
				username = "<none>";
			findPreference("bookmark.credentials").setSummary(username);
		}
		else if (key.equals("bookmark.resolution") || key.equals("bookmark.colors") ||
		         key.equals("bookmark.width") || key.equals("bookmark.height"))
		{
			String resolution = sharedPreferences.getString("bookmark.resolution", "800x600");
			// compare english string from resolutions_values_array array,
			// decode to localized
			// text for display
			if (resolution.equals("automatic"))
			{
				resolution = getResources().getString(R.string.resolution_automatic);
			}
			if (resolution.equals("custom"))
			{
				resolution = getResources().getString(R.string.resolution_custom);
			}
			if (resolution.equals("fitscreen"))
			{
				resolution = getResources().getString(R.string.resolution_fit);
			}
			resolution += "@" + sharedPreferences.getInt("bookmark.colors", 16);
			findPreference("bookmark.screen").setSummary(resolution);
		}
	}

	private void initAdvancedSettings(SharedPreferences sharedPreferences)
	{
		advancedSettingsChanged(sharedPreferences, "bookmark.enable_gateway_settings");
		advancedSettingsChanged(sharedPreferences, "bookmark.enable_3g_settings");
		advancedSettingsChanged(sharedPreferences, "bookmark.security");
		advancedSettingsChanged(sharedPreferences, "bookmark.resolution_3g");
		advancedSettingsChanged(sharedPreferences, "bookmark.remote_program");
		advancedSettingsChanged(sharedPreferences, "bookmark.work_dir");
	}

	private void advancedSettingsChanged(SharedPreferences sharedPreferences, String key)
	{
		if (key.equals("bookmark.enable_gateway_settings"))
		{
			boolean enabled = sharedPreferences.getBoolean(key, false);
			findPreference("bookmark.gateway_settings").setEnabled(enabled);
		}
		else if (key.equals("bookmark.enable_3g_settings"))
		{
			boolean enabled = sharedPreferences.getBoolean(key, false);
			findPreference("bookmark.screen_3g").setEnabled(enabled);
			findPreference("bookmark.performance_3g").setEnabled(enabled);
		}
		else if (key.equals("bookmark.security"))
		{
			ListPreference listPreference = (ListPreference)findPreference(key);
			CharSequence security = listPreference.getEntries()[sharedPreferences.getInt(key, 0)];
			listPreference.setSummary(security);
		}
		else if (key.equals("bookmark.resolution_3g") || key.equals("bookmark.colors_3g") ||
		         key.equals("bookmark.width_3g") || key.equals("bookmark.height_3g"))
		{
			String resolution = sharedPreferences.getString("bookmark.resolution_3g", "800x600");
			if (resolution.equals("automatic"))
				resolution = getResources().getString(R.string.resolution_automatic);
			else if (resolution.equals("custom"))
				resolution = getResources().getString(R.string.resolution_custom);
			resolution += "@" + sharedPreferences.getInt("bookmark.colors_3g", 16);
			findPreference("bookmark.screen_3g").setSummary(resolution);
		}
		else if (key.equals("bookmark.remote_program"))
			findPreference(key).setSummary(sharedPreferences.getString(key, ""));
		else if (key.equals("bookmark.work_dir"))
			findPreference(key).setSummary(sharedPreferences.getString(key, ""));
	}

	private void initCredentialsSettings(SharedPreferences sharedPreferences)
	{
		credentialsSettingsChanged(sharedPreferences, "bookmark.username");
		credentialsSettingsChanged(sharedPreferences, "bookmark.password");
		credentialsSettingsChanged(sharedPreferences, "bookmark.domain");
	}

	private void credentialsSettingsChanged(SharedPreferences sharedPreferences, String key)
	{
		if (key.equals("bookmark.username"))
			findPreference(key).setSummary(sharedPreferences.getString(key, ""));
		else if (key.equals("bookmark.password"))
		{
			if (sharedPreferences.getString(key, "").length() == 0)
				findPreference(key).setSummary(
				    getResources().getString(R.string.settings_password_empty));
			else
				findPreference(key).setSummary(
				    getResources().getString(R.string.settings_password_present));
		}
		else if (key.equals("bookmark.domain"))
			findPreference(key).setSummary(sharedPreferences.getString(key, ""));
	}

	private void initScreenSettings(SharedPreferences sharedPreferences)
	{
		screenSettingsChanged(sharedPreferences, "bookmark.colors");
		screenSettingsChanged(sharedPreferences, "bookmark.resolution");
		screenSettingsChanged(sharedPreferences, "bookmark.width");
		screenSettingsChanged(sharedPreferences, "bookmark.height");
	}

	private void initScreenSettings3G(SharedPreferences sharedPreferences)
	{
		screenSettingsChanged(sharedPreferences, "bookmark.colors_3g");
		screenSettingsChanged(sharedPreferences, "bookmark.resolution_3g");
		screenSettingsChanged(sharedPreferences, "bookmark.width_3g");
		screenSettingsChanged(sharedPreferences, "bookmark.height_3g");
	}

	private void screenSettingsChanged(SharedPreferences sharedPreferences, String key)
	{
		// could happen during initialization because 3g and non-3g settings
		// share this routine - just skip
		if (findPreference(key) == null)
			return;

		if (key.equals("bookmark.colors") || key.equals("bookmark.colors_3g"))
		{
			ListPreference listPreference = (ListPreference)findPreference(key);
			listPreference.setSummary(listPreference.getEntry());
		}
		else if (key.equals("bookmark.resolution") || key.equals("bookmark.resolution_3g"))
		{
			ListPreference listPreference = (ListPreference)findPreference(key);
			listPreference.setSummary(listPreference.getEntry());

			String value = listPreference.getValue();
			boolean enabled = value.equalsIgnoreCase("custom");
			if (key.equals("bookmark.resolution"))
			{
				findPreference("bookmark.width").setEnabled(enabled);
				findPreference("bookmark.height").setEnabled(enabled);
			}
			else
			{
				findPreference("bookmark.width_3g").setEnabled(enabled);
				findPreference("bookmark.height_3g").setEnabled(enabled);
			}
		}
		else if (key.equals("bookmark.width") || key.equals("bookmark.width_3g"))
			findPreference(key).setSummary(String.valueOf(sharedPreferences.getInt(key, 800)));
		else if (key.equals("bookmark.height") || key.equals("bookmark.height_3g"))
			findPreference(key).setSummary(String.valueOf(sharedPreferences.getInt(key, 600)));
	}

	private void initDebugSettings(SharedPreferences sharedPreferences)
	{
		debugSettingsChanged(sharedPreferences, "bookmark.debug_level");
		debugSettingsChanged(sharedPreferences, "bookmark.async_channel");
		debugSettingsChanged(sharedPreferences, "bookmark.async_update");
		debugSettingsChanged(sharedPreferences, "bookmark.async_input");
	}

	private void initGatewaySettings(SharedPreferences sharedPreferences)
	{
		gatewaySettingsChanged(sharedPreferences, "bookmark.gateway_hostname");
		gatewaySettingsChanged(sharedPreferences, "bookmark.gateway_port");
		gatewaySettingsChanged(sharedPreferences, "bookmark.gateway_username");
		gatewaySettingsChanged(sharedPreferences, "bookmark.gateway_password");
		gatewaySettingsChanged(sharedPreferences, "bookmark.gateway_domain");
	}

	private void debugSettingsChanged(SharedPreferences sharedPreferences, String key)
	{
		if (key.equals("bookmark.debug_level"))
		{
			String level = sharedPreferences.getString(key, "INFO");
			Preference pref = findPreference("bookmark.debug_level");
			pref.setDefaultValue(level);
		}
		else if (key.equals("bookmark.async_channel"))
		{
			boolean enabled = sharedPreferences.getBoolean(key, false);
			Preference pref = findPreference("bookmark.async_channel");
			pref.setDefaultValue(enabled);
		}
		else if (key.equals("bookmark.async_update"))
		{
			boolean enabled = sharedPreferences.getBoolean(key, false);
			Preference pref = findPreference("bookmark.async_update");
			pref.setDefaultValue(enabled);
		}
		else if (key.equals("bookmark.async_input"))
		{
			boolean enabled = sharedPreferences.getBoolean(key, false);
			Preference pref = findPreference("bookmark.async_input");
			pref.setDefaultValue(enabled);
		}
	}

	private void gatewaySettingsChanged(SharedPreferences sharedPreferences, String key)
	{
		if (key.equals("bookmark.gateway_hostname"))
		{
			findPreference(key).setSummary(sharedPreferences.getString(key, ""));
		}
		else if (key.equals("bookmark.gateway_port"))
		{
			findPreference(key).setSummary(String.valueOf(sharedPreferences.getInt(key, 443)));
		}
		else if (key.equals("bookmark.gateway_username"))
		{
			findPreference(key).setSummary(sharedPreferences.getString(key, ""));
		}
		else if (key.equals("bookmark.gateway_password"))
		{
			if (sharedPreferences.getString(key, "").length() == 0)
				findPreference(key).setSummary(
				    getResources().getString(R.string.settings_password_empty));
			else
				findPreference(key).setSummary(
				    getResources().getString(R.string.settings_password_present));
		}
		else if (key.equals("bookmark.gateway_domain"))
			findPreference(key).setSummary(sharedPreferences.getString(key, ""));
	}

	private boolean verifySettings(SharedPreferences sharedPreferences)
	{

		boolean verifyFailed = false;
		// perform sanity checks on settings
		// Label set
		if (sharedPreferences.getString("bookmark.label", "").length() == 0)
			verifyFailed = true;

		// Server and port specified
		if (!verifyFailed && sharedPreferences.getString("bookmark.hostname", "").length() == 0)
			verifyFailed = true;

		// Server and port specified
		if (!verifyFailed && sharedPreferences.getInt("bookmark.port", -1) <= 0)
			verifyFailed = true;

		// if an error occurred - display toast and return false
		return (!verifyFailed);
	}

	private void finishAndResetBookmark()
	{
		bookmark = null;
		getPreferenceManager().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(
		    this);
		finish();
	}

	@Override public void onBackPressed()
	{
		// only proceed if we are in the main preferences screen
		if (current_preferences != PREFERENCES_BOOKMARK)
		{
			super.onBackPressed();
			getPreferenceManager()
			    .getSharedPreferences()
			    .unregisterOnSharedPreferenceChangeListener(this);
			return;
		}

		SharedPreferences sharedPreferences = getPreferenceManager().getSharedPreferences();
		if (!verifySettings(sharedPreferences))
		{
			// ask the user if he wants to cancel or continue editing
			AlertDialog.Builder builder = new AlertDialog.Builder(this);
			builder.setTitle(R.string.error_bookmark_incomplete_title)
			    .setMessage(R.string.error_bookmark_incomplete)
			    .setPositiveButton(R.string.cancel,
			                       new DialogInterface.OnClickListener() {
				                       @Override
				                       public void onClick(DialogInterface dialog, int which)
				                       {
					                       finishAndResetBookmark();
				                       }
			                       })
			    .setNegativeButton(R.string.cont,
			                       new DialogInterface.OnClickListener() {
				                       @Override
				                       public void onClick(DialogInterface dialog, int which)
				                       {
					                       dialog.cancel();
				                       }
			                       })
			    .show();

			return;
		}
		else
		{
			// ask the user if he wants to save or cancel editing if a setting
			// has changed
			if (new_bookmark || settings_changed)
			{
				AlertDialog.Builder builder = new AlertDialog.Builder(this);
				builder.setTitle(R.string.dlg_title_save_bookmark)
				    .setMessage(R.string.dlg_save_bookmark)
				    .setPositiveButton(
				        R.string.yes,
				        new DialogInterface.OnClickListener() {
					        @Override public void onClick(DialogInterface dialog, int which)
					        {
						        // read shared prefs back to bookmark
						        bookmark.readFromSharedPreferences(
						            getPreferenceManager().getSharedPreferences());

						        BookmarkBaseGateway bookmarkGateway;
						        if (bookmark.getType() == BookmarkBase.TYPE_MANUAL)
						        {
							        bookmarkGateway = GlobalApp.getManualBookmarkGateway();
							        // remove any history entry for this
							        // bookmark
							        GlobalApp.getQuickConnectHistoryGateway().removeHistoryItem(
							            bookmark.<ManualBookmark>get().getHostname());
						        }
						        else
						        {
							        assert false;
							        return;
						        }

						        // insert or update bookmark and leave
						        // activity
						        if (bookmark.getId() > 0)
							        bookmarkGateway.update(bookmark);
						        else
							        bookmarkGateway.insert(bookmark);

						        finishAndResetBookmark();
					        }
				        })
				    .setNegativeButton(R.string.no,
				                       new DialogInterface.OnClickListener() {
					                       @Override
					                       public void onClick(DialogInterface dialog, int which)
					                       {
						                       finishAndResetBookmark();
					                       }
				                       })
				    .show();
			}
			else
			{
				finishAndResetBookmark();
			}
		}
	}
}
