/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

#include "ebook/e-book-async.h"

static GThread *worker_thread;
static GAsyncQueue *to_worker_queue;
static GAsyncQueue *from_worker_queue;

typedef struct _EBookMsg EBookMsg;

typedef void (*EBookMsgHandler)(EBookMsg* msg);
typedef void (*EBookMsgDtor)(EBookMsg* msg);

struct _EBookMsg {
	EBookMsgHandler handler;
	EBookMsgDtor dtor;
};

static gpointer
worker (gpointer data)
{
	while (TRUE) {
		EBookMsg *msg = g_async_queue_pop (to_worker_queue);
		msg->handler (msg);
		msg->dtor (msg);
	}

	return NULL;
}

static gboolean
main_thread_check_for_response (gpointer data)
{
	EBookMsg *msg;

	while ((msg = g_async_queue_try_pop (from_worker_queue)) != NULL) {
		msg->handler (msg);
		msg->dtor (msg);
	}
	
	return TRUE;
}

static void
e_book_msg_init (EBookMsg *msg, EBookMsgHandler handler, EBookMsgDtor dtor)
{
	msg->handler = handler;
	msg->dtor = dtor;
}

static void
init_async()
{
	static gboolean init_done = FALSE;
	if (!init_done) {
		init_done = TRUE;
		to_worker_queue = g_async_queue_new ();
		from_worker_queue = g_async_queue_new ();
		worker_thread = g_thread_create (worker, NULL, FALSE, NULL);
		g_timeout_add (300, main_thread_check_for_response, NULL);
	}
}



typedef struct {
	EBookMsg msg;

	EBook *book;
	char *uri;
	EBookCallback open_response;
	gpointer closure;
} LoadUriMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookStatus status;
	EBookCallback open_response;
	gpointer closure;
} LoadUriResponse;

static void
_load_uri_response_handler (EBookMsg *msg)
{
	LoadUriResponse *resp = (LoadUriResponse*)msg;

	resp->open_response (resp->book, resp->status, resp->closure);
}

static void
_load_uri_response_dtor (EBookMsg *msg)
{
	LoadUriResponse *resp = (LoadUriResponse*)msg;

	g_object_unref (resp->book);
	g_free (resp);
}

static void
_load_uri_handler (EBookMsg *msg)
{
	LoadUriMsg *uri_msg = (LoadUriMsg *)msg;
	LoadUriResponse *response;
	GError *error = NULL;

	response = g_new (LoadUriResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _load_uri_response_handler, _load_uri_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_load_uri (uri_msg->book, uri_msg->uri, FALSE, &error)) {
		response->status = error->code;
		g_error_free (error);
	}

	response->book = uri_msg->book;
	response->open_response = uri_msg->open_response;
	response->closure = uri_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

static void
_load_uri_dtor (EBookMsg *msg)
{
	LoadUriMsg *uri_msg = (LoadUriMsg *)msg;
	
	g_free (uri_msg->uri);
	g_free (uri_msg);
}

void
e_book_async_load_uri (EBook                 *book,
		       const char            *uri,
		       EBookCallback          open_response,
		       gpointer               closure)
{
	LoadUriMsg *msg;

	init_async ();

	msg = g_new (LoadUriMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _load_uri_handler, _load_uri_dtor);

	msg->book = g_object_ref (book);
	msg->uri = g_strdup (uri);
	msg->open_response = open_response;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);
}


void
e_book_async_unload_uri (EBook                 *book)
{
	e_book_unload_uri (book, NULL);
}




typedef struct {
	EBookMsg msg;

	EBookCallback open_response;
	gpointer closure;
} DefaultBookMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookStatus status;
	EBookCallback open_response;
	gpointer closure;
} DefaultBookResponse;

static void
_default_book_response_handler (EBookMsg *msg)
{
	LoadUriResponse *resp = (LoadUriResponse*)msg;

	resp->open_response (resp->book, resp->status, resp->closure);
}

static void
_default_book_response_dtor (EBookMsg *msg)
{
	LoadUriResponse *resp = (LoadUriResponse*)msg;

	g_object_unref (resp->book);
	g_free (resp);
}

