/*
 * e-attachment-store.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/>  
 *
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#include "e-attachment-store.h"

#include <glib/gi18n.h>

#include "e-util/e-util.h"
#include "e-util/gconf-bridge.h"

#include "e-file-activity.h"

#define E_ATTACHMENT_STORE_GET_PRIVATE(obj) \
	(G_TYPE_INSTANCE_GET_PRIVATE \
	((obj), E_TYPE_ATTACHMENT_STORE, EAttachmentStorePrivate))

#define DEFAULT_ICON_NAME	"mail-attachment"

struct _EAttachmentStorePrivate {
	GHashTable *activity_index;
	GHashTable *attachment_index;
	gchar *background_filename;
	gchar *background_options;
	gchar *current_folder;

	guint ignore_row_changed : 1;
};

enum {
	PROP_0,
	PROP_BACKGROUND_FILENAME,
	PROP_BACKGROUND_OPTIONS,
	PROP_CURRENT_FOLDER,
	PROP_NUM_ATTACHMENTS,
	PROP_NUM_LOADING,
	PROP_TOTAL_SIZE
};

enum {
	NEW_ACTIVITY,
	LAST_SIGNAL
};

static gpointer parent_class;
static guint signals[LAST_SIGNAL];

static const gchar *
attachment_store_get_background_filename (EAttachmentStore *store)
{
	return store->priv->background_filename;
}

static void
attachment_store_set_background_filename (EAttachmentStore *store,
                                          const gchar *background_filename)
{
	if (background_filename == NULL)
		background_filename = "";

	g_free (store->priv->background_filename);
	store->priv->background_filename = g_strdup (background_filename);

	g_object_notify (G_OBJECT (store), "background-filename");
}

static const gchar *
attachment_store_get_background_options (EAttachmentStore *store)
{
	return store->priv->background_options;
}

static void
attachment_store_set_background_options (EAttachmentStore *store,
                                         const gchar *background_options)
{
	if (background_options == NULL)
		background_options = "";

	g_free (store->priv->background_options);
	store->priv->background_options = g_strdup (background_options);

	g_object_notify (G_OBJECT (store), "background-options");
}

static void
attachment_store_remove_activity (EAttachmentStore *store,
                                  EActivity *activity)
{
	GtkTreeRowReference *reference;
	GHashTable *hash_table;

	hash_table = store->priv->activity_index;
	reference = g_hash_table_lookup (hash_table, activity);

	if (gtk_tree_row_reference_valid (reference)) {
		GtkTreeModel *model;
		GtkTreePath *path;
		GtkTreeIter iter;

		model = gtk_tree_row_reference_get_model (reference);
		path = gtk_tree_row_reference_get_path (reference);
		gtk_tree_model_get_iter (model, &iter, path);
		gtk_tree_path_free (path);

		gtk_list_store_set (
			GTK_LIST_STORE (store), &iter,
			E_ATTACHMENT_STORE_COLUMN_ACTIVITY, NULL, -1);
	}

	g_hash_table_remove (hash_table, activity);

	g_object_notify (G_OBJECT (store), "num-loading");
}

static void
attachment_store_copy_ready (GFile *source,
                             GAsyncResult *result,
                             GtkTreeRowReference *reference)
{
	EAttachmentStore *store;
	EAttachment *attachment;
	EActivity *activity;
	GFile *destination;
	GtkTreeModel *model;
	GtkTreePath *path;
	GtkTreeIter iter;
	gboolean valid;
	GError *error = NULL;

	model = gtk_tree_row_reference_get_model (reference);
	path = gtk_tree_row_reference_get_path (reference);
	valid = gtk_tree_model_get_iter (model, &iter, path);
	gtk_tree_path_free (path);
	g_return_if_fail (valid);

	gtk_tree_model_get (
		model, &iter,
		E_ATTACHMENT_STORE_COLUMN_ACTIVITY, &activity,
		E_ATTACHMENT_STORE_COLUMN_ATTACHMENT, &attachment, -1);

	gtk_tree_row_reference_free (reference);

	store = E_ATTACHMENT_STORE (model);

	if (!g_file_copy_finish (source, result, &error))
		goto fail;

	gtk_list_store_set (
		GTK_LIST_STORE (store), &iter,
		E_ATTACHMENT_STORE_COLUMN_ACTIVITY, NULL, -1);

	destination = e_file_activity_get_file (E_FILE_ACTIVITY (activity));
	e_attachment_set_file (attachment, destination);

	e_activity_complete (activity);

	g_object_unref (attachment);
	g_object_unref (activity);

	return;

fail:
	e_attachment_store_remove_attachment (store, attachment);

	g_object_unref (attachment);
	g_object_unref (activity);

	/* XXX Do something more useful with the error. */
	g_warning ("%s", error->message);
	g_error_free (error);
}

