/*

 * e-contact-photo-source.c

 *

 * 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.

 *

 * 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 Lesser General Public License

 * along with this program; if not, see <http://www.gnu.org/licenses/>.

 *

 */

#include "e-contact-photo-source.h"

#define E_CONTACT_PHOTO_SOURCE_GET_PRIVATE(obj) \

	(G_TYPE_INSTANCE_GET_PRIVATE \

	((obj), E_TYPE_CONTACT_PHOTO_SOURCE, EContactPhotoSourcePrivate))

typedef struct _AsyncContext AsyncContext;

struct _EContactPhotoSourcePrivate {

	EClientCache *client_cache;

	ESource *source;

};

struct _AsyncContext {

	EBookClient *client;

	gchar *query_string;

	GInputStream *stream;

	GCancellable *cancellable;

	gint priority;

};

enum {

	PROP_0,

	PROP_CLIENT_CACHE,

	PROP_SOURCE

};

/* Forward Declarations */

static void	e_contact_photo_source_interface_init

					(EPhotoSourceInterface *iface);

G_DEFINE_DYNAMIC_TYPE_EXTENDED (

	EContactPhotoSource,

	e_contact_photo_source,

	G_TYPE_OBJECT,

	0,

	G_IMPLEMENT_INTERFACE_DYNAMIC (

		E_TYPE_PHOTO_SOURCE,

		e_contact_photo_source_interface_init))

static void

async_context_free (AsyncContext *async_context)

{

	g_clear_object (&async_context->client);

	g_free (async_context->query_string);

	g_clear_object (&async_context->stream);

	g_clear_object (&async_context->cancellable);

	g_slice_free (AsyncContext, async_context);

}

static EContactPhoto *

contact_photo_source_extract_photo (EContact *contact,

                                    gint *out_priority)

{

	EContactPhoto *photo;

	photo = e_contact_get (contact, E_CONTACT_PHOTO);

	*out_priority = G_PRIORITY_HIGH;

	if (photo == NULL) {

		photo = e_contact_get (contact, E_CONTACT_LOGO);

		*out_priority = G_PRIORITY_LOW;

	}

	return photo;

}

static void

contact_photo_source_get_photo_thread (GSimpleAsyncResult *simple,

                                       GObject *source_object,

                                       GCancellable *cancellable)

{

	AsyncContext *async_context;

	GSList *slist = NULL;

	GSList *slink;

	GError *error = NULL;

	async_context = g_simple_async_result_get_op_res_gpointer (simple);

	e_book_client_get_contacts_sync (

		async_context->client,

		async_context->query_string,

		&slist, cancellable, &error);

	if (error != NULL) {

		g_warn_if_fail (slist == NULL);

		g_simple_async_result_take_error (simple, error);

		return;

	}

	/* See if any of the contacts have a photo. */

	for (slink = slist; slink != NULL; slink = g_slist_next (slink)) {

		EContact *contact = E_CONTACT (slink->data);

		GInputStream *stream = NULL;

		EContactPhoto *photo;

		photo = contact_photo_source_extract_photo (

			contact, &async_context->priority);

		if (photo == NULL)

			continue;

		/* Stream takes ownership of the inlined data. */

		if (photo->type == E_CONTACT_PHOTO_TYPE_INLINED) {

			stream = g_memory_input_stream_new_from_data (

				photo->data.inlined.data,

				photo->data.inlined.length,

				(GDestroyNotify) g_free);

			photo->data.inlined.data = NULL;

			photo->data.inlined.length = 0;

		} else {

			GFileInputStream *file_stream;

			GFile *file;

			file = g_file_new_for_uri (photo->data.uri);

			/* Disregard errors and proceed as

			 * though the contact has no photo. */

			/* XXX Return type should have been GInputStream. */

			file_stream = g_file_read (file, cancellable, NULL);

			if (file_stream != NULL)

				stream = G_INPUT_STREAM (file_stream);

			g_object_unref (file);

		}

		e_contact_photo_free (photo);

		/* Stop on the first input stream. */

		if (stream != NULL) {

			async_context->stream = g_object_ref (stream);

			g_object_unref (stream);

			break;

		}

	}

	g_slist_free_full (slist, (GDestroyNotify) g_object_unref);

}

static void

contact_photo_source_get_client_cb (GObject *source_object,

                                    GAsyncResult *result,

                                    gpointer user_data)

