/*
 *
 * 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/>  
 *
 *
 * Authors:
 *			Ettore Perazzoli <ettore@ximian.com>
 *          Jeffrey Stedfast <fejj@ximian.com>
 *	     	Srinivasa Ragavan <sragavan@novell.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "e-attachment.h"
#include "e-attachment-dialog.h"

#ifdef G_OS_WIN32
/* Include <windows.h> early (as the gio stuff below will
 * include it anyway, sigh) to workaround the DATADIR problem.
 * <windows.h> (and the headers it includes) stomps all over the
 * namespace like a baboon on crack, and especially the DATADIR enum
 * in objidl.h causes problems.
 */
#undef DATADIR
#define DATADIR crap_DATADIR
#include <windows.h>
#undef DATADIR
#endif

#include <sys/stat.h>
#include <string.h>
#include <errno.h>

#include <camel/camel.h>

#include <glib/gi18n.h>
#include <glib/gstdio.h>

#include <libebook/e-vcard.h>

#include "e-util/e-util.h"
#include "e-util/e-error.h"
#include "e-util/e-mktemp.h"
#include "e-util/e-util-private.h"

#define E_ATTACHMENT_GET_PRIVATE(obj) \
	(G_TYPE_INSTANCE_GET_PRIVATE \
	((obj), E_TYPE_ATTACHMENT, EAttachmentPrivate))

struct _EAttachmentPrivate {
	gchar *filename;
	gchar *description;
	gchar *disposition;
	gchar *mime_type;

	GdkPixbuf *thumbnail;
	CamelMimePart *mime_part;
};

enum {
	PROP_0,
	PROP_DESCRIPTION,
	PROP_DISPOSITION,
	PROP_FILENAME,
	PROP_THUMBNAIL
};

enum {
	CHANGED,
	UPDATE,
	LAST_SIGNAL
};

static gpointer parent_class;
static guint signals[LAST_SIGNAL];

