/*
 * This file is part of roccat-tools.
 *
 * roccat-tools 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.
 *
 * roccat-tools 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 roccat-tools. If not, see <http://www.gnu.org/licenses/>.
 */

#include "kone_eventhandler.h"
#include "kone_eventhandler_channel.h"
#include "kone_dbus_server.h"
#include "roccat/kone.h"
#include "config.h"
#include <glib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <linux/input.h>

#define KONE_EVENTHANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), KONE_EVENTHANDLER_TYPE, KoneEventhandlerClass))
#define IS_KONE_EVENTHANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), KONE_EVENTHANDLER_TYPE))
#define KONE_EVENTHANDLER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), KONE_EVENTHANDLER_TYPE, KoneEventhandlerPrivate))

typedef struct _KoneEventhandlerClass KoneEventhandlerClass;

struct _KoneEventhandlerClass {
	GObjectClass parent_class;
};

struct _KoneEventhandlerPrivate {
	RoccatEventhandlerHost *host;
	KoneDBusServer *dbus_server;
	RoccatDeviceScanner *device_scanner;
	RoccatDevice *device;
	gboolean device_set_up;
	RoccatKeyFile *config;
	guint actual_profile_index;
	KoneRMP *rmp[KONE_PROFILE_NUM];
	KoneEventhandlerChannel *channel;
	
	/*
	 * FIXME notificator für Fehlermeldungen verwenden,
	 * notificator refaktorisieren und Basis für beides verwenden oder
	 * Eigene Implementierung eines Fehlernotificators
	 */
	RoccatNotificationProfile *profile_note;
	RoccatNotificationCpi *cpi_note;

	int kbd_dev;
	int mouse_dev;
	int misc_dev;
	RoccatMacroThreads *threads;
};

enum {
	PROP_0,
	PROP_HOST,
};

static void profile_osd(KoneEventhandler *eventhandler, guint profile_number) {
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	guint profile_index = profile_number - 1;
	
	roccat_notification_profile_update(priv->profile_note, kone_configuration_get_profile_notification_type(priv->config),
			profile_number, kone_rmp_get_profile_name(priv->rmp[profile_index]));
}

static void profile_changed(KoneEventhandler *eventhandler, guint profile_number) {
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	guint profile_index = profile_number - 1;

	priv->actual_profile_index = profile_index;

	profile_osd(eventhandler, profile_number);

	kone_dbus_server_emit_profile_changed(priv->dbus_server, profile_number);
}

static gboolean set_profile(KoneEventhandler *eventhandler, guint profile_number) {
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	guint profile_index = profile_number - 1;
	GError *local_error = NULL;

	if (priv->actual_profile_index != profile_index) {
		if (!kone_profile_activate(priv->device, profile_number, &local_error)) {
			// FIXME error message
			g_clear_error(&local_error);
			return FALSE;
		}
		profile_changed(eventhandler, profile_number);
	}
	return TRUE;
}

static void window_changed_cb(RoccatEventhandlerHost *host, gchar const *title, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	guint profile_index;
	gchar *pattern;

	for (profile_index = 0; profile_index < KONE_PROFILE_NUM; ++profile_index) {
		pattern = kone_rmp_get_game_file_name(priv->rmp[profile_index]);
		if (strcmp(pattern, "") == 0) {
			g_free(pattern);
			continue;
		}

		if (g_regex_match_simple(pattern, title, 0, 0)) {
			set_profile(eventhandler, profile_index + 1);
			g_free(pattern);
			return;
		}
		g_free(pattern);
	}

	set_profile(eventhandler, kone_configuration_get_default_profile_number(priv->config));
	return;
}

static guint kone_eventhandler_get_talk_device(RoccatEventhandlerPlugin *self) {
	return 0;
}

static void kone_roccat_eventhandler_interface_init(RoccatEventhandlerPluginInterface *iface) {
	iface->get_talk_device = kone_eventhandler_get_talk_device;
	iface->talk_easyshift = NULL;
	iface->talk_easyshift_lock = NULL;
	iface->talk_easyaim = NULL;
	iface->set_led_rgb = NULL;
	iface->restore_led_rgb = NULL;
}