{

	GSimpleAsyncResult *simple;

	AsyncContext *async_context;

	EClient *client;

	GError *error = NULL;

	simple = G_SIMPLE_ASYNC_RESULT (user_data);

	async_context = g_simple_async_result_get_op_res_gpointer (simple);

	client = e_client_cache_get_client_finish (

		E_CLIENT_CACHE (source_object), result, &error);

	/* Sanity check. */

	g_return_if_fail (

		((client != NULL) && (error == NULL)) ||

		((client == NULL) && (error != NULL)));

	if (client != NULL) {

		async_context->client = g_object_ref (client);

		/* The rest of the operation we can run from a

		 * worker thread to keep the logic flow simple. */

		g_simple_async_result_run_in_thread (

			simple, contact_photo_source_get_photo_thread,

			G_PRIORITY_DEFAULT, async_context->cancellable);

		g_object_unref (client);

	} else {

		g_simple_async_result_take_error (simple, error);

		g_simple_async_result_complete_in_idle (simple);

	}

	g_object_unref (simple);

}

static void

contact_photo_source_set_client_cache (EContactPhotoSource *photo_source,

                                       EClientCache *client_cache)

{

	g_return_if_fail (E_IS_CLIENT_CACHE (client_cache));

	g_return_if_fail (photo_source->priv->client_cache == NULL);

	photo_source->priv->client_cache = g_object_ref (client_cache);

}

static void

contact_photo_source_set_source (EContactPhotoSource *photo_source,

                                 ESource *source)

{

	g_return_if_fail (E_IS_SOURCE (source));

	g_return_if_fail (photo_source->priv->source == NULL);

	photo_source->priv->source = g_object_ref (source);

}

static void

contact_photo_source_set_property (GObject *object,

                                   guint property_id,

                                   const GValue *value,

                                   GParamSpec *pspec)

