/*

 *

 *  Copyright (C) 2013  Bastien Nocera <hadess@hadess.net>

 *

 *  This library is free software; you can redistribute it and/or

 *  modify it under the terms of the GNU Lesser General Public

 *  License as published by the Free Software Foundation; either

 *  version 2.1 of the License, or (at your option) any later version.

 *

 *  This library 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

 *  Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <gtk/gtk.h>

#include <glib/gi18n-lib.h>

#include <math.h>

#include "bluetooth-client.h"

#include "bluetooth-client-private.h"

#include "bluetooth-client-glue.h"

#include "bluetooth-agent.h"

#include "bluetooth-utils.h"

#include "bluetooth-settings-widget.h"

#include "bluetooth-settings-resources.h"

#include "bluetooth-settings-row.h"

#include "bluetooth-settings-obexpush.h"

#include "bluetooth-pairing-dialog.h"

#include "pin.h"

#define BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE(obj) \

	(bluetooth_settings_widget_get_instance_private (obj))

typedef struct _BluetoothSettingsWidgetPrivate BluetoothSettingsWidgetPrivate;

struct _BluetoothSettingsWidgetPrivate {

	GtkBuilder          *builder;

	GtkWidget           *child_box;

	BluetoothClient     *client;

	GtkTreeModel        *model;

	gboolean             debug;

	GCancellable        *cancellable;

	/* Pairing */

	BluetoothAgent      *agent;

	GtkWidget           *pairing_dialog;

	GHashTable          *pairing_devices; /* key=object-path, value=boolean */

	/* Properties */

	GtkWidget           *properties_dialog;

	char                *selected_bdaddr;

	char                *selected_name;

	char                *selected_object_path;

	/* Device section */

	GtkWidget           *device_list;

	GtkAdjustment       *focus_adjustment;

	GtkSizeGroup        *row_sizegroup;

	GtkWidget           *device_stack;

	GtkWidget           *device_spinner;

	GHashTable          *connecting_devices; /* key=bdaddr, value=boolean */

	/* Hack to work-around:

	 * http://thread.gmane.org/gmane.linux.bluez.kernel/41471 */

	GHashTable          *devices_type; /* key=bdaddr, value=guint32 */

	/* Sharing section */

	GtkWidget           *visible_label;

	gboolean             has_console;

	GDBusProxy          *session_proxy;

};

G_DEFINE_TYPE_WITH_PRIVATE(BluetoothSettingsWidget, bluetooth_settings_widget, GTK_TYPE_BOX)

enum {

	PANEL_CHANGED,

	ADAPTER_STATUS_CHANGED,

	LAST_SIGNAL

};

static guint signals[LAST_SIGNAL] = { 0 };

#define WID(s) GTK_WIDGET (gtk_builder_get_object (priv->builder, s))

#define KEYBOARD_PREFS		"keyboard"

#define MOUSE_PREFS		"mouse"

#define SOUND_PREFS		"sound"

#define ICON_SIZE 128

/* We'll try to connect to the device repeatedly for that

 * amount of time before we bail out */

#define CONNECT_TIMEOUT 3.0

#define BLUEZ_SERVICE	"org.bluez"

#define ADAPTER_IFACE	"org.bluez.Adapter1"

#define AGENT_PATH "/org/gnome/bluetooth/settings"

#define GNOME_SESSION_DBUS_NAME      "org.gnome.SessionManager"

#define GNOME_SESSION_DBUS_OBJECT    "/org/gnome/SessionManager"

#define GNOME_SESSION_DBUS_INTERFACE "org.gnome.SessionManager"

#define FILLER_PAGE                  "filler-page"

#define DEVICES_PAGE                 "devices-page"

enum {

	CONNECTING_NOTEBOOK_PAGE_SWITCH = 0,

	CONNECTING_NOTEBOOK_PAGE_SPINNER = 1

};

static void

set_connecting_page (BluetoothSettingsWidget *self,

		     int               page)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (self);

	if (page == CONNECTING_NOTEBOOK_PAGE_SPINNER)

		gtk_spinner_start (GTK_SPINNER (WID ("connecting_spinner")));

	gtk_notebook_set_current_page (GTK_NOTEBOOK (WID ("connecting_notebook")), page);

	if (page == CONNECTING_NOTEBOOK_PAGE_SWITCH)

		gtk_spinner_stop (GTK_SPINNER (WID ("connecting_spinner")));

}

