/*
 * 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:
 *		Praveen Kumar <kpraveen@novell.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

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

#include "exchange-operations.h"
#include <e-folder-exchange.h>
#include <exchange-hierarchy.h>
#include <e-util/e-error.h>

ExchangeConfigListener *exchange_global_config_listener=NULL;

static char *error_ids[] = { "config-error",
			     "password-weak-error",
			     "password-change-error",
			     "password-change-success",
			     "account-offline",
			     "password-incorrect",
			     "account-domain-error",
			     "account-mailbox-na",
			     "account-version-error",
			     "account-wss-error",
			     "account-no-mailbox",
			     "account-resolve-error",
			     "account-connect-error",
			     "password-expired",
			     "account-unknown-error",
			     "account-quota-error",
			     "account-quota-send-error",
			     "account-quota-warn" };

static void
free_exchange_listener (void)
{
	g_object_unref (exchange_global_config_listener);
}

int
e_plugin_lib_enable (EPluginLib *eplib, int enable)
{
	if (!exchange_global_config_listener) {
		exchange_global_config_listener = exchange_config_listener_new ();
		g_atexit (free_exchange_listener);
	}
	return 0;
}

ExchangeConfigListenerStatus
exchange_is_offline (gint *mode)
{
	return exchange_config_listener_get_offline_status (exchange_global_config_listener, mode);
}

/* FIXME: See if a GLib variant of this function available */
gboolean
exchange_operations_tokenize_string (char **string, char *token, char delimit, unsigned int maxsize)
{
	unsigned int i=0;
	char *str=*string;
	while (*str!=delimit && *str!='\0' && i<maxsize-1) {
		token[i++]=*str++;
	}
	while (*str==delimit)
		str++;
	token[i]='\0';
	*string = str;
	if (i==0)
		return FALSE;
	return TRUE;
}

gboolean
exchange_operations_cta_add_node_to_tree (GtkTreeStore *store, GtkTreeIter *parent, const char *ruri)
{
	GtkTreeIter iter;
	char *luri=(char *)ruri;
	char nodename[80];
	gchar *uri;
	gboolean status, found;

	exchange_operations_tokenize_string (&luri, nodename, '/', sizeof(nodename));

       	if (!nodename[0]) {
		return TRUE;
	}

	if (!parent) {
	  uri = g_strdup (nodename);
	}
	else {
	  gchar *tmpuri;
	  gtk_tree_model_get (GTK_TREE_MODEL (store), parent, 1, &tmpuri, -1);
	  uri = g_strconcat (tmpuri, "/", nodename, NULL);
	  g_free (tmpuri);
	}

	if (!strcmp (nodename, "personal") && !parent) {
		/* FIXME: Don't hardcode this */
		strcpy (nodename, _("Personal Folders"));
	}

	found = FALSE;
	status = gtk_tree_model_iter_children (GTK_TREE_MODEL (store), &iter, parent);
	while (status) {
	  gchar *readname;
	  gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, 0, &readname, -1);
	  if (!strcmp (nodename, readname)) {
	    found = TRUE;
	    exchange_operations_cta_add_node_to_tree (store, &iter, luri);
	    g_free (readname);
	    break;
	  }
	  status = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
	}

	if (!found) {
	  gtk_tree_store_append (store, &iter, parent);
	  gtk_tree_store_set (store, &iter, 0, nodename, 1, uri, -1);
	  exchange_operations_cta_add_node_to_tree (store, &iter, luri);
	}

	g_free (uri);
	return TRUE;
}

void
exchange_operations_cta_select_node_from_tree (GtkTreeStore *store, GtkTreeIter *parent, const char *nuri, const char *ruri, GtkTreeSelection *selection)
{
	char *luri=(char *)nuri;
	char nodename[80];
	GtkTreeIter iter;
	gboolean status;

	if (!luri)
		return;

	exchange_operations_tokenize_string (&luri, nodename, '/', sizeof(nodename));
       	if (!nodename[0]) {
		return;
	}

	if (!strcmp (nodename, "personal") && !parent) {
		/* FIXME: Don't hardcode this */
		strcpy (nodename, _("Personal Folders"));
	}

	status = gtk_tree_model_iter_children (GTK_TREE_MODEL (store), &iter, parent);
	while (status) {
		gchar *readname;
		gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, 0, &readname, -1);
		if (!strcmp (nodename, readname)) {
			gchar *readruri;
			gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, 1, &readruri, -1);
			if (!strcmp (ruri, readruri)) {
				gtk_tree_selection_select_iter (selection, &iter);
				return;
			}
			g_free (readname);
			g_free (readruri);
			exchange_operations_cta_select_node_from_tree (store, &iter, luri, ruri, selection);
			break;
		}
		status = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
	}
	return;
}

