/*
 * Copyright (C) 2002-2006 Sergey V. Udaltsov <svu@gnome.org>
 *
 * This library 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 of the License, or (at your option) any later version.
 *
 * This library 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 library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include <time.h>
#include <stdlib.h>
#include <string.h>

#include <X11/Xmd.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>

#include "config.h"

#include "xklavier_private.h"
#include "xklavier_private_xmm.h"

#define SHORTCUT_OPTION_PREFIX "grp:"

const gchar **
xkl_xmm_get_groups_names(XklEngine * engine)
{
	return (const gchar **) xkl_engine_backend(engine, XklXmm,
						   current_config).layouts;
}

const gchar **
xkl_xmm_get_indicators_names(XklEngine * engine)
{
	return NULL;
}

void
xkl_xmm_shortcuts_grab(XklEngine * engine)
{
	const XmmShortcut *shortcut;
	const XmmSwitchOption *option =
	    xkl_xmm_shortcut_get_current(engine);

	xkl_debug(150, "Found shortcut option: %p\n", option);
	if (option == NULL)
		return;

	shortcut = option->shortcuts;
	while (shortcut->keysym != XK_VoidSymbol) {
		int keycode =
		    XKeysymToKeycode(xkl_engine_get_display(engine),
				     shortcut->keysym);
		xkl_xmm_grab_ignoring_indicators(engine, keycode,
						 shortcut->modifiers);
		shortcut++;
	}
}

void
xkl_xmm_shortcuts_ungrab(XklEngine * engine)
{
	const XmmShortcut *shortcut;
	const XmmSwitchOption *option =
	    xkl_xmm_shortcut_get_current(engine);

	if (option == NULL)
		return;

	shortcut = option->shortcuts;
	while (shortcut->keysym != XK_VoidSymbol) {
		int keycode =
		    XKeysymToKeycode(xkl_engine_get_display(engine),
				     shortcut->keysym);
		xkl_xmm_ungrab_ignoring_indicators(engine, keycode,
						   shortcut->modifiers);
		shortcut++;
	}
}

XmmSwitchOption *
xkl_xmm_shortcut_get_current(XklEngine * engine)
{
	const gchar *option_name =
	    xkl_xmm_shortcut_get_current_option_name(engine);

	xkl_debug(150, "Configured switch option: [%s]\n", option_name);

	if (option_name == NULL)
		return NULL;

	return (XmmSwitchOption *)
	    g_hash_table_lookup(xkl_engine_backend
				(engine, XklXmm, switch_options),
				(gconstpointer) option_name);
}

const gchar *
xkl_xmm_shortcut_get_current_option_name(XklEngine * engine)
{
	gchar **option =
	    xkl_engine_backend(engine, XklXmm, current_config).options;
	if (option == NULL)
		return NULL;

	while (*option != NULL) {
		/* starts with "grp:" */
		if (strstr(*option, SHORTCUT_OPTION_PREFIX) != NULL) {
			return *option + sizeof SHORTCUT_OPTION_PREFIX - 1;
		}
		option++;
	}
	return NULL;
}

const XmmSwitchOption *
xkl_xmm_find_switch_option(XklEngine * engine, gint keycode,
			   guint state, gint * current_shortcut_rv)
{
	const XmmSwitchOption *rv = xkl_xmm_shortcut_get_current(engine);

	if (rv != NULL) {
		const XmmShortcut *sc = rv->shortcuts;
		while (sc->keysym != XK_VoidSymbol) {
			if ((XKeysymToKeycode
			     (xkl_engine_get_display(engine),
			      sc->keysym) == keycode)
			    && ((state & sc->modifiers) == sc->modifiers)) {
				return rv;
			}
			sc++;
		}
	}
	return NULL;
}

gint
xkl_xmm_resume_listen(XklEngine * engine)
{
	if (xkl_engine_is_listening_for(engine, XKLL_MANAGE_LAYOUTS))
		xkl_xmm_shortcuts_grab(engine);
	return 0;
}

gint
xkl_xmm_pause_listen(XklEngine * engine)
{
	if (xkl_engine_is_listening_for(engine, XKLL_MANAGE_LAYOUTS))
		xkl_xmm_shortcuts_ungrab(engine);
	return 0;
}

guint
xkl_xmm_get_max_num_groups(XklEngine * engine)
{
	return 0;
}

guint
xkl_xmm_get_num_groups(XklEngine * engine)
{
	gint rv = 0;
	gchar **p =
	    xkl_engine_backend(engine, XklXmm, current_config).layouts;
	if (p != NULL)
		while (*p++ != NULL)
			rv++;
	return rv;
}

void
xkl_xmm_free_all_info(XklEngine * engine)
{
	gchar *current_rules =
	    xkl_engine_backend(engine, XklXmm, current_rules);
	if (current_rules != NULL) {
		g_free(current_rules);
		current_rules = NULL;
		xkl_engine_backend(engine, XklXmm, current_rules) = NULL;
	}
	xkl_config_rec_reset(&xkl_engine_backend
			     (engine, XklXmm, current_config));
}

gboolean
xkl_xmm_if_cached_info_equals_actual(XklEngine * engine)
{
	return FALSE;
}

gboolean
xkl_xmm_load_all_info(XklEngine * engine)
{
	return
	    xkl_config_rec_get_full_from_server(&xkl_engine_backend
						(engine, XklXmm,
						 current_rules),
						&xkl_engine_backend(engine,
								    XklXmm,
								    current_config),
						engine);
}