static void
_default_book_handler (EBookMsg *msg)
{
	DefaultBookMsg *dfb_msg = (DefaultBookMsg *)msg;
	DefaultBookResponse *response;
	GError *error = NULL;

	response = g_new (DefaultBookResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _default_book_response_handler, _default_book_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_get_default_addressbook (&response->book, &error)) {
		response->status = error->code;
		g_error_free (error);
	}

	response->open_response = dfb_msg->open_response;
	response->closure = dfb_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

static void
_default_book_dtor (EBookMsg *msg)
{
	DefaultBookMsg *dfb_msg = (DefaultBookMsg *)msg;
	
	g_free (dfb_msg);
}

void
e_book_async_get_default_addressbook (EBookCallback open_response,
				      gpointer      closure)
{
	DefaultBookMsg *msg;

	init_async ();

	msg = g_new (DefaultBookMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _default_book_handler, _default_book_dtor);

	msg->open_response = open_response;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);
}



typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookFieldsCallback cb;
	gpointer closure;
} GetFieldsMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookStatus status;
	GList *fields;
	EBookFieldsCallback cb;
	gpointer closure;
} GetFieldsResponse;

static void
_get_fields_response_handler (EBookMsg *msg)
{
	GetFieldsResponse *resp = (GetFieldsResponse*)msg;
	GList *l;
	EList *fields = e_list_new ((EListCopyFunc) g_strdup, 
				    (EListFreeFunc) g_free,
				    NULL);

	for (l = resp->fields; l; l = l->next)
		e_list_append (fields, l->data);

	if (resp->cb)
		resp->cb (resp->book, resp->status, fields, resp->closure);

	g_object_unref (fields);
}

static void
_get_fields_response_dtor (EBookMsg *msg)
{
	GetFieldsResponse *resp = (GetFieldsResponse*)msg;

	g_list_foreach (resp->fields, (GFunc)g_free, NULL);
	g_list_free (resp->fields);
	g_object_unref (resp->book);
	g_free (resp);
}

static void
_get_fields_handler (EBookMsg *msg)
{
	GetFieldsMsg *fields_msg = (GetFieldsMsg *)msg;
	GetFieldsResponse *response;
	GError *error = NULL;

	response = g_new (GetFieldsResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _get_fields_response_handler, _get_fields_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_get_supported_fields (fields_msg->book, &response->fields, &error)) {
		response->status = error->code;
		g_error_free (error);
	}
	response->book = fields_msg->book;
	response->cb = fields_msg->cb;
	response->closure = fields_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

guint
e_book_async_get_supported_fields (EBook                 *book,
				   EBookFieldsCallback    cb,
				   gpointer               closure)
{
	GetFieldsMsg *msg;

	init_async ();

	msg = g_new (GetFieldsMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _get_fields_handler, (EBookMsgDtor)g_free);

	msg->book = g_object_ref (book);
	msg->cb = cb;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);

	return 0;
}



typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookAuthMethodsCallback cb;
	gpointer closure;
} GetMethodsMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookStatus status;
	GList *methods;
	EBookAuthMethodsCallback cb;
	gpointer closure;
} GetMethodsResponse;

static void
_get_methods_response_handler (EBookMsg *msg)
{
	GetMethodsResponse *resp = (GetMethodsResponse*)msg;
	GList *l;
	EList *methods = e_list_new ((EListCopyFunc) g_strdup, 
				    (EListFreeFunc) g_free,
				    NULL);

	for (l = resp->methods; l; l = l->next)
		e_list_append (methods, l->data);

	if (resp->cb)
		resp->cb (resp->book, resp->status, methods, resp->closure);

	g_object_unref (methods);
}

static void
_get_methods_response_dtor (EBookMsg *msg)
{
	GetMethodsResponse *resp = (GetMethodsResponse*)msg;

	g_list_foreach (resp->methods, (GFunc)g_free, NULL);
	g_list_free (resp->methods);
	g_object_unref (resp->book);
	g_free (resp);
}