ExchangeAccount *
exchange_operations_get_exchange_account (void)
{
	ExchangeAccount *account = NULL;
	ExchangeAccountResult result;
	GSList *acclist;
	gint mode;

	acclist = exchange_config_listener_get_accounts (exchange_global_config_listener);
	/* FIXME: Need to be changed for handling multiple accounts */
	if (acclist) {
		account = acclist->data;

		exchange_config_listener_get_offline_status (exchange_global_config_listener,
							     &mode);

		if (mode == OFFLINE_MODE) {
			return account;
		}
		else if (exchange_account_get_context (account)) {
			return account;
		} else {
			/* Try authenticating */
			result = exchange_config_listener_authenticate(exchange_global_config_listener, account);
			if (result != EXCHANGE_ACCOUNT_CONNECT_SUCCESS) {
				exchange_operations_report_error (account, result);
				return NULL;
			}
			if (exchange_account_get_context (account))
				return account;
		}
	}

	return NULL;
}

void
exchange_operations_report_error (ExchangeAccount *account, ExchangeAccountResult result)
{
	gchar *error_string;
	gchar *quota_value;
	GtkWidget *widget;

	g_return_if_fail (account != NULL);

	if (result == EXCHANGE_ACCOUNT_CONNECT_SUCCESS)
		return;

	error_string = g_strconcat ("org-gnome-exchange-operations:", error_ids[result], NULL);

	switch (result) {
		case EXCHANGE_ACCOUNT_MAILBOX_NA:
			widget = e_error_new (NULL, error_string, exchange_account_get_username (account), NULL);
			break;
		case EXCHANGE_ACCOUNT_NO_MAILBOX:
			widget = e_error_new (NULL, error_string, exchange_account_get_username (account),
					      account->exchange_server, NULL);
			break;
		case EXCHANGE_ACCOUNT_RESOLVE_ERROR:
		case EXCHANGE_ACCOUNT_CONNECT_ERROR:
		case EXCHANGE_ACCOUNT_UNKNOWN_ERROR:
			widget = e_error_new (NULL, error_string, account->exchange_server, NULL);
			break;
		case EXCHANGE_ACCOUNT_QUOTA_RECIEVE_ERROR:
		case EXCHANGE_ACCOUNT_QUOTA_SEND_ERROR:
		case EXCHANGE_ACCOUNT_QUOTA_WARN:
			quota_value = g_strdup_printf ("%.2f", account->mbox_size);
			widget = e_error_new (NULL, error_string, quota_value, NULL);
			g_free (quota_value);
			break;
		default:
			widget = e_error_new (NULL, error_string, NULL);
	}
	g_signal_connect ((GtkDialog *)widget, "response", G_CALLBACK (gtk_widget_destroy), widget);
	gtk_widget_show (widget);
	g_free (error_string);
}

void exchange_operations_update_child_esources (ESource *source, const gchar *old_path, const gchar *new_path)
{
	ESourceGroup *group;
	GSList *sources, *tsource;
	group = e_source_peek_group (source);
	sources = e_source_group_peek_sources (group);
	for (tsource = sources; tsource != NULL; tsource = tsource->next) {
		gchar *ruri;
		ruri = (gchar*) e_source_peek_relative_uri (tsource->data);
		if (ruri && g_strrstr (ruri, old_path)) {
			/* This ESource points to one of the child folders */
			gchar **tmpv, *truri;
			/* A nasty search and replace */
		  	tmpv = g_strsplit (ruri, old_path, -1);
			truri = g_strjoinv (new_path, tmpv);
			e_source_set_relative_uri (tsource->data, truri);
			g_strfreev (tmpv);
			g_free (truri);
		}
	}
}

gboolean
is_exchange_personal_folder (ExchangeAccount *account, char *uri)
{
	ExchangeHierarchy *hier;
	EFolder *folder;

	folder = exchange_account_get_folder (account, uri);
	if (folder) {
		hier = e_folder_exchange_get_hierarchy (folder);
		if (hier->type != EXCHANGE_HIERARCHY_PERSONAL)
			return FALSE;
		else
			return TRUE;
	}
	return FALSE;
}