/*

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

#include <locale.h>

#include <string.h>

#include <X11/Xlib.h>

#include <X11/Xatom.h>

#include <libxml/xpath.h>

#include "config.h"

#include "xklavier_private.h"

static GObjectClass *parent_class = NULL;

static void xkl_config_rec_destroy(XklConfigRec * data);

G_DEFINE_TYPE(XklConfigItem, xkl_config_item, G_TYPE_OBJECT)

static void

xkl_config_item_init(XklConfigItem * this)

{

}

static void

xkl_config_item_class_init(XklConfigItemClass * klass)

{

}

XklConfigItem *

xkl_config_item_new(void)

{

	return

	    XKL_CONFIG_ITEM(g_object_new

			    (xkl_config_item_get_type(), NULL));

}

const gchar *

xkl_config_item_get_name(XklConfigItem * item)

{

	return item->name;

}

void

xkl_config_item_set_name(XklConfigItem * item,

			 const gchar * name)

{

	if (name != NULL)

		strncpy (item->name, name, XKL_MAX_CI_SHORT_DESC_LENGTH-1);

	else

		item->name[0] = '\0';

}

const gchar *

xkl_config_item_get_short_description(XklConfigItem * item)

{

	return item->short_description;

}

void

xkl_config_item_set_short_description(XklConfigItem * item,

				      const gchar * short_description)

{

	if (short_description != NULL)

		strncpy (item->short_description, short_description, XKL_MAX_CI_DESC_LENGTH-1);

	else

		item->short_description[0] = '\0';

}

const gchar *

xkl_config_item_get_description(XklConfigItem * item)

{

	return item->description;

}

void

xkl_config_item_set_description(XklConfigItem * item,

				const gchar * description)

{

	if (description != NULL)

		strncpy (item->description, description, XKL_MAX_CI_NAME_LENGTH-1);

	else

		item->description[0] = '\0';

}

G_DEFINE_TYPE(XklConfigRec, xkl_config_rec, G_TYPE_OBJECT)

static void

xkl_config_rec_finalize(GObject * obj)

{

	XklConfigRec *this = (XklConfigRec *) obj;

	xkl_config_rec_destroy(this);

	G_OBJECT_CLASS(parent_class)->finalize(obj);

}

static void

xkl_config_rec_class_init(XklConfigRecClass * klass)

{

	GObjectClass *object_class;

	object_class = (GObjectClass *) klass;

	parent_class = g_type_class_peek_parent(object_class);

	object_class->finalize = xkl_config_rec_finalize;

}

XklConfigRec *

xkl_config_rec_new(void)

{

	return

	    XKL_CONFIG_REC(g_object_new(xkl_config_rec_get_type(), NULL));

}

static gboolean

xkl_strings_equal(gchar * p1, gchar * p2)

{

	if (p1 == p2)

		return TRUE;

	if ((p1 == NULL && p2 != NULL) || (p1 != NULL && p2 == NULL))

		return FALSE;

	return !g_ascii_strcasecmp(p1, p2);

}

static gboolean

xkl_lists_equal(gchar ** items1, gchar ** items2)

{

	if (items1 == items2)

		return TRUE;

	if ((items1 == NULL && items2 != NULL) ||

	    (items1 != NULL && items2 == NULL))

		return FALSE;

	while (*items1 != NULL && *items2 != NULL)

		if (!xkl_strings_equal(*items1++, *items2++))

			return FALSE;

	return (*items1 == NULL && *items2 == NULL);

}

static gboolean

xkl_engine_get_default_names_prop(XklEngine * engine,

				  char **rules_file_out,

				  XklConfigRec * data)

{

	if (rules_file_out != NULL)

		*rules_file_out = g_strdup(XKB_DEFAULT_RULESET);

	data->model = g_strdup(xkl_engine_priv(engine, default_model));

/* keeping Nvariants = Nlayouts */

	data->layouts = g_new0(char *, 2);

	data->layouts[0] =

	    g_strdup(xkl_engine_priv(engine, default_layout));

	data->variants = g_new0(char *, 2);

	data->variants[0] = g_strdup("");

	data->options = g_new0(char *, 1);

	return TRUE;

}

