/*

 * /net/reactivated/Fprint/Manager object implementation

 * Copyright (C) 2008 Daniel Drake <dsd@gentoo.org>

 *

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

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#include <unistd.h>

#include <stdlib.h>

#include <dbus/dbus-glib-bindings.h>

#include <glib.h>

#include <glib/gi18n.h>

#include <fprint.h>

#include <glib-object.h>

#include "fprintd.h"

DBusGConnection *fprintd_dbus_conn;

static gboolean fprint_manager_get_devices(FprintManager *manager,

	GPtrArray **devices, GError **error);

static gboolean fprint_manager_get_default_device(FprintManager *manager,

	const char **device, GError **error);

#include "manager-dbus-glue.h"

static GObjectClass *parent_class = NULL;

G_DEFINE_TYPE(FprintManager, fprint_manager, G_TYPE_OBJECT);

typedef struct

{

	FpContext *context;

	GSList *dev_registry;

	gboolean no_timeout;

	guint timeout_id;

} FprintManagerPrivate;

#define FPRINT_MANAGER_GET_PRIVATE(o)  \

	(G_TYPE_INSTANCE_GET_PRIVATE ((o), FPRINT_TYPE_MANAGER, FprintManagerPrivate))

static void fprint_manager_finalize(GObject *object)

{

	FprintManagerPrivate *priv = FPRINT_MANAGER_GET_PRIVATE (object);

	g_slist_free(priv->dev_registry);

	G_OBJECT_CLASS(parent_class)->finalize(object);

}

static void fprint_manager_class_init(FprintManagerClass *klass)

{

	dbus_g_object_type_install_info(FPRINT_TYPE_MANAGER,

					&dbus_glib_fprint_manager_object_info);

	dbus_g_error_domain_register (FPRINT_ERROR, FPRINT_ERROR_DBUS_INTERFACE, FPRINT_TYPE_ERROR);

	g_type_class_add_private ((GObjectClass *) klass, sizeof (FprintManagerPrivate));

	G_OBJECT_CLASS(klass)->finalize = fprint_manager_finalize;

	parent_class = g_type_class_peek_parent(klass);

}

static gchar *get_device_path(FprintDevice *rdev)

{

	return g_strdup_printf("/net/reactivated/Fprint/Device/%d",

		_fprint_device_get_id(rdev));

}

static gboolean

fprint_manager_timeout_cb (FprintManager *manager)

{

	//FIXME kill all the devices

	exit(0);

	return FALSE;

}

static void

fprint_manager_in_use_notified (FprintDevice *rdev, GParamSpec *spec, FprintManager *manager)

{

	FprintManagerPrivate *priv = FPRINT_MANAGER_GET_PRIVATE (manager);

	guint num_devices_used = 0;

	GSList *l;

	gboolean in_use;

	if (priv->timeout_id > 0) {

		g_source_remove (priv->timeout_id);

		priv->timeout_id = 0;

	}

	if (priv->no_timeout)

		return;

	for (l = priv->dev_registry; l != NULL; l = l->next) {

		FprintDevice *dev = l->data;

		g_object_get (G_OBJECT(dev), "in-use", &in_use, NULL);

		if (in_use != FALSE)

			num_devices_used++;

	}

	if (num_devices_used == 0)

		priv->timeout_id = g_timeout_add_seconds (TIMEOUT, (GSourceFunc) fprint_manager_timeout_cb, manager);

}

static void

device_added_cb (FprintManager *manager, FpDevice *device, FpContext *context)

{

	FprintManagerPrivate *priv = FPRINT_MANAGER_GET_PRIVATE (manager);

	FprintDevice *rdev = fprint_device_new(device);

	g_autofree gchar *path = NULL;

	g_signal_connect (G_OBJECT(rdev), "notify::in-use",

			  G_CALLBACK (fprint_manager_in_use_notified), manager);

	priv->dev_registry = g_slist_prepend (priv->dev_registry, rdev);

	path = get_device_path (rdev);

	dbus_g_connection_register_g_object(fprintd_dbus_conn, path,

		G_OBJECT(rdev));

}

static void

device_removed_cb (FprintManager *manager, FpDevice *device, FpContext *context)

{

	FprintManagerPrivate *priv = FPRINT_MANAGER_GET_PRIVATE (manager);

	GSList *item;

	g_autofree gchar *path = NULL;

	for (item = priv->dev_registry; item; item = item->next) {

		FprintDevice *rdev;

		g_autoptr(FpDevice) dev = NULL;

		rdev = item->data;

		g_object_get (rdev, "dev", &dev, NULL);

		if (dev != device)

			continue;

		priv->dev_registry = g_slist_delete_link (priv->dev_registry, item);

		dbus_g_connection_unregister_g_object(fprintd_dbus_conn, G_OBJECT(rdev));

		g_signal_handlers_disconnect_by_data (rdev, manager);

		g_object_unref (rdev);

		/* We cannot continue to iterate at this point, but we don't need to either */

		break;

	}

	/* The device that disappeared might have been in-use.

	 * Do we need to do anything else in this case to clean up more gracefully? */

	fprint_manager_in_use_notified (NULL, NULL, manager);

}