static void

remove_connecting (BluetoothSettingsWidget *self,

		   const char       *bdaddr)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (self);

	g_hash_table_remove (priv->connecting_devices, bdaddr);

}

static void

add_connecting (BluetoothSettingsWidget *self,

		const char       *bdaddr)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (self);

	g_hash_table_insert (priv->connecting_devices,

			     g_strdup (bdaddr),

			     GINT_TO_POINTER (1));

}

static gboolean

is_connecting (BluetoothSettingsWidget *self,

	       const char       *bdaddr)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (self);

	return GPOINTER_TO_INT (g_hash_table_lookup (priv->connecting_devices,

						     bdaddr));

}

typedef struct {

	char             *bdaddr;

	BluetoothSettingsWidget *self;

} ConnectData;

static void

connect_done (GObject      *source_object,

	      GAsyncResult *res,

	      gpointer      user_data)

{

	BluetoothSettingsWidget *self;

	BluetoothSettingsWidgetPrivate *priv;

	gboolean success;

	GError *error = NULL;

	ConnectData *data = (ConnectData *) user_data;

	success = bluetooth_client_connect_service_finish (BLUETOOTH_CLIENT (source_object),

							   res, &error);

	if (!success && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))

		goto out;

	self = data->self;

	priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (self);

	/* Check whether the same device is now selected, and update the UI */

	if (g_strcmp0 (priv->selected_bdaddr, data->bdaddr) == 0) {

		GtkSwitch *button;

		button = GTK_SWITCH (WID ("switch_connection"));

		/* Ensure the switch position is in the correct place. */

		gtk_switch_set_active (button, gtk_switch_get_state (button));

		if (success == FALSE) {

			g_debug ("Connection failed to %s: %s", data->bdaddr, error->message);

		}

		set_connecting_page (self, CONNECTING_NOTEBOOK_PAGE_SWITCH);

	}

	g_clear_error (&error);

	remove_connecting (self, data->bdaddr);

	//FIXME show an error if it failed?

out:

	g_clear_error (&error);

	g_free (data->bdaddr);

	g_free (data);

}

static void

add_device_type (BluetoothSettingsWidget *self,

		 const char              *bdaddr,

		 BluetoothType            type)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (self);

	BluetoothType t;

	t = GPOINTER_TO_UINT (g_hash_table_lookup (priv->devices_type, bdaddr));

	if (t == 0 || t == BLUETOOTH_TYPE_ANY) {

		g_hash_table_insert (priv->devices_type, g_strdup (bdaddr), GUINT_TO_POINTER (type));

		g_debug ("Saving device type %s for %s", bluetooth_type_to_string (type), bdaddr);

	}

}

static void

setup_pairing_dialog (BluetoothSettingsWidget *self)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (self);

	GtkWidget *toplevel;

	g_clear_pointer (&priv->pairing_dialog, gtk_widget_destroy);

	priv->pairing_dialog = bluetooth_pairing_dialog_new ();

	toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self));

	gtk_window_set_transient_for (GTK_WINDOW (priv->pairing_dialog), GTK_WINDOW (toplevel));

	gtk_window_set_modal (GTK_WINDOW (priv->pairing_dialog), TRUE);

}

static gboolean

get_properties_for_device (BluetoothSettingsWidget  *self,

			   GDBusProxy               *device,

			   char                    **name,

			   char                    **ret_bdaddr,

			   BluetoothType            *type)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (self);

	GVariant *value;

	char *bdaddr;

	g_return_val_if_fail (name != NULL, FALSE);

	value = g_dbus_proxy_get_cached_property (device, "Name");

	if (value == NULL) {

		/* What?! */

		return FALSE;

	}

	*name = g_variant_dup_string (value, NULL);

	g_variant_unref (value);

	value = g_dbus_proxy_get_cached_property (device, "Address");

	bdaddr = g_variant_dup_string (value, NULL);

	g_variant_unref (value);

	if (ret_bdaddr)

		*ret_bdaddr = g_strdup (bdaddr);

	if (type) {

		value = g_dbus_proxy_get_cached_property (device, "Class");

		if (value != NULL) {

			*type = bluetooth_class_to_type (g_variant_get_uint32 (value));

			g_variant_unref (value);

		} else {

			*type = GPOINTER_TO_UINT (g_hash_table_lookup (priv->devices_type, bdaddr));

			if (*type == 0)

				*type = BLUETOOTH_TYPE_ANY;

		}

	}

	g_free (bdaddr);

	return TRUE;

}

