/*
 * e-mail-config-service-page.c
 *
 * This program 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 of the License, or (at your option) version 3.
 *
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 */

#include "e-mail-config-service-page.h"

#include <config.h>
#include <glib/gi18n-lib.h>

#include <camel/camel.h>
#include <libebackend/libebackend.h>

#include <mail/e-mail-config-page.h>
#include <mail/e-mail-config-service-notebook.h>

#define E_MAIL_CONFIG_SERVICE_PAGE_GET_PRIVATE(obj) \
	(G_TYPE_INSTANCE_GET_PRIVATE \
	((obj), E_TYPE_MAIL_CONFIG_SERVICE_PAGE, EMailConfigServicePagePrivate))

/* Used for autoconfiguration. */
#define POP3_BACKEND_NAME "pop"
#define IMAP_BACKEND_NAME "imapx"
#define SMTP_BACKEND_NAME "smtp"

typedef struct _Candidate Candidate;

struct _EMailConfigServicePagePrivate {
	ESourceRegistry *registry;
	EMailConfigServiceBackend *active_backend;
	gchar *email_address;

	GHashTable *backends;
	GPtrArray *candidates;

	/* Hidden candidates are not listed in the
	 * combo box but can still be accessed through
	 * e_mail_config_service_page_lookup_backend(). */
	GPtrArray *hidden_candidates;

	GtkWidget *type_combo;
	GtkWidget *type_label;
	GtkWidget *desc_label;
	GtkWidget *notebook;

	/* Combo box list store */
	GtkListStore *list_store;
};

struct _Candidate {
	gchar *name;
	EMailConfigServiceBackend *backend;

	CamelProvider *provider;
	CamelSettings *settings;
	gulong settings_notify_handler_id;

	GtkWidget *widget;
};

enum {
	PROP_0,
	PROP_ACTIVE_BACKEND,
	PROP_EMAIL_ADDRESS,
	PROP_REGISTRY
};

enum {
	COLUMN_BACKEND_NAME,
	COLUMN_DISPLAY_NAME,
	COLUMN_SELECTABLE,
	NUM_COLUMNS
};

/* Forward Declarations */
static void	e_mail_config_service_page_interface_init
					(EMailConfigPageInterface *interface);

G_DEFINE_ABSTRACT_TYPE_WITH_CODE (
	EMailConfigServicePage,
	e_mail_config_service_page,
	E_TYPE_MAIL_CONFIG_ACTIVITY_PAGE,
	G_IMPLEMENT_INTERFACE (
		E_TYPE_EXTENSIBLE, NULL)
	G_IMPLEMENT_INTERFACE (
		E_TYPE_MAIL_CONFIG_PAGE,
		e_mail_config_service_page_interface_init))

static void
mail_config_service_page_settings_notify_cb (CamelSettings *settings,
                                             GParamSpec *pspec,
                                             EMailConfigPage *page)
{
	e_mail_config_page_changed (page);
}