static void

fprint_manager_init (FprintManager *manager)

{

	FprintManagerPrivate *priv = FPRINT_MANAGER_GET_PRIVATE (manager);

	GPtrArray *devices;

	priv->context = fp_context_new ();

	/* And register the signals for initial enumeration and hotplug. */

	g_signal_connect_object (priv->context,

				 "device-added",

				 (GCallback) device_added_cb,

				 manager,

				 G_CONNECT_SWAPPED);

	g_signal_connect_object (priv->context,

				 "device-removed",

				 (GCallback) device_removed_cb,

				 manager,

				 G_CONNECT_SWAPPED);

	/* Prepare everthing by enumerating all devices. */

	fp_context_enumerate (priv->context);

	dbus_g_connection_register_g_object(fprintd_dbus_conn,

		"/net/reactivated/Fprint/Manager", G_OBJECT(manager));

}

FprintManager *fprint_manager_new(gboolean no_timeout)

{

	FprintManagerPrivate *priv;

	GObject *object;

	object = g_object_new(FPRINT_TYPE_MANAGER, NULL);

	priv = FPRINT_MANAGER_GET_PRIVATE (object);

	priv->no_timeout = no_timeout;

	if (!priv->no_timeout)

		priv->timeout_id = g_timeout_add_seconds (TIMEOUT, (GSourceFunc) fprint_manager_timeout_cb, object);

	return FPRINT_MANAGER (object);

}

static gboolean fprint_manager_get_devices(FprintManager *manager,

	GPtrArray **devices, GError **error)

{

	FprintManagerPrivate *priv = FPRINT_MANAGER_GET_PRIVATE (manager);

	GSList *elem;

	GSList *l;

	int num_open;

	GPtrArray *devs;

	elem = g_slist_reverse(g_slist_copy(priv->dev_registry));

	num_open = g_slist_length(elem);

	devs = g_ptr_array_sized_new(num_open);

	if (num_open > 0) {

		for (l = elem; l != NULL; l = l->next) {

			FprintDevice *rdev = l->data;

			g_ptr_array_add(devs, get_device_path(rdev));

		}

	}

	g_slist_free(elem);

	*devices = devs;

	return TRUE;

}

static gboolean fprint_manager_get_default_device(FprintManager *manager,

	const char **device, GError **error)

{

	FprintManagerPrivate *priv = FPRINT_MANAGER_GET_PRIVATE (manager);

	GSList *elem;;

	int num_open;

	elem = priv->dev_registry;

	num_open = g_slist_length(elem);

	if (num_open > 0) {

		*device = get_device_path (g_slist_last (elem)->data);

		return TRUE;

	} else {

		g_set_error (error, FPRINT_ERROR, FPRINT_ERROR_NO_SUCH_DEVICE,

			     "No devices available");

		*device = NULL;

		return FALSE;

	}

}

GQuark fprint_error_quark(void)

{

	static GQuark quark = 0;

	if (!quark)

		quark = g_quark_from_static_string("fprintd-error-quark");

	return quark;

}

#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }

GType

fprint_error_get_type (void)

{

	static GType etype = 0;

	if (etype == 0) {

		static const GEnumValue values[] =

		{

			ENUM_ENTRY (FPRINT_ERROR_CLAIM_DEVICE, "ClaimDevice"),

			ENUM_ENTRY (FPRINT_ERROR_ALREADY_IN_USE, "AlreadyInUse"),

			ENUM_ENTRY (FPRINT_ERROR_INTERNAL, "Internal"),

			ENUM_ENTRY (FPRINT_ERROR_PERMISSION_DENIED, "PermissionDenied"),

			ENUM_ENTRY (FPRINT_ERROR_NO_ENROLLED_PRINTS, "NoEnrolledPrints"),

			ENUM_ENTRY (FPRINT_ERROR_NO_ACTION_IN_PROGRESS, "NoActionInProgress"),

			ENUM_ENTRY (FPRINT_ERROR_INVALID_FINGERNAME, "InvalidFingername"),

			ENUM_ENTRY (FPRINT_ERROR_NO_SUCH_DEVICE, "NoSuchDevice"),

			{ 0, 0, 0 }

		};

		etype = g_enum_register_static ("FprintError", values);

	}

	return etype;

}