static char *

get_random_pincode (guint num_digits)

{

	if (num_digits == 0)

		num_digits = PIN_NUM_DIGITS;

	return g_strdup_printf ("%d", g_random_int_range (pow (10, num_digits - 1),

							  pow (10, num_digits)));

}

static char *

get_icade_pincode (char **pin_display_str)

{

	GString *pin, *pin_display;

	guint i;

	static char *arrows[] = {

		NULL,

		"⬆", /* up = 1    */

		"⬇", /* down = 2  */

		"⬅", /* left = 3  */

		"➡"  /* right = 4 */

	};

	pin = g_string_new (NULL);

	pin_display = g_string_new (NULL);

	for (i = 0; i < PIN_NUM_DIGITS; i++) {

		int r;

		char *c;

		r = g_random_int_range (1, 5);

		c = g_strdup_printf ("%d", r);

		g_string_append (pin, c);

		g_free (c);

		g_string_append (pin_display, arrows[r]);

	}

	g_string_append (pin_display, "❍");

	*pin_display_str = g_string_free (pin_display, FALSE);

	return g_string_free (pin, FALSE);

}

static void

display_cb (GtkDialog *dialog,

	    int        response,

	    gpointer   user_data)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	g_clear_pointer (&priv->pairing_dialog, gtk_widget_destroy);

}

static void

enter_pin_cb (GtkDialog *dialog,

	      int        response,

	      gpointer   user_data)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	GDBusMethodInvocation *invocation;

	invocation = g_object_get_data (G_OBJECT (dialog), "invocation");

	if (response == GTK_RESPONSE_ACCEPT) {

		const char *name;

		char *pin;

		BluetoothPairingMode mode;

		mode = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (dialog), "mode"));

		name = g_object_get_data (G_OBJECT (dialog), "name");

		pin = bluetooth_pairing_dialog_get_pin (BLUETOOTH_PAIRING_DIALOG (dialog));

		g_dbus_method_invocation_return_value (invocation,

						       g_variant_new ("(s)", pin));

		if (bluetooth_pairing_dialog_get_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog)) == BLUETOOTH_PAIRING_MODE_PIN_QUERY) {

			g_clear_pointer (&priv->pairing_dialog, gtk_widget_destroy);

			return;

		}

		bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

						   mode, pin, name);

		g_free (pin);

		g_signal_connect (G_OBJECT (priv->pairing_dialog), "response",

				  G_CALLBACK (display_cb), user_data);

	} else {

		g_dbus_method_invocation_return_dbus_error (invocation,

							    "org.bluez.Error.Canceled",

							    "User cancelled pairing");

		g_clear_pointer (&priv->pairing_dialog, gtk_widget_destroy);

		return;

	}

	g_object_set_data (G_OBJECT (priv->pairing_dialog), "invocation", NULL);

	g_object_set_data (G_OBJECT (priv->pairing_dialog), "mode", NULL);

	g_object_set_data (G_OBJECT (priv->pairing_dialog), "name", NULL);

}

static void

confirm_remote_pin_cb (GtkDialog *dialog,

		       int        response,

		       gpointer   user_data)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	GDBusMethodInvocation *invocation;

	invocation = g_object_get_data (G_OBJECT (dialog), "invocation");

	if (response == GTK_RESPONSE_ACCEPT) {

		GDBusProxy *device;

		const char *pin;

		pin = g_object_get_data (G_OBJECT (invocation), "pin");

		device = g_object_get_data (G_OBJECT (invocation), "device");

		bluetooth_client_set_trusted (priv->client, g_dbus_proxy_get_object_path (device), TRUE);

		g_dbus_method_invocation_return_value (invocation,

						       g_variant_new ("(s)", pin));

	} else {

		g_dbus_method_invocation_return_dbus_error (invocation, "org.bluez.Error.Rejected", "Pairing refused from settings panel");

	}

	g_clear_pointer (&priv->pairing_dialog, gtk_widget_destroy);

}

static void

