/*

 * Copyright (C) 2015 Red Hat, Inc. (www.redhat.com)

 *

 * This program is free software: you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by

 * the Free Software Foundation.

 *

 * 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 General Public License

 * for more details.

 *

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

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 *

 */

#include "evolution-config.h"

#include <glib/gi18n-lib.h>

#include <gtk/gtk.h>

#include <libedataserver/libedataserver.h>

#include <libecal/libecal.h>

#include <e-util/e-util.h>

#include "calendar-config.h"

#include "comp-util.h"

#include "e-cal-dialogs.h"

#include "itip-utils.h"

#include "print.h"

#include "e-comp-editor-page-general.h"

#include "e-comp-editor-page-attachments.h"

#include "e-comp-editor-event.h"

#include "e-comp-editor-memo.h"

#include "e-comp-editor-task.h"

#include "e-comp-editor.h"

struct _ECompEditorPrivate {

	EAlertBar *alert_bar; /* not referenced */

	EActivityBar *activity_bar; /* not referenced */

	GtkNotebook *content; /* not referenced */

	EAlert *validation_alert;

	EShell *shell;

	GSettings *calendar_settings;

	ESource *origin_source;

	icalcomponent *component;

	guint32 flags;

	EFocusTracker *focus_tracker;

	GtkUIManager *ui_manager;

	GSList *pages; /* ECompEditorPage * */

	gulong show_attendees_handler_id;

	ECompEditorPageGeneral *page_general; /* special page, can be added only once; not referenced */

	EActivity *target_client_opening;

	ECalClient *source_client;

	ECalClient *target_client;

	gchar *cal_email_address;

	gchar *alarm_email_address;

	gboolean changed;

	guint updating;

	gchar *title_suffix;

	ECompEditorPropertyPart *dtstart_part;

	ECompEditorPropertyPart *dtend_part;

	GtkWidget *restore_focus;

};

enum {

	PROP_0,

	PROP_ALARM_EMAIL_ADDRESS,

	PROP_CAL_EMAIL_ADDRESS,

	PROP_CHANGED,

	PROP_COMPONENT,

	PROP_FLAGS,

	PROP_ORIGIN_SOURCE,

	PROP_SHELL,

	PROP_SOURCE_CLIENT,

	PROP_TARGET_CLIENT,

	PROP_TITLE_SUFFIX

};

enum {

	TIMES_CHANGED,

	OBJECT_CREATED,

	EDITOR_CLOSED,

	LAST_SIGNAL

};

static guint signals[LAST_SIGNAL];

static GSList *opened_editors = NULL;

static void e_comp_editor_alert_sink_iface_init (EAlertSinkInterface *iface);

G_DEFINE_ABSTRACT_TYPE_WITH_CODE (ECompEditor, e_comp_editor, GTK_TYPE_WINDOW,

	G_IMPLEMENT_INTERFACE (E_TYPE_ALERT_SINK, e_comp_editor_alert_sink_iface_init)

	G_IMPLEMENT_INTERFACE (E_TYPE_EXTENSIBLE, NULL))

static void

ece_restore_focus (ECompEditor *comp_editor)

{

	g_return_if_fail (E_IS_COMP_EDITOR (comp_editor));

	if (comp_editor->priv->restore_focus) {

		gtk_widget_grab_focus (comp_editor->priv->restore_focus);

		if (GTK_IS_ENTRY (comp_editor->priv->restore_focus))

			gtk_editable_set_position (GTK_EDITABLE (comp_editor->priv->restore_focus), 0);

		comp_editor->priv->restore_focus = NULL;

	}

}

static void

e_comp_editor_enable (ECompEditor *comp_editor,

		      gboolean enable)