static void
attachment_store_copy_async (EAttachmentStore *store,
                             EAttachment *attachment)
{
	EActivity *activity;
	GCancellable *cancellable;
	GtkTreeRowReference *reference;
	GtkTreeModel *model;
	GtkTreePath *path;
	GtkTreeIter iter;
	GHashTable *hash_table;
	GFile *destination;
	GFile *source;
	gboolean valid;
	gchar *filename;
	gchar *uri;
	gint fd;
	GError *error = NULL;

	hash_table = store->priv->attachment_index;
	reference = g_hash_table_lookup (hash_table, attachment);
	g_return_if_fail (reference != NULL);

	fd = e_file_open_tmp (&filename, &error);
	if (error != NULL)
		goto fail;

	source = e_attachment_get_file (attachment);
	destination = g_file_new_for_path (filename);

	g_free (filename);
	close (fd);

	model = gtk_tree_row_reference_get_model (reference);
	path = gtk_tree_row_reference_get_path (reference);
	valid = gtk_tree_model_get_iter (model, &iter, path);
	gtk_tree_path_free (path);
	g_return_if_fail (valid);

	uri = g_file_get_uri (source);
	activity = e_file_activity_newv (_("Downloading '%s'"), uri);
	g_free (uri);

	gtk_list_store_set (
		GTK_LIST_STORE (store), &iter,
		E_ATTACHMENT_STORE_COLUMN_ACTIVITY, activity, -1);

	reference = gtk_tree_row_reference_copy (reference);

	hash_table = store->priv->activity_index;
	g_hash_table_insert (hash_table, g_object_ref (activity), reference);

	g_signal_connect_swapped (
		activity, "cancelled",
		G_CALLBACK (attachment_store_remove_activity), store);

	g_signal_connect_swapped (
		activity, "completed",
		G_CALLBACK (attachment_store_remove_activity), store);

	reference = gtk_tree_row_reference_copy (reference);

	cancellable = e_file_activity_get_cancellable (
		E_FILE_ACTIVITY (activity));

	g_file_copy_async (
		source, destination, G_FILE_COPY_OVERWRITE,
		G_PRIORITY_DEFAULT, cancellable, (GFileProgressCallback)
		e_file_activity_progress, activity, (GAsyncReadyCallback)
		attachment_store_copy_ready, reference);

	e_file_activity_set_file (E_FILE_ACTIVITY (activity), destination);
	g_signal_emit (store, signals[NEW_ACTIVITY], 0, activity);

	g_object_notify (G_OBJECT (store), "num-loading");

	g_object_unref (activity);
	g_object_unref (destination);

	return;

fail:
	e_attachment_store_remove_attachment (store, attachment);

	/* XXX Do something more useful with the error. */
	g_warning ("%s", error->message);
	g_error_free (error);
}