pincode_callback (GDBusMethodInvocation *invocation,

		  GDBusProxy            *device,

		  gpointer               user_data)

{

	BluetoothSettingsWidget *self = user_data;

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	BluetoothType type;

	char *name, *bdaddr;

	guint max_digits;

	gboolean confirm_pin = TRUE;

	char *default_pin;

	char *display_pin = NULL;

	BluetoothPairingMode mode;

	gboolean remote_initiated;

	g_debug ("pincode_callback (%s)", g_dbus_proxy_get_object_path (device));

	if (!get_properties_for_device (self, device, &name, &bdaddr, &type)) {

		char *msg;

		msg = g_strdup_printf ("Missing information for %s", g_dbus_proxy_get_object_path (device));

		g_dbus_method_invocation_return_dbus_error (invocation, "org.bluez.Error.Rejected", msg);

		g_free (msg);

		return;

	}

	remote_initiated = !GPOINTER_TO_UINT (g_hash_table_lookup (priv->pairing_devices,

								   g_dbus_proxy_get_object_path (device)));

	default_pin = get_pincode_for_device (type, bdaddr, name, &max_digits, &confirm_pin);

	if (g_strcmp0 (default_pin, "KEYBOARD") == 0) {

		mode = BLUETOOTH_PAIRING_MODE_PIN_DISPLAY_KEYBOARD;

		g_free (default_pin);

		default_pin = get_random_pincode (max_digits);

		display_pin = g_strdup_printf ("%s⏎", default_pin);

	} else if (g_strcmp0 (default_pin, "ICADE") == 0) {

		mode = BLUETOOTH_PAIRING_MODE_PIN_DISPLAY_ICADE;

		confirm_pin = FALSE;

		g_free (default_pin);

		default_pin = get_icade_pincode (&display_pin);

	} else if (default_pin == NULL) {

		mode = BLUETOOTH_PAIRING_MODE_PIN_DISPLAY_NORMAL;

		confirm_pin = TRUE;

		default_pin = get_random_pincode (0);

	} else if (g_strcmp0 (default_pin, "NULL") == 0) {

		g_assert_not_reached ();

	} else {

		mode = BLUETOOTH_PAIRING_MODE_PIN_DISPLAY_NORMAL;

		display_pin = g_strdup (default_pin);

	}

	setup_pairing_dialog (BLUETOOTH_SETTINGS_WIDGET (user_data));

	g_object_set_data_full (G_OBJECT (priv->pairing_dialog), "name", g_strdup (name), g_free);

	g_object_set_data (G_OBJECT (priv->pairing_dialog), "mode", GUINT_TO_POINTER (mode));

	if (confirm_pin) {

		g_object_set_data (G_OBJECT (priv->pairing_dialog), "invocation", invocation);

		if (remote_initiated) {

			bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

							   BLUETOOTH_PAIRING_MODE_PIN_QUERY,

							   default_pin,

							   name);

		} else {

			bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

							   BLUETOOTH_PAIRING_MODE_PIN_CONFIRMATION,

							   default_pin,

							   name);

		}

		g_signal_connect (G_OBJECT (priv->pairing_dialog), "response",

				  G_CALLBACK (enter_pin_cb), user_data);

	} else if (!remote_initiated) {

		bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

						   mode, display_pin, name);

		g_dbus_method_invocation_return_value (invocation,

						       g_variant_new ("(s)", default_pin));

		g_signal_connect (G_OBJECT (priv->pairing_dialog), "response",

				  G_CALLBACK (display_cb), user_data);

	} else {

		bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

						   BLUETOOTH_PAIRING_MODE_YES_NO,

						   default_pin, name);

		g_object_set_data_full (G_OBJECT (invocation), "pin", g_strdup (default_pin), g_free);

		g_object_set_data_full (G_OBJECT (invocation), "device", g_object_ref (device), g_object_unref);

		g_object_set_data (G_OBJECT (priv->pairing_dialog), "invocation", invocation);

		g_signal_connect (G_OBJECT (priv->pairing_dialog), "response",

				  G_CALLBACK (confirm_remote_pin_cb), user_data);

	}

	g_free (name);

	g_free (bdaddr);

	g_free (default_pin);

	g_free (display_pin);

	gtk_widget_show (priv->pairing_dialog);

}

static void