static void
attachment_set_property (GObject *object,
                         guint property_id,
                         const GValue *value,
                         GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_DESCRIPTION:
			e_attachment_set_description (
				E_ATTACHMENT (object),
				g_value_get_string (value));
			return;

		case PROP_DISPOSITION:
			e_attachment_set_disposition (
				E_ATTACHMENT (object),
				g_value_get_string (value));
			return;

		case PROP_FILENAME:
			e_attachment_set_filename (
				E_ATTACHMENT (object),
				g_value_get_string (value));
			return;

		case PROP_THUMBNAIL:
			e_attachment_set_thumbnail (
				E_ATTACHMENT (object),
				g_value_get_object (value));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
attachment_get_property (GObject *object,
                         guint property_id,
                         GValue *value,
                         GParamSpec *pspec)
{
	switch (property_id) {
		case PROP_DESCRIPTION:
			g_value_set_string (
				value, e_attachment_get_description (
				E_ATTACHMENT (object)));
			return;

		case PROP_DISPOSITION:
			g_value_set_string (
				value, e_attachment_get_disposition (
				E_ATTACHMENT (object)));
			return;

		case PROP_FILENAME:
			g_value_set_string (
				value, e_attachment_get_filename (
				E_ATTACHMENT (object)));
			return;

		case PROP_THUMBNAIL:
			g_value_set_object (
				value, e_attachment_get_thumbnail (
				E_ATTACHMENT (object)));
			return;
	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
attachment_dispose (GObject *object)
{
	EAttachmentPrivate *priv;

	priv = E_ATTACHMENT_GET_PRIVATE (object);

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

	if (priv->mime_part != NULL) {
		camel_object_unref (priv->mime_part);
		priv->mime_part = NULL;
	}

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

static void
attachment_finalize (GObject *object)
{
	EAttachment *attachment = (EAttachment *) object;

	if (attachment->cancellable) {
		/* the operation is still running, so cancel it */
		g_cancellable_cancel (attachment->cancellable);
		attachment->cancellable = NULL;
	}

	g_free (attachment->store_uri);

	g_free (attachment->priv->filename);
	g_free (attachment->priv->description);
	g_free (attachment->priv->disposition);
	g_free (attachment->priv->mime_type);

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

static void
attachment_class_init (EAttachmentClass *class)
{
	GObjectClass *object_class;

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

	object_class = G_OBJECT_CLASS (class);
	object_class->set_property = attachment_set_property;
	object_class->get_property = attachment_get_property;
	object_class->dispose = attachment_dispose;
	object_class->finalize = attachment_finalize;

	g_object_class_install_property (
		object_class,
		PROP_DESCRIPTION,
		g_param_spec_string (
			"description",
			"Description",
			NULL,
			NULL,
			G_PARAM_READWRITE |
			G_PARAM_CONSTRUCT));

	g_object_class_install_property (
		object_class,
		PROP_DESCRIPTION,
		g_param_spec_string (
			"disposition",
			"Disposition",
			NULL,
			NULL,
			G_PARAM_READWRITE |
			G_PARAM_CONSTRUCT));

	g_object_class_install_property (
		object_class,
		PROP_DESCRIPTION,
		g_param_spec_string (
			"filename",
			"Filename",
			NULL,
			NULL,
			G_PARAM_READWRITE |
			G_PARAM_CONSTRUCT));

	g_object_class_install_property (
		object_class,
		PROP_THUMBNAIL,
		g_param_spec_object (
			"thumbnail",
			"Thumbnail Image",
			NULL,
			GDK_TYPE_PIXBUF,
			G_PARAM_READWRITE));

	signals[CHANGED] = g_signal_new (
		"changed",
		G_OBJECT_CLASS_TYPE (class),
		G_SIGNAL_RUN_FIRST,
		G_STRUCT_OFFSET (EAttachmentClass, changed),
		NULL, NULL,
		g_cclosure_marshal_VOID__VOID,
		G_TYPE_NONE, 0);

	signals[UPDATE] = g_signal_new (
		"update",
		G_OBJECT_CLASS_TYPE (class),
		G_SIGNAL_RUN_FIRST,
		G_STRUCT_OFFSET (EAttachmentClass, update),
		NULL, NULL,
		g_cclosure_marshal_VOID__VOID,
		G_TYPE_NONE, 0);
}

static void
attachment_init (EAttachment *attachment)
{
	attachment->priv = E_ATTACHMENT_GET_PRIVATE (attachment);

	attachment->index = -1;
	attachment->percentage = -1;
	attachment->sign = CAMEL_CIPHER_VALIDITY_SIGN_NONE;
	attachment->encrypt = CAMEL_CIPHER_VALIDITY_ENCRYPT_NONE;
}

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

	if (G_UNLIKELY (type == 0)) {
		static const GTypeInfo type_info = {
			sizeof (EAttachmentClass),
			(GBaseInitFunc) NULL,
			(GBaseFinalizeFunc) NULL,
			(GClassInitFunc) attachment_class_init,
			(GClassFinalizeFunc) NULL,
			NULL,  /* class_data */
			sizeof (EAttachment),
			0,     /* n_preallocs */
			(GInstanceInitFunc) attachment_init,
			NULL   /* value_table */
		};

		type = g_type_register_static (
			G_TYPE_OBJECT, "EAttachment", &type_info, 0);
	}

	return type;
}

/**
 * file_ext_is:
 * @param filename: path for file
 * @param ext: desired extension, with a dot
 * @return if filename has extension ext or not
 **/

static gboolean
file_ext_is (const char *filename, const char *ext)
{
	int i, dot = -1;

	if (!filename || !ext)
		return FALSE;

	for (i = 0; filename[i]; i++) {
		if (filename [i] == '.')
			dot = i;
	}

	if (dot > 0) {
		return 0 == g_ascii_strcasecmp (filename + dot, ext);
	}

	return FALSE;
}

static char *
attachment_guess_mime_type (const char *filename)
{
	char *type;
	gchar *content = NULL;

	type = e_util_guess_mime_type (filename, TRUE);

	if (type && strcmp (type, "text/directory") == 0 &&
	    file_ext_is (filename, ".vcf") &&
	    g_file_get_contents (filename, &content, NULL, NULL) &&
	    content) {
		EVCard *vc = e_vcard_new_from_string (content);

		if (vc) {
			g_free (type);
			g_object_unref (G_OBJECT (vc));

			type = g_strdup ("text/x-vcard");
		}

	}

	g_free (content);

	if (type) {
		/* Check if returned mime_type is valid */
		CamelContentType *ctype = camel_content_type_decode (type);

		if (!ctype) {
			g_free (type);
			type = NULL;
		} else
			camel_content_type_unref (ctype);
	}

	return type;
}


/**
 * e_attachment_new:
 * @filename: filename to attach
 * @disposition: Content-Disposition of the attachment
 * @ex: exception
 *
 * Return value: the new attachment, or %NULL on error
 **/
EAttachment *
e_attachment_new (const char *filename, const char *disposition, CamelException *ex)
{
	EAttachment *new;
	CamelMimePart *part;
	CamelDataWrapper *wrapper;
	CamelStream *stream;
	struct stat statbuf;
	gchar *mime_type;
	gchar *basename;
	CamelURL *url;

	g_return_val_if_fail (filename != NULL, NULL);

	if (g_stat (filename, &statbuf) < 0) {
		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
				      _("Cannot attach file %s: %s"),
				      filename, g_strerror (errno));
		return NULL;
	}

	/* return if it's not a regular file */
	if (!S_ISREG (statbuf.st_mode)) {
		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
				      _("Cannot attach file %s: not a regular file"),
				      filename);
		return NULL;
	}

	if (!(stream = camel_stream_fs_new_with_name (filename, O_RDONLY, 0))) {
		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
				      _("Cannot attach file %s: %s"),
				      filename, g_strerror (errno));
		return NULL;
	}

	if ((mime_type = attachment_guess_mime_type (filename))) {
		if (!g_ascii_strcasecmp (mime_type, "message/rfc822")) {
			wrapper = (CamelDataWrapper *) camel_mime_message_new ();
		} else {
			wrapper = camel_data_wrapper_new ();
		}

		camel_data_wrapper_construct_from_stream (wrapper, stream);
		camel_data_wrapper_set_mime_type (wrapper, mime_type);
		g_free (mime_type);
	} else {
		wrapper = camel_data_wrapper_new ();
		camel_data_wrapper_construct_from_stream (wrapper, stream);
		camel_data_wrapper_set_mime_type (wrapper, "application/octet-stream");
	}

	camel_object_unref (stream);

	part = camel_mime_part_new ();
	camel_medium_set_content_object (CAMEL_MEDIUM (part), wrapper);
	camel_object_unref (wrapper);

	camel_mime_part_set_disposition (part, disposition);
	basename = g_path_get_basename (filename);
	camel_mime_part_set_filename (part, basename);

#if 0
	/* Note: Outlook 2002 is broken with respect to Content-Ids on
           non-multipart/related parts, so as an interoperability
           workaround, don't set a Content-Id on these parts. Fixes
           bug #10032 */
	/* set the Content-Id */
	content_id = camel_header_msgid_generate ();
	camel_mime_part_set_content_id (part, content_id);
	g_free (content_id);
#endif

	new = g_object_new (E_TYPE_ATTACHMENT, "filename", basename, NULL);
	new->priv->mime_part = part;
	new->size = statbuf.st_size;
	new->guessed_type = TRUE;
	new->cancellable = NULL;
	new->is_available_local = TRUE;

	url = camel_url_new ("file://", NULL);
	camel_url_set_path (url, filename);
	new->store_uri = camel_url_to_string (url, 0);
	camel_url_free (url);

	return new;
}


typedef struct {
	EAttachment *attachment;
	char *filename;
	char *uri;
	GtkWindow *parent; /* for error dialog */

	guint64 file_size; /* zero indicates unknown size */
	GInputStream *istream; /* read from here ... */
	GOutputStream *ostream; /* ...and write into this. */
	gboolean was_error;
	GCancellable *cancellable;

	void *buffer; /* read into this, not more than buffer_size bytes */
	gsize buffer_size;
} DownloadInfo;

static void
download_info_free (DownloadInfo *download_info)
{
	/* if there was an error, then free attachment too */
	if (download_info->was_error)
		g_object_unref (download_info->attachment);

	if (download_info->ostream)
		g_object_unref (download_info->ostream);

	if (download_info->istream)
		g_object_unref (download_info->istream);

	if (download_info->cancellable)
		g_object_unref (download_info->cancellable);

	g_free (download_info->filename);
	g_free (download_info->uri);
	g_free (download_info->buffer);
	g_free (download_info);
}

static void
data_ready_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
	DownloadInfo *download_info = (DownloadInfo *)user_data;
	GError *error = NULL;
	gssize read;

	g_return_if_fail (download_info != NULL);

	if (g_cancellable_is_cancelled (download_info->cancellable)) {
		/* finish the operation and close both streams */
		g_input_stream_read_finish (G_INPUT_STREAM (source_object), res, NULL);

		g_output_stream_close (download_info->ostream, NULL, NULL);
		g_input_stream_close  (download_info->istream, NULL, NULL);

		/* The only way how to get this canceled is in EAttachment's finalize method,
		   and because the download_info_free free's the attachment on error,
		   then do not consider cancellation as an error. */
		download_info_free (download_info);
		return;
	}

	read = g_input_stream_read_finish (G_INPUT_STREAM (source_object), res, &error);

	if (!error)
		g_output_stream_write_all (download_info->ostream, download_info->buffer, read, NULL, download_info->cancellable, &error);

	if (error) {
		download_info->was_error = error->domain != G_IO_ERROR || error->code != G_IO_ERROR_CANCELLED;
		if (download_info->was_error)
			e_error_run (download_info->parent, "mail-composer:no-attach", download_info->uri, error->message, NULL);

		g_error_free (error);

		download_info->attachment->cancellable = NULL;
		download_info_free (download_info);
		return;
	}

	if (read == 0) {
		CamelException ex;

		/* done with reading */
		g_output_stream_close (download_info->ostream, NULL, NULL);
		g_input_stream_close  (download_info->istream, NULL, NULL);

		download_info->attachment->cancellable = NULL;

		camel_exception_init (&ex);
		e_attachment_build_remote_file (download_info->filename, download_info->attachment, &ex);

		if (camel_exception_is_set (&ex)) {
			download_info->was_error = TRUE;
			e_error_run (download_info->parent, "mail-composer:no-attach", download_info->uri, camel_exception_get_description (&ex), NULL);
			camel_exception_clear (&ex);
		}

		download_info->attachment->percentage = -1;
		download_info->attachment->is_available_local = TRUE;
		g_signal_emit (download_info->attachment, signals[UPDATE], 0);

		download_info_free (download_info);
		return;
	} else 	if (download_info->file_size) {
		download_info->attachment->percentage = read * 100 / download_info->file_size;
		download_info->file_size -= MIN (download_info->file_size, read);
		g_signal_emit (download_info->attachment, signals[UPDATE], 0);
	} else {
		download_info->attachment->percentage = 0;
		g_signal_emit (download_info->attachment, signals[UPDATE], 0);
	}

	/* read next chunk */
	g_input_stream_read_async (download_info->istream, download_info->buffer, download_info->buffer_size, G_PRIORITY_DEFAULT, download_info->cancellable, data_ready_cb, download_info);
}