G_DEFINE_TYPE_WITH_CODE(KoneEventhandler, kone_eventhandler, G_TYPE_OBJECT,
		G_IMPLEMENT_INTERFACE(ROCCAT_EVENTHANDLER_PLUGIN_TYPE, kone_roccat_eventhandler_interface_init));

GObject *kone_eventhandler_new(RoccatEventhandlerHost *host) {
	return g_object_new(KONE_EVENTHANDLER_TYPE,
			"host", host,
			NULL);
}

static void open_gui_cb(gpointer source, gpointer user_data) {
	gchar *path;
	path = g_build_path("/", INSTALL_PREFIX, "bin", "koneconfig", (gchar const *)NULL);
	roccat_double_fork(path);
	g_free(path);
}

static void profile_data_changed_outside_cb(KoneDBusServer *server, guchar profile_number, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	guint profile_index = profile_number - 1;

	/* Just load rmp without updating data from hardware */
	kone_rmp_free(priv->rmp[profile_index]);
	priv->rmp[profile_index] = kone_rmp_load_actual(profile_number);
}

static void configuration_reload(KoneEventhandler *eventhandler) {
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	if (priv->config)
		kone_configuration_free(priv->config);
	priv->config = kone_configuration_load();
}

static void configuration_changed_outside_cb(KoneDBusServer *server, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	configuration_reload(eventhandler);
}

static void cpi_osd(KoneEventhandler *eventhandler, guchar cpi_raw) {
	KoneEventhandlerPrivate *priv = eventhandler->priv;

	roccat_notification_cpi_update(priv->cpi_note,
			kone_configuration_get_cpi_notification_type(priv->config),
			kone_dpi_raw_to_dpi(cpi_raw));
}

static void cpi_osd_cb(KoneEventhandlerChannel *channel, guchar cpi_raw, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	cpi_osd(eventhandler, cpi_raw);
}

static void cpi_changed_cb(KoneEventhandlerChannel *channel, guchar cpi_raw, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	KoneEventhandlerPrivate *priv = eventhandler->priv;

	if (!kone_configuration_get_only_notify_on_osd(priv->config))
		cpi_osd(eventhandler, cpi_raw);
}

static void profile_osd_cb(gpointer source, guchar profile_number, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	profile_osd(eventhandler, profile_number);
}

static void profile_changed_cb(gpointer source, guchar profile_number, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	profile_changed(eventhandler, profile_number);
}

static void multimedia_cb(KoneEventhandlerChannel *channel, guchar button_type, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	KoneEventhandlerPrivate *priv = eventhandler->priv;

	switch (button_type) {
	case KONE_BUTTON_INFO_TYPE_MULTIMEDIA_NEXT_TRACK:
		roccat_input_event_write_single(priv->misc_dev, KEY_NEXTSONG);
		break;
	case KONE_BUTTON_INFO_TYPE_MULTIMEDIA_PREV_TRACK:
		roccat_input_event_write_single(priv->misc_dev, KEY_PREVIOUSSONG);
		break;
	case KONE_BUTTON_INFO_TYPE_MULTIMEDIA_PLAY_PAUSE:
		roccat_input_event_write_single(priv->misc_dev, KEY_PLAYPAUSE);
		break;
	case KONE_BUTTON_INFO_TYPE_MULTIMEDIA_STOP:
		roccat_input_event_write_single(priv->misc_dev, KEY_STOPCD);
		break;
	case KONE_BUTTON_INFO_TYPE_MULTIMEDIA_MUTE:
		roccat_input_event_write_single(priv->misc_dev, KEY_MUTE);
		break;
	case KONE_BUTTON_INFO_TYPE_MULTIMEDIA_VOLUME_UP:
		roccat_input_event_write_single(priv->misc_dev, KEY_VOLUMEUP);
		break;
	case KONE_BUTTON_INFO_TYPE_MULTIMEDIA_VOLUME_DOWN:
		roccat_input_event_write_single(priv->misc_dev, KEY_VOLUMEDOWN);
		break;
	default:
		g_debug("unsupported multimedia event of type 0x%02x", button_type);
		break;
	}
}