display_callback (GDBusMethodInvocation *invocation,

		  GDBusProxy            *device,

		  guint                  pin,

		  guint                  entered,

		  gpointer               user_data)

{

	BluetoothSettingsWidget *self = user_data;

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	char *pin_str, *name;

	g_debug ("display_callback (%s, %i, %i)", g_dbus_proxy_get_object_path (device), pin, entered);

	if (priv->pairing_dialog == NULL ||

	    bluetooth_pairing_dialog_get_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog)) != BLUETOOTH_PAIRING_MODE_PIN_DISPLAY_KEYBOARD)

		setup_pairing_dialog (BLUETOOTH_SETTINGS_WIDGET (user_data));

	pin_str = g_strdup_printf ("%06d", pin);

	get_properties_for_device (self, device, &name, NULL, NULL);

	bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

					   BLUETOOTH_PAIRING_MODE_PIN_DISPLAY_KEYBOARD,

					   pin_str,

					   name);

	bluetooth_pairing_dialog_set_pin_entered (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

						  entered);

	g_free (pin_str);

	g_free (name);

	gtk_widget_show (priv->pairing_dialog);

}

static void

display_pincode_callback (GDBusMethodInvocation *invocation,

			  GDBusProxy            *device,

			  const char            *pincode,

			  gpointer               user_data)

{

	BluetoothSettingsWidget *self = user_data;

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	BluetoothType type;

	char *display_pin = NULL;

	char *name, *bdaddr;

	char *db_pin;

	g_debug ("display_pincode_callback (%s, %s)", g_dbus_proxy_get_object_path (device), pincode);

	if (!get_properties_for_device (self, device, &name, &bdaddr, &type)) {

		char *msg;

		msg = g_strdup_printf ("Missing information for %s", g_dbus_proxy_get_object_path (device));

		g_dbus_method_invocation_return_dbus_error (invocation, "org.bluez.Error.Rejected", msg);

		g_free (msg);

		return;

	}

	/* Verify PIN code validity */

	db_pin = get_pincode_for_device (type,

					 bdaddr,

					 name,

					 NULL,

					 NULL);

	if (g_strcmp0 (db_pin, "KEYBOARD") == 0) {

		/* Should work, follow through */

	} else if (g_strcmp0 (db_pin, "ICADE") == 0) {

		char *msg;

		msg = g_strdup_printf ("Generated pincode for %s when it shouldn't have", name);

		g_dbus_method_invocation_return_dbus_error (invocation, "org.bluez.Error.Rejected", msg);

		g_free (msg);

		goto bail;

	} else if (g_strcmp0 (db_pin, "0000") == 0) {

		g_debug ("Ignoring generated keyboard PIN '%s', should get 0000 soon", pincode);

		g_dbus_method_invocation_return_value (invocation, NULL);

		goto bail;

	} else if (g_strcmp0 (db_pin, "NULL") == 0) {

		char *msg;

		msg = g_strdup_printf ("Attempting pairing for %s that doesn't support pairing", name);

		g_dbus_method_invocation_return_dbus_error (invocation, "org.bluez.Error.Rejected", msg);

		g_free (msg);

		goto bail;

	}

	setup_pairing_dialog (BLUETOOTH_SETTINGS_WIDGET (user_data));

	display_pin = g_strdup_printf ("%s⏎", pincode);

	bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

					   BLUETOOTH_PAIRING_MODE_PIN_DISPLAY_KEYBOARD,

					   display_pin,

					   name);

	gtk_widget_show (priv->pairing_dialog);

	g_dbus_method_invocation_return_value (invocation, NULL);

bail:

	g_free (db_pin);

	g_free (display_pin);

	g_free (bdaddr);

	g_free (name);

}

static void

passkey_callback (GDBusMethodInvocation *invocation,

		  GDBusProxy            *device,

		  gpointer               data)

{

	g_warning ("RequestPasskey(): not implemented");

	g_dbus_method_invocation_return_dbus_error (invocation,

						    "org.bluez.Error.Rejected",

						    "RequestPasskey not implemented");

}

static gboolean