static Candidate *
mail_config_service_page_new_candidate (EMailConfigServicePage *page,
                                        ESource *scratch_source,
                                        ESource *opt_collection)
{
	Candidate *candidate;
	CamelProvider *provider;
	CamelSettings *settings;
	ESourceBackend *extension;
	EMailConfigServiceBackend *backend;
	EMailConfigServicePageClass *class;
	const gchar *extension_name;
	const gchar *backend_name;
	gulong handler_id;

	/* Get the backend name for this scratch source. */
	class = E_MAIL_CONFIG_SERVICE_PAGE_GET_CLASS (page);
	extension_name = class->extension_name;
	extension = e_source_get_extension (scratch_source, extension_name);
	backend_name = e_source_backend_get_backend_name (extension);
	g_return_val_if_fail (backend_name != NULL, NULL);

	/* Make sure we have a corresponding EMailConfigServicePageBackend. */
	backend = g_hash_table_lookup (page->priv->backends, backend_name);
	g_return_val_if_fail (E_IS_MAIL_CONFIG_SERVICE_BACKEND (backend), NULL);

	/* Make sure we have a corresponding CamelProvider. */
	provider = e_mail_config_service_backend_get_provider (backend);
	g_return_val_if_fail (provider != NULL, NULL);

	/* Need to give the backend a scratch source and (if provided) a
	 * scratch collection source before we can extract a CamelSettings
	 * instance, since the CamelSettings instance comes from either the
	 * scratch collection source or else the scratch source. */
	e_mail_config_service_backend_set_source (backend, scratch_source);
	if (opt_collection != NULL)
		e_mail_config_service_backend_set_collection (
			backend, opt_collection);

	/* Backend may have created its own collection source,
	 * so we need to get it from the backend before binding. */
	opt_collection = e_mail_config_service_backend_get_collection (backend);

	/* Keep display names synchronized. */
	if (opt_collection != NULL)
		g_object_bind_property (
			scratch_source, "display-name",
			opt_collection, "display-name",
			G_BINDING_BIDIRECTIONAL |
			G_BINDING_SYNC_CREATE);

	/* Make sure we have a corresponding CamelSettings. */
	settings = e_mail_config_service_backend_get_settings (backend);
	g_return_val_if_fail (CAMEL_IS_SETTINGS (settings), NULL);

	candidate = g_slice_new0 (Candidate);
	candidate->name = g_strdup (backend_name);
	candidate->backend = g_object_ref (backend);
	candidate->provider = provider;
	candidate->settings = g_object_ref (settings);

	/* Remove the backend so it can't be reused.  If another scratch
	 * source with the same backend name gets added, the hash table
	 * lookup will fail and emit a runtime warning, which we want. */
	g_hash_table_remove (page->priv->backends, backend_name);

	/* Emit "changed" signals for subsequent CamelSettings changes. */
	handler_id = g_signal_connect (
		candidate->settings, "notify",
		G_CALLBACK (mail_config_service_page_settings_notify_cb), page);
	candidate->settings_notify_handler_id = handler_id;

	return candidate;
}

static void
mail_config_service_page_free_candidate (Candidate *candidate)
{
	g_free (candidate->name);

	if (candidate->backend != NULL)
		g_object_unref (candidate->backend);

	if (candidate->settings != NULL) {
		g_signal_handler_disconnect (
			candidate->settings,
			candidate->settings_notify_handler_id);
		g_object_unref (candidate->settings);
	}

	if (candidate->widget != NULL)
		g_object_unref (candidate->widget);

	g_slice_free (Candidate, candidate);
}

static void
mail_config_service_page_init_backends (EMailConfigServicePage *page)
{
	GList *list, *iter;

	page->priv->backends = g_hash_table_new_full (
		(GHashFunc) g_str_hash,
		(GEqualFunc) g_str_equal,
		(GDestroyNotify) g_free,
		(GDestroyNotify) g_object_unref);

	e_extensible_load_extensions (E_EXTENSIBLE (page));

	list = e_extensible_list_extensions (
		E_EXTENSIBLE (page), E_TYPE_MAIL_CONFIG_SERVICE_BACKEND);

	for (iter = list; iter != NULL; iter = g_list_next (iter)) {
		EMailConfigServiceBackend *backend;
		EMailConfigServiceBackendClass *class;

		backend = E_MAIL_CONFIG_SERVICE_BACKEND (iter->data);
		class = E_MAIL_CONFIG_SERVICE_BACKEND_GET_CLASS (backend);

		if (class->backend_name != NULL)
			g_hash_table_insert (
				page->priv->backends,
				g_strdup (class->backend_name),
				g_object_ref (backend));
	}

	g_list_free (list);
}

