/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
/* e-tasks.c
 *
 * Copyright (C) 2001  Helix Code, Inc.
 *
 * 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; either version 2 of the
 * License, or (at your option) any later version.
 *
 * 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, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Authors: Federico Mena Quintero <federico@helixcode.com>
 *	    Damon Chaplin <damon@helixcode.com>
 */

#include <config.h>
#include <gnome.h>
#include <gal/util/e-util.h>
#include <gal/e-table/e-table-scrolled.h>
#include "e-calendar-table.h"
#include "alarm-notify.h"

#include "e-tasks.h"


/* States for the calendar loading and creation state machine */
typedef enum {
	LOAD_STATE_NOT_LOADED,
	LOAD_STATE_WAIT_LOAD,
	LOAD_STATE_WAIT_LOAD_BEFORE_CREATE,
	LOAD_STATE_WAIT_CREATE,
	LOAD_STATE_LOADED
} LoadState;

/* Private part of the GnomeCalendar structure */
struct _ETasksPrivate {
	/* The calendar client object we monitor */
	CalClient   *client;

	/* Loading state; we can be loading or creating a calendar */
	LoadState load_state;

	/* URI being loaded, NULL if we are not being loaded */
	char *loading_uri;

	/* The ECalendarTable showing the tasks. */
	GtkWidget   *tasks_view;
};


static void e_tasks_class_init (ETasksClass *class);
static void e_tasks_init (ETasks *tasks);
static void setup_widgets (ETasks *tasks);
static void e_tasks_destroy (GtkObject *object);

static void cal_loaded_cb (CalClient *client, CalClientLoadStatus status, gpointer data);
static void obj_updated_cb (CalClient *client, const char *uid, gpointer data);
static void obj_removed_cb (CalClient *client, const char *uid, gpointer data);

static GtkTableClass *parent_class;

E_MAKE_TYPE (e_tasks, "ETasks", ETasks,
	     e_tasks_class_init, e_tasks_init,
	     GTK_TYPE_TABLE)


/* Class initialization function for the gnome calendar */
static void
e_tasks_class_init (ETasksClass *class)
{
	GtkObjectClass *object_class;

	object_class = (GtkObjectClass *) class;

	parent_class = gtk_type_class (GTK_TYPE_TABLE);

	object_class->destroy = e_tasks_destroy;
}


/* Object initialization function for the gnome calendar */
static void
e_tasks_init (ETasks *tasks)
{
	ETasksPrivate *priv;

	priv = g_new0 (ETasksPrivate, 1);
	tasks->priv = priv;

	priv->load_state = LOAD_STATE_NOT_LOADED;

	setup_widgets (tasks);
}


#define E_TASKS_TABLE_DEFAULT_STATE					\
	"<?xml version=\"1.0\"?>"					\
	"<ETableState>"							\
	"<column source=\"13\"/>"					\
	"<column source=\"14\"/>"					\
	"<column source=\"9\"/>"					\
	"<column source=\"5\"/>"					\
	"<grouping/>"							\
	"</ETableState>"