cancel_callback (GDBusMethodInvocation *invocation,

		 gpointer               user_data)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	GList *l, *children;

	g_debug ("cancel_callback ()");

	g_clear_pointer (&priv->pairing_dialog, gtk_widget_destroy);

	children = gtk_container_get_children (GTK_CONTAINER (priv->device_list));

	for (l = children; l != NULL; l = l->next)

		g_object_set (l->data, "pairing", FALSE, NULL);

	g_list_free (children);

	g_dbus_method_invocation_return_value (invocation, NULL);

	return TRUE;

}

static void

confirm_cb (GtkDialog *dialog,

	    int        response,

	    gpointer   user_data)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	GDBusMethodInvocation *invocation;

	invocation = g_object_get_data (G_OBJECT (dialog), "invocation");

	if (response == GTK_RESPONSE_ACCEPT) {

		g_dbus_method_invocation_return_value (invocation, NULL);

	} else {

		g_dbus_method_invocation_return_dbus_error (invocation,

							    "org.bluez.Error.Canceled",

							    "User cancelled pairing");

	}

	g_clear_pointer (&priv->pairing_dialog, gtk_widget_destroy);

}

static void

confirm_callback (GDBusMethodInvocation *invocation,

		  GDBusProxy            *device,

		  guint                  pin,

		  gpointer               user_data)

{

	BluetoothSettingsWidget *self = user_data;

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	char *name, *pin_str;

	g_debug ("confirm_callback (%s, %i)", g_dbus_proxy_get_object_path (device), pin);

	setup_pairing_dialog (BLUETOOTH_SETTINGS_WIDGET (user_data));

	pin_str = g_strdup_printf ("%06d", pin);

	get_properties_for_device (self, device, &name, NULL, NULL);

	bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

					   BLUETOOTH_PAIRING_MODE_PIN_MATCH,

					   pin_str, name);

	g_signal_connect (G_OBJECT (priv->pairing_dialog), "response",

			  G_CALLBACK (confirm_cb), user_data);

	g_object_set_data (G_OBJECT (priv->pairing_dialog), "invocation", invocation);

	gtk_widget_show (priv->pairing_dialog);

	g_free (pin_str);

	g_free (name);

}

static void

authorize_callback (GDBusMethodInvocation *invocation,

		    GDBusProxy            *device,

		    gpointer               user_data)

{

	BluetoothSettingsWidget *self = user_data;

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	char *name;

	g_debug ("authorize_callback (%s)", g_dbus_proxy_get_object_path (device));

	setup_pairing_dialog (BLUETOOTH_SETTINGS_WIDGET (user_data));

	get_properties_for_device (self, device, &name, NULL, NULL);

	bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

					   BLUETOOTH_PAIRING_MODE_YES_NO,

					   NULL, name);

	g_signal_connect (G_OBJECT (priv->pairing_dialog), "response",

			  G_CALLBACK (confirm_cb), user_data);

	g_object_set_data (G_OBJECT (priv->pairing_dialog), "invocation", invocation);

	gtk_widget_show (priv->pairing_dialog);

	g_free (name);

}

static void

authorize_service_cb (GtkDialog *dialog,

		      int        response,

		      gpointer   user_data)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	GDBusMethodInvocation *invocation;

	invocation = g_object_get_data (G_OBJECT (dialog), "invocation");

	if (response == GTK_RESPONSE_ACCEPT) {

		GDBusProxy *device;

		device = g_object_get_data (G_OBJECT (invocation), "device");

		bluetooth_client_set_trusted (priv->client, g_dbus_proxy_get_object_path (device), TRUE);

		g_dbus_method_invocation_return_value (invocation, NULL);

	} else {

		char *msg;

		msg = g_strdup_printf ("Rejecting service auth (HID): not paired or trusted");

		g_dbus_method_invocation_return_dbus_error (invocation, "org.bluez.Error.Rejected", msg);

		g_free (msg);

	}

	g_clear_pointer (&priv->pairing_dialog, gtk_widget_destroy);

}

static void

authorize_service_callback (GDBusMethodInvocation *invocation,

			    GDBusProxy            *device,

			    const char            *uuid,

			    gpointer               user_data)