{

	GtkActionGroup *group;

	GtkWidget *current_focus;

	g_return_if_fail (E_IS_COMP_EDITOR (comp_editor));

	current_focus = gtk_window_get_focus (GTK_WINDOW (comp_editor));

	gtk_widget_set_sensitive (GTK_WIDGET (comp_editor->priv->content), enable);

	group = e_comp_editor_get_action_group (comp_editor, "individual");

	gtk_action_group_set_sensitive (group, enable);

	group = e_comp_editor_get_action_group (comp_editor, "core");

	gtk_action_group_set_sensitive (group, enable);

	group = e_comp_editor_get_action_group (comp_editor, "editable");

	gtk_action_group_set_sensitive (group, enable);

	if (enable) {

		e_comp_editor_sensitize_widgets (comp_editor);

		ece_restore_focus (comp_editor);

	} else {

		comp_editor->priv->restore_focus = current_focus;

	}

}

static void

ece_set_attendees_for_delegation (ECalComponent *comp,

				  const gchar *address)

{

	icalproperty *prop;

	icalparameter *param;

	icalcomponent *icalcomp;

	gboolean again;

	icalcomp = e_cal_component_get_icalcomponent (comp);

	for (prop = icalcomponent_get_first_property (icalcomp, ICAL_ATTENDEE_PROPERTY);

	     prop;

	     prop = again ? icalcomponent_get_first_property (icalcomp, ICAL_ATTENDEE_PROPERTY) :

	     icalcomponent_get_next_property (icalcomp, ICAL_ATTENDEE_PROPERTY)) {

		const gchar *attendee = icalproperty_get_attendee (prop);

		const gchar *delfrom = NULL;

		again = FALSE;

		param = icalproperty_get_first_parameter (prop, ICAL_DELEGATEDFROM_PARAMETER);

		if (param)

			delfrom = icalparameter_get_delegatedfrom (param);

		if (!(g_str_equal (itip_strip_mailto (attendee), address) ||

		     ((delfrom && *delfrom) && g_str_equal (itip_strip_mailto (delfrom), address)))) {

			icalcomponent_remove_property (icalcomp, prop);

			icalproperty_free (prop);

			again = TRUE;

		}

	}

}

/* Utility function to get the mime-attachment list from the attachment

 * bar for sending the comp via itip. The list and its contents must

 * be freed by the caller.

 */

static GSList *

ece_get_mime_attach_list (ECompEditor *comp_editor)

{

	ECompEditorPage *page_attachments;

	EAttachmentStore *store;

	GtkTreeModel *model;

	GtkTreeIter iter;

	struct CalMimeAttach *cal_mime_attach;

	GSList *attach_list = NULL;

	gboolean valid;

	g_return_val_if_fail (E_IS_COMP_EDITOR (comp_editor), NULL);

	page_attachments = e_comp_editor_get_page (comp_editor, E_TYPE_COMP_EDITOR_PAGE_ATTACHMENTS);

	if (!page_attachments)

		return NULL;

	store = e_comp_editor_page_attachments_get_store (E_COMP_EDITOR_PAGE_ATTACHMENTS (page_attachments));

	if (!store)

		return NULL;

	model = GTK_TREE_MODEL (store);

	valid = gtk_tree_model_get_iter_first (model, &iter);

	while (valid) {

		EAttachment *attachment;

		CamelDataWrapper *wrapper;

		CamelMimePart *mime_part;

		CamelStream *stream;

		GByteArray *byte_array;

		guchar *buffer = NULL;

		const gchar *description;

		const gchar *disposition;

		gint column_id;

		column_id = E_ATTACHMENT_STORE_COLUMN_ATTACHMENT;

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

		mime_part = e_attachment_ref_mime_part (attachment);

		g_object_unref (attachment);

		valid = gtk_tree_model_iter_next (model, &iter);

		if (mime_part == NULL)

			continue;

		cal_mime_attach = g_malloc0 (sizeof (struct CalMimeAttach));

		wrapper = camel_medium_get_content (CAMEL_MEDIUM (mime_part));

		byte_array = g_byte_array_new ();

		stream = camel_stream_mem_new_with_byte_array (byte_array);

		camel_data_wrapper_decode_to_stream_sync (

			wrapper, stream, NULL, NULL);

		buffer = g_memdup (byte_array->data, byte_array->len);

		camel_mime_part_set_content_id (mime_part, NULL);

		cal_mime_attach->encoded_data = (gchar *) buffer;

		cal_mime_attach->length = byte_array->len;

		cal_mime_attach->filename =

			g_strdup (camel_mime_part_get_filename (mime_part));

		description = camel_mime_part_get_description (mime_part);

		if (description == NULL || *description == '\0')

			description = _("attachment");

		cal_mime_attach->description = g_strdup (description);

		cal_mime_attach->content_type = camel_data_wrapper_get_mime_type (wrapper);

		cal_mime_attach->content_id = g_strdup (

			camel_mime_part_get_content_id (mime_part));

		disposition = camel_mime_part_get_disposition (mime_part);

		cal_mime_attach->disposition =

			(disposition != NULL) &&

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

		attach_list = g_slist_append (attach_list, cal_mime_attach);

		g_object_unref (mime_part);

		g_object_unref (stream);

	}

	return attach_list;

}