static void
_get_methods_handler (EBookMsg *msg)
{
	GetMethodsMsg *methods_msg = (GetMethodsMsg *)msg;
	GetMethodsResponse *response;
	GError *error = NULL;

	response = g_new (GetMethodsResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _get_methods_response_handler, _get_methods_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_get_supported_auth_methods (methods_msg->book, &response->methods, &error)) {
		response->status = error->code;
		g_error_free (error);
	}

	response->book = methods_msg->book;
	response->cb = methods_msg->cb;
	response->closure = methods_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

guint
e_book_async_get_supported_auth_methods (EBook                    *book,
					 EBookAuthMethodsCallback  cb,
					 gpointer                  closure)
{
	GetMethodsMsg *msg;

	init_async ();

	msg = g_new (GetMethodsMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _get_methods_handler, (EBookMsgDtor)g_free);

	msg->book = g_object_ref (book);
	msg->cb = cb;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);

	return 0;
}



typedef struct {
	EBookMsg msg;

	EBook *book;
	char *user;
	char *passwd;
	char *auth_method;
	EBookCallback cb;
	gpointer closure;
} AuthUserMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookStatus status;
	EBookCallback cb;
	gpointer closure;
} AuthUserResponse;

static void
_auth_user_response_handler (EBookMsg *msg)
{
	AuthUserResponse *resp = (AuthUserResponse*)msg;

	if (resp->cb)
		resp->cb (resp->book, resp->status, resp->closure);
}

static void
_auth_user_response_dtor (EBookMsg *msg)
{
	AuthUserResponse *resp = (AuthUserResponse*)msg;

	g_object_unref (resp->book);
	g_free (resp);
}

static void
_auth_user_handler (EBookMsg *msg)
{
	AuthUserMsg *auth_msg = (AuthUserMsg *)msg;
	AuthUserResponse *response;
	GError *error = NULL;

	response = g_new (AuthUserResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _auth_user_response_handler, _auth_user_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_authenticate_user (auth_msg->book, auth_msg->user, auth_msg->passwd, auth_msg->auth_method, &error)) {
		response->status = error->code;
		g_error_free (error);
	}
	response->book = auth_msg->book;
	response->cb = auth_msg->cb;
	response->closure = auth_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

static void
_auth_user_dtor (EBookMsg *msg)
{
	AuthUserMsg *auth_msg = (AuthUserMsg *)msg;

	g_free (auth_msg->user);
	g_free (auth_msg->passwd);
	g_free (auth_msg->auth_method);

	g_free (auth_msg);
}

/* User authentication. */
void
e_book_async_authenticate_user (EBook                 *book,
				const char            *user,
				const char            *passwd,
				const char            *auth_method,
				EBookCallback         cb,
				gpointer              closure)
{
	AuthUserMsg *msg;

	init_async ();

	msg = g_new (AuthUserMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _auth_user_handler, _auth_user_dtor);

	msg->book = g_object_ref (book);
	msg->user = g_strdup (user);
	msg->passwd = g_strdup (passwd);
	msg->auth_method = g_strdup (auth_method);
	msg->cb = cb;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);
}



typedef struct {
	EBookMsg msg;

	EBook *book;
	char *id;
	EBookContactCallback cb;
	gpointer closure;
} GetContactMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EContact *contact;
	EBookStatus status;
	EBookContactCallback cb;
	gpointer closure;
} GetContactResponse;

static void
_get_contact_response_handler (EBookMsg *msg)
{
	GetContactResponse *resp = (GetContactResponse*)msg;

	if (resp->cb)
		resp->cb (resp->book, resp->status, resp->contact, resp->closure);
}

static void
_get_contact_response_dtor (EBookMsg *msg)
{
	GetContactResponse *resp = (GetContactResponse*)msg;

	g_object_unref (resp->contact);
	g_object_unref (resp->book);
	g_free (resp);
}

