/*
 *
 * Author:
 *   Nat Friedman (nat@helixcode.com)
 *
 * Copyright 2000, Helix Code, Inc.
 */

#include <addressbook.h>
#include <pas-book-factory.h>

static GnomeObjectClass          *pas_book_factory_parent_class;
POA_Evolution_BookFactory__vepv   pas_book_factory_vepv;

typedef struct {
	Evolution_BookListener             listener;
	Evolution_BookListener_CallStatus  status;
} PASBookFactoryQueuedResponse;

typedef struct {
	char                              *uri;
	Evolution_BookListener             listener;
} PASBookFactoryQueuedRequest;

struct _PASBookFactoryPrivate {
	GHashTable *backends;
	GHashTable *active_server_map;
	GList      *queued_responses;
	GList      *queued_requests;
};

static char *
pas_book_factory_canonicalize_uri (const char *uri)
{
	char *canon;
	char *p;

	/* FIXME: What do I do here? */

	canon = g_strdup (uri);

	for (p = canon; *p != '\0'; p ++)
		*p = toupper (*p);

	return canon;
}

static char *
pas_book_factory_extract_proto_from_uri (const char *uri)
{
	char *proto;
	char *p;

	p = strchr (uri, ':');

	if (p == NULL)
		return NULL;

	proto = g_malloc0 (p - uri + 1);

	strncpy (proto, uri, p - uri);

	return proto;
}

/**
 * pas_book_factory_register_backend:
 * @factory:
 * @proto:
 * @backend:
 */
void
pas_book_factory_register_backend (PASBookFactory               *factory,
				   const char                   *proto,
				   PASBookFactoryBackendFactory  backend)
{
	g_return_if_fail (factory != NULL);
	g_return_if_fail (PAS_IS_BOOK_FACTORY (factory));
	g_return_if_fail (proto != NULL);
	g_return_if_fail (backend != NULL);

	if (g_hash_table_lookup (factory->priv->backends, proto) != NULL) {
		g_warning ("pas_book_factory_register_backend: "
			   "Proto \"%s\" already registered!\n", proto);
	}

	g_hash_table_insert (factory->priv->backends,
			     g_strdup (proto), backend);
}

static PASBookFactoryBackendFactory
pas_book_factory_lookup_backend_factory (PASBookFactory *factory,
					 const char     *uri)
{
	PASBookFactoryBackendFactory  backend;
	char                         *proto;
	char                         *canonical_uri;

	g_assert (factory != NULL);
	g_assert (PAS_IS_BOOK_FACTORY (factory));
	g_assert (uri != NULL);

	canonical_uri = pas_book_factory_canonicalize_uri (uri);
	if (canonical_uri == NULL)
		return NULL;

	proto = pas_book_factory_extract_proto_from_uri (canonical_uri);
	if (proto == NULL) {
		g_free (canonical_uri);
		return NULL;
	}

	backend = g_hash_table_lookup (factory->priv->backends, proto);

	g_free (proto); 
	g_free (canonical_uri);

	return backend;
}

static void
pas_book_factory_process_request (PASBookFactory              *factory,
				  PASBookFactoryQueuedRequest *request)
{
	request = factory->priv->queued_requests->data;

	/*
	 * Check to see if there is already a running backend for this
	 * URI.
	 */
	

	backend = pas_book_factory_lookup_backend_factory (
		factory, request->uri);
	g_assert (backend != NULL);

	(backend) (factory, request->uri, request->listener);
}


static void
pas_book_factory_process_response (PASBookFactory               *factory,
				   PASBookFactoryQueuedResponse *response)
{
	CORBA_Environment ev;

	CORBA_exception_init (&ev);

	Evolution_BookListener_respond_open_book (
		response->listener, response->status,
		CORBA_OBJECT_NIL, &ev);

	if (ev._major != CORBA_NO_EXCEPTION) {
		g_warning ("PASBookFactory: Exception while sending "
			   "response to BookListener!\n");

		CORBA_exception_free (&ev);
		CORBA_exception_init (&ev);
	}

	CORBA_Object_release (response->listener, &ev);

	if (ev._major != CORBA_NO_EXCEPTION) {
		g_warning ("PASBookFactory: Exception releasing "
			   "BookListener!\n");
	}

	CORBA_exception_free (&ev);
}