gboolean

xkl_config_rec_get_full_from_server(char **rules_file_out,

				    XklConfigRec * data,

				    XklEngine * engine)

{

	gboolean rv = xkl_config_rec_get_from_root_window_property(data,

								   xkl_engine_priv

								   (engine,

								    base_config_atom),

								   rules_file_out,

								   engine);

	if (!rv)

		rv = xkl_engine_get_default_names_prop(engine,

						       rules_file_out,

						       data);

	return rv;

}

gboolean

xkl_config_rec_equals(XklConfigRec * data1, XklConfigRec * data2)

{

	if (data1 == data2)

		return TRUE;

	if (!xkl_strings_equal(data1->model, data2->model))

		return FALSE;

	if (!xkl_lists_equal(data1->layouts, data2->layouts))

		return FALSE;

	if (!xkl_lists_equal(data1->variants, data2->variants))

		return FALSE;

	return xkl_lists_equal(data1->options, data2->options);

}

void

xkl_config_rec_set_layouts(XklConfigRec * data,

			   const gchar ** new_layouts)

{

        g_strfreev (data->layouts);

	data->layouts = g_strdupv ((gchar**) new_layouts);

}

void

xkl_config_rec_set_variants(XklConfigRec * data,

			   const gchar ** new_variants)

{

        g_strfreev (data->variants);

	data->variants = g_strdupv ((gchar**) new_variants);

}

void

xkl_config_rec_set_options(XklConfigRec * data,

			   const gchar ** new_options)

{

        g_strfreev (data->options);

	data->options = g_strdupv ((gchar**) new_options);

}

void

xkl_config_rec_set_model(XklConfigRec * data,

			 const gchar * new_model)

{

        g_free (data->model);

	data->model = g_strdup (new_model);

}

void

xkl_config_rec_init(XklConfigRec * data)

{

	/* clear the structure VarDefsPtr... */

	data->model = NULL;

	data->layouts = data->variants = data->options = NULL;

}

void

xkl_config_rec_destroy(XklConfigRec * data)

{

	if (data->model != NULL)

		g_free(data->model);

	g_strfreev(data->layouts);

	g_strfreev(data->variants);

	g_strfreev(data->options);

	data->layouts = data->variants = data->options = NULL;

}

void

xkl_config_rec_reset(XklConfigRec * data)

{

	xkl_config_rec_destroy(data);

	xkl_config_rec_init(data);

}

gboolean

xkl_config_rec_get_from_server(XklConfigRec * data, XklEngine * engine)

{

	return xkl_config_rec_get_full_from_server(NULL, data, engine);

}

gboolean

xkl_config_rec_get_from_backup(XklConfigRec * data, XklEngine * engine)

{

	return xkl_config_rec_get_from_root_window_property(data,

							    xkl_engine_priv

							    (engine,

							     backup_config_atom),

							    NULL, engine);

}

gboolean

xkl_engine_backup_names_prop(XklEngine * engine)

{

	gboolean rv = TRUE;

	gchar *rf = NULL;

	XklConfigRec *data = xkl_config_rec_new();

	gboolean cgp = FALSE;

	if (xkl_config_rec_get_from_root_window_property

	    (data, xkl_engine_priv(engine, backup_config_atom), NULL,

	     engine)) {

		g_object_unref(G_OBJECT(data));

		return TRUE;

	}

	/* "backup" property is not defined */

	xkl_config_rec_reset(data);

	cgp = xkl_config_rec_get_full_from_server(&rf, data, engine);

	if (cgp) {

		if (!xkl_config_rec_set_to_root_window_property

		    (data, xkl_engine_priv(engine, backup_config_atom),

		     rf, engine)) {

			xkl_debug(150,

				  "Could not backup the configuration");

			rv = FALSE;

		}

		if (rf != NULL)

			g_free(rf);

	} else {

		xkl_debug(150,

			  "Could not get the configuration for backup");

		rv = FALSE;

	}

	g_object_unref(G_OBJECT(data));

	return rv;

}