static void
attachment_store_set_property (GObject *object,
                               guint property_id,
                               const GValue *value,
                               GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_BACKGROUND_FILENAME:
			attachment_store_set_background_filename (
				E_ATTACHMENT_STORE (object),
				g_value_get_string (value));
			return;

		case PROP_BACKGROUND_OPTIONS:
			attachment_store_set_background_options (
				E_ATTACHMENT_STORE (object),
				g_value_get_string (value));
			return;

		case PROP_CURRENT_FOLDER:
			e_attachment_store_set_current_folder (
				E_ATTACHMENT_STORE (object),
				g_value_get_string (value));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
attachment_store_get_property (GObject *object,
                               guint property_id,
                               GValue *value,
                               GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_BACKGROUND_FILENAME:
			g_value_set_string (
				value,
				attachment_store_get_background_filename (
				E_ATTACHMENT_STORE (object)));
			return;

		case PROP_BACKGROUND_OPTIONS:
			g_value_set_string (
				value,
				attachment_store_get_background_options (
				E_ATTACHMENT_STORE (object)));
			return;

		case PROP_CURRENT_FOLDER:
			g_value_set_string (
				value,
				e_attachment_store_get_current_folder (
				E_ATTACHMENT_STORE (object)));
			return;

		case PROP_NUM_ATTACHMENTS:
			g_value_set_uint (
				value,
				e_attachment_store_get_num_attachments (
				E_ATTACHMENT_STORE (object)));
			return;

		case PROP_NUM_LOADING:
			g_value_set_uint (
				value,
				e_attachment_store_get_num_loading (
				E_ATTACHMENT_STORE (object)));
			return;

		case PROP_TOTAL_SIZE:
			g_value_set_uint64 (
				value,
				e_attachment_store_get_total_size (
				E_ATTACHMENT_STORE (object)));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
attachment_store_dispose (GObject *object)
{
	EAttachmentStorePrivate *priv;

	priv = E_ATTACHMENT_STORE_GET_PRIVATE (object);

	g_hash_table_remove_all (priv->activity_index);
	g_hash_table_remove_all (priv->attachment_index);

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

static void
attachment_store_finalize (GObject *object)
{
	EAttachmentStorePrivate *priv;

	priv = E_ATTACHMENT_STORE_GET_PRIVATE (object);

	g_hash_table_destroy (priv->activity_index);
	g_hash_table_destroy (priv->attachment_index);

	g_free (priv->background_filename);
	g_free (priv->background_options);
	g_free (priv->current_folder);

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

static void
attachment_store_constructed (GObject *object)
{
	EAttachmentStorePrivate *priv;
	GConfBridge *bridge;
	const gchar *prop;
	const gchar *key;

	priv = E_ATTACHMENT_STORE_GET_PRIVATE (object);
	bridge = gconf_bridge_get ();

	prop = "background-filename";
	key = "/desktop/gnome/background/picture_filename";
	gconf_bridge_bind_property (bridge, key, object, prop);

	prop = "background-options";
	key = "/desktop/gnome/background/picture_options";
	gconf_bridge_bind_property (bridge, key, object, prop);
}

static void
attachment_store_row_changed (GtkTreeModel *model,
                              GtkTreePath *path,
                              GtkTreeIter *iter)
{
	EAttachmentStorePrivate *priv;
	EAttachment *attachment;
	GFile *file;
	GIcon *icon;
	GList *list;
	const gchar *content_type;
	const gchar *display_name;
	const gchar *thumbnail_path;
	gchar *content_description;
	gchar *display_size;
	gchar *caption;
	gboolean loading;
	gboolean saving;
	guint64 size;
	gint column_id;

	priv = E_ATTACHMENT_STORE_GET_PRIVATE (model);

	if (priv->ignore_row_changed)
		return;

	column_id = E_ATTACHMENT_STORE_COLUMN_ATTACHMENT;
	gtk_tree_model_get (model, iter, column_id, &attachment, -1);
	g_return_if_fail (E_IS_ATTACHMENT (attachment));

	content_type = e_attachment_get_content_type (attachment);
	display_name = e_attachment_get_display_name (attachment);
	thumbnail_path = e_attachment_get_thumbnail_path (attachment);
	loading = e_attachment_get_loading (attachment);
	saving = e_attachment_get_saving (attachment);
	icon = e_attachment_get_icon (attachment);
	size = e_attachment_get_size (attachment);

	content_type = (content_type != NULL) ? content_type : "";
	content_description = g_content_type_get_description (content_type);
	display_size = g_format_size_for_display ((goffset) size);

	if (size > 0)
		caption = g_strdup_printf (
			"%s\n(%s)", display_name, display_size);
	else
		caption = g_strdup (display_name);

	/* Prefer the thumbnail if we have one. */
	if (thumbnail_path != NULL && *thumbnail_path != '\0') {
		file = g_file_new_for_path (thumbnail_path);
		icon = g_file_icon_new (file);
		g_object_unref (file);

	/* Else use the standard icon for the content type. */
	} else if (icon != NULL)
		g_object_ref (icon);

	/* Last ditch fallback.  (GFileInfo not yet loaded?) */
	else
		icon = g_themed_icon_new (DEFAULT_ICON_NAME);

	/* Apply emblems. */
	list = e_attachment_list_emblems (attachment);
	if (list != NULL) {
		GIcon *emblemed_icon;
		GEmblem *emblem;

		emblem = G_EMBLEM (list->data);
		emblemed_icon = g_emblemed_icon_new (icon, emblem);
		list = g_list_delete_link (list, list);
		g_object_unref (emblem);

		while (list != NULL) {
			emblem = G_EMBLEM (list->data);
			g_emblemed_icon_add_emblem (
				G_EMBLEMED_ICON (emblemed_icon), emblem);
			list = g_list_delete_link (list, list);
			g_object_unref (emblem);
		}

		g_object_unref (icon);
		icon = emblemed_icon;
	}

	/* We're about to trigger another "row-changed"
	 * signal, so this prevents infinite recursion. */
	priv->ignore_row_changed = TRUE;

	gtk_list_store_set (
		GTK_LIST_STORE (model), iter,
		E_ATTACHMENT_STORE_COLUMN_CONTENT_TYPE, content_description,
		E_ATTACHMENT_STORE_COLUMN_DISPLAY_NAME, display_name,
		E_ATTACHMENT_STORE_COLUMN_CAPTION, caption,
		E_ATTACHMENT_STORE_COLUMN_ICON, icon,
		E_ATTACHMENT_STORE_COLUMN_LOADING, loading,
		E_ATTACHMENT_STORE_COLUMN_SAVING, saving,
		E_ATTACHMENT_STORE_COLUMN_SIZE, size,
		-1);

	priv->ignore_row_changed = FALSE;

	g_object_unref (icon);
	g_free (content_description);
	g_free (display_size);
}

static void
attachment_store_class_init (EAttachmentStoreClass *class)
{
	GObjectClass *object_class;

	parent_class = g_type_class_peek_parent (class);
	g_type_class_add_private (class, sizeof (EAttachmentStorePrivate));

	object_class = G_OBJECT_CLASS (class);
	object_class->set_property = attachment_store_set_property;
	object_class->get_property = attachment_store_get_property;
	object_class->dispose = attachment_store_dispose;
	object_class->finalize = attachment_store_finalize;
	object_class->constructed = attachment_store_constructed;

	g_object_class_install_property (
		object_class,
		PROP_BACKGROUND_FILENAME,
		g_param_spec_string (
			"background-filename",
			"Background Filename",
			NULL,
			NULL,
			G_PARAM_READWRITE |
			G_PARAM_CONSTRUCT));

	g_object_class_install_property (
		object_class,
		PROP_BACKGROUND_OPTIONS,
		g_param_spec_string (
			"background-options",
			"Background Options",
			NULL,
			NULL,
			G_PARAM_READWRITE |
			G_PARAM_CONSTRUCT));

	g_object_class_install_property (
		object_class,
		PROP_CURRENT_FOLDER,
		g_param_spec_string (
			"current-folder",
			"Current Folder",
			NULL,
			NULL,
			G_PARAM_READWRITE |
			G_PARAM_CONSTRUCT));

	g_object_class_install_property (
		object_class,
		PROP_NUM_ATTACHMENTS,
		g_param_spec_uint (
			"num-attachments",
			"Num Attachments",
			NULL,
			0,
			G_MAXUINT,
			0,
			G_PARAM_READABLE));

	g_object_class_install_property (
		object_class,
		PROP_NUM_LOADING,
		g_param_spec_uint (
			"num-loading",
			"Num Loading",
			NULL,
			0,
			G_MAXUINT,
			0,
			G_PARAM_READABLE));

	g_object_class_install_property (
		object_class,
		PROP_TOTAL_SIZE,
		g_param_spec_uint64 (
			"total-size",
			"Total Size",
			NULL,
			0,
			G_MAXUINT64,
			0,
			G_PARAM_READABLE));
}

static void
attachment_store_iface_init (GtkTreeModelIface *iface)
{
	iface->row_changed = attachment_store_row_changed;
}

static void
attachment_store_init (EAttachmentStore *store)
{
	GType types[E_ATTACHMENT_STORE_NUM_COLUMNS];
	GHashTable *activity_index;
	GHashTable *attachment_index;
	gint column = 0;

	activity_index = g_hash_table_new_full (
		g_direct_hash, g_direct_equal,
		(GDestroyNotify) g_object_unref,
		(GDestroyNotify) gtk_tree_row_reference_free);

	attachment_index = g_hash_table_new_full (
		g_direct_hash, g_direct_equal,
		(GDestroyNotify) g_object_unref,
		(GDestroyNotify) gtk_tree_row_reference_free);

	store->priv = E_ATTACHMENT_STORE_GET_PRIVATE (store);
	store->priv->activity_index = activity_index;
	store->priv->attachment_index = attachment_index;

	types[column++] = E_TYPE_ACTIVITY;	/* COLUMN_ACTIVITY */
	types[column++] = E_TYPE_ATTACHMENT;	/* COLUMN_ATTACHMENT */
	types[column++] = G_TYPE_STRING;	/* COLUMN_CAPTION */
	types[column++] = G_TYPE_STRING;	/* COLUMN_CONTENT_TYPE */
	types[column++] = G_TYPE_STRING;	/* COLUMN_DISPLAY_NAME */
	types[column++] = G_TYPE_ICON;		/* COLUMN_ICON */
	types[column++] = G_TYPE_BOOLEAN;	/* COLUMN_LOADING */
	types[column++] = G_TYPE_BOOLEAN;	/* COLUMN_SAVING */
	types[column++] = G_TYPE_UINT64;	/* COLUMN_SIZE */

	g_assert (column == E_ATTACHMENT_STORE_NUM_COLUMNS);

	gtk_list_store_set_column_types (
		GTK_LIST_STORE (store), G_N_ELEMENTS (types), types);
}

GType
e_attachment_store_get_type (void)
{
	static GType type = 0;

	if (G_UNLIKELY (type == 0)) {
		static const GTypeInfo type_info = {
			sizeof (EAttachmentStoreClass),
			(GBaseInitFunc) NULL,
			(GBaseFinalizeFunc) NULL,
			(GClassInitFunc) attachment_store_class_init,
			(GClassFinalizeFunc) NULL,
			NULL,  /* class_data */
			sizeof (EAttachmentStore),
			0,     /* n_preallocs */
			(GInstanceInitFunc) attachment_store_init,
			NULL   /* value_table */
		};

		static const GInterfaceInfo iface_info = {
			(GInterfaceInitFunc) attachment_store_iface_init,
			(GInterfaceFinalizeFunc) NULL,
			NULL   /* interface_data */
		};

		type = g_type_register_static (
			GTK_TYPE_LIST_STORE, "EAttachmentStore",
			&type_info, 0);

		g_type_add_interface_static (
			type, GTK_TYPE_TREE_MODEL, &iface_info);
	}

	return type;
}

GtkTreeModel *
e_attachment_store_new (void)
{
	return g_object_new (E_TYPE_ATTACHMENT_STORE, NULL);
}

void
e_attachment_store_add_attachment (EAttachmentStore *store,
                                   EAttachment *attachment)
{
	GtkTreeRowReference *reference;
	GtkTreeModel *model;
	GtkTreePath *path;
	GtkTreeIter iter;
	GFile *file;

	g_return_if_fail (E_IS_ATTACHMENT_STORE (store));
	g_return_if_fail (E_IS_ATTACHMENT (attachment));

	gtk_list_store_append (GTK_LIST_STORE (store), &iter);

	gtk_list_store_set (
		GTK_LIST_STORE (store), &iter,
		E_ATTACHMENT_STORE_COLUMN_ATTACHMENT, attachment, -1);

	model = GTK_TREE_MODEL (store);
	path = gtk_tree_model_get_path (model, &iter);
	reference = gtk_tree_row_reference_new (model, path);
	gtk_tree_path_free (path);

	g_hash_table_insert (
		store->priv->attachment_index,
		g_object_ref (attachment), reference);

	file = e_attachment_get_file (attachment);

	/* This lets the attachment tell us when to update. */
	_e_attachment_set_reference (attachment, reference);

	if (file != NULL && !g_file_is_native (file))
		attachment_store_copy_async (store, attachment);

	g_object_freeze_notify (G_OBJECT (store));
	g_object_notify (G_OBJECT (store), "num-attachments");
	g_object_notify (G_OBJECT (store), "total-size");
	g_object_thaw_notify (G_OBJECT (store));
}

gboolean
e_attachment_store_remove_attachment (EAttachmentStore *store,
                                      EAttachment *attachment)
{
	GtkTreeRowReference *reference;
	GHashTable *hash_table;
	EActivity *activity;
	GtkTreeModel *model;
	GtkTreePath *path;
	GtkTreeIter iter;

	g_return_val_if_fail (E_IS_ATTACHMENT_STORE (store), FALSE);
	g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);

	hash_table = store->priv->attachment_index;
	reference = g_hash_table_lookup (hash_table, attachment);

	if (reference == NULL)
		return FALSE;

	if (!gtk_tree_row_reference_valid (reference)) {
		g_hash_table_remove (hash_table, attachment);
		return FALSE;
	}

	model = gtk_tree_row_reference_get_model (reference);
	path = gtk_tree_row_reference_get_path (reference);
	gtk_tree_model_get_iter (model, &iter, path);
	gtk_tree_path_free (path);

	gtk_tree_model_get (
		model, &iter,
		E_ATTACHMENT_STORE_COLUMN_ACTIVITY, &activity, -1);

	if (activity != NULL) {
		/* Cancel the file transfer. */
		e_activity_cancel (activity);
		g_object_unref (activity);
	}

	gtk_list_store_remove (GTK_LIST_STORE (store), &iter);
	g_hash_table_remove (hash_table, attachment);

	g_object_freeze_notify (G_OBJECT (store));
	g_object_notify (G_OBJECT (store), "num-attachments");
	g_object_notify (G_OBJECT (store), "total-size");
	g_object_thaw_notify (G_OBJECT (store));

	return TRUE;
}

void
e_attachment_store_add_to_multipart (EAttachmentStore *store,
                                     CamelMultipart *multipart,
                                     const gchar *default_charset)
{
	GtkTreeModel *model;
	GtkTreeIter iter;
	gboolean valid;

	g_return_if_fail (E_IS_ATTACHMENT_STORE (store));
	g_return_if_fail (CAMEL_MULTIPART (multipart));

	model = GTK_TREE_MODEL (store);
	valid = gtk_tree_model_get_iter_first (model, &iter);

	while (valid) {
		EAttachment *attachment;
		gint column_id;

		column_id = E_ATTACHMENT_STORE_COLUMN_ATTACHMENT;
		gtk_tree_model_get (model, &iter, column_id, &attachment, -1);

		e_attachment_add_to_multipart (
			attachment, multipart, default_charset);

		g_object_unref (attachment);

		valid = gtk_tree_model_iter_next (model, &iter);
	}
}

const gchar *
e_attachment_store_get_current_folder (EAttachmentStore *store)
{
	g_return_val_if_fail (E_IS_ATTACHMENT_STORE (store), NULL);

	return store->priv->current_folder;
}

void
e_attachment_store_set_current_folder (EAttachmentStore *store,
                                       const gchar *current_folder)
{
	g_return_if_fail (E_IS_ATTACHMENT_STORE (store));

	if (current_folder == NULL)
		current_folder = g_get_home_dir ();

	g_free (store->priv->current_folder);
	store->priv->current_folder = g_strdup (current_folder);

	g_object_notify (G_OBJECT (store), "current-folder");
}

guint
e_attachment_store_get_num_attachments (EAttachmentStore *store)
{
	g_return_val_if_fail (E_IS_ATTACHMENT_STORE (store), 0);

	return g_hash_table_size (store->priv->attachment_index);
}

guint
e_attachment_store_get_num_loading (EAttachmentStore *store)
{
	g_return_val_if_fail (E_IS_ATTACHMENT_STORE (store), 0);

	return g_hash_table_size (store->priv->activity_index);
}

guint64
e_attachment_store_get_total_size (EAttachmentStore *store)
{
	GtkTreeModel *model;
	GtkTreeIter iter;
	guint64 total_size = 0;
	gboolean valid;

	g_return_val_if_fail (E_IS_ATTACHMENT_STORE (store), 0);

	model = GTK_TREE_MODEL (store);
	valid = gtk_tree_model_get_iter_first (model, &iter);

	while (valid) {
		EAttachment *attachment;
		gint column_id;

		column_id = E_ATTACHMENT_STORE_COLUMN_ATTACHMENT;
		gtk_tree_model_get (model, &iter, column_id, &attachment, -1);
		total_size += e_attachment_get_size (attachment);
		g_object_unref (attachment);

		valid = gtk_tree_model_iter_next (model, &iter);
	}

	return total_size;
}

gint
e_attachment_store_run_file_chooser_dialog (EAttachmentStore *store,
                                            GtkWidget *dialog)
{
	GtkFileChooser *file_chooser;
	gint response = GTK_RESPONSE_NONE;
	const gchar *current_folder;
	gboolean update_folder;

	g_return_val_if_fail (E_IS_ATTACHMENT_STORE (store), response);
	g_return_val_if_fail (GTK_IS_FILE_CHOOSER_DIALOG (dialog), response);

	file_chooser = GTK_FILE_CHOOSER (dialog);
	current_folder = e_attachment_store_get_current_folder (store);
	gtk_file_chooser_set_current_folder (file_chooser, current_folder);

	response = gtk_dialog_run (GTK_DIALOG (dialog));

	update_folder =
		(response == GTK_RESPONSE_ACCEPT) ||
		(response == GTK_RESPONSE_OK) ||
		(response == GTK_RESPONSE_YES) ||
		(response == GTK_RESPONSE_APPLY);

	if (update_folder) {
		gchar *folder;

		folder = gtk_file_chooser_get_current_folder (file_chooser);
		e_attachment_store_set_current_folder (store, folder);
		g_free (folder);
	}

	return response;
}

void
e_attachment_store_run_load_dialog (EAttachmentStore *store,
                                    GtkWindow *parent)
{
	GtkFileChooser *file_chooser;
	GtkWidget *dialog;
	GtkWidget *option;
	GSList *files, *iter;
	const gchar *disposition;
	gboolean active;
	gint response;

	g_return_if_fail (E_IS_ATTACHMENT_STORE (store));

	dialog = gtk_file_chooser_dialog_new (
		_("Add Attachment"), parent,
		GTK_FILE_CHOOSER_ACTION_OPEN,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		_("A_ttach"), GTK_RESPONSE_OK, NULL);

	file_chooser = GTK_FILE_CHOOSER (dialog);
	gtk_file_chooser_set_local_only (file_chooser, FALSE);
	gtk_file_chooser_set_select_multiple (file_chooser, TRUE);
	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
	gtk_window_set_icon_name (GTK_WINDOW (dialog), "mail-attachment");

	option = gtk_check_button_new_with_mnemonic (
		_("_Suggest automatic display of attachment"));
	gtk_file_chooser_set_extra_widget (file_chooser, option);
	gtk_widget_show (option);

	response = e_attachment_store_run_file_chooser_dialog (store, dialog);

	if (response != GTK_RESPONSE_OK)
		goto exit;

	files = gtk_file_chooser_get_files (file_chooser);
	active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (option));
	disposition = active ? "inline" : "attachment";

	for (iter = files; iter != NULL; iter = g_slist_next (iter)) {
		EAttachment *attachment;
		GFile *file = iter->data;

		attachment = e_attachment_new ();
		e_attachment_set_file (attachment, file);
		e_attachment_store_add_attachment (store, attachment);
		g_object_unref (attachment);
	}

	g_slist_foreach (files, (GFunc) g_object_unref, NULL);
	g_slist_free (files);

exit:
	gtk_widget_destroy (dialog);
}

void
e_attachment_store_run_save_dialog (EAttachmentStore *store,
                                    EAttachment *attachment,
                                    GtkWindow *parent)
{
	GtkFileChooser *file_chooser;
	GtkWidget *dialog;
	GFile *file;
	EActivity *activity;
	const gchar *display_name;
	gint response;

	g_return_if_fail (E_IS_ATTACHMENT_STORE (store));
	g_return_if_fail (E_IS_ATTACHMENT (attachment));

	dialog = gtk_file_chooser_dialog_new (
		_("Save Attachment"), parent,
		GTK_FILE_CHOOSER_ACTION_SAVE,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL);

	file_chooser = GTK_FILE_CHOOSER (dialog);
	gtk_file_chooser_set_local_only (file_chooser, FALSE);
	gtk_file_chooser_set_do_overwrite_confirmation (file_chooser, TRUE);
	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
	gtk_window_set_icon_name (GTK_WINDOW (dialog), "mail-attachment");

	display_name = e_attachment_get_display_name (attachment);
	if (display_name != NULL)
		gtk_file_chooser_set_current_name (file_chooser, display_name);

	response = e_attachment_store_run_file_chooser_dialog (store, dialog);

	if (response != GTK_RESPONSE_OK)
		goto exit;

	file = gtk_file_chooser_get_file (file_chooser);
	activity = e_file_activity_new (_("Saving attachment"));
	e_attachment_save_async (
		attachment, E_FILE_ACTIVITY (activity), file);
	g_signal_emit (store, signals[NEW_ACTIVITY], 0, activity);
	g_object_unref (activity);
	g_object_unref (file);

exit:
	gtk_widget_destroy (dialog);
}