static gboolean
pas_book_factory_process_queues (PASBookFactory *factory)
{
	/* Process pending Book-creation requests. */
	while (factory->priv->queued_requests != NULL) {
		PASBookFactoryQueuedRequest  *request;

		pas_book_factory_process_request (factory, request);

		factory->priv->queued_requests = g_list_remove (
			factory->priv->queued_requests, request);

		g_free (request);
	}

	/* Flush the outgoing error queue. */
	while (factory->priv->queued_responses != NULL) {
		PASBookFactoryQueuedResponse *response;

		response = factory->priv->queued_responses->data;

		pas_book_factory_process_response (factory, response);
		factory->priv->queued_responses = g_list_remove (
			factory->priv->queued_responses, response);

		g_free (response);
	}

	return TRUE;
}

static void
pas_book_factory_queue_response (PASBookFactory                    *factory,
				 const Evolution_BookListener       listener,
				 Evolution_BookListener_CallStatus  status)
{
	PASBookFactoryQueuedResponse *response;
	Evolution_BookListener        listener_copy;
	CORBA_Environment             ev;

	CORBA_exception_init (&ev);

	listener_copy = CORBA_Object_duplicate (listener, &ev);

	if (ev._major != CORBA_NO_EXCEPTION) {
		g_warning ("PASBookFactory: Could not duplicate BookListener!\n");
		CORBA_exception_free (&ev);
		return;
	}

	CORBA_exception_free (&ev);

	response           = g_new0 (PASBookFactoryQueuedResponse, 1);
	response->listener = listener_copy;
	response->status   = status;

	factory->priv->queued_responses =
		g_list_prepend (factory->priv->queued_responses, response);
}

static void
pas_book_factory_queue_request (PASBookFactory               *factory,
				const char                   *uri,
				const Evolution_BookListener  listener)
{
	PASBookFactoryQueuedRequest *request;
	Evolution_BookListener       listener_copy;
	CORBA_Environment            ev;

	CORBA_exception_init (&ev);

	listener_copy = CORBA_Object_duplicate (listener, &ev);

	if (ev._major != CORBA_NO_EXCEPTION) {
		g_warning ("PASBookFactory: Could not duplicate BookListener!\n");
		CORBA_exception_free (&ev);
		return;
	}

	CORBA_exception_free (&ev);

	request           = g_new0 (PASBookFactoryQueuedRequest, 1);
	request->listener = listener_copy;
	request->uri      = g_strdup (uri);

	factory->priv->queued_requests =
		g_list_prepend (factory->priv->queued_requests, request);
}

static void
impl_Evolution_BookFactory_open_book (PortableServer_Servant        servant,
				      const CORBA_char             *uri,
				      const Evolution_BookListener  listener,
				      CORBA_Environment            *ev)
{
	PASBookFactory               *factory =
		PAS_BOOK_FACTORY (gnome_object_from_servant (servant));

	PASBookFactoryBackendFactory  backend;

	backend = pas_book_factory_lookup_backend_factory (factory, uri);

	if (backend == NULL) {
		g_warning ("PASBookFactory: No backend found for uri: %s\n", uri);

		pas_book_factory_queue_response (
			factory, listener,
			Evolution_BookListener_ProtocolNotSupported);

		return;
	}

	pas_book_factory_queue_request (factory, uri, listener);
}

static PASBookFactory *
pas_book_factory_construct (PASBookFactory *factory)
{
	POA_Evolution_BookFactory  *servant;
	CORBA_Environment           ev;
	CORBA_Object                obj;

	g_assert (factory != NULL);
	g_assert (PAS_IS_BOOK_FACTORY (factory));

	servant = (POA_Evolution_BookFactory *) g_new0 (GnomeObjectServant, 1);
	servant->vepv = &pas_book_factory_vepv;

	CORBA_exception_init (&ev);

	POA_Evolution_BookFactory__init ((PortableServer_Servant) servant, &ev);
	if (ev._major != CORBA_NO_EXCEPTION) {
		g_free (servant);
		CORBA_exception_free (&ev);

		return NULL;
	}

	CORBA_exception_free (&ev);

	obj = gnome_object_activate_servant (GNOME_OBJECT (factory), servant);
	if (obj == CORBA_OBJECT_NIL) {
		g_free (servant);

		return NULL;
	}

	gnome_object_construct (GNOME_OBJECT (factory), obj);

	return factory;
}

/**
 * pas_book_factory_new:
 */