static void macro_cb(KoneEventhandlerChannel *channel, guchar key_number, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	KoneRMPButtonInfo *button_info;
	RoccatMacro *roccat_macro;
	
	button_info = kone_rmp_get_rmp_button_info(priv->rmp[priv->actual_profile_index], key_number - 1);
	roccat_macro = kone_rmp_button_info_to_roccat_macro(button_info);
	g_free(button_info);
	roccat_play_macro_threaded(priv->threads, key_number - 1, priv->kbd_dev, priv->mouse_dev, roccat_macro);
	roccat_macro_free(roccat_macro);
}

static gboolean profile_data_load(KoneEventhandler *eventhandler, GError **error) {
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	guint i;

	for (i = 0; i < KONE_PROFILE_NUM; ++i) {
		priv->rmp[i] = kone_rmp_load(priv->device, i + 1, error);
		if (priv->rmp[i] == NULL)
			return FALSE;
	}
	return TRUE;
}

static gboolean add_cb(RoccatDevice *device, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	GError *error = NULL;

	if (priv->device) {
		g_critical("Multiple devices present.");
		return TRUE;
	}

	priv->device = device;

	configuration_reload(eventhandler);

	/* Notificator gets initialized only once if a device is found.
	 * Gets deinited once in finalizer.
	 */
	if (!priv->profile_note)
		priv->profile_note = roccat_notification_profile_new(roccat_eventhandler_host_get_notificator(priv->host), KONE_DEVICE_NAME);
	if (!priv->cpi_note)
		priv->cpi_note = roccat_notification_cpi_new(roccat_eventhandler_host_get_notificator(priv->host), KONE_DEVICE_NAME);
	
	priv->actual_profile_index = kone_actual_profile_read(priv->device, &error) - 1;
	if (error) {
		g_warning("Error reading actual profile: %s", error->message);
		g_clear_error(&error);
	}
	
	priv->kbd_dev = roccat_device_open_keyboard_evdev(priv->device);
	if (priv->kbd_dev == -1)
		g_critical("Can't play keyboard events.");

	priv->mouse_dev = roccat_device_open_mouse_evdev(priv->device);
	if (priv->mouse_dev == -1)
		g_critical("Can't play mouse events.");

	priv->misc_dev = roccat_device_open_misc_evdev(priv->device);
	if (priv->misc_dev == -1)
		g_critical("Can't play multimedia events.");

	profile_data_load(eventhandler, &error);
	if (error) {
		g_warning("Error reading profile data: %s", error->message);
		g_clear_error(&error);
	}

	// FIXME create in init and just disconnect/reconnect?
	priv->dbus_server = kone_dbus_server_new();
	kone_dbus_server_connect(priv->dbus_server);
	g_signal_connect(G_OBJECT(priv->dbus_server), "open-gui", G_CALLBACK(open_gui_cb), eventhandler);
	g_signal_connect(G_OBJECT(priv->dbus_server), "profile-changed-outside", G_CALLBACK(profile_changed_cb), eventhandler);
	g_signal_connect(G_OBJECT(priv->dbus_server), "profile-data-changed-outside", G_CALLBACK(profile_data_changed_outside_cb), eventhandler);
	g_signal_connect(G_OBJECT(priv->dbus_server), "configuration-changed-outside", G_CALLBACK(configuration_changed_outside_cb), eventhandler);

	priv->threads = roccat_macro_threads_new(KONE_BUTTON_INFO_NUM);

	g_signal_connect(G_OBJECT(priv->host), "active-window-changed", G_CALLBACK(window_changed_cb), eventhandler);
	
	kone_eventhandler_channel_start(priv->channel, roccat_device_get_roccat_dev(priv->device), &error);
	if (error) {
		g_warning("Error starting chardev eventhandler: %s", error->message);
		g_clear_error(&error);
	}

	priv->device_set_up = TRUE;

	return FALSE;
}

static void stop(KoneEventhandler *eventhandler) {
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	guint i;

	priv->device_set_up = FALSE;

	g_object_unref(priv->dbus_server);
	priv->dbus_server = NULL;

	kone_eventhandler_channel_stop(priv->channel);

	roccat_macro_threads_free(priv->threads);
	priv->threads = NULL;
	
	if (priv->kbd_dev != -1)
		close(priv->kbd_dev);

	if (priv->mouse_dev != -1)
		close(priv->mouse_dev);

	if (priv->misc_dev != -1)
		roccat_device_close_misc_evdev(priv->misc_dev);

	roccat_device_free(priv->device);
	priv->device = NULL;

	kone_configuration_free(priv->config);
	priv->config = NULL;

	for (i = 0; i < KONE_PROFILE_NUM; ++i) {
		kone_rmp_free(priv->rmp[i]);
		priv->rmp[i] = NULL;
	}
}