static gboolean
mail_config_service_page_backend_to_id (GBinding *binding,
                                        const GValue *source_value,
                                        GValue *target_value,
                                        gpointer user_data)
{
	EMailConfigServiceBackend *backend;
	EMailConfigServiceBackendClass *backend_class;

	backend = g_value_get_object (source_value);
	g_return_val_if_fail (backend != NULL, FALSE);

	backend_class = E_MAIL_CONFIG_SERVICE_BACKEND_GET_CLASS (backend);
	g_value_set_string (target_value, backend_class->backend_name);

	return TRUE;
}

static gboolean
mail_config_service_page_id_to_backend (GBinding *binding,
                                        const GValue *source_value,
                                        GValue *target_value,
                                        gpointer user_data)
{
	EMailConfigServiceBackend *backend = NULL;
	GObject *source_object;
	const gchar *backend_name;

	source_object = g_binding_get_source (binding);
	backend_name = g_value_get_string (source_value);

	if (backend_name != NULL)
		backend = e_mail_config_service_page_lookup_backend (
			E_MAIL_CONFIG_SERVICE_PAGE (source_object),
			backend_name);

	g_value_set_object (target_value, backend);

	return TRUE;
}

static gboolean
mail_config_service_page_backend_name_to_description (GBinding *binding,
                                                      const GValue *source_value,
                                                      GValue *target_value,
                                                      gpointer user_data)
{
	CamelProvider *provider;
	const gchar *description;
	const gchar *backend_name;

	backend_name = g_value_get_string (source_value);

	/* XXX Silly special case. */
	if (backend_name == NULL)
		backend_name = "none";

	provider = camel_provider_get (backend_name, NULL);

	if (provider != NULL && provider->description != NULL)
		description = g_dgettext (
			provider->translation_domain,
			provider->description);
	else
		description = "";

	g_value_set_string (target_value, description);

	return TRUE;
}

static void
mail_config_service_page_set_registry (EMailConfigServicePage *page,
                                       ESourceRegistry *registry)
{
	g_return_if_fail (E_IS_SOURCE_REGISTRY (registry));
	g_return_if_fail (page->priv->registry == NULL);

	page->priv->registry = g_object_ref (registry);
}