static void

e_comp_editor_set_component (ECompEditor *comp_editor,

			     const icalcomponent *component)

{

	g_return_if_fail (E_IS_COMP_EDITOR (comp_editor));

	g_return_if_fail (component != NULL);

	if (comp_editor->priv->component)

		icalcomponent_free (comp_editor->priv->component);

	comp_editor->priv->component = icalcomponent_new_clone ((icalcomponent *) component);

	g_warn_if_fail (comp_editor->priv->component != NULL);

}

typedef struct _SaveData {

	ECompEditor *comp_editor;

	ECalClient *source_client;

	ECalClient *target_client;

	icalcomponent *component;

	gboolean with_send;

	gboolean close_after_save;

	ECalObjModType recur_mod;

	gboolean success;

	GError *error;

	gchar *alert_ident;

	gchar *alert_arg_0;

	gboolean object_created;

	ECalComponentItipMethod first_send;

	ECalComponentItipMethod second_send;

	ECalComponent *send_comp;

	EActivity *send_activity;

	gboolean strip_alarms;

	gboolean only_new_attendees;

	GSList *mime_attach_list;

} SaveData;

static void

save_data_free (SaveData *sd)

{

	if (sd) {

		e_comp_editor_enable (sd->comp_editor, TRUE);

		if (sd->success) {

			if (sd->close_after_save) {

				g_signal_emit (sd->comp_editor, signals[EDITOR_CLOSED], 0, TRUE, NULL);

				gtk_widget_destroy (GTK_WIDGET (sd->comp_editor));

			} else {

				e_comp_editor_set_component (sd->comp_editor, sd->component);

				e_comp_editor_fill_widgets (sd->comp_editor, sd->component);

				g_clear_object (&sd->comp_editor->priv->source_client);

				sd->comp_editor->priv->source_client = g_object_ref (sd->target_client);

				sd->comp_editor->priv->flags = sd->comp_editor->priv->flags & (~E_COMP_EDITOR_FLAG_IS_NEW);

				e_comp_editor_sensitize_widgets (sd->comp_editor);

				e_comp_editor_set_changed (sd->comp_editor, FALSE);

			}

		} else if (sd->alert_ident) {

			e_alert_submit (

				E_ALERT_SINK (sd->comp_editor), sd->alert_ident, sd->alert_arg_0,

				sd->error ? sd->error->message : _("Unknown error"), NULL);

		}

		if (sd->send_activity && e_activity_get_state (sd->send_activity) != E_ACTIVITY_CANCELLED)

			e_activity_set_state (sd->send_activity, E_ACTIVITY_COMPLETED);

		g_clear_object (&sd->comp_editor);

		g_clear_object (&sd->source_client);

		g_clear_object (&sd->target_client);

		g_clear_object (&sd->send_comp);

		g_clear_object (&sd->send_activity);

		g_clear_error (&sd->error);

		if (sd->component)

			icalcomponent_free (sd->component);

		g_slist_free_full (sd->mime_attach_list, itip_cal_mime_attach_free);

		g_free (sd->alert_ident);

		g_free (sd->alert_arg_0);

		g_free (sd);

	}

}

