/* Copyright (c) 2007, 2010 Christophe Fergeau  <teuf@gnome.org>
 * Part of the libgpod project.
 * 
 * URL: http://www.gtkpod.org/
 * URL: http://gtkpod.sourceforge.net/
 *
 * The code contained in this file 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; either version
 * 2.1 of the License, or (at your option) any later version.
 *
 * This file 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this code; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * iTunes and iPod are trademarks of Apple
 *
 * This product is not supported/written/published by Apple!
 *
 */
#include "config.h"
#include "backends.h"

#include <libhal.h>
#include <itdb_device.h>
#include <glib-object.h>
#include <string.h>

#define LIBGPOD_HAL_NS "org.libgpod."

struct _HalBackend {
	ItdbBackend parent;
	LibHalContext *ctx;
	char *udi;
};
typedef struct _HalBackend HalBackend;


static void hal_backend_destroy (ItdbBackend *itdb_backend)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
	g_free (backend->udi);
	libhal_ctx_free(backend->ctx);
	g_free (backend);
}

static gboolean
hal_backend_set_version (ItdbBackend *itdb_backend, unsigned int version)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
        libhal_device_set_property_int (backend->ctx, backend->udi, 
			                LIBGPOD_HAL_NS"version", 1, NULL);
	return TRUE;
}

static gboolean
hal_backend_set_is_unknown (ItdbBackend *itdb_backend, gboolean unknown)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
	libhal_device_set_property_bool (backend->ctx, backend->udi,
					 LIBGPOD_HAL_NS"ipod.is_unknown", 
					 TRUE, NULL);
	return TRUE;
}

static gboolean
hal_backend_set_icon_name (ItdbBackend *itdb_backend, const char *icon_name)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
	libhal_device_set_property_string (backend->ctx, backend->udi,
					   "info.desktop.icon",
					   icon_name, NULL);

	return TRUE;
}

static gboolean
hal_backend_set_firewire_id (ItdbBackend *itdb_backend, const char *fwid)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
     	libhal_device_set_property_string (backend->ctx, backend->udi,
					   LIBGPOD_HAL_NS"ipod.firewire_id",
					   fwid, NULL);
	return TRUE;
}

static gboolean
hal_backend_set_serial_number (ItdbBackend *itdb_backend, const char *serial_number)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_string (backend->ctx, backend->udi,
					   LIBGPOD_HAL_NS"ipod.serial_number",
					   serial_number,
					   NULL);
	return TRUE;
}

static gboolean hal_backend_set_firmware_version (ItdbBackend *itdb_backend,
						  const char *firmware_version)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_string (backend->ctx, backend->udi,
					   LIBGPOD_HAL_NS"ipod.firmware_version",
					   firmware_version,
					   NULL);
	return TRUE;
}

static gboolean
hal_backend_set_model_name (ItdbBackend *itdb_backend, const char *model_name)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_string (backend->ctx, backend->udi,
					   LIBGPOD_HAL_NS"ipod.model.device_class",
					   model_name,
					   NULL);
	return TRUE;
}

static gboolean
hal_backend_set_generation (ItdbBackend *itdb_backend, gdouble generation)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_double (backend->ctx, backend->udi,
					   LIBGPOD_HAL_NS"ipod.model.generation",
					   generation,
					   NULL);
	return TRUE;
}

static gboolean
hal_backend_set_color (ItdbBackend *itdb_backend, const char *color_name)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_string (backend->ctx, backend->udi,
					   LIBGPOD_HAL_NS"ipod.model.shell_color",
					   color_name,
					   NULL);
	return TRUE;
}

static gboolean
hal_backend_set_factory_id (ItdbBackend *itdb_backend,
			    const char *factory_id)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_string (backend->ctx, backend->udi,
					   LIBGPOD_HAL_NS"ipod.production.factory_id",
					   factory_id,
					   NULL);
	return TRUE;
}

static gboolean
hal_backend_set_production_year (ItdbBackend *itdb_backend, guint year)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_int (backend->ctx, backend->udi, 
					LIBGPOD_HAL_NS"ipod.production.year",
					year, NULL);
	return TRUE;
}

static gboolean 
hal_backend_set_production_week (ItdbBackend *itdb_backend, guint week)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_int (backend->ctx, backend->udi, 
					LIBGPOD_HAL_NS"ipod.production.week",
					week, NULL);
	return TRUE;
}