static gboolean
download_to_local_path (DownloadInfo *download_info, CamelException *ex)
{
	GError *error = NULL;
	GFile *src = g_file_new_for_uri (download_info->uri);
	GFile *des = g_file_new_for_path (download_info->filename);
	gboolean res = FALSE;

	g_return_val_if_fail (src != NULL && des != NULL, FALSE);

	download_info->ostream = G_OUTPUT_STREAM (g_file_replace (des, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error));

	if (download_info->ostream && !error) {
		GFileInfo *fi;

		fi = g_file_query_info (src, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NONE, NULL, NULL);

		if (fi) {
			download_info->file_size = g_file_info_get_attribute_uint64 (fi, G_FILE_ATTRIBUTE_STANDARD_SIZE);
			g_object_unref (fi);
		} else {
			download_info->file_size = 0;
		}

		download_info->istream = G_INPUT_STREAM (g_file_read (src, NULL, &error));

		if (download_info->istream && !error) {
			download_info->cancellable = g_cancellable_new ();
			download_info->attachment->cancellable = download_info->cancellable;
			download_info->buffer_size = 10240; /* max 10KB chunk */
			download_info->buffer = g_malloc (sizeof (char) * download_info->buffer_size);

			g_input_stream_read_async (download_info->istream, download_info->buffer, download_info->buffer_size, G_PRIORITY_DEFAULT, download_info->cancellable, data_ready_cb, download_info);

			res = TRUE;
		}
	}

	if (error) {
		/* propagate error */
		if (ex)
			camel_exception_set (ex, CAMEL_EXCEPTION_SYSTEM, error->message);

		g_error_free (error);
		download_info->was_error = TRUE;
		download_info_free (download_info);
	}

	g_object_unref (src);
	g_object_unref (des);

	return res;
}