{

	BluetoothSettingsWidget *self = user_data;

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (user_data);

	char *msg;

	GVariant *value;

	gboolean paired, trusted;

	g_debug ("authorize_service_callback (%s, %s)", g_dbus_proxy_get_object_path (device), uuid);

	value = g_dbus_proxy_get_cached_property (device, "Paired");

	paired = g_variant_get_boolean (value);

	g_variant_unref (value);

	value = g_dbus_proxy_get_cached_property (device, "Trusted");

	trusted = g_variant_get_boolean (value);

	g_variant_unref (value);

	/* Device was paired, initiated from the remote device,

	 * so we didn't get the opportunity to set the trusted bit */

	if (paired && !trusted) {

		bluetooth_client_set_trusted (priv->client,

					      g_dbus_proxy_get_object_path (device), TRUE);

		g_dbus_method_invocation_return_value (invocation, NULL);

		return;

	}

	if (g_strcmp0 (bluetooth_uuid_to_string (uuid), "HumanInterfaceDeviceService") != 0) {

		msg = g_strdup_printf ("Rejecting service auth (%s) for %s: not HID",

				       uuid, g_dbus_proxy_get_object_path (device));

		g_dbus_method_invocation_return_dbus_error (invocation, "org.bluez.Error.Rejected", msg);

		g_free (msg);

		return;

	}

	/* We shouldn't get asked, but shizzle happens */

	if (paired || trusted) {

		g_dbus_method_invocation_return_value (invocation, NULL);

	} else {

		char *name;

		setup_pairing_dialog (BLUETOOTH_SETTINGS_WIDGET (user_data));

		get_properties_for_device (self, device, &name, NULL, NULL);

		bluetooth_pairing_dialog_set_mode (BLUETOOTH_PAIRING_DIALOG (priv->pairing_dialog),

						   BLUETOOTH_PAIRING_MODE_CONFIRM_AUTH,

						   NULL, name);

		g_signal_connect (G_OBJECT (priv->pairing_dialog), "response",

				  G_CALLBACK (authorize_service_cb), user_data);

		g_object_set_data_full (G_OBJECT (invocation), "device", g_object_ref (device), g_object_unref);

		g_object_set_data (G_OBJECT (priv->pairing_dialog), "invocation", invocation);

		gtk_widget_show (priv->pairing_dialog);

		g_free (name);

	}

}

static void

turn_off_pairing (BluetoothSettingsWidget *self,

		  const char              *object_path)

{

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (self);

	GList *l, *children;

	children = gtk_container_get_children (GTK_CONTAINER (priv->device_list));

	for (l = children; l != NULL; l = l->next) {

		GDBusProxy *proxy;

		g_object_get (l->data, "proxy", &proxy, NULL);

		if (g_strcmp0 (g_dbus_proxy_get_object_path (proxy), object_path) == 0) {

			g_object_set (l->data, "pairing", FALSE, NULL);

			g_object_unref (proxy);

			break;

		}

		g_object_unref (proxy);

	}

	g_list_free (children);

}

typedef struct {

	BluetoothSettingsWidget *self;

	char *device;

	GTimer *timer;

	guint timeout_id;

} SetupConnectData;

static void connect_callback (GObject      *source_object,

			      GAsyncResult *res,

			      gpointer      user_data);

static gboolean

connect_timeout_cb (gpointer user_data)

{

	SetupConnectData *data = (SetupConnectData *) user_data;

	BluetoothSettingsWidgetPrivate *priv = BLUETOOTH_SETTINGS_WIDGET_GET_PRIVATE (data->self);

	bluetooth_client_connect_service (priv->client, data->device, TRUE, NULL, connect_callback, data);

	data->timeout_id = 0;

	return G_SOURCE_REMOVE;

}

static void

connect_callback (GObject      *source_object,

		  GAsyncResult *res,

		  gpointer      user_data)

{

	SetupConnectData *data = (SetupConnectData *) user_data;

	GError *error = NULL;

	gboolean success;

	success = bluetooth_client_connect_service_finish (BLUETOOTH_CLIENT (source_object), res, &error);

	if (success == FALSE) {

		if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {

			g_error_free (error);

			goto bail;

		} else if (g_timer_elapsed (data->timer, NULL) < CONNECT_TIMEOUT) {

			g_assert (data->timeout_id == 0);

			data->timeout_id = g_timeout_add (500, connect_timeout_cb, data);

			g_error_free (error);

			return;

		}

		g_debug ("Failed to connect to device %s", data->device);

	}

	turn_off_pairing (data->self, data->device);

bail:

	if (data->timeout_id > 0)

		g_source_remove (data->timeout_id);