static void
_get_contact_handler (EBookMsg *msg)
{
	GetContactMsg *get_contact_msg = (GetContactMsg *)msg;
	GetContactResponse *response;
	GError *error = NULL;

	response = g_new (GetContactResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _get_contact_response_handler, _get_contact_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_get_contact (get_contact_msg->book, get_contact_msg->id, &response->contact, &error)) {
		response->status = error->code;
		g_error_free (error);
	}
	response->book = get_contact_msg->book;
	response->cb = get_contact_msg->cb;
	response->closure = get_contact_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

static void
_get_contact_dtor (EBookMsg *msg)
{
	GetContactMsg *get_contact_msg = (GetContactMsg *)msg;

	g_free (get_contact_msg->id);
	g_free (get_contact_msg);
}

/* Fetching contacts. */
guint
e_book_async_get_contact (EBook                 *book,
			  const char            *id,
			  EBookContactCallback   cb,
			  gpointer               closure)
{
	GetContactMsg *msg;

	init_async ();

	msg = g_new (GetContactMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _get_contact_handler, _get_contact_dtor);

	msg->book = g_object_ref (book);
	msg->id = g_strdup (id);
	msg->cb = cb;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);

	return 0;
}



/* Deleting cards. */
gboolean
e_book_async_remove_contact (EBook                 *book,
			     EContact              *contact,
			     EBookCallback          cb,
			     gpointer               closure)
{
	const char *id = e_contact_get_const (contact, E_CONTACT_UID);

	return e_book_async_remove_contact_by_id (book, id, cb, closure);
}

gboolean
e_book_async_remove_contact_by_id (EBook                 *book,
				const char            *id,
				EBookCallback          cb,
				gpointer               closure)
{
	GList *list = g_list_append (NULL, g_strdup (id));

	return e_book_async_remove_contacts (book, list, cb, closure);
}


typedef struct {
	EBookMsg msg;

	EBook *book;
	GList *id_list;
	EBookCallback cb;
	gpointer closure;
} RemoveContactsMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookStatus status;
	EBookCallback cb;
	gpointer closure;
} RemoveContactsResponse;

static void
_remove_contacts_response_handler (EBookMsg *msg)
{
	RemoveContactsResponse *resp = (RemoveContactsResponse*)msg;

	if (resp->cb)
		resp->cb (resp->book, resp->status, resp->closure);
}

static void
_remove_contacts_response_dtor (EBookMsg *msg)
{
	RemoveContactsResponse *resp = (RemoveContactsResponse*)msg;

	g_object_unref (resp->book);
	g_free (resp);
}

static void
_remove_contacts_handler (EBookMsg *msg)
{
	RemoveContactsMsg *remove_contacts_msg = (RemoveContactsMsg *)msg;
	RemoveContactsResponse *response;
	GError *error = NULL;

	response = g_new (RemoveContactsResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _remove_contacts_response_handler, _remove_contacts_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_remove_contacts (remove_contacts_msg->book, remove_contacts_msg->id_list, &error)) {
		response->status = error->code;
		g_error_free (error);
	}
	response->book = remove_contacts_msg->book;
	response->cb = remove_contacts_msg->cb;
	response->closure = remove_contacts_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

static void
_remove_contacts_dtor (EBookMsg *msg)
{
	RemoveContactsMsg *remove_contacts_msg = (RemoveContactsMsg *)msg;

	g_list_foreach (remove_contacts_msg->id_list, (GFunc)g_free, NULL);
	g_list_free (remove_contacts_msg->id_list);
	g_free (remove_contacts_msg);
}

gboolean
e_book_async_remove_contacts (EBook                 *book,
			   GList                 *id_list,
			   EBookCallback          cb,
			   gpointer               closure)
{
	RemoveContactsMsg *msg;
	GList *l;
	init_async ();

	msg = g_new (RemoveContactsMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _remove_contacts_handler, _remove_contacts_dtor);

	msg->book = g_object_ref (book);
	msg->id_list = g_list_copy (id_list);
	for (l = msg->id_list; l; l = l->next)
		l->data = g_strdup (l->data);
	msg->cb = cb;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);

	return 0;
}



/* Adding contacts. */
typedef struct {
	EBookMsg msg;

	EBook *book;
	EContact *contact;
	EBookIdCallback cb;
	gpointer closure;
} AddContactMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	char *id;
	EBookStatus status;
	EBookIdCallback cb;
	gpointer closure;
} AddContactResponse;