EAttachment *
e_attachment_new_remote_file (GtkWindow *error_dlg_parent, const char *uri, const char *disposition, const char *path, CamelException *ex)
{
	EAttachment *new;
	DownloadInfo *download_info;
	CamelURL *url;
	char *base;
	gchar *filename;

	g_return_val_if_fail (uri != NULL, NULL);

	url = camel_url_new (uri, NULL);
	base = g_path_get_basename (url->path);
	camel_url_free (url);

	filename = g_build_filename (path, base, NULL);

	new = g_object_new (E_TYPE_ATTACHMENT, "filename", filename, NULL);
	new->size = 0;
	new->guessed_type = FALSE;
	new->cancellable = NULL;
	new->is_available_local = FALSE;
	new->percentage = 0;

	g_free (base);

	download_info = g_new0 (DownloadInfo, 1);
	download_info->attachment = new;
	download_info->filename = g_strdup (filename);
	download_info->uri = g_strdup (uri);
	download_info->parent = error_dlg_parent;
	download_info->was_error = FALSE;

	g_free (filename);

	/* it frees all on the error, so do not free it twice */
	if (!download_to_local_path (download_info, ex))
		return NULL;

	return new;
}


void
e_attachment_build_remote_file (const gchar *filename,
                                EAttachment *attachment,
                                CamelException *ex)
{
	CamelMimePart *part;
	CamelDataWrapper *wrapper;
	CamelStream *stream;
	struct stat statbuf;
	const gchar *description;
	const gchar *disposition;
	gchar *mime_type;
	gchar *basename;
	CamelURL *url;

	g_return_if_fail (filename != NULL);

	if (g_stat (filename, &statbuf) == -1) {
		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
				      _("Cannot attach file %s: %s"),
				      filename, g_strerror (errno));
		g_message ("Cannot attach file %s: %s\n", filename, g_strerror (errno));
		return;
	}

	/* return if it's not a regular file */
	if (!S_ISREG (statbuf.st_mode)) {
		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
				      _("Cannot attach file %s: not a regular file"),
				      filename);
		g_message ("Cannot attach file %s: not a regular file", filename);
		return;
	}

	if (!(stream = camel_stream_fs_new_with_name (filename, O_RDONLY, 0))) {
		camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
				      _("Cannot attach file %s: %s"),
				      filename, g_strerror (errno));
		return;
	}

	if ((mime_type = attachment_guess_mime_type (filename))) {
		if (!g_ascii_strcasecmp (mime_type, "message/rfc822")) {
			wrapper = (CamelDataWrapper *) camel_mime_message_new ();
		} else {
			wrapper = camel_data_wrapper_new ();
		}

		camel_data_wrapper_construct_from_stream (wrapper, stream);
		camel_data_wrapper_set_mime_type (wrapper, mime_type);
		g_free (mime_type);
	} else {
		wrapper = camel_data_wrapper_new ();
		camel_data_wrapper_construct_from_stream (wrapper, stream);
		camel_data_wrapper_set_mime_type (wrapper, "application/octet-stream");
	}

	camel_object_unref (stream);

	part = camel_mime_part_new ();
	camel_medium_set_content_object (CAMEL_MEDIUM (part), wrapper);
	camel_object_unref (wrapper);

	disposition = e_attachment_get_disposition (attachment);
	camel_mime_part_set_disposition (part, disposition);

	if (e_attachment_get_filename (attachment) == NULL)
		basename = g_path_get_basename (filename);
	else
		basename = g_path_get_basename (e_attachment_get_filename (attachment));

	camel_mime_part_set_filename (part, filename);

	description = e_attachment_get_description (attachment);
	if (description != NULL) {
		camel_mime_part_set_description (part, description);
		e_attachment_set_description (attachment, NULL);
	}

	attachment->priv->mime_part = part;
	attachment->size = statbuf.st_size;
	attachment->guessed_type = TRUE;

	e_attachment_set_filename (attachment, basename);

	url = camel_url_new ("file://", NULL);
	camel_url_set_path (url, filename);
	attachment->store_uri = camel_url_to_string (url, 0);
	camel_url_free (url);

	g_free (basename);
}


