/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 *
 * Author:
 *   Miguel de Icaza (miguel@gnu.org)
 *
 * (C) 1999 Helix Code, Inc.
 */

#include <config.h>
#include "e-test-model.h"
#include <gnome-xml/tree.h>
#include <gnome-xml/parser.h>
#include <gnome-xml/xmlmemory.h>
#include <gnome.h>

#define PARENT_TYPE e_table_model_get_type()
/*
 * ETestModel callbacks
n * These are the callbacks that define the behavior of our custom model.
 */

static void
test_destroy(GtkObject *object)
{
	ETestModel *model = E_TEST_MODEL(object);
	int i;
	if (model->book)
		gtk_object_unref(GTK_OBJECT(model->book));
	if (model->book_view)
		gtk_object_unref(GTK_OBJECT(model->book_view));
	for ( i = 0; i < model->data_count; i++ ) {
		gtk_object_unref(GTK_OBJECT(model->data[i]));
	}
	g_free(model->data);
	g_free(model->uri);
}

/* This function returns the number of columns in our ETableModel. */
static int
test_col_count (ETableModel *etc)
{
	return LAST_COL;
}

/* This function returns the number of rows in our ETableModel. */
static int
test_row_count (ETableModel *etc)
{
	ETestModel *test = E_TEST_MODEL(etc);
	return test->data_count;
}

/* This function returns the value at a particular point in our ETableModel. */
static void *
test_value_at (ETableModel *etc, int col, int row)
{
	ETestModel *test = E_TEST_MODEL(etc);
	ECardList *list;
	ECardIterator *iterator;
	gchar *string;
	if ( col >= LAST_COL || row >= test->data_count )
		return NULL;
	switch (col) {
	case EMAIL:
		gtk_object_get(GTK_OBJECT(test->data[row]),
			       "email", &list,
			       NULL);
		iterator = e_card_list_get_iterator(list);
		if (e_card_iterator_get(iterator))
			return (void *) e_card_iterator_get(iterator);
		else
			return "";
		gtk_object_unref(GTK_OBJECT(iterator));
		break;
	case FULL_NAME:
		gtk_object_get(GTK_OBJECT(test->data[row]),
			       "full_name", &string,
			       NULL);
		if (string)
			return string;
		else
			return "";
		break;
	case STREET:
		gtk_object_get(GTK_OBJECT(test->data[row]),
			       "street", &list,
			       NULL);
		iterator = e_card_list_get_iterator(list);
		if (e_card_iterator_get(iterator))
			return ((ECardDeliveryAddress *)e_card_iterator_get(iterator))->street;
		else
			return "";
		gtk_object_unref(GTK_OBJECT(iterator));
		break;
	case PHONE:
		gtk_object_get(GTK_OBJECT(test->data[row]),
			       "phone", &list,
			       NULL);
		iterator = e_card_list_get_iterator(list);
		if (e_card_iterator_get(iterator))
			return ((ECardPhone *)e_card_iterator_get(iterator))->number;
		else
			return "";
		gtk_object_unref(GTK_OBJECT(iterator));
		break;
	default:
		return NULL;
	}
}