static gboolean

ece_send_process_method (SaveData *sd,

			 ECalComponentItipMethod send_method,

			 ECalComponent *send_comp,

			 ESourceRegistry *registry,

			 GCancellable *cancellable,

			 GAsyncReadyCallback callback,

			 gpointer user_data)

{

	GSList *mime_attach_list = NULL;

	g_return_val_if_fail (sd != NULL, FALSE);

	g_return_val_if_fail (E_IS_CAL_COMPONENT (send_comp), FALSE);

	g_return_val_if_fail (send_method != E_CAL_COMPONENT_METHOD_NONE, FALSE);

	if (e_cal_component_has_attachments (send_comp) &&

	    e_client_check_capability (E_CLIENT (sd->target_client), CAL_STATIC_CAPABILITY_CREATE_MESSAGES)) {

		/* Clone the component with attachments set to CID:...  */

		GSList *attach_list = NULL;

		GSList *attach;

		/* mime_attach_list is freed by itip_send_component() */

		mime_attach_list = sd->mime_attach_list;

		sd->mime_attach_list = NULL;

		for (attach = mime_attach_list; attach; attach = attach->next) {

			struct CalMimeAttach *cma = (struct CalMimeAttach *) attach->data;

			attach_list = g_slist_append (

				attach_list, g_strconcat (

				"cid:", cma->content_id, NULL));

		}

		if (attach_list) {

			e_cal_component_set_attachment_list (send_comp, attach_list);

			g_slist_free_full (attach_list, g_free);

		}

	}

	itip_send_component (

		registry, send_method, send_comp, sd->target_client,

		NULL, mime_attach_list, NULL, sd->strip_alarms,

		sd->only_new_attendees, FALSE,

		cancellable, callback, user_data);

	return TRUE;

}

static void

ecep_second_send_processed_cb (GObject *source_object,

			       GAsyncResult *result,

			       gpointer user_data)

{

	SaveData *sd = user_data;

	g_return_if_fail (sd != NULL);

	sd->success = itip_send_component_finish (result, &sd->error);

	save_data_free (sd);

}

static void

ecep_first_send_processed_cb (GObject *source_object,

			      GAsyncResult *result,

			      gpointer user_data)

{

	SaveData *sd = user_data;

	g_return_if_fail (sd != NULL);

	sd->success = itip_send_component_finish (result, &sd->error);

	if (!sd->success || sd->second_send == E_CAL_COMPONENT_METHOD_NONE) {

		save_data_free (sd);

	} else {

		sd->success = ece_send_process_method (sd, sd->second_send, sd->send_comp,

			e_shell_get_registry (sd->comp_editor->priv->shell),

			e_activity_get_cancellable (sd->send_activity),

			ecep_second_send_processed_cb, sd);

		if (!sd->success)

			save_data_free (sd);

	}

}

static void

ece_prepare_send_component_done (gpointer ptr)

{

	SaveData *sd = ptr;

	g_return_if_fail (sd != NULL);

	g_return_if_fail (E_IS_COMP_EDITOR (sd->comp_editor));

	g_return_if_fail (sd->send_activity != NULL);

	sd->success = ece_send_process_method (sd, sd->first_send, sd->send_comp,

		e_shell_get_registry (sd->comp_editor->priv->shell),

		e_activity_get_cancellable (sd->send_activity),

		ecep_first_send_processed_cb, sd);

	if (!sd->success)

		save_data_free (sd);

}

static void