static void
_add_contact_response_handler (EBookMsg *msg)
{
	AddContactResponse *resp = (AddContactResponse*)msg;

	if (resp->cb)
		resp->cb (resp->book, resp->status, resp->id, resp->closure);
}

static void
_add_contact_response_dtor (EBookMsg *msg)
{
	AddContactResponse *resp = (AddContactResponse*)msg;

	g_object_unref (resp->book);
	g_free (resp->id);
	g_free (resp);
}

static void
_add_contact_handler (EBookMsg *msg)
{
	AddContactMsg *add_contact_msg = (AddContactMsg *)msg;
	AddContactResponse *response;
	GError *error = NULL;

	response = g_new (AddContactResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _add_contact_response_handler, _add_contact_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_add_contact (add_contact_msg->book, add_contact_msg->contact, &error)) {
		response->status = error->code;
		response->id = NULL;
		g_error_free (error);
	}
	else {
		response->id = e_contact_get (add_contact_msg->contact, E_CONTACT_UID);
	}
	response->book = add_contact_msg->book;
	response->cb = add_contact_msg->cb;
	response->closure = add_contact_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

static void
_add_contact_dtor (EBookMsg *msg)
{
	AddContactMsg *add_contact_msg = (AddContactMsg *)msg;

	g_object_unref (add_contact_msg->contact);
	g_free (add_contact_msg);
}

gboolean
e_book_async_add_contact (EBook                 *book,
			  EContact              *contact,
			  EBookIdCallback        cb,
			  gpointer               closure)
{
	AddContactMsg *msg;

	init_async ();

	msg = g_new (AddContactMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _add_contact_handler, _add_contact_dtor);

	msg->book = g_object_ref (book);
	msg->contact = g_object_ref (contact); /* XXX maybe we should _duplicate it here instead */
	msg->cb = cb;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);

	return TRUE;
}



/* Modifying cards. */
typedef struct {
	EBookMsg msg;

	EBook *book;
	EContact *contact;
	EBookCallback cb;
	gpointer closure;
} CommitContactMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookStatus status;
	EBookCallback cb;
	gpointer closure;
} CommitContactResponse;

static void
_commit_contact_response_handler (EBookMsg *msg)
{
	CommitContactResponse *resp = (CommitContactResponse*)msg;

	if (resp->cb)
		resp->cb (resp->book, resp->status, resp->closure);
}

static void
_commit_contact_response_dtor (EBookMsg *msg)
{
	CommitContactResponse *resp = (CommitContactResponse*)msg;

	g_object_unref (resp->book);
	g_free (resp);
}

static void
_commit_contact_handler (EBookMsg *msg)
{
	CommitContactMsg *commit_contact_msg = (CommitContactMsg *)msg;
	CommitContactResponse *response;
	GError *error = NULL;

	response = g_new (CommitContactResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _commit_contact_response_handler, _commit_contact_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_commit_contact (commit_contact_msg->book, commit_contact_msg->contact, &error)) {
		response->status = error->code;
		g_error_free (error);
	}
	response->book = commit_contact_msg->book;
	response->cb = commit_contact_msg->cb;
	response->closure = commit_contact_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

static void
_commit_contact_dtor (EBookMsg *msg)
{
	CommitContactMsg *commit_contact_msg = (CommitContactMsg *)msg;

	g_object_unref (commit_contact_msg->contact);
	g_free (commit_contact_msg);
}


gboolean
e_book_async_commit_contact (EBook                 *book,
			     EContact              *contact,
			     EBookCallback          cb,
			     gpointer               closure)
{
	CommitContactMsg *msg;

	init_async ();

	msg = g_new (CommitContactMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _commit_contact_handler, _commit_contact_dtor);

	msg->book = g_object_ref (book);
	msg->contact = g_object_ref (contact); /* XXX maybe we should _duplicate it here instead */
	msg->cb = cb;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);

	return TRUE;
}



typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookQuery *query;
	EBookBookViewCallback cb;
	gpointer closure;
} GetBookViewMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookStatus status;
	EBookView *book_view;
	EBookBookViewCallback cb;
	gpointer closure;
} GetBookViewResponse;

