/*
 * e-shell-migrate.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)
 *
 */

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

#include "e-shell-migrate.h"

#include <glib/gstdio.h>
#include <libedataserver/e-xml-utils.h>

#include "libevolution-utils/e-alert-dialog.h"
#include "e-util/e-file-utils.h"
#include "e-util/e-util.h"

#include "es-event.h"

static gboolean
shell_migrate_attempt (EShell *shell,
                       gint major,
                       gint minor,
                       gint micro)
{
	GtkWindow *parent;
	GList *backends;
	gboolean success = TRUE;

	parent = e_shell_get_active_window (shell);
	backends = e_shell_get_shell_backends (shell);

	/* New user accounts have nothing to migrate. */
	if (major == 0 && minor == 0 && micro == 0)
		return TRUE;

	/* We only support migrating from version 2 now. */
	if (major < 2) {
		gchar *version;
		gint response;

		version = g_strdup_printf ("%d.%d", major, minor);
		response = e_alert_run_dialog_for_args (
			parent, "shell:upgrade-version-too-old",
			version, NULL);
		g_free (version);

		return (response == GTK_RESPONSE_OK);
	}

	/* Ask each of the shell backends to migrate their own data.
	 * XXX If something fails the user may end up with only partially
	 *     migrated data.  Need transaction semantics here, but how? */
	while (success && backends != NULL) {
		EShellBackend *shell_backend = backends->data;
		GError *error = NULL;

		success = e_shell_backend_migrate (
			shell_backend, major, minor, micro, &error);

		if (error != NULL) {
			gint response;

			response = e_alert_run_dialog_for_args (
				parent, "shell:upgrade-failed",
				error->message, NULL);

			success = (response == GTK_RESPONSE_OK);

			g_error_free (error);
		}

		backends = g_list_next (backends);
	}

	return success;
}

static void
shell_migrate_get_version (EShell *shell,
                           gint *major,
                           gint *minor,
                           gint *micro)
{
	GSettings *settings;
	gchar *string;

	*major = 0;
	*minor = 0;
	*micro = 0;

	settings = g_settings_new ("org.gnome.evolution");
	string = g_settings_get_string (settings, "version");

	if (string != NULL) {
		/* Since 1.4.0 we've kept the version key in GConf. */
		sscanf (string, "%d.%d.%d", major, minor, micro);
		g_free (string);
	}

	g_object_unref (settings);
}

static void
change_dir_modes (const gchar *path)
{
	GDir *dir;
	GError *err = NULL;
	const gchar *file = NULL;

	dir = g_dir_open (path, 0, &err);
	if (err) {
		g_warning ("Error opening directory %s: %s \n", path, err->message);
		g_clear_error (&err);
		return;
	}

	while ((file = g_dir_read_name (dir))) {
		gchar *full_path = g_build_filename (path, file, NULL);

		if (g_file_test (full_path, G_FILE_TEST_IS_DIR))
			change_dir_modes (full_path);

		g_free (full_path);
	}

	g_chmod (path, 0700);
	g_dir_close (dir);
}

static void
fix_folder_permissions (const gchar *data_dir)
{
	struct stat sb;

	if (g_stat (data_dir, &sb) == -1) {
		g_warning ("error stat: %s \n", data_dir);
		return;
	}

	if (((guint32) sb.st_mode & 0777) != 0700)
		change_dir_modes (data_dir);
}