ece_prepare_send_component_thread (EAlertSinkThreadJobData *job_data,

				   gpointer user_data,

				   GCancellable *cancellable,

				   GError **error)

{

	SaveData *sd = user_data;

	const gchar *alert_ident;

	ECalComponent *send_comp = NULL;

	guint32 flags;

	ESourceRegistry *registry;

	g_return_if_fail (sd != NULL);

	g_return_if_fail (E_IS_CAL_CLIENT (sd->target_client));

	g_return_if_fail (sd->component != NULL);

	while (!sd->send_activity) {

		/* Give the main thread a chance to set this object

		   and give it a 50 milliseconds delay too */

		g_thread_yield ();

		g_usleep (50000);

	}

	switch (icalcomponent_isa (sd->component)) {

		case ICAL_VEVENT_COMPONENT:

			alert_ident = "calendar:failed-send-event";

			break;

		case ICAL_VJOURNAL_COMPONENT:

			alert_ident = "calendar:failed-send-memo";

			break;

		case ICAL_VTODO_COMPONENT:

			alert_ident = "calendar:failed-send-task";

			break;

		default:

			g_warning ("%s: Cannot send component of kind %d", G_STRFUNC, icalcomponent_isa (sd->component));

			sd->success = FALSE;

			sd->alert_ident = g_strdup ("calendar:failed-send-event");

			return;

	}

	g_free (sd->alert_ident);

	sd->alert_ident = g_strdup (alert_ident);

	e_alert_sink_thread_job_set_alert_ident (job_data, alert_ident);

	flags = e_comp_editor_get_flags (sd->comp_editor);

	registry = e_shell_get_registry (sd->comp_editor->priv->shell);

	if (sd->recur_mod == E_CAL_OBJ_MOD_ALL && e_cal_component_is_instance (sd->send_comp)) {

		/* Ensure we send the master object, not the instance only */

		icalcomponent *icalcomp = NULL;

		const gchar *uid = NULL;

		e_cal_component_get_uid (sd->send_comp, &uid);

		if (e_cal_client_get_object_sync (sd->target_client, uid, NULL, &icalcomp, cancellable, NULL) &&

		    icalcomp != NULL) {

			send_comp = e_cal_component_new_from_icalcomponent (icalcomp);

		}

	}

	if (!send_comp)

		send_comp = e_cal_component_clone (sd->send_comp);

	cal_comp_util_copy_new_attendees (send_comp, sd->send_comp);

	/* The user updates the delegated status to the Organizer,

	 * so remove all other attendees. */

	if ((flags & E_COMP_EDITOR_FLAG_DELEGATE) != 0) {

		gchar *address;

		address = itip_get_comp_attendee (registry, send_comp, sd->target_client);

		if (address) {

			ece_set_attendees_for_delegation (send_comp, address);

			g_free (address);

		}

	}

	g_clear_object (&sd->send_comp);

	sd->send_comp = send_comp;

}

static void

ece_save_component_done (gpointer ptr)