static gboolean
hal_backend_set_production_index (ItdbBackend *itdb_backend, guint index)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_int (backend->ctx, backend->udi, 
					LIBGPOD_HAL_NS"ipod.production.number",
					index, NULL);
	return TRUE;
}

static gboolean
hal_backend_set_control_path (ItdbBackend *itdb_backend, const char *control_path)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_string (backend->ctx, backend->udi,
					   LIBGPOD_HAL_NS"ipod.model.control_path",
					   control_path, NULL);
	return TRUE;
}

static gboolean
hal_backend_set_name (ItdbBackend *itdb_backend, const char *name)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	libhal_device_set_property_string (backend->ctx, backend->udi,
					   "info.desktop.name",
					   name, NULL);
	return TRUE;
}

static char *
get_format_string (const Itdb_ArtworkFormat *format, enum ArtworkType type)
{
	const char *format_name;
	const char *artwork_type;

	g_return_val_if_fail (format != NULL, NULL);
	switch (format->format) {
            case THUMB_FORMAT_UYVY_BE:
		    format_name = "iyuv";
		    break;
            case THUMB_FORMAT_RGB565_BE:
		    format_name = "rgb565_be";
		    break;		 
	    case THUMB_FORMAT_RGB565_LE:
		    format_name = "rgb565";
		    break;
	    case THUMB_FORMAT_I420_LE:
		    format_name = "iyuv420";
		    break;
	    default:
		    g_return_val_if_reached (NULL);
	}

	switch (type) {
            case UNKNOWN:
		    artwork_type = "unknown";
		    break;
            case PHOTO:
	            artwork_type = "photo";
		    break;
	    case ALBUM:
		    artwork_type = "album";
		    break;
	    case CHAPTER:
		    artwork_type = "chapter";
		    break;
	    default:
		    g_return_val_if_reached (NULL);
	}

	return g_strdup_printf ("corr_id=%u,width=%u,height=%u,rotation=%u,pixel_format=%s,image_type=%s",
  		                format->format_id, 
				format->width, format->height, 
			        format->rotation, format_name, artwork_type);
}

static gboolean hal_backend_set_artwork_type_supported (ItdbBackend *itdb_backend,
							enum ArtworkType type,
							gboolean supported)
{
	HalBackend *backend = (HalBackend *)itdb_backend;
    	char *propname;
	switch (type) {
	    case ALBUM:
		propname = LIBGPOD_HAL_NS"ipod.images.album_art_supported";
		break;
	    case PHOTO:
		propname = LIBGPOD_HAL_NS"ipod.images.photos_supported";
		break;
	    case CHAPTER:
		propname = LIBGPOD_HAL_NS"ipod.images.chapter_images_supported";
		break;
	    default:
		g_return_val_if_reached (FALSE);
	}
        libhal_device_set_property_bool (backend->ctx, backend->udi,
                                         propname, supported, NULL);
	return TRUE;
}

static gboolean hal_backend_set_artwork_formats (ItdbBackend *itdb_backend,
						 enum ArtworkType type,
						 const GList *formats)
{
	HalBackend *backend = (HalBackend *)itdb_backend;

	const GList *it;
	hal_backend_set_artwork_type_supported (itdb_backend, type,
					       	(formats != NULL));

        for (it = formats; it != NULL; it = it->next) {
                char *format_str;

                format_str = get_format_string (it->data, type);
                libhal_device_property_strlist_append (backend->ctx, backend->udi,
                                                       LIBGPOD_HAL_NS"ipod.images.formats",
                                                       format_str, 
                                                       NULL);
                g_free (format_str);
        }

	return TRUE;
}