/* This function sets the value at a particular point in our ETableModel. */
static void
test_set_value_at (ETableModel *etc, int col, int row, const void *val)
{
	ETestModel *test = E_TEST_MODEL(etc);
	ECardList *list;
	ECardIterator *iterator;
	if ( col >= LAST_COL || row >= test->data_count )
		return;
	switch (col) {
	case EMAIL:
		gtk_object_get(GTK_OBJECT(test->data[row]),
			       "email", &list,
			       NULL);
		iterator = e_card_list_get_iterator(list);
		if (e_card_iterator_is_valid(iterator)) {
			e_card_iterator_set(iterator, val);
		} else {
			e_card_list_append(list, val);
		}
		gtk_object_unref(GTK_OBJECT(iterator));
		break;
	case FULL_NAME:
		gtk_object_set(GTK_OBJECT(test->data[row]),
			       "full_name", val,
			       NULL);
		break;
	case STREET:
		gtk_object_get(GTK_OBJECT(test->data[row]),
			       "address", &list,
			       NULL);
		iterator = e_card_list_get_iterator(list);
		if (e_card_iterator_is_valid(iterator)) {
			const ECardDeliveryAddress *address = e_card_iterator_get(iterator);
			ECardDeliveryAddress *address_copy = e_card_delivery_address_copy(address);
			g_free(address_copy->street);
			address_copy->street = g_strdup(val);
			e_card_iterator_set(iterator, address_copy);
			e_card_delivery_address_free(address_copy);
		} else {
			ECardDeliveryAddress *address = g_new(ECardDeliveryAddress, 1);
			address->po = NULL;
			address->ext = NULL;
			address->street = g_strdup(val);
			address->city = NULL;
			address->region = NULL;
			address->code = NULL;
			address->country = NULL;
			address->flags = 0;
			e_card_list_append(list, address);
			e_card_delivery_address_free(address);
		}
		gtk_object_unref(GTK_OBJECT(iterator));
		break;
	case PHONE:
		gtk_object_get(GTK_OBJECT(test->data[row]),
			       "phone", &list,
			       NULL);
		iterator = e_card_list_get_iterator(list);
		if (e_card_iterator_is_valid(iterator)) {
			const ECardPhone *phone = e_card_iterator_get(iterator);
			ECardPhone *phone_copy = e_card_phone_copy(phone);
			g_free(phone_copy->number);
			phone_copy->number = g_strdup(val);
			e_card_iterator_set(iterator, phone_copy);
			e_card_phone_free(phone_copy);
		} else {
			ECardPhone *phone = g_new(ECardPhone, 1);
			phone->number = g_strdup(val);
			phone->flags = 0;
			e_card_list_append(list, phone);
			e_card_phone_free(phone);
		}
		gtk_object_unref(GTK_OBJECT(iterator));
		break;
	default:
		return;
	}
	e_book_commit_card(test->book, test->data[row], NULL, NULL);
	if ( !etc->frozen )
		e_table_model_cell_changed(etc, col, row);
}

/* This function returns whether a particular cell is editable. */
static gboolean
test_is_cell_editable (ETableModel *etc, int col, int row)
{
	return TRUE;
}

/* This function duplicates the value passed to it. */
static void *
test_duplicate_value (ETableModel *etc, int col, const void *value)
{
	return g_strdup(value);
}

/* This function frees the value passed to it. */
static void
test_free_value (ETableModel *etc, int col, void *value)
{
	g_free(value);
}

/* This function is for when the model is unfrozen.  This can mostly
   be ignored for simple models.  */
static void
test_thaw (ETableModel *etc)
{
	e_table_model_changed(etc);
}

static void
e_test_model_class_init (GtkObjectClass *object_class)
{
	ETableModelClass *model_class = (ETableModelClass *) object_class;
	
	object_class->destroy = test_destroy;

	model_class->column_count = test_col_count;
	model_class->row_count = test_row_count;
	model_class->value_at = test_value_at;
	model_class->set_value_at = test_set_value_at;
	model_class->is_cell_editable = test_is_cell_editable;
	model_class->duplicate_value = test_duplicate_value;
	model_class->free_value = test_free_value;
	model_class->thaw = test_thaw;
}

static void
e_test_model_init (GtkObject *object)
{
	ETestModel *model = E_TEST_MODEL(object);
	model->data = NULL;
	model->data_count = 0;
	model->book = NULL;
	model->book_view = NULL;
}

GtkType
e_test_model_get_type (void)
{
	static GtkType type = 0;

	if (!type){
		GtkTypeInfo info = {
			"ETestModel",
			sizeof (ETestModel),
			sizeof (ETestModelClass),
			(GtkClassInitFunc) e_test_model_class_init,
			(GtkObjectInitFunc) e_test_model_init,
			NULL, /* reserved 1 */
			NULL, /* reserved 2 */
			(GtkClassInitFunc) NULL
		};

		type = gtk_type_unique (PARENT_TYPE, &info);
	}

	return type;
}