{

	SaveData *sd = ptr;

	g_return_if_fail (sd != NULL);

	g_return_if_fail (E_IS_COMP_EDITOR (sd->comp_editor));

	if (sd->success) {

		ECalComponent *comp;

		gboolean delegated, is_new_meeting;

		gboolean only_new_attendees = FALSE;

		gboolean strip_alarms = TRUE;

		guint32 flags;

		if (sd->object_created)

			g_signal_emit (sd->comp_editor, signals[OBJECT_CREATED], 0, NULL);

		comp = e_cal_component_new_from_icalcomponent (icalcomponent_new_clone (sd->component));

		if (sd->comp_editor->priv->page_general) {

			GSList *added_attendees;

			added_attendees = e_comp_editor_page_general_get_added_attendees (sd->comp_editor->priv->page_general);

			cal_comp_util_set_added_attendees_mails (comp, added_attendees);

		}

		flags = e_comp_editor_get_flags (sd->comp_editor);

		is_new_meeting = (flags & E_COMP_EDITOR_FLAG_WITH_ATTENDEES) == 0 ||

			(flags & E_COMP_EDITOR_FLAG_IS_NEW) != 0;

		delegated = (flags & E_COMP_EDITOR_FLAG_DELEGATE) != 0 &&

			e_cal_client_check_save_schedules (sd->target_client);

		if (delegated || (sd->with_send && e_cal_dialogs_send_component (

			GTK_WINDOW (sd->comp_editor), sd->target_client, comp,

			is_new_meeting, &strip_alarms, &only_new_attendees))) {

			ESourceRegistry *registry;

			EActivity *activity;

			registry = e_shell_get_registry (sd->comp_editor->priv->shell);

			if (delegated)

				only_new_attendees = FALSE;

			if ((itip_organizer_is_user (registry, comp, sd->target_client) ||

			     itip_sentby_is_user (registry, comp, sd->target_client))) {

				if (e_cal_component_get_vtype (comp) == E_CAL_COMPONENT_JOURNAL)

					sd->first_send = E_CAL_COMPONENT_METHOD_PUBLISH;

				else

					sd->first_send = E_CAL_COMPONENT_METHOD_REQUEST;

			} else {

				sd->first_send = E_CAL_COMPONENT_METHOD_REQUEST;

				if ((flags & E_COMP_EDITOR_FLAG_DELEGATE) != 0)

					sd->second_send = E_CAL_COMPONENT_METHOD_REPLY;

			}

			sd->mime_attach_list = ece_get_mime_attach_list (sd->comp_editor);

			sd->strip_alarms = strip_alarms;

			sd->only_new_attendees = only_new_attendees;

			sd->send_comp = comp;

			sd->success = FALSE;

			sd->alert_ident = g_strdup ("calendar:failed-send-event");

			sd->alert_arg_0 = e_util_get_source_full_name (registry, e_client_get_source (E_CLIENT (sd->target_client)));

			activity = e_alert_sink_submit_thread_job (E_ALERT_SINK (sd->comp_editor),

				_("Sending notifications to attendees..."), sd->alert_ident, sd->alert_arg_0,

				ece_prepare_send_component_thread, sd, ece_prepare_send_component_done);

			if (activity)

				e_activity_bar_set_activity (sd->comp_editor->priv->activity_bar, activity);

			/* The thread is waiting for this to be set first */

			sd->send_activity = activity;

			return;

		}

		g_clear_object (&comp);

	}

	save_data_free (sd);

}

static gboolean

ece_save_component_attachments_sync (ECalClient *cal_client,

				     icalcomponent *component,

				     GCancellable *cancellable,

				     GError **error)