PASBookFactory *
pas_book_factory_new (void)
{
	PASBookFactory *factory;
	PASBookFactory *retval;

	factory = gtk_type_new (PAS_BOOK_FACTORY_TYPE);

	retval = pas_book_factory_construct (factory);

	if (retval == NULL) {
		g_warning ("pas_book_factoy_new: Could not construct PASBookFactory!\n");
		gtk_object_unref (GTK_OBJECT (factory));

		return NULL;
	}

	return retval;
}

static void
pas_book_factory_init (PASBookFactory *factory)
{
	factory->priv = g_new0 (PASBookFactoryPrivate, 1);

	factory->priv->active_server_map = g_hash_table_new (g_str_hash, g_str_equal);
	factory->priv->backends          = g_hash_table_new (g_str_hash, g_str_equal);
	factory->priv->queued_requests   = NULL;
	factory->priv->queued_responses  = NULL;

	g_idle_add ((GSourceFunc) pas_book_factory_process_queues, factory);
}

static gboolean
pas_book_factory_remove_asm_entry (gpointer key, gpointer value,
				   gpointer data)
{
	CORBA_Environment ev;

	g_free (key);

	CORBA_exception_init (&ev);
	CORBA_Object_release ((CORBA_Object) value, &ev);
	CORBA_exception_free (&ev);

	return TRUE;
}

static gboolean
pas_book_factory_remove_backend_entry (gpointer key, gpointer value,
				       gpointer data)
{
	g_free (key);
	return TRUE;
}

static void
pas_book_factory_destroy (GtkObject *object)
{
	PASBookFactory *factory = PAS_BOOK_FACTORY (object);
	GList          *l;

	for (l = factory->priv->queued_requests; l != NULL; l = l->next) {
		PASBookFactoryQueuedRequest *request = l->data;
		CORBA_Environment ev;

		g_free (request->uri);

		CORBA_exception_init (&ev);
		CORBA_Object_release (request->listener, &ev);
		CORBA_exception_free (&ev);

		g_free (request);
	}
	g_list_free (factory->priv->queued_requests);
	factory->priv->queued_requests = NULL;

	for (l = factory->priv->queued_responses; l != NULL; l = l->next) {
		PASBookFactoryQueuedResponse *response = l->data;
		CORBA_Environment ev;

		CORBA_exception_init (&ev);
		CORBA_Object_release (response->listener, &ev);
		CORBA_exception_free (&ev);

		g_free (response);
	}
	g_list_free (factory->priv->queued_responses);
	factory->priv->queued_responses = NULL;

	g_hash_table_foreach_remove (factory->priv->active_server_map,
				     pas_book_factory_remove_asm_entry,
				     NULL);
	g_hash_table_destroy (factory->priv->active_server_map);

	g_hash_table_foreach_remove (factory->priv->backends,
				     pas_book_factory_remove_backend_entry,
				     NULL);
	g_hash_table_destroy (factory->priv->backends);
	
	g_free (factory->priv);

	GTK_OBJECT_CLASS (pas_book_factory_parent_class)->destroy (object);
}

static POA_Evolution_BookFactory__epv *
pas_book_factory_get_epv (void)
{
	POA_Evolution_BookFactory__epv *epv;

	epv = g_new0 (POA_Evolution_BookFactory__epv, 1);

	epv->open_book = impl_Evolution_BookFactory_open_book;

	return epv;
	
}

static void
pas_book_factory_corba_class_init (void)
{
	pas_book_factory_vepv.GNOME_Unknown_epv         = gnome_object_get_epv ();
	pas_book_factory_vepv.Evolution_BookFactory_epv = pas_book_factory_get_epv ();
}

static void
pas_book_factory_class_init (PASBookFactoryClass *klass)
{
	GtkObjectClass *object_class = (GtkObjectClass *) klass;

	pas_book_factory_parent_class = gtk_type_class (gnome_object_get_type ());

	object_class->destroy = pas_book_factory_destroy;

	pas_book_factory_corba_class_init ();
}

/**
 * pas_book_factory_get_type:
 */
GtkType
pas_book_factory_get_type (void)
{
	static GtkType type = 0;

	if (! type) {
		GtkTypeInfo info = {
			"PASBookFactory",
			sizeof (PASBookFactory),
			sizeof (PASBookFactoryClass),
			(GtkClassInitFunc)  pas_book_factory_class_init,
			(GtkObjectInitFunc) pas_book_factory_init,
			NULL, /* reserved 1 */
			NULL, /* reserved 2 */
			(GtkClassInitFunc) NULL
		};

		type = gtk_type_unique (gnome_object_get_type (), &info);
	}

	return type;
}