/* taken from libipoddevice proper */
static ItdbBackend *hal_backend_new (void) 
{
	LibHalContext *hal_context;
	HalBackend *backend;
	const char *udi;
	DBusError error;
	DBusConnection *dbus_connection;

        udi = g_getenv ("UDI");
	if (udi == NULL) {
	    	return NULL;
	}

	hal_context = libhal_ctx_new();
	if(hal_context == NULL) {
		return NULL;
	}

	dbus_error_init(&error);
	dbus_connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
	if (dbus_error_is_set(&error)) {
		dbus_error_free(&error);
		libhal_ctx_free(hal_context);
		return NULL;
	}

	libhal_ctx_set_dbus_connection(hal_context, dbus_connection);

	if(!libhal_ctx_init(hal_context, &error)) {
		if (dbus_error_is_set(&error)) {
			dbus_error_free(&error);
		}
		libhal_ctx_free(hal_context);
		return NULL;
	}

	backend = g_new0 (HalBackend, 1);
	backend->ctx = hal_context;
	backend->udi = g_strdup (udi);

	backend->parent.destroy = hal_backend_destroy;
	backend->parent.set_version = hal_backend_set_version;
	backend->parent.set_is_unknown = hal_backend_set_is_unknown;
	backend->parent.set_icon_name = hal_backend_set_icon_name;
	backend->parent.set_firewire_id = hal_backend_set_firewire_id;
	backend->parent.set_serial_number = hal_backend_set_serial_number;
	backend->parent.set_firmware_version = hal_backend_set_firmware_version;
	backend->parent.set_model_name = hal_backend_set_model_name;
	backend->parent.set_generation = hal_backend_set_generation;
	backend->parent.set_color = hal_backend_set_color;
	backend->parent.set_factory_id = hal_backend_set_factory_id;
	backend->parent.set_production_year = hal_backend_set_production_year;
	backend->parent.set_production_week = hal_backend_set_production_week;
	backend->parent.set_production_index = hal_backend_set_production_index;
	backend->parent.set_control_path = hal_backend_set_control_path;
	backend->parent.set_name = hal_backend_set_name;
	backend->parent.set_artwork_formats = hal_backend_set_artwork_formats;

	return (ItdbBackend *)backend;
}

#ifdef HAVE_LIBUSB
static gboolean hal_get_ipod_usb_position (LibHalContext *ctx, const char *udi,
                                           int *usb_bus_number, int *usb_device_number)
{
	char *parent_udi;
	char *subsystem;
	gboolean found_ids;
	DBusError error;


	parent_udi = NULL;
	subsystem = NULL;
	found_ids = FALSE;
	dbus_error_init (&error);
	while (TRUE) {
		parent_udi = libhal_device_get_property_string (ctx, udi,
				"info.parent", &error);
		if (parent_udi == NULL || dbus_error_is_set (&error))
			goto end;
		udi = parent_udi;
		subsystem = libhal_device_get_property_string (ctx, udi,
							       "linux.subsystem",
							       &error);
		if (subsystem == NULL || dbus_error_is_set (&error)) {
			dbus_error_free (&error);
			dbus_error_init (&error);
			continue;
		}
		if (strcmp (subsystem, "usb") == 0) {
			*usb_bus_number = libhal_device_get_property_int (ctx, udi,
									  "usb.bus_number", &error);
			if (dbus_error_is_set (&error)) {
				goto end;
			}
			*usb_device_number = libhal_device_get_property_int (ctx, udi,
									     "usb.linux.device_number", &error);
			if (dbus_error_is_set (&error)) {
				goto end;
			}
			found_ids = TRUE;
			goto end;
		}
	}
end:
	libhal_free_string (parent_udi);
	libhal_free_string (subsystem);
	if (dbus_error_is_set (&error)) {
	    g_print ("Error: %s\n", error.message);
	    dbus_error_free (&error);
	}

	return found_ids;
}
#endif

int main (int argc, char **argv)
{
	ItdbBackend *backend;
	int result;
	const char *dev;
	const char *fstype;
        gint usb_bus_number = 0;
        gint usb_device_number = 0;
        HalBackend *hal_backend;

	g_type_init ();

	backend = hal_backend_new ();
        if (backend == NULL) {
                return -1;
        }

	dev = g_getenv ("HAL_PROP_BLOCK_DEVICE");
	if (dev == NULL) {
		return -1;
	}

        fstype = g_getenv ("HAL_PROP_VOLUME_FSTYPE");
        if (fstype == NULL) {
                return -1;
        }

        hal_backend = (HalBackend *)backend;
#ifdef HAVE_LIBUSB
        hal_get_ipod_usb_position (hal_backend->ctx, hal_backend->udi,
                                   &usb_bus_number, &usb_device_number);
#endif

	result = itdb_callout_set_ipod_properties (backend, dev,
                                                   usb_bus_number,
                                                   usb_device_number,
                                                   fstype);
	backend->destroy (backend);

	return result;
}