{

	icalproperty *prop;

	const gchar *local_store;

	gchar *target_filename_prefix, *filename_prefix, *tmp;

	gboolean success = TRUE;

	g_return_val_if_fail (E_IS_CAL_CLIENT (cal_client), FALSE);

	g_return_val_if_fail (component != NULL, FALSE);

	tmp = g_strdup (icalcomponent_get_uid (component));

	e_filename_make_safe (tmp);

	filename_prefix = g_strconcat (tmp, "-", NULL);

	g_free (tmp);

	local_store = e_cal_client_get_local_attachment_store (cal_client);

	if (local_store && *local_store &&

	    g_mkdir_with_parents (local_store, 0700) < 0) {

		g_debug ("%s: Failed to create local store directory '%s'", G_STRFUNC, local_store);

	}

	target_filename_prefix = g_build_filename (local_store, filename_prefix, NULL);

	g_free (filename_prefix);

	for (prop = icalcomponent_get_first_property (component, ICAL_ATTACH_PROPERTY);

	     prop && success;

	     prop = icalcomponent_get_next_property (component, ICAL_ATTACH_PROPERTY)) {

		icalattach *attach;

		gchar *uri = NULL;

		attach = icalproperty_get_attach (prop);

		if (!attach)

			continue;

		if (icalattach_get_is_url (attach)) {

			const gchar *data;

			gsize buf_size;

			data = icalattach_get_url (attach);

			buf_size = strlen (data);

			uri = g_malloc0 (buf_size + 1);

			icalvalue_decode_ical_string (data, uri, buf_size);

		}

		if (uri) {

			if (g_ascii_strncasecmp (uri, "file://", 7) == 0 &&

			    !g_str_has_prefix (uri + 7, target_filename_prefix)) {

				GFile *source, *destination;

				gchar *decoded_filename;

				gchar *target_filename;

				decoded_filename = g_uri_unescape_string (strrchr (uri, '/') + 1, NULL);

				target_filename = g_strconcat (target_filename_prefix, decoded_filename, NULL);

				g_free (decoded_filename);

				source = g_file_new_for_uri (uri);

				destination = g_file_new_for_path (target_filename);

				if (source && destination) {

					success = g_file_copy (source, destination, G_FILE_COPY_OVERWRITE, cancellable, NULL, NULL, error);

					if (success) {

						g_free (uri);

						uri = g_file_get_uri (destination);

						if (uri) {

							icalattach *new_attach;

							gsize buf_size;

							gchar *buf;

							buf_size = 2 * strlen (uri) + 1;

							buf = g_malloc0 (buf_size);

							icalvalue_encode_ical_string (uri, buf, buf_size);

							new_attach = icalattach_new_from_url (buf);

							icalproperty_set_attach (prop, new_attach);

							icalattach_unref (new_attach);

							g_free (buf);

						}

					}

				}

				g_clear_object (&source);

				g_clear_object (&destination);

				g_free (target_filename);

			}

			g_free (uri);

		}

		success = success & !g_cancellable_set_error_if_cancelled (cancellable, error);

	}

	g_free (target_filename_prefix);

	return success;

}

static void

ece_gather_tzids_cb (icalparameter *param,

		     gpointer user_data)

{

	GHashTable *tzids = user_data;

	const gchar *tzid;

	g_return_if_fail (param != NULL);

	g_return_if_fail (tzids != NULL);

	tzid = icalparameter_get_tzid (param);

	if (tzid && *tzid && g_ascii_strcasecmp (tzid, "UTC") != 0)

		g_hash_table_insert (tzids, g_strdup (tzid), NULL);

}

static gboolean

ece_save_component_add_timezones_sync (SaveData *sd,

				       GCancellable *cancellable,

				       GError **error)

{

	GHashTable *tzids;

	GHashTableIter iter;

	gpointer key, value;

	gboolean source_is_target;

	g_return_val_if_fail (sd != NULL, FALSE);

	g_return_val_if_fail (sd->component != NULL, FALSE);

	g_return_val_if_fail (sd->target_client != NULL, FALSE);

	sd->success = TRUE;

	tzids = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

	source_is_target = !sd->source_client ||

		e_source_equal (e_client_get_source (E_CLIENT (sd->target_client)),

				e_client_get_source (E_CLIENT (sd->source_client)));

	icalcomponent_foreach_tzid (sd->component, ece_gather_tzids_cb, tzids);

	g_hash_table_iter_init (&iter, tzids);

	while (sd->success && g_hash_table_iter_next (&iter, &key, &value)) {

		const gchar *tzid = key;

		icaltimezone *zone = NULL;

		GError *local_error = NULL;

		if (!e_cal_client_get_timezone_sync (source_is_target ? sd->target_client : sd->source_client,

			tzid, &zone, cancellable, &local_error)) {

			zone = icaltimezone_get_builtin_timezone_from_tzid (tzid);

			if (!zone)

				zone = icaltimezone_get_builtin_timezone (tzid);

			if (!zone) {

				g_propagate_error (error, local_error);

				local_error = NULL;

				sd->success = FALSE;

				break;

			}

		}

		sd->success = e_cal_client_add_timezone_sync (sd->target_client, zone, cancellable, error);

		g_clear_error (&local_error);

	}

	g_hash_table_destroy (tzids);

	return sd->success;

}