{

	switch (property_id) {

		case PROP_CLIENT_CACHE:

			contact_photo_source_set_client_cache (

				E_CONTACT_PHOTO_SOURCE (object),

				g_value_get_object (value));

			return;

		case PROP_SOURCE:

			contact_photo_source_set_source (

				E_CONTACT_PHOTO_SOURCE (object),

				g_value_get_object (value));

			return;

	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

}

static void

contact_photo_source_get_property (GObject *object,

                                   guint property_id,

                                   GValue *value,

                                   GParamSpec *pspec)

{

	switch (property_id) {

		case PROP_CLIENT_CACHE:

			g_value_take_object (

				value,

				e_contact_photo_source_ref_client_cache (

				E_CONTACT_PHOTO_SOURCE (object)));

			return;

		case PROP_SOURCE:

			g_value_take_object (

				value,

				e_contact_photo_source_ref_source (

				E_CONTACT_PHOTO_SOURCE (object)));

			return;

	}

	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

}

static void

contact_photo_source_dispose (GObject *object)

{

	EContactPhotoSourcePrivate *priv;

	priv = E_CONTACT_PHOTO_SOURCE_GET_PRIVATE (object);

	g_clear_object (&priv->client_cache);

	g_clear_object (&priv->source);

	/* Chain up to parent's dispose() method. */

	G_OBJECT_CLASS (e_contact_photo_source_parent_class)->dispose (object);

}

static void

contact_photo_source_get_photo (EPhotoSource *photo_source,

                                const gchar *email_address,

                                GCancellable *cancellable,

                                GAsyncReadyCallback callback,

                                gpointer user_data)

{

	GSimpleAsyncResult *simple;

	AsyncContext *async_context;

	EClientCache *client_cache;

	ESourceRegistry *registry;

	EBookQuery *book_query;

	ESource *source;

	book_query = e_book_query_field_test (

		E_CONTACT_EMAIL, E_BOOK_QUERY_IS, email_address);

	async_context = g_slice_new0 (AsyncContext);

	async_context->query_string = e_book_query_to_string (book_query);

	if (G_IS_CANCELLABLE (cancellable))

		async_context->cancellable = g_object_ref (cancellable);

	e_book_query_unref (book_query);

	simple = g_simple_async_result_new (

		G_OBJECT (photo_source), callback,

		user_data, contact_photo_source_get_photo);

	g_simple_async_result_set_check_cancellable (simple, cancellable);

	g_simple_async_result_set_op_res_gpointer (

		simple, async_context, (GDestroyNotify) async_context_free);

	client_cache = e_contact_photo_source_ref_client_cache (

		E_CONTACT_PHOTO_SOURCE (photo_source));

	registry = e_client_cache_ref_registry (client_cache);

	source = e_contact_photo_source_ref_source (

		E_CONTACT_PHOTO_SOURCE (photo_source));

	if (e_source_registry_check_enabled (registry, source)) {

		/* Obtain the EClient asynchronously.  If an instance needs

		 * to be created, it's more likely created in a thread with

		 * a main loop so signal emissions can work. */

		e_client_cache_get_client (

			client_cache, source,

			E_SOURCE_EXTENSION_ADDRESS_BOOK, (guint32) -1,

			cancellable,

			contact_photo_source_get_client_cb,

			g_object_ref (simple));

	} else {

		/* Return no result if the source is disabled. */

		g_simple_async_result_complete_in_idle (simple);

	}

	g_object_unref (client_cache);

	g_object_unref (registry);

	g_object_unref (source);

	g_object_unref (simple);

}

static gboolean

contact_photo_source_get_photo_finish (EPhotoSource *photo_source,

                                       GAsyncResult *result,

                                       GInputStream **out_stream,

                                       gint *out_priority,

                                       GError **error)

{

	GSimpleAsyncResult *simple;

	AsyncContext *async_context;

	g_return_val_if_fail (

		g_simple_async_result_is_valid (

		result, G_OBJECT (photo_source),

		contact_photo_source_get_photo), FALSE);

	simple = G_SIMPLE_ASYNC_RESULT (result);

	async_context = g_simple_async_result_get_op_res_gpointer (simple);

	if (g_simple_async_result_propagate_error (simple, error))

		return FALSE;

	if (async_context->stream != NULL) {

		*out_stream = g_object_ref (async_context->stream);

		if (out_priority != NULL)

			*out_priority = async_context->priority;

	} else {

		*out_stream = NULL;

	}

	return TRUE;

}

static void

e_contact_photo_source_class_init (EContactPhotoSourceClass *class)

{

	GObjectClass *object_class;

	g_type_class_add_private (class, sizeof (EContactPhotoSourcePrivate));

	object_class = G_OBJECT_CLASS (class);

	object_class->set_property = contact_photo_source_set_property;

	object_class->get_property = contact_photo_source_get_property;

	object_class->dispose = contact_photo_source_dispose;

	g_object_class_install_property (

		object_class,

		PROP_CLIENT_CACHE,

		g_param_spec_object (

			"client-cache",

			"Client Cache",

			"Cache of shared EClient instances",

			E_TYPE_CLIENT_CACHE,

			G_PARAM_READWRITE |

			G_PARAM_CONSTRUCT_ONLY));

	g_object_class_install_property (

		object_class,

		PROP_SOURCE,

		g_param_spec_object (

			"source",

			"Source",

			"An address book source",

			E_TYPE_SOURCE,

			G_PARAM_READWRITE |

			G_PARAM_CONSTRUCT_ONLY));

}

static void

e_contact_photo_source_class_finalize (EContactPhotoSourceClass *class)

{

}

static void

e_contact_photo_source_interface_init (EPhotoSourceInterface *iface)

{

	iface->get_photo = contact_photo_source_get_photo;

	iface->get_photo_finish = contact_photo_source_get_photo_finish;

}

static void

e_contact_photo_source_init (EContactPhotoSource *photo_source)

{

	photo_source->priv = E_CONTACT_PHOTO_SOURCE_GET_PRIVATE (photo_source);

}

void

e_contact_photo_source_type_register (GTypeModule *type_module)

{

	/* XXX G_DEFINE_DYNAMIC_TYPE declares a static type registration

	 *     function, so we have to wrap it with a public function in

	 *     order to register types from a separate compilation unit. */

	e_contact_photo_source_register_type (type_module);

}

EPhotoSource *

e_contact_photo_source_new (EClientCache *client_cache,

                            ESource *source)

{

	g_return_val_if_fail (E_IS_CLIENT_CACHE (client_cache), NULL);

	g_return_val_if_fail (E_IS_SOURCE (source), NULL);

	return g_object_new (

		E_TYPE_CONTACT_PHOTO_SOURCE,

		"client-cache", client_cache,

		"source", source,

		NULL);

}

EClientCache *

e_contact_photo_source_ref_client_cache (EContactPhotoSource *photo_source)

{

	g_return_val_if_fail (E_IS_CONTACT_PHOTO_SOURCE (photo_source), NULL);

	return g_object_ref (photo_source->priv->client_cache);

}

ESource *

e_contact_photo_source_ref_source (EContactPhotoSource *photo_source)

{

	g_return_val_if_fail (E_IS_CONTACT_PHOTO_SOURCE (photo_source), NULL);

	return g_object_ref (photo_source->priv->source);

}