static void
_get_book_view_response_handler (EBookMsg *msg)
{
	GetBookViewResponse *resp = (GetBookViewResponse*)msg;

	if (resp->cb)
		resp->cb (resp->book, resp->status, resp->book_view, resp->closure);
}

static void
_get_book_view_response_dtor (EBookMsg *msg)
{
	GetBookViewResponse *resp = (GetBookViewResponse*)msg;

	g_object_unref (resp->book);
	g_object_unref (resp->book_view);
	g_free (resp);
}

static void
_get_book_view_handler (EBookMsg *msg)
{
	GetBookViewMsg *view_msg = (GetBookViewMsg *)msg;
	GetBookViewResponse *response;
	GError *error = NULL;

	response = g_new (GetBookViewResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _get_book_view_response_handler, _get_book_view_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_get_book_view (view_msg->book, view_msg->query, NULL, -1, &response->book_view, &error)) {
		response->status = error->code;
		g_error_free (error);
	}
	response->book = view_msg->book;
	response->cb = view_msg->cb;
	response->closure = view_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

static void
_get_book_view_dtor (EBookMsg *msg)
{
	GetBookViewMsg *view_msg = (GetBookViewMsg *)msg;
	
	e_book_query_unref (view_msg->query);
	g_free (view_msg);
}

guint
e_book_async_get_book_view (EBook                 *book,
			    const gchar           *query,
			    EBookBookViewCallback  cb,
			    gpointer               closure)
{
	GetBookViewMsg *msg;

	init_async ();

	msg = g_new (GetBookViewMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _get_book_view_handler, _get_book_view_dtor);

	msg->book = g_object_ref (book);
	msg->query = e_book_query_from_string (query);
	msg->cb = cb;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);

	return 0;
}



typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookQuery *query;
	EBookContactsCallback cb;
	gpointer closure;
} GetContactsMsg;

typedef struct {
	EBookMsg msg;

	EBook *book;
	EBookStatus status;
	GList *contacts;
	EBookContactsCallback cb;
	gpointer closure;
} GetContactsResponse;

static void
_get_contacts_response_handler (EBookMsg *msg)
{
	GetContactsResponse *resp = (GetContactsResponse*)msg;

	if (resp->cb)
		resp->cb (resp->book, resp->status, resp->contacts, resp->closure);
}

static void
_get_contacts_response_dtor (EBookMsg *msg)
{
	GetContactsResponse *resp = (GetContactsResponse*)msg;

	g_object_unref (resp->book);
	g_free (resp);
}

static void
_get_contacts_handler (EBookMsg *msg)
{
	GetContactsMsg *view_msg = (GetContactsMsg *)msg;
	GetContactsResponse *response;
	GError *error = NULL;

	response = g_new (GetContactsResponse, 1);
	e_book_msg_init ((EBookMsg*)response, _get_contacts_response_handler, _get_contacts_response_dtor);

	response->status = E_BOOK_ERROR_OK;
	if (!e_book_get_contacts (view_msg->book, view_msg->query, &response->contacts, &error)) {
		response->status = error->code;
		g_error_free (error);
	}
	response->book = view_msg->book;
	response->cb = view_msg->cb;
	response->closure = view_msg->closure;

	g_async_queue_push (from_worker_queue, response);
}

static void
_get_contacts_dtor (EBookMsg *msg)
{
	GetContactsMsg *view_msg = (GetContactsMsg *)msg;
	
	e_book_query_unref (view_msg->query);
	g_free (view_msg);
}

guint
e_book_async_get_contacts (EBook                 *book,
			   const gchar           *query,
			   EBookContactsCallback  cb,
			   gpointer              closure)
{
	GetContactsMsg *msg;

	init_async ();

	msg = g_new (GetContactsMsg, 1);
	e_book_msg_init ((EBookMsg*)msg, _get_contacts_handler, _get_contacts_dtor);

	msg->book = g_object_ref (book);
	msg->query = e_book_query_from_string (query);
	msg->cb = cb;
	msg->closure = closure;

	g_async_queue_push (to_worker_queue, msg);

	return 0;
}