static void
setup_widgets (ETasks *tasks)
{
	ETasksPrivate *priv;
	ETable *etable;

	priv = tasks->priv;

	priv->tasks_view = e_calendar_table_new ();
	etable = e_table_scrolled_get_table (E_TABLE_SCROLLED (E_CALENDAR_TABLE (priv->tasks_view)->etable));
	e_table_set_state (etable, E_TASKS_TABLE_DEFAULT_STATE);
	gtk_table_attach (GTK_TABLE (tasks), priv->tasks_view, 0, 1, 0, 1,
			  GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
	gtk_widget_show (priv->tasks_view);

}


GtkWidget *
e_tasks_construct (ETasks *tasks)
{
	ETasksPrivate *priv;

	g_return_val_if_fail (tasks != NULL, NULL);
	g_return_val_if_fail (E_IS_TASKS (tasks), NULL);

	priv = tasks->priv;

	priv->client = cal_client_new ();
	if (!priv->client)
		return NULL;

	gtk_signal_connect (GTK_OBJECT (priv->client), "cal_loaded",
			    GTK_SIGNAL_FUNC (cal_loaded_cb), tasks);
	gtk_signal_connect (GTK_OBJECT (priv->client), "obj_updated",
			    GTK_SIGNAL_FUNC (obj_updated_cb), tasks);
	gtk_signal_connect (GTK_OBJECT (priv->client), "obj_removed",
			    GTK_SIGNAL_FUNC (obj_removed_cb), tasks);

	alarm_notify_add_client (priv->client);

	e_calendar_table_set_cal_client (E_CALENDAR_TABLE (priv->tasks_view),
					 priv->client);

	return GTK_WIDGET (tasks);
}


GtkWidget *
e_tasks_new (void)
{
	ETasks *tasks;

	tasks = gtk_type_new (e_tasks_get_type ());

	if (!e_tasks_construct (tasks)) {
		g_message ("e_tasks_new(): Could not construct the tasks GUI");
		gtk_object_unref (GTK_OBJECT (tasks));
		return NULL;
	}

	return GTK_WIDGET (tasks);
}


static void
e_tasks_destroy (GtkObject *object)
{
	ETasks *tasks;
	ETasksPrivate *priv;

	g_return_if_fail (object != NULL);
	g_return_if_fail (E_IS_TASKS (object));

	tasks = E_TASKS (object);
	priv = tasks->priv;

	/* Save the ETable layout. FIXME: Need to save in a per-folder config
	   file like the mail folders use. */
#if 0
	filename = g_strdup_printf ("%s/config/TaskPad", evolution_dir);
	e_calendar_table_save_state (E_CALENDAR_TABLE (priv->todo), filename);
	g_free (filename);
#endif

	priv->load_state = LOAD_STATE_NOT_LOADED;

	if (priv->loading_uri) {
		g_free (priv->loading_uri);
		priv->loading_uri = NULL;
	}

	if (priv->client) {
		alarm_notify_remove_client (priv->client);
		gtk_object_unref (GTK_OBJECT (priv->client));
		priv->client = NULL;
	}

	g_free (priv);
	tasks->priv = NULL;

	if (GTK_OBJECT_CLASS (parent_class)->destroy)
		(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}


gboolean
e_tasks_open			(ETasks		*tasks,
				 char		*file,
				 ETasksOpenMode	 gcom)
{
	ETasksPrivate *priv;

	g_return_val_if_fail (tasks != NULL, FALSE);
	g_return_val_if_fail (E_IS_TASKS (tasks), FALSE);
	g_return_val_if_fail (file != NULL, FALSE);

	priv = tasks->priv;
	g_return_val_if_fail (priv->load_state == LOAD_STATE_NOT_LOADED,
			      FALSE);

	g_assert (priv->loading_uri == NULL);

	priv->loading_uri = g_strdup (file);

	if (gcom == E_TASKS_OPEN)
		priv->load_state = LOAD_STATE_WAIT_LOAD;
	else if (gcom == E_TASKS_OPEN_OR_CREATE)
		priv->load_state = LOAD_STATE_WAIT_LOAD_BEFORE_CREATE;
	else {
		g_assert_not_reached ();
		return FALSE;
	}

	if (!cal_client_load_calendar (priv->client, file)) {
		priv->load_state = LOAD_STATE_NOT_LOADED;
		g_free (priv->loading_uri);
		priv->loading_uri = NULL;

		g_message ("e_tasks_open(): Could not issue the request");
		return FALSE;
	}

	return TRUE;
}


/* Loads the initial data into the calendar; this should be called right after
 * the cal_loaded signal from the client is invoked.
 */
static void
initial_load (ETasks *tasks)
{
	ETasksPrivate *priv;

	priv = tasks->priv;

	/* FIXME: Do we need to do anything? */
}

/* Displays an error to indicate that loading a calendar failed */
static void
load_error (ETasks *tasks, const char *uri)
{
	char *msg;

	msg = g_strdup_printf (_("Could not load the tasks in `%s'"), uri);
	gnome_error_dialog_parented (msg, GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (tasks))));
	g_free (msg);
}

/* Displays an error to indicate that creating a calendar failed */
static void
create_error (ETasks *tasks, const char *uri)
{
	char *msg;

	msg = g_strdup_printf (_("Could not create a tasks file in `%s'"),
			       uri);
	gnome_error_dialog_parented (msg, GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (tasks))));
	g_free (msg);
}

/* Displays an error to indicate that the specified URI method is not supported */
static void
method_error (ETasks *tasks, const char *uri)
{
	char *msg;

	msg = g_strdup_printf (_("The method required to load `%s' is not supported"), uri);
	gnome_error_dialog_parented (msg, GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (tasks))));
	g_free (msg);
}