/**
 * e_attachment_new_from_mime_part:
 * @part: a CamelMimePart
 *
 * Return value: a new EAttachment based on the mime part
 **/
EAttachment *
e_attachment_new_from_mime_part (CamelMimePart *part)
{
	EAttachment *new;
	const gchar *filename;

	g_return_val_if_fail (CAMEL_IS_MIME_PART (part), NULL);

	filename = camel_mime_part_get_filename (part);

	new = g_object_new (E_TYPE_ATTACHMENT, "filename", filename, NULL);
	camel_object_ref (part);
	new->priv->mime_part = part;
	new->guessed_type = FALSE;
	new->is_available_local = TRUE;
	new->size = camel_mime_part_get_content_size (part);

	return new;
}

void
e_attachment_edit (EAttachment *attachment,
                   GtkWindow *parent)
{
	GtkWidget *dialog;

	g_return_if_fail (E_IS_ATTACHMENT (attachment));

	dialog = e_attachment_dialog_new (parent, attachment);
	gtk_dialog_run (GTK_DIALOG (dialog));
	gtk_widget_destroy (dialog);
}

const gchar *
e_attachment_get_description (EAttachment *attachment)
{
	CamelMimePart *mime_part;
	const gchar *description;

	g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);

	mime_part = e_attachment_get_mime_part (attachment);
	if (mime_part != NULL)
		description = camel_mime_part_get_description (mime_part);
	else 
		description = attachment->priv->description;

	return description;
}