static gboolean remove_cb(RoccatDevice *device, gpointer user_data) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(user_data);
	KoneEventhandlerPrivate *priv = eventhandler->priv;
	if (priv->device && strcmp(roccat_device_get_identifier(device), roccat_device_get_identifier(priv->device)) == 0) {
		stop(eventhandler);
	}
	return TRUE;
}

static void kone_eventhandler_init(KoneEventhandler *eventhandler) {
	eventhandler->priv = KONE_EVENTHANDLER_GET_PRIVATE(eventhandler);
}

static void finalize(GObject *object) {
	KoneEventhandler *eventhandler = KONE_EVENTHANDLER(object);
	KoneEventhandlerPrivate *priv = eventhandler->priv;

	g_object_unref(priv->channel);
	priv->channel = NULL;

	roccat_device_scanner_free(priv->device_scanner);
	priv->device_scanner = NULL;

	stop(eventhandler);

	if (priv->profile_note) {
		roccat_notification_profile_free(priv->profile_note);
		priv->profile_note = NULL;
	}

	if (priv->cpi_note) {
		roccat_notification_cpi_free(priv->cpi_note);
		priv->cpi_note = NULL;
	}
	
	G_OBJECT_CLASS(kone_eventhandler_parent_class)->finalize(object);
}

static GObject *constructor(GType gtype, guint n_properties, GObjectConstructParam *properties) {
	KoneEventhandler *eventhandler;
	KoneEventhandlerPrivate *priv;
	GObject *obj;

	obj = G_OBJECT_CLASS(kone_eventhandler_parent_class)->constructor(gtype, n_properties, properties);
	eventhandler = KONE_EVENTHANDLER(obj);
	priv = eventhandler->priv;

	priv->channel = kone_eventhandler_channel_new();
	g_signal_connect(G_OBJECT(priv->channel), "cpi-changed", G_CALLBACK(cpi_changed_cb), eventhandler);
	g_signal_connect(G_OBJECT(priv->channel), "cpi-osd", G_CALLBACK(cpi_osd_cb), eventhandler);
	g_signal_connect(G_OBJECT(priv->channel), "profile-changed", G_CALLBACK(profile_changed_cb), eventhandler);
	g_signal_connect(G_OBJECT(priv->channel), "profile-osd", G_CALLBACK(profile_osd_cb), eventhandler);
	g_signal_connect(G_OBJECT(priv->channel), "macro", G_CALLBACK(macro_cb), eventhandler);
	g_signal_connect(G_OBJECT(priv->channel), "multimedia", G_CALLBACK(multimedia_cb), eventhandler);

	priv->kbd_dev = -1;
	priv->mouse_dev = -1;

	priv->device_scanner = kone_device_scanner_new(add_cb, remove_cb, eventhandler);

	return obj;
}

static void set_property(GObject *object, guint prop_id, GValue const *value, GParamSpec *pspec) {
	KoneEventhandlerPrivate *priv = KONE_EVENTHANDLER(object)->priv;

	switch(prop_id) {
	case PROP_HOST:
		priv->host = g_value_get_pointer(value);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
	}
}

static void kone_eventhandler_class_init(KoneEventhandlerClass *klass) {
	GObjectClass *gobject_class;

	gobject_class = G_OBJECT_CLASS(klass);

	gobject_class->constructor = constructor;
	gobject_class->finalize = finalize;
	gobject_class->set_property = set_property;

	g_type_class_add_private(klass, sizeof(KoneEventhandlerPrivate));

	g_object_class_install_property(gobject_class, PROP_HOST,
			g_param_spec_pointer("host",
					"Host",
					"Pointer to RoccatEventhandlerHost interface",
					G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
}

ROCCAT_EVENTHANDLER_PLUGIN_API RoccatEventhandlerPlugin *roccat_eventhandler_plugin_new(RoccatEventhandlerHost *host) {
	return ROCCAT_EVENTHANDLER_PLUGIN(kone_eventhandler_new(host));
}