void
e_test_model_add_column (ETestModel *model, Address *newadd)
{
#if 0
	model->data = g_realloc(model->data, (++model->data_count) * sizeof(Address *));
	model->data[model->data_count - 1] = newadd;
	e_test_model_queue_save(model);
	if ( model && !E_TABLE_MODEL(model)->frozen )
		e_table_model_changed(E_TABLE_MODEL(model));
#endif
}

static void
e_test_model_card_added(EBookView *book_view,
			const GList *cards,
			ETestModel *model)
{
	model->data = g_realloc(model->data, (model->data_count + g_list_length((GList *)cards)) * sizeof(ECard *));
	for ( ; cards; cards = cards->next) {
		gtk_object_ref(GTK_OBJECT(cards->data));
		model->data[model->data_count++] = E_CARD (cards->data);
	}
	e_table_model_changed(E_TABLE_MODEL(model));
}

static void
e_test_model_card_removed(EBookView *book_view,
			  const char *id,
			  ETestModel *model)
{
	int i;
	for ( i = 0; i < model->data_count; i++) {
		if ( !strcmp(e_card_get_id(model->data[i]), id) ) {
			gtk_object_unref(GTK_OBJECT(model->data[i]));
			memmove(model->data + i, model->data + i + 1, (model->data_count - i - 1) * sizeof (ECard *));
		}
	}
	e_table_model_changed(E_TABLE_MODEL(model));
}

static void
e_test_model_card_changed(EBookView *book_view,
			  const GList *cards,
			  ETestModel *model)
{
	for ( ; cards; cards = cards->next) {
		int i;
		for ( i = 0; i < model->data_count; i++) {
			if ( !strcmp(e_card_get_id(model->data[i]), e_card_get_id(E_CARD(cards->data))) ) {
				gtk_object_unref(GTK_OBJECT(model->data[i]));
				model->data[i] = E_CARD(cards->data);
				gtk_object_ref(GTK_OBJECT(model->data[i]));
				e_table_model_row_changed(E_TABLE_MODEL(model), i);
				break;
			}
		}
	}
}

static void
e_test_model_book_respond_get_view(EBook *book,
				   EBookStatus status,
				   EBookView *book_view,
				   ETestModel *model)
{
	if (status == E_BOOK_STATUS_SUCCESS) {
		model->book_view = book_view;
		gtk_object_ref(GTK_OBJECT(book_view));
		gtk_signal_connect(GTK_OBJECT(book_view),
				   "card_changed",
				   GTK_SIGNAL_FUNC(e_test_model_card_changed),
				   model);
		gtk_signal_connect(GTK_OBJECT(book_view),
				   "card_removed",
				   GTK_SIGNAL_FUNC(e_test_model_card_removed),
				   model);
		gtk_signal_connect(GTK_OBJECT(book_view),
				   "card_added",
				   GTK_SIGNAL_FUNC(e_test_model_card_added),
				   model);
	}
}

static void
e_test_model_uri_loaded(EBook *book,
			EBookStatus status,
			ETestModel *model)
{
	if (status == E_BOOK_STATUS_SUCCESS) {
		e_book_get_book_view (book,
				      "",
				      (EBookBookViewCallback) e_test_model_book_respond_get_view,
				      model);
	}
}

ETableModel *
e_test_model_new (gchar *uri)
{
	ETestModel *et;

	et = gtk_type_new (e_test_model_get_type ());
	
	et->uri = g_strdup(uri);
	et->book = e_book_new();
	e_book_load_uri(et->book,
			et->uri,
			(EBookCallback) e_test_model_uri_loaded,
			et);

	return E_TABLE_MODEL(et);
}