/* Callback from the calendar client when a calendar is loaded */
static void
cal_loaded_cb (CalClient *client, CalClientLoadStatus status, gpointer data)
{
	ETasks *tasks;
	ETasksPrivate *priv;
	gboolean free_uri;

	tasks = E_TASKS (data);
	priv = tasks->priv;

	g_assert (priv->load_state != LOAD_STATE_NOT_LOADED
		  && priv->load_state != LOAD_STATE_LOADED);
	g_assert (priv->loading_uri != NULL);

	free_uri = TRUE;

	switch (priv->load_state) {
	case LOAD_STATE_WAIT_LOAD:
		if (status == CAL_CLIENT_LOAD_SUCCESS) {
			priv->load_state = LOAD_STATE_LOADED;
			initial_load (tasks);
		} else if (status == CAL_CLIENT_LOAD_ERROR) {
			priv->load_state = LOAD_STATE_NOT_LOADED;
			load_error (tasks, priv->loading_uri);
		} else if (status == CAL_CLIENT_LOAD_METHOD_NOT_SUPPORTED) {
			priv->load_state = LOAD_STATE_NOT_LOADED;
			method_error (tasks, priv->loading_uri);
		} else
			g_assert_not_reached ();

		break;

	case LOAD_STATE_WAIT_LOAD_BEFORE_CREATE:
		if (status == CAL_CLIENT_LOAD_SUCCESS) {
			priv->load_state = LOAD_STATE_LOADED;
			initial_load (tasks);
		} else if (status == CAL_CLIENT_LOAD_ERROR) {
			priv->load_state = LOAD_STATE_WAIT_CREATE;
			free_uri = FALSE;

			if (!cal_client_create_calendar (priv->client,
							 priv->loading_uri)) {
				priv->load_state = LOAD_STATE_NOT_LOADED;
				free_uri = TRUE;
				g_message ("cal_loaded_cb(): Could not issue the create request");
			}
		} else if (status == CAL_CLIENT_LOAD_METHOD_NOT_SUPPORTED) {
			priv->load_state = LOAD_STATE_NOT_LOADED;
			method_error (tasks, priv->loading_uri);
		} else
			g_assert_not_reached ();

		break;

	case LOAD_STATE_WAIT_CREATE:
		if (status == CAL_CLIENT_LOAD_SUCCESS) {
			priv->load_state = LOAD_STATE_LOADED;
			initial_load (tasks);
		} else if (status == CAL_CLIENT_LOAD_ERROR) {
			priv->load_state = LOAD_STATE_NOT_LOADED;
			create_error (tasks, priv->loading_uri);
		} else if (status == CAL_CLIENT_LOAD_IN_USE) {
			/* Someone created the URI while we were issuing the
			 * create request, so we just try to reload.
			 */
			priv->load_state = LOAD_STATE_WAIT_LOAD;
			free_uri = FALSE;

			if (!cal_client_load_calendar (priv->client,
						       priv->loading_uri)) {
				priv->load_state = LOAD_STATE_NOT_LOADED;
				free_uri = TRUE;
				g_message ("cal_loaded_cb(): Could not issue the load request");
			}
		} else if (status == CAL_CLIENT_LOAD_METHOD_NOT_SUPPORTED) {
			priv->load_state = LOAD_STATE_NOT_LOADED;
			method_error (tasks, priv->loading_uri);
		} else
			g_assert_not_reached ();

		break;

	default:
		g_assert_not_reached ();
	}

	if (free_uri) {
		g_free (priv->loading_uri);
		priv->loading_uri = NULL;
	}
}


/* Callback from the calendar client when an object is updated */
static void
obj_updated_cb (CalClient *client, const char *uid, gpointer data)
{
	ETasks *tasks;
	ETasksPrivate *priv;

	tasks = E_TASKS (data);
	priv = tasks->priv;

	/* FIXME: Do we need to do anything? */
}


/* Callback from the calendar client when an object is removed */
static void
obj_removed_cb (CalClient *client, const char *uid, gpointer data)
{
	ETasks *tasks;
	ETasksPrivate *priv;

	tasks = E_TASKS (data);
	priv = tasks->priv;

	/* FIXME: Do we need to do anything? */
}


/**
 * e_tasks_get_cal_client:
 * @tasks: An #ETasks.
 *
 * Queries the calendar client interface object that a tasks view is using.
 *
 * Return value: A calendar client interface object.
 **/
CalClient *
e_tasks_get_cal_client (ETasks *tasks)
{
	ETasksPrivate *priv;

	g_return_val_if_fail (tasks != NULL, NULL);
	g_return_val_if_fail (E_IS_TASKS (tasks), NULL);

	priv = tasks->priv;

	return priv->client;
}