static void
mail_config_service_page_set_property (GObject *object,
                                       guint property_id,
                                       const GValue *value,
                                       GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_ACTIVE_BACKEND:
			e_mail_config_service_page_set_active_backend (
				E_MAIL_CONFIG_SERVICE_PAGE (object),
				g_value_get_object (value));
			return;

		case PROP_EMAIL_ADDRESS:
			e_mail_config_service_page_set_email_address (
				E_MAIL_CONFIG_SERVICE_PAGE (object),
				g_value_get_string (value));
			return;

		case PROP_REGISTRY:
			mail_config_service_page_set_registry (
				E_MAIL_CONFIG_SERVICE_PAGE (object),
				g_value_get_object (value));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
mail_config_service_page_get_property (GObject *object,
                                       guint property_id,
                                       GValue *value,
                                       GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_ACTIVE_BACKEND:
			g_value_set_object (
				value,
				e_mail_config_service_page_get_active_backend (
				E_MAIL_CONFIG_SERVICE_PAGE (object)));
			return;

		case PROP_EMAIL_ADDRESS:
			g_value_set_string (
				value,
				e_mail_config_service_page_get_email_address (
				E_MAIL_CONFIG_SERVICE_PAGE (object)));
			return;

		case PROP_REGISTRY:
			g_value_set_object (
				value,
				e_mail_config_service_page_get_registry (
				E_MAIL_CONFIG_SERVICE_PAGE (object)));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
mail_config_service_page_dispose (GObject *object)
{
	EMailConfigServicePagePrivate *priv;

	priv = E_MAIL_CONFIG_SERVICE_PAGE_GET_PRIVATE (object);

	if (priv->registry != NULL) {
		g_object_unref (priv->registry);
		priv->registry = NULL;
	}

	if (priv->active_backend != NULL) {
		g_object_unref (priv->active_backend);
		priv->active_backend = NULL;
	}

	g_hash_table_remove_all (priv->backends);
	g_ptr_array_set_size (priv->candidates, 0);
	g_ptr_array_set_size (priv->hidden_candidates, 0);

	if (priv->list_store != NULL) {
		g_object_unref (priv->list_store);
		priv->list_store = NULL;
	}

	/* Chain up to parent's dispose() method. */
	G_OBJECT_CLASS (e_mail_config_service_page_parent_class)->dispose (object);
}

static void
mail_config_service_page_finalize (GObject *object)
{
	EMailConfigServicePagePrivate *priv;

	priv = E_MAIL_CONFIG_SERVICE_PAGE_GET_PRIVATE (object);

	g_free (priv->email_address);
	g_hash_table_destroy (priv->backends);
	g_ptr_array_free (priv->candidates, TRUE);
	g_ptr_array_free (priv->hidden_candidates, TRUE);

	/* Chain up to parent's finalize() method. */
	G_OBJECT_CLASS (e_mail_config_service_page_parent_class)->finalize (object);
}

static void
mail_config_service_page_constructed (GObject *object)
{
	EMailConfigServicePage *page;

	page = E_MAIL_CONFIG_SERVICE_PAGE (object);

	/* Chain up to parent's constructed() method. */
	G_OBJECT_CLASS (e_mail_config_service_page_parent_class)->
		constructed (object);

	mail_config_service_page_init_backends (page);
}

static void
mail_config_service_page_setup_defaults (EMailConfigPage *page)
{
	EMailConfigServicePageClass *class;
	EMailConfigServicePagePrivate *priv;
	guint ii;

	class = E_MAIL_CONFIG_SERVICE_PAGE_GET_CLASS (page);
	priv = E_MAIL_CONFIG_SERVICE_PAGE_GET_PRIVATE (page);

	for (ii = 0; ii < priv->candidates->len; ii++) {
		Candidate *candidate;

		candidate = priv->candidates->pdata[ii];
		g_return_if_fail (candidate != NULL);

		e_mail_config_service_backend_setup_defaults (
			candidate->backend);
	}

	/* XXX Not sure if we need to call setup_defaults() for
	 *     hidden candidates.  Hold off until a need arises. */

	if (class->default_backend_name != NULL)
		gtk_combo_box_set_active_id (
			GTK_COMBO_BOX (priv->type_combo),
			class->default_backend_name);
}

static gboolean
mail_config_service_page_check_complete (EMailConfigPage *page)
{
	EMailConfigServicePagePrivate *priv;
	EMailConfigServiceBackend *backend;
	GtkComboBox *type_combo;
	const gchar *backend_name;

	priv = E_MAIL_CONFIG_SERVICE_PAGE_GET_PRIVATE (page);

	type_combo = GTK_COMBO_BOX (priv->type_combo);
	backend_name = gtk_combo_box_get_active_id (type_combo);

	if (backend_name == NULL)
		return FALSE;

	backend = e_mail_config_service_page_lookup_backend (
		E_MAIL_CONFIG_SERVICE_PAGE (page), backend_name);

	return e_mail_config_service_backend_check_complete (backend);
}

static void
mail_config_service_page_commit_changes (EMailConfigPage *page,
                                         GQueue *source_queue)
{
	EMailConfigServicePagePrivate *priv;
	EMailConfigServiceBackend *backend;
	GtkComboBox *type_combo;
	const gchar *backend_name;

	priv = E_MAIL_CONFIG_SERVICE_PAGE_GET_PRIVATE (page);

	type_combo = GTK_COMBO_BOX (priv->type_combo);
	backend_name = gtk_combo_box_get_active_id (type_combo);
	g_return_if_fail (backend_name != NULL);

	backend = e_mail_config_service_page_lookup_backend (
		E_MAIL_CONFIG_SERVICE_PAGE (page), backend_name);

	e_mail_config_service_backend_commit_changes (backend);
}

static void
e_mail_config_service_page_class_init (EMailConfigServicePageClass *class)
{
	GObjectClass *object_class;

	g_type_class_add_private (class, sizeof (EMailConfigServicePagePrivate));

	object_class = G_OBJECT_CLASS (class);
	object_class->set_property = mail_config_service_page_set_property;
	object_class->get_property = mail_config_service_page_get_property;
	object_class->dispose = mail_config_service_page_dispose;
	object_class->finalize = mail_config_service_page_finalize;
	object_class->constructed = mail_config_service_page_constructed;

	g_object_class_install_property (
		object_class,
		PROP_ACTIVE_BACKEND,
		g_param_spec_object (
			"active-backend",
			"Active Backend",
			"The active service backend",
			E_TYPE_MAIL_CONFIG_SERVICE_BACKEND,
			G_PARAM_READWRITE |
			G_PARAM_STATIC_STRINGS));

	g_object_class_install_property (
		object_class,
		PROP_EMAIL_ADDRESS,
		g_param_spec_string (
			"email-address",
			"Email Address",
			"The user's email address",
			NULL,
			G_PARAM_READWRITE |
			G_PARAM_STATIC_STRINGS));

	g_object_class_install_property (
		object_class,
		PROP_REGISTRY,
		g_param_spec_object (
			"registry",
			"Registry",
			"Data source registry",
			E_TYPE_SOURCE_REGISTRY,
			G_PARAM_READWRITE |
			G_PARAM_CONSTRUCT_ONLY |
			G_PARAM_STATIC_STRINGS));
}

static void
e_mail_config_service_page_interface_init (EMailConfigPageInterface *interface)
{
	interface->setup_defaults = mail_config_service_page_setup_defaults;
	interface->check_complete = mail_config_service_page_check_complete;
	interface->commit_changes = mail_config_service_page_commit_changes;
}

static void
e_mail_config_service_page_init (EMailConfigServicePage *page)
{
	GPtrArray *candidates;
	GPtrArray *hidden_candidates;
	PangoAttribute *attr;
	PangoAttrList *attr_list;
	GtkLabel *label;
	GtkWidget *widget;
	GtkWidget *container;
	GtkTreeModel *tree_model;
	GtkCellRenderer *renderer;

	/* The candidates array holds scratch ESources, one for each
	 * item in the "type" combo box.  Scratch ESources are never
	 * added to the registry, so backend extensions can make any
	 * changes they want to them.  Whichever scratch ESource is
	 * "active" (selected in the "type" combo box) when the user
	 * clicks OK wins and is written to disk.  The others are
	 * discarded. */
	candidates = g_ptr_array_new_with_free_func (
		(GDestroyNotify) mail_config_service_page_free_candidate);

	/* Hidden candidates are not listed in the "type" combo box
	 * but their scratch ESource can still be "active".  This is
	 * a hack to accommodate groupware backends.  Usually when a
	 * hidden candidate is active the service page will not be
	 * visible anyway. */
	hidden_candidates = g_ptr_array_new_with_free_func (
		(GDestroyNotify) mail_config_service_page_free_candidate);

	gtk_box_set_spacing (GTK_BOX (page), 12);

	page->priv = E_MAIL_CONFIG_SERVICE_PAGE_GET_PRIVATE (page);
	page->priv->candidates = candidates;
	page->priv->hidden_candidates = hidden_candidates;

	/* Build a filtered model for the combo box, where row
	 * visibility is determined by the "selectable" column. */

	page->priv->list_store = gtk_list_store_new (
		NUM_COLUMNS,
		G_TYPE_STRING,		/* COLUMN_BACKEND_NAME */
		G_TYPE_STRING,		/* COLUMN_DISPLAY_NAME */
		G_TYPE_BOOLEAN);	/* COLUMN_SELECTABLE */

	tree_model = gtk_tree_model_filter_new (
		GTK_TREE_MODEL (page->priv->list_store), NULL);

	gtk_tree_model_filter_set_visible_column (
		GTK_TREE_MODEL_FILTER (tree_model), COLUMN_SELECTABLE);

	/* Either the combo box or the label is shown, never both.
	 * But we create both widgets and keep them both up-to-date
	 * regardless just because it makes the logic simpler. */

	container = GTK_WIDGET (page);

	widget = gtk_grid_new ();
	gtk_grid_set_row_spacing (GTK_GRID (widget), 12);
	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
	gtk_widget_show (widget);

	container = widget;

	attr_list = pango_attr_list_new ();

	attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
	pango_attr_list_insert (attr_list, attr);

	widget = gtk_label_new_with_mnemonic (_("Server _Type:"));
	gtk_widget_set_margin_right (widget, 12);
	gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.5);
	gtk_grid_attach (GTK_GRID (container), widget, 0, 0, 1, 1);
	gtk_widget_show (widget);

	label = GTK_LABEL (widget);

	widget = gtk_combo_box_new_with_model (tree_model);
	gtk_widget_set_hexpand (widget, TRUE);
	gtk_label_set_mnemonic_widget (label, widget);
	gtk_combo_box_set_id_column (
		GTK_COMBO_BOX (widget), COLUMN_BACKEND_NAME);
	gtk_grid_attach (GTK_GRID (container), widget, 1, 0, 1, 1);
	page->priv->type_combo = widget;  /* not referenced */
	gtk_widget_show (widget);

	renderer = gtk_cell_renderer_text_new ();
	gtk_cell_layout_pack_start (
		GTK_CELL_LAYOUT (widget), renderer, TRUE);
	gtk_cell_layout_add_attribute (
		GTK_CELL_LAYOUT (widget), renderer,
		"text", COLUMN_DISPLAY_NAME);

	widget = gtk_label_new (NULL);
	gtk_widget_set_hexpand (widget, TRUE);
	gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
	gtk_label_set_attributes (GTK_LABEL (widget), attr_list);
	gtk_grid_attach (GTK_GRID (container), widget, 2, 0, 1, 1);
	page->priv->type_label = widget;  /* not referenced */
	gtk_widget_show (widget);

	widget = gtk_label_new (_("Description:"));
	gtk_widget_set_margin_right (widget, 12);
	gtk_misc_set_alignment (GTK_MISC (widget), 1.0, 0.0);
	gtk_grid_attach (GTK_GRID (container), widget, 0, 1, 1, 1);
	gtk_widget_show (widget);

	widget = gtk_label_new (NULL);
	gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
	gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
	gtk_grid_attach (GTK_GRID (container), widget, 1, 1, 2, 1);
	page->priv->desc_label = widget;  /* not referenced */
	gtk_widget_show (widget);

	pango_attr_list_unref (attr_list);

	container = GTK_WIDGET (page);

	widget = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
	gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
	gtk_widget_show (widget);

	widget = e_mail_config_service_notebook_new ();
	gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
	page->priv->notebook = widget;  /* not referenced */
	gtk_widget_show (widget);

	/* Keep the notebook's active page number synchronized with our
	 * own "active-backend" property.  Avoid G_BINDING_SYNC_CREATE
	 * since we haven't added any notebook pages. */
	g_object_bind_property (
		page, "active-backend",
		page->priv->notebook, "active-backend",
		G_BINDING_BIDIRECTIONAL);

	/* Keep the combo box's active row number synchronized with our
	 * own "active-backend" property.  Avoid G_BINDING_SYNC_CREATE
	 * since we haven't added any combo box rows. */
	g_object_bind_property_full (
		page, "active-backend",
		page->priv->type_combo, "active-id",
		G_BINDING_BIDIRECTIONAL,
		mail_config_service_page_backend_to_id,
		mail_config_service_page_id_to_backend,
		NULL, (GDestroyNotify) NULL);

	/* This keeps the description field up-to-date. */
	g_object_bind_property_full (
		page->priv->type_combo, "active-id",
		page->priv->desc_label, "label",
		G_BINDING_DEFAULT,
		mail_config_service_page_backend_name_to_description,
		NULL,
		NULL, (GDestroyNotify) NULL);

	/* For the "Server Type", either the combo
	 * box or the label is visible, never both. */
	g_object_bind_property (
		page->priv->type_combo, "visible",
		page->priv->type_label, "visible",
		G_BINDING_SYNC_CREATE |
		G_BINDING_BIDIRECTIONAL |
		G_BINDING_INVERT_BOOLEAN);

	g_signal_connect_swapped (
		page->priv->type_combo, "changed",
		G_CALLBACK (e_mail_config_page_changed), page);

	g_object_unref (tree_model);
}

EMailConfigServiceBackend *
e_mail_config_service_page_get_active_backend (EMailConfigServicePage *page)
{
	g_return_val_if_fail (E_IS_MAIL_CONFIG_SERVICE_PAGE (page), NULL);

	return page->priv->active_backend;
}

void
e_mail_config_service_page_set_active_backend (EMailConfigServicePage *page,
                                               EMailConfigServiceBackend *backend)
{
	g_return_if_fail (E_IS_MAIL_CONFIG_SERVICE_PAGE (page));

	if (page->priv->active_backend == backend)
		return;

	if (backend != NULL) {
		g_return_if_fail (E_IS_MAIL_CONFIG_SERVICE_BACKEND (backend));
		g_object_ref (backend);
	}

	if (page->priv->active_backend != NULL)
		g_object_unref (page->priv->active_backend);

	page->priv->active_backend = backend;

	g_object_notify (G_OBJECT (page), "active-backend");
}

const gchar *
e_mail_config_service_page_get_email_address (EMailConfigServicePage *page)
{
	g_return_val_if_fail (E_IS_MAIL_CONFIG_SERVICE_PAGE (page), NULL);

	return page->priv->email_address;
}

void
e_mail_config_service_page_set_email_address (EMailConfigServicePage *page,
                                              const gchar *email_address)
{
	g_return_if_fail (E_IS_MAIL_CONFIG_SERVICE_PAGE (page));

	if (g_strcmp0 (page->priv->email_address, email_address) == 0)
		return;

	g_free (page->priv->email_address);
	page->priv->email_address = g_strdup (email_address);

	g_object_notify (G_OBJECT (page), "email-address");
}

ESourceRegistry *
e_mail_config_service_page_get_registry (EMailConfigServicePage *page)
{
	g_return_val_if_fail (E_IS_MAIL_CONFIG_SERVICE_PAGE (page), NULL);

	return page->priv->registry;
}

EMailConfigServiceBackend *
e_mail_config_service_page_add_scratch_source (EMailConfigServicePage *page,
                                               ESource *scratch_source,
                                               ESource *opt_collection)
{
	GtkWidget *widget;
	GtkLabel *type_label;
	GtkComboBox *type_combo;
	GtkTreeIter iter;
	Candidate *candidate;
	const gchar *display_name;
	gboolean selectable;
	gint page_num;

	g_return_val_if_fail (E_IS_MAIL_CONFIG_SERVICE_PAGE (page), NULL);
	g_return_val_if_fail (E_IS_SOURCE (scratch_source), NULL);

	if (opt_collection != NULL)
		g_return_val_if_fail (E_IS_SOURCE (opt_collection), NULL);

	type_label = GTK_LABEL (page->priv->type_label);
	type_combo = GTK_COMBO_BOX (page->priv->type_combo);

	candidate = mail_config_service_page_new_candidate (
		page, scratch_source, opt_collection);
	g_return_val_if_fail (candidate != NULL, NULL);

	widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
	e_mail_config_service_backend_insert_widgets (
		candidate->backend, GTK_BOX (widget));
	candidate->widget = g_object_ref_sink (widget);
	gtk_widget_show (widget);

	g_ptr_array_add (page->priv->candidates, candidate);

	display_name = g_dgettext (
		candidate->provider->translation_domain,
		candidate->provider->name);

	page_num = e_mail_config_service_notebook_add_page (
		E_MAIL_CONFIG_SERVICE_NOTEBOOK (page->priv->notebook),
		candidate->backend, widget);

	selectable = e_mail_config_service_backend_get_selectable (
		candidate->backend);

	gtk_list_store_append (page->priv->list_store, &iter);

	gtk_list_store_set (
		page->priv->list_store, &iter,
		COLUMN_BACKEND_NAME, candidate->name,
		COLUMN_DISPLAY_NAME, display_name,
		COLUMN_SELECTABLE, selectable,
		-1);

	/* The type label is only visible if we have one scratch source,
	 * so just always set the label text to the most recently added
	 * scratch source. */
	gtk_label_set_text (type_label, display_name);

	/* If no combo box row is active yet, choose the new row. */
	if (gtk_combo_box_get_active_id (type_combo) == NULL)
		gtk_combo_box_set_active_id (type_combo, candidate->name);

	/* If the page number of the newly-added notebook page is zero,
	 * show the "type" label.  Otherwise show the "type" combo box.
	 * There's an inverted "visible" binding between the combo box
	 * and label, so we only need to change one of the widgets. */
	gtk_widget_set_visible (GTK_WIDGET (type_combo), page_num > 0);

	return candidate->backend;
}

EMailConfigServiceBackend *
e_mail_config_service_page_lookup_backend (EMailConfigServicePage *page,
                                           const gchar *backend_name)
{
	guint index;

	g_return_val_if_fail (E_IS_MAIL_CONFIG_SERVICE_PAGE (page), NULL);
	g_return_val_if_fail (backend_name != NULL, NULL);

	for (index = 0; index < page->priv->candidates->len; index++) {
		Candidate *candidate;

		candidate = page->priv->candidates->pdata[index];

		if (g_strcmp0 (backend_name, candidate->name) == 0)
			return candidate->backend;
	}

	return NULL;
}

void
e_mail_config_service_page_auto_configure (EMailConfigServicePage *page,
                                           EMailAutoconfig *autoconfig)
{
	EMailConfigServiceBackend *pop3 = NULL;
	EMailConfigServiceBackend *imap = NULL;
	EMailConfigServiceBackend *smtp = NULL;
	guint ii;

	g_return_if_fail (E_IS_MAIL_CONFIG_SERVICE_PAGE (page));
	g_return_if_fail (E_IS_MAIL_AUTOCONFIG (autoconfig));

	for (ii = 0; ii < page->priv->candidates->len; ii++) {
		EMailConfigServiceBackendClass *class;
		EMailConfigServiceBackend *backend;
		Candidate *candidate;
		gboolean configured;

		candidate = page->priv->candidates->pdata[ii];

		backend = candidate->backend;
		class = E_MAIL_CONFIG_SERVICE_BACKEND_GET_CLASS (backend);

		configured = e_mail_config_service_backend_auto_configure (
			backend, autoconfig);

		/* XXX There's a few specific backends to check for.
		 *     It requires that we know about these backends,
		 *     which violates the abstraction, but we need to
		 *     break our own rule to be practical here. */
		if (g_strcmp0 (class->backend_name, POP3_BACKEND_NAME) == 0)
			pop3 = configured ? backend : NULL;
		if (g_strcmp0 (class->backend_name, IMAP_BACKEND_NAME) == 0)
			imap = configured ? backend : NULL;
		if (g_strcmp0 (class->backend_name, SMTP_BACKEND_NAME) == 0)
			smtp = configured ? backend : NULL;
	}

	/* Select POP3 before IMAP.  If both are present we want IMAP. */
	if (pop3 != NULL)
		e_mail_config_service_page_set_active_backend (page, pop3);
	if (imap != NULL)
		e_mail_config_service_page_set_active_backend (page, imap);
	if (smtp != NULL)
		e_mail_config_service_page_set_active_backend (page, smtp);
}