void
xkl_xmm_get_server_state(XklEngine * engine, XklState * state)
{
	unsigned char *propval = NULL;
	Atom actual_type;
	int actual_format;
	unsigned long bytes_remaining;
	unsigned long actual_items;
	int result;

	memset(state, 0, sizeof(*state));

	result =
	    XGetWindowProperty(xkl_engine_get_display(engine),
			       xkl_engine_priv(engine, root_window),
			       xkl_engine_backend(engine, XklXmm,
						  state_atom), 0L, 1L,
			       False, XA_INTEGER, &actual_type,
			       &actual_format, &actual_items,
			       &bytes_remaining, &propval);

	if (Success == result) {
		if (actual_format == 32 || actual_items == 1) {
			state->group = *(CARD32 *) propval;
		} else {
			xkl_debug(160,
				  "Could not get the xmodmap current group\n");
		}
		XFree(propval);
	} else {
		xkl_debug(160,
			  "Could not get the xmodmap current group: %d\n",
			  result);
	}
}

void
xkl_xmm_actualize_group(XklEngine * engine, gint group)
{
	char cmd[1024];
	int res;
	const gchar *layout_name = NULL;

	if (xkl_xmm_get_num_groups(engine) < group)
		return;

	layout_name =
	    xkl_engine_backend(engine, XklXmm,
			       current_config).layouts[group];

	g_snprintf(cmd, sizeof cmd,
		   "xmodmap %s/xmodmap.%s", XMODMAP_BASE, layout_name);

	res = system(cmd);
	if (res > 0) {
		xkl_debug(0, "xmodmap error %d\n", res);
	} else if (res < 0) {
		xkl_debug(0, "Could not execute xmodmap: %d\n", res);
	}
	XSync(xkl_engine_get_display(engine), False);
}

void
xkl_xmm_lock_group(XklEngine * engine, gint group)
{
	CARD32 propval;
	Display *display;

	if (xkl_xmm_get_num_groups(engine) < group)
		return;

	/* updating the status property */
	propval = group;
	display = xkl_engine_get_display(engine);
	XChangeProperty(display, xkl_engine_priv(engine, root_window),
			xkl_engine_backend(engine, XklXmm, state_atom),
			XA_INTEGER, 32, PropModeReplace,
			(unsigned char *) &propval, 1);
	XSync(display, False);
}

void
xkl_xmm_set_indicators(XklEngine * engine, const XklState * window_state)
{
}


gint
xkl_xmm_init(XklEngine * engine)
{
	Display *display;

	xkl_engine_priv(engine, backend_id) = "xmodmap";
	xkl_engine_priv(engine, features) =
	    XKLF_MULTIPLE_LAYOUTS_SUPPORTED |
	    XKLF_REQUIRES_MANUAL_LAYOUT_MANAGEMENT;
	xkl_engine_priv(engine, activate_config_rec) =
	    xkl_xmm_activate_config_rec;
	xkl_engine_priv(engine, init_config_registry) =
	    xkl_xmm_init_config_registry;
	xkl_engine_priv(engine, load_config_registry) =
	    xkl_xmm_load_config_registry;
	xkl_engine_priv(engine, write_config_rec_to_file) = NULL;

	xkl_engine_priv(engine, get_groups_names) =
	    xkl_xmm_get_groups_names;
	xkl_engine_priv(engine, get_indicators_names) =
	    xkl_xmm_get_indicators_names;
	xkl_engine_priv(engine, get_max_num_groups) =
	    xkl_xmm_get_max_num_groups;
	xkl_engine_priv(engine, get_num_groups) = xkl_xmm_get_num_groups;
	xkl_engine_priv(engine, lock_group) = xkl_xmm_lock_group;

	xkl_engine_priv(engine, process_x_event) = xkl_xmm_process_x_event;
	xkl_engine_priv(engine, process_x_error) = NULL;
	xkl_engine_priv(engine, free_all_info) = xkl_xmm_free_all_info;
	xkl_engine_priv(engine, if_cached_info_equals_actual) =
	    xkl_xmm_if_cached_info_equals_actual;
	xkl_engine_priv(engine, load_all_info) = xkl_xmm_load_all_info;
	xkl_engine_priv(engine, get_server_state) =
	    xkl_xmm_get_server_state;
	xkl_engine_priv(engine, pause_listen) = xkl_xmm_pause_listen;
	xkl_engine_priv(engine, resume_listen) = xkl_xmm_resume_listen;
	xkl_engine_priv(engine, set_indicators) = xkl_xmm_set_indicators;
	xkl_engine_priv(engine, finalize) = xkl_xmm_term;

	if (getenv("XKL_XMODMAP_DISABLE") != NULL)
		return -1;

	display = xkl_engine_get_display(engine);
	xkl_engine_priv(engine, base_config_atom) =
	    XInternAtom(display, "_XMM_NAMES", False);
	xkl_engine_priv(engine, backup_config_atom) =
	    XInternAtom(display, "_XMM_NAMES_BACKUP", False);

	xkl_engine_priv(engine, backend) = g_new0(XklXmm, 1);

	xkl_engine_backend(engine, XklXmm, state_atom) =
	    XInternAtom(display, "_XMM_STATE", False);

	xkl_engine_priv(engine, default_model) = "generic";
	xkl_engine_priv(engine, default_layout) = "us";

	xkl_xmm_init_switch_options((XklXmm *)
				    xkl_engine_priv(engine, backend));

	return 0;
}

void
xkl_xmm_term(XklEngine * engine)
{
	xkl_xmm_term_switch_options((XklXmm *)
				    xkl_engine_priv(engine, backend));
}