static void

ece_save_component_thread (EAlertSinkThreadJobData *job_data,

			   gpointer user_data,

			   GCancellable *cancellable,

			   GError **error)

{

	SaveData *sd = user_data;

	const gchar *create_alert_ident, *modify_alert_ident, *remove_alert_ident, *get_alert_ident;

	gchar *orig_uid, *new_uid = NULL;

	g_return_if_fail (sd != NULL);

	g_return_if_fail (E_IS_CAL_CLIENT (sd->target_client));

	g_return_if_fail (sd->component != NULL);

	switch (icalcomponent_isa (sd->component)) {

		case ICAL_VEVENT_COMPONENT:

			create_alert_ident = "calendar:failed-create-event";

			modify_alert_ident = "calendar:failed-modify-event";

			remove_alert_ident = "calendar:failed-remove-event";

			get_alert_ident = "calendar:failed-get-event";

			break;

		case ICAL_VJOURNAL_COMPONENT:

			create_alert_ident = "calendar:failed-create-memo";

			modify_alert_ident = "calendar:failed-modify-memo";

			remove_alert_ident = "calendar:failed-remove-memo";

			get_alert_ident = "calendar:failed-get-memo";

			break;

		case ICAL_VTODO_COMPONENT:

			create_alert_ident = "calendar:failed-create-task";

			modify_alert_ident = "calendar:failed-modify-task";

			remove_alert_ident = "calendar:failed-remove-task";

			get_alert_ident = "calendar:failed-get-task";

			break;

		default:

			g_warning ("%s: Cannot save component of kind %d", G_STRFUNC, icalcomponent_isa (sd->component));

			return;

	}

	sd->success = ece_save_component_add_timezones_sync (sd, cancellable, error);

	if (!sd->success) {

		e_alert_sink_thread_job_set_alert_ident (job_data, "calendar:failed-add-timezone");

		return;

	}

	sd->success = ece_save_component_attachments_sync (sd->target_client, sd->component, cancellable, error);

	if (!sd->success) {

		e_alert_sink_thread_job_set_alert_ident (job_data, "calendar:failed-save-attachments");

		return;

	}

	orig_uid = g_strdup (icalcomponent_get_uid (sd->component));

	if (cal_comp_is_icalcomp_on_server_sync (sd->component, sd->target_client, cancellable, error)) {

		ECalComponent *comp;

		gboolean has_recurrences;

		e_alert_sink_thread_job_set_alert_ident (job_data, modify_alert_ident);

		comp = e_cal_component_new_from_icalcomponent (icalcomponent_new_clone (sd->component));

		g_return_if_fail (comp != NULL);

		has_recurrences = e_cal_util_component_has_recurrences (sd->component);

		if (has_recurrences && sd->recur_mod == E_CAL_OBJ_MOD_ALL)

			sd->success = comp_util_sanitize_recurrence_master_sync (comp, sd->target_client, cancellable, error);

		else

			sd->success = TRUE;

		if (sd->recur_mod == E_CAL_OBJ_MOD_THIS) {

			e_cal_component_set_rdate_list (comp, NULL);

			e_cal_component_set_rrule_list (comp, NULL);

			e_cal_component_set_exdate_list (comp, NULL);

			e_cal_component_set_exrule_list (comp, NULL);

		}

		sd->success = sd->success && e_cal_client_modify_object_sync (

			sd->target_client, e_cal_component_get_icalcomponent (comp), sd->recur_mod, cancellable, error);

		g_clear_object (&comp);

	} else {

		e_alert_sink_thread_job_set_alert_ident (job_data, create_alert_ident);

		sd->success = e_cal_client_create_object_sync (sd->target_client, sd->component, &new_uid, cancellable, error);