void
e_attachment_set_description (EAttachment *attachment,
                              const gchar *description)
{
	CamelMimePart *mime_part;

	g_return_if_fail (E_IS_ATTACHMENT (attachment));

	g_free (attachment->priv->description);
	attachment->priv->description = g_strdup (description);

	mime_part = e_attachment_get_mime_part (attachment);
	if (mime_part != NULL)
		camel_mime_part_set_description (mime_part, description);

	g_object_notify (G_OBJECT (attachment), "description");
}

const gchar *
e_attachment_get_disposition (EAttachment *attachment)
{
	CamelMimePart *mime_part;
	const gchar *disposition;

	g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);

	mime_part = e_attachment_get_mime_part (attachment);
	if (mime_part != NULL)
		disposition = camel_mime_part_get_disposition (mime_part);
	else
		disposition = attachment->priv->disposition;

	return disposition;
}

void
e_attachment_set_disposition (EAttachment *attachment,
                              const gchar *disposition)
{
	CamelMimePart *mime_part;

	g_return_if_fail (E_IS_ATTACHMENT (attachment));

	g_free (attachment->priv->disposition);
	attachment->priv->disposition = g_strdup (disposition);

	mime_part = e_attachment_get_mime_part (attachment);
	if (mime_part != NULL)
		camel_mime_part_set_disposition (mime_part, disposition);

	g_object_notify (G_OBJECT (attachment), "disposition");
}