static void
merge_duplicate_local_sources (GConfClient *client,
                               const gchar *gconf_key)
{
	ESourceList *source_list;
	GSList *iter, *to_remove = NULL;
	ESourceGroup *first_local = NULL;

	g_return_if_fail (client != NULL);
	g_return_if_fail (gconf_key != NULL);

	source_list = e_source_list_new_for_gconf (client, gconf_key);

	for (iter = e_source_list_peek_groups (source_list); iter; iter = iter->next) {
		GSList *sources;
		ESourceGroup *group = iter->data;

		if (!group || !e_source_group_peek_base_uri (group) ||
			g_ascii_strncasecmp (
			e_source_group_peek_base_uri (group), "local:", 6) != 0)
			continue;

		if (!first_local) {
			first_local = group;
			continue;
		}

		/* merging respective sources */
		for (sources = e_source_group_peek_sources (group);
				sources != NULL; sources = sources->next) {
			GSList *liter;
			ESource *dupe_source = sources->data;

			if (!dupe_source)
				continue;

			for (liter = e_source_group_peek_sources (first_local);
					liter != NULL; liter = liter->next) {
				ESource *my_source = liter->data;
				const gchar *val1, *val2;

				if (!my_source)
					continue;

				/* pretty unlikely, but just in case */
				val1 = e_source_peek_uid (dupe_source);
				val2 = e_source_peek_uid (my_source);
				if (g_strcmp0 (val1, val2) == 0)
					break;

				/* relative uri should not be empty
				 * (but adressbook can have it empty) */
				val1 = e_source_peek_relative_uri (dupe_source);
				val2 = e_source_peek_relative_uri (my_source);
				if (g_strcmp0 (val1, val2) == 0 && val1 && *val1)
					break;
			}

			/* didn't find matching source, thus add its copy */
			if (liter == NULL) {
				ESource *copy;

				copy = e_source_copy (dupe_source);
				e_source_group_add_source (first_local, copy, -1);
				g_object_unref (copy);
			}
		}

		to_remove = g_slist_prepend (to_remove, group);
	}

	if (first_local) {
		GSList *sources;

		for (sources = e_source_group_peek_sources (first_local);
				sources != NULL; sources = sources->next) {
			ESource *source = sources->data;
			const gchar *relative_uri;

			if (!source)
				continue;

			relative_uri = e_source_peek_relative_uri (source);
			if (!relative_uri || !*relative_uri)
				e_source_set_relative_uri (source, e_source_peek_uid (source));
		}
	}

	if (!to_remove) {
		g_object_unref (source_list);
		return;
	}

	for (iter = to_remove; iter; iter = iter->next) {
		e_source_list_remove_group (source_list, iter->data);
	}

	e_source_list_sync (source_list, NULL);

	g_object_unref (source_list);
	g_slist_free (to_remove);
}

gboolean
e_shell_migrate_attempt (EShell *shell)
{
	ESEvent *ese;
	GSettings *settings;
	GConfClient *client;
	gint major, minor, micro;
	gint last_major, last_minor, last_micro;
	gint curr_major, curr_minor, curr_micro;
	gboolean migrated = FALSE;
	gchar *string;

	g_return_val_if_fail (E_IS_SHELL (shell), FALSE);

	settings = g_settings_new ("org.gnome.evolution");

	if (sscanf (BASE_VERSION, "%d.%d", &curr_major, &curr_minor) != 2) {
		g_warning ("Could not parse BASE_VERSION (%s)", BASE_VERSION);
		return TRUE;
	}

	curr_micro = atoi (UPGRADE_REVISION);

	shell_migrate_get_version (shell, &major, &minor, &micro);

	/* This sets the folder permissions to S_IRWXU if needed */
	if (curr_major <= 2 && curr_minor <= 30)
		fix_folder_permissions (e_get_user_data_dir ());

	/* Attempt to run migration all the time and let the backend
	 * make the choice */
	if (!shell_migrate_attempt (shell, major, minor, micro))
		_exit (EXIT_SUCCESS);

	/* The 2.32.x (except of 2.32.2) lefts duplicate
	 * On This Computer/Personal sources, thus clean the mess up */
	client = gconf_client_get_default ();
	merge_duplicate_local_sources (client, "/apps/evolution/addressbook/sources");
	merge_duplicate_local_sources (client, "/apps/evolution/calendar/sources");
	merge_duplicate_local_sources (client, "/apps/evolution/tasks/sources");
	merge_duplicate_local_sources (client, "/apps/evolution/memos/sources");
	g_object_unref (client);

	/* Record a successful migration. */
	string = g_strdup_printf (
		"%d.%d.%d", curr_major, curr_minor, curr_micro);
	g_settings_set_string (settings, "version", string);
	g_free (string);

	migrated = TRUE;

	/* Try to retrieve the last migrated version from GSettings. */
	string = g_settings_get_string (settings, "last-upgraded-version");
	if (migrated || string == NULL || sscanf (string, "%d.%d.%d",
		&last_major, &last_minor, &last_micro) != 3) {
		last_major = major;
		last_minor = minor;
		last_micro = micro;
	}
	g_free (string);

	string = g_strdup_printf (
		"%d.%d.%d", last_major, last_minor, last_micro);
	g_settings_set_string (settings, "last-upgraded-version", string);
	g_free (string);

	g_object_unref (settings);

	/** @Event: Shell attempted upgrade
	 * @Id: upgrade.done
	 * @Target: ESMenuTargetState
	 *
	 * This event is emitted whenever the shell successfully attempts
	 * an upgrade.
	 **/
	ese = es_event_peek ();
	e_event_emit (
		(EEvent *) ese, "upgrade.done",
		(EEventTarget *) es_event_target_new_upgrade (
		ese, curr_major, curr_minor, curr_micro));

	return TRUE;
}

GQuark
e_shell_migrate_error_quark (void)
{
	static GQuark quark = 0;

	if (G_UNLIKELY (quark == 0))
		quark = g_quark_from_static_string (
			"e-shell-migrate-error-quark");

	return quark;
}