gboolean

xkl_restore_names_prop(XklEngine * engine)

{

	gboolean rv = TRUE;

	gchar *rf = NULL;

	XklConfigRec *data = xkl_config_rec_new();

	if (!xkl_config_rec_get_from_root_window_property

	    (data, xkl_engine_priv(engine, backup_config_atom), NULL,

	     engine)) {

		g_object_unref(G_OBJECT(data));

		return FALSE;

	}

	if (!xkl_config_rec_set_to_root_window_property

	    (data, xkl_engine_priv(engine, base_config_atom), rf,

	     engine)) {

		xkl_debug(150, "Could not backup the configuration");

		rv = FALSE;

	}

	g_object_unref(G_OBJECT(data));

	return rv;

}

gboolean

xkl_config_rec_get_from_root_window_property(XklConfigRec * data,

					     Atom rules_atom,

					     gchar ** rules_file_out,

					     XklEngine * engine)

{

	Atom real_prop_type;

	int fmt;

	unsigned long nitems, extra_bytes;

	char *prop_data = NULL, *out;

	Status rtrn;

	/* no such atom! */

	if (rules_atom == None) {	/* property cannot exist */

		xkl_last_error_message = "Could not find the atom";

		return FALSE;

	}

	rtrn =

	    XGetWindowProperty(xkl_engine_get_display(engine),

			       xkl_engine_priv(engine, root_window),

			       rules_atom, 0L, XKB_RF_NAMES_PROP_MAXLEN,

			       False, XA_STRING, &real_prop_type, &fmt,

			       &nitems, &extra_bytes,

			       (unsigned char **) (void *) &prop_data);

	/* property not found! */

	if (rtrn != Success) {

		xkl_last_error_message = "Could not get the property";

		return FALSE;

	}

	/* set rules file to "" */

	if (rules_file_out)

		*rules_file_out = NULL;

	/* has to be array of strings */

	if ((extra_bytes > 0) || (real_prop_type != XA_STRING)

	    || (fmt != 8)) {

		if (prop_data)

			XFree(prop_data);

		xkl_last_error_message = "Wrong property format";

		return FALSE;

	}

	if (!prop_data) {

		xkl_last_error_message = "No properties returned";

		return FALSE;

	}

	/* rules file */

	out = prop_data;

	if (out && (*out) && rules_file_out)

		*rules_file_out = g_strdup(out);

	out += strlen(out) + 1;

	/* if user is interested in rules only - don't waste the time */

	if (!data) {

		XFree(prop_data);

		return TRUE;

	}

	if ((out - prop_data) < nitems) {

		if (*out)

			data->model = g_strdup(out);

		out += strlen(out) + 1;

	}

	if ((out - prop_data) < nitems) {

		xkl_config_rec_split_layouts(data, out);

		out += strlen(out) + 1;

	}

	if ((out - prop_data) < nitems) {

		gint nv, nl;

		gchar **layout, **variant;

		xkl_config_rec_split_variants(data, out);

		/*

		   Now have to ensure that number of variants matches the number of layouts

		   The 'remainder' is filled with NULLs (not ""s!)

		 */

		nv = g_strv_length(data->variants);

		nl = g_strv_length(data->layouts);

		if (nv < nl) {

			data->variants = g_realloc(data->variants,

						   (nl +

						    1) * sizeof(char *));

			memset(data->variants + nv + 1, 0,

			       (nl - nv) * sizeof(char *));

		}

		/* take variants from layouts like ru(winkeys) */

		layout = data->layouts;

		variant = data->variants;

		while (*layout != NULL && *variant == NULL) {

			gchar *varstart = g_strstr_len(*layout, -1, "(");

			if (varstart != NULL) {

				gchar *varend =

				    g_strstr_len(varstart, -1, ")");

				if (varend != NULL) {

					gint varlen = varend - varstart;

					gint laylen = varstart - *layout;

					/* I am not sure - but I assume variants in layout have priority */

					gchar *var = *variant =

					    (*variant !=

					     NULL) ? g_realloc(*variant,

							       varlen) :

					    g_new(gchar, varlen);

					memcpy(var, varstart + 1,

					       --varlen);

					var[varlen] = '\0';

					/* Resize the original layout */

					*layout =

					    g_realloc(*layout, laylen + 1);

					(*layout)[laylen] = '\0';

				}

			}

			layout++;

			variant++;

		}

		out += strlen(out) + 1;

	}

	if ((out - prop_data) < nitems) {

		xkl_config_rec_split_options(data, out);

	}

	XFree(prop_data);

	return TRUE;

}

/* taken from XFree86 maprules.c */

gboolean

xkl_config_rec_set_to_root_window_property(const XklConfigRec * data,

					   Atom rules_atom,

					   gchar * rules_file,

					   XklEngine * engine)

{

	gint len;

	gchar *pval;

	gchar *next;

	gchar *all_layouts = xkl_config_rec_merge_layouts(data);

	gchar *all_variants = xkl_config_rec_merge_variants(data);

	gchar *all_options = xkl_config_rec_merge_options(data);

	Display *display;

	len = (rules_file ? strlen(rules_file) : 0);

	len += (data->model ? strlen(data->model) : 0);

	len += (all_layouts ? strlen(all_layouts) : 0);

	len += (all_variants ? strlen(all_variants) : 0);

	len += (all_options ? strlen(all_options) : 0);

	if (len < 1) {

		if (all_layouts)

			g_free(all_layouts);

		if (all_variants)

			g_free(all_variants);

		if (all_options)

			g_free(all_options);

		return TRUE;

	}

	len += 5;		/* trailing NULs */

	pval = next = g_new(char, len + 1);

	if (!pval) {

		xkl_last_error_message = "Could not allocate buffer";

		if (all_layouts != NULL)

			g_free(all_layouts);

		if (all_variants != NULL)

			g_free(all_variants);

		if (all_options != NULL)

			g_free(all_options);

		return FALSE;

	}

	if (rules_file) {

		strcpy(next, rules_file);

		next += strlen(rules_file);

	}

	*next++ = '\0';

	if (data->model) {

		strcpy(next, data->model);

		next += strlen(data->model);

	}

	*next++ = '\0';

	if (data->layouts) {

		strcpy(next, all_layouts);

		next += strlen(all_layouts);

	}

	*next++ = '\0';

	if (data->variants) {

		strcpy(next, all_variants);

		next += strlen(all_variants);

	}

	*next++ = '\0';

	if (data->options) {

		strcpy(next, all_options);

		next += strlen(all_options);

	}

	*next++ = '\0';

	if ((next - pval) != len) {

		xkl_debug(150, "Illegal final position: %d/%d\n",

			  (next - pval), len);

		if (all_layouts != NULL)

			g_free(all_layouts);

		if (all_variants != NULL)

			g_free(all_variants);

		if (all_options != NULL)

			g_free(all_options);

		g_free(pval);

		xkl_last_error_message = "Internal property parsing error";

		return FALSE;

	}

	display = xkl_engine_get_display(engine);

	XChangeProperty(display, xkl_engine_priv(engine, root_window),

			     rules_atom, XA_STRING, 8, PropModeReplace,

			     (unsigned char *) pval, len);

	XSync(display, False);

#if 0

	for (i = len - 1; --i >= 0;)

		if (pval[i] == '\0')

			pval[i] = '?';

	XklDebug(150, "Stored [%s] of length %d to [%s] of %X\n", pval,

		 len, propName, _xklRootWindow);

#endif

	if (all_layouts != NULL)

		g_free(all_layouts);

	if (all_variants != NULL)

		g_free(all_variants);

	if (all_options != NULL)

		g_free(all_options);

	g_free(pval);

	return TRUE;

}