const gchar *
e_attachment_get_filename (EAttachment *attachment)
{
	CamelMimePart *mime_part;
	const gchar *filename;

	g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);

	mime_part = e_attachment_get_mime_part (attachment);
	if (mime_part != NULL)
		filename = camel_mime_part_get_filename (mime_part);
	else
		filename = attachment->priv->filename;

	return filename;
}

void
e_attachment_set_filename (EAttachment *attachment,
                           const gchar *filename)
{
	CamelMimePart *mime_part;

	g_return_if_fail (E_IS_ATTACHMENT (attachment));

	g_free (attachment->priv->filename);
	attachment->priv->filename = g_strdup (filename);

	mime_part = e_attachment_get_mime_part (attachment);
	if (mime_part != NULL)
		camel_mime_part_set_filename (mime_part, filename);

	g_object_notify (G_OBJECT (attachment), "filename");
}

CamelMimePart *
e_attachment_get_mime_part (EAttachment *attachment)
{
	g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);

	return attachment->priv->mime_part;
}

const gchar *
e_attachment_get_mime_type (EAttachment *attachment)
{
	CamelContentType *content_type;
	CamelMimePart *mime_part;
	const gchar *filename;
	gchar *mime_type;

	g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);

	if (attachment->priv->mime_type != NULL)
		goto exit;

	mime_part = e_attachment_get_mime_part (attachment);
	filename = e_attachment_get_filename (attachment);
	content_type = camel_mime_part_get_content_type (mime_part);

	if (mime_part == NULL)
		mime_type = attachment_guess_mime_type (filename);
	else {
		content_type = camel_mime_part_get_content_type (mime_part);
		mime_type = camel_content_type_simple (content_type);
	}

	attachment->priv->mime_type = mime_type;

exit:
	return attachment->priv->mime_type;
}

GdkPixbuf *
e_attachment_get_thumbnail (EAttachment *attachment)
{
	g_return_val_if_fail (E_IS_ATTACHMENT (attachment), NULL);

	return attachment->priv->thumbnail;
}

void
e_attachment_set_thumbnail (EAttachment *attachment,
                            GdkPixbuf *thumbnail)
{
	g_return_if_fail (E_IS_ATTACHMENT (attachment));

	if (thumbnail != NULL) {
		g_return_if_fail (GDK_IS_PIXBUF (thumbnail));
		g_object_ref (thumbnail);
	}

	if (attachment->priv->thumbnail != NULL)
		g_object_unref (attachment->priv->thumbnail);

	attachment->priv->thumbnail = thumbnail;

	g_object_notify (G_OBJECT (attachment), "thumbnail");
}

gboolean
e_attachment_is_image (EAttachment *attachment)
{
	CamelContentType *content_type;
	CamelMimePart *mime_part;

	g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);

	mime_part = e_attachment_get_mime_part (attachment);
	if (mime_part == NULL)
		return FALSE;

	content_type = camel_mime_part_get_content_type (mime_part);

	return camel_content_type_is (content_type, "image", "*");
}

gboolean
e_attachment_is_inline (EAttachment *attachment)
{
	const gchar *disposition;

	g_return_val_if_fail (E_IS_ATTACHMENT (attachment), FALSE);

	disposition = e_attachment_get_disposition (attachment);
	g_return_val_if_fail (disposition != NULL, FALSE);

	return (g_ascii_strcasecmp (disposition, "inline") == 0);
}