#include "config.h"

#include <linux/keyboard.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include "keymap.h"

#include "contextP.h"

#include "ksyms.h"

#include "nls.h"

#include "syms.cp1250.h"

#include "syms.ethiopic.h"

#include "syms.iso8859_15.h"

#include "syms.iso8859_5.h"

#include "syms.iso8859_7.h"

#include "syms.iso8859_8.h"

#include "syms.iso8859_9.h"

#include "syms.koi8.h"

#include "syms.latin1.h"

#include "syms.latin2.h"

#include "syms.latin3.h"

#include "syms.latin4.h"

#include "syms.mazovia.h"

#include "syms.sami.h"

#include "syms.thai.h"

#include "syms.synonyms.h"

#include "syms.ktyp.h"

#define E(x)                                \

	{                                   \

		x, sizeof(x) / sizeof(x[0]) \

	}

const syms_entry syms[] = {

	E(iso646_syms), /* KT_LATIN */

	E(fn_syms),     /* KT_FN */

	E(spec_syms),   /* KT_SPEC */

	E(pad_syms),    /* KT_PAD */

	E(dead_syms),   /* KT_DEAD */

	E(cons_syms),   /* KT_CONS */

	E(cur_syms),    /* KT_CUR */

	E(shift_syms),  /* KT_SHIFT */

	{ 0, 0 },       /* KT_META */

	E(ascii_syms),  /* KT_ASCII */

	E(lock_syms),   /* KT_LOCK */

	{ 0, 0 },       /* KT_LETTER */

	E(sticky_syms), /* KT_SLOCK */

	{ 0, 0 },       /*  */

	E(brl_syms)     /* KT_BRL */

};

#undef E

const unsigned int syms_size = sizeof(syms) / sizeof(syms_entry);

const unsigned int syn_size  = sizeof(synonyms) / sizeof(synonyms[0]);

const struct cs {

	const char *charset;

	const sym *charnames;

	const int start;

} charsets[] = {

	{ "iso-8859-1", latin1_syms, 160 },

	{ "iso-8859-2", latin2_syms, 160 },

	{ "iso-8859-3", latin3_syms, 160 },

	{ "iso-8859-4", latin4_syms, 160 },

	{ "iso-8859-5", iso8859_5_syms, 160 },

	{ "iso-8859-7", iso8859_7_syms, 160 },

	{ "iso-8859-8", iso8859_8_syms, 160 },

	{ "iso-8859-9", iso8859_9_syms, 160 },

	{ "iso-8859-10", latin6_syms, 160 },

	{ "iso-8859-15", iso8859_15_syms, 160 },

	{ "mazovia", mazovia_syms, 128 },

	{ "cp-1250", cp1250_syms, 128 },

	{ "koi8-r", koi8_syms, 128 },

	{ "koi8-u", koi8_syms, 128 },

	{ "tis-620", tis_620_syms, 160 },          /* thai */

	{ "iso-10646-18", iso10646_18_syms, 159 }, /* ethiopic */

	{ "iso-ir-197", iso_ir_197_syms, 160 },    /* sami */

	{ "iso-ir-209", iso_ir_209_syms, 160 },    /* sami */

};

static const unsigned int charsets_size = sizeof(charsets) / sizeof(charsets[0]);

/* Functions for both dumpkeys and loadkeys. */

void lk_list_charsets(FILE *f)

{

	int lth, ct;

	unsigned int i, j;

	char *mm[] = { "iso-8859-", "koi8-" };

	for (j = 0; j < sizeof(mm) / sizeof(mm[0]); j++) {

		if (j)

			fprintf(f, ",");

		fprintf(f, "%s{", mm[j]);

		ct  = 0;

		lth = strlen(mm[j]);

		for (i = 1; i < charsets_size; i++) {

			if (!strncmp(charsets[i].charset, mm[j], lth)) {

				if (ct++)

					fprintf(f, ",");

				fprintf(f, "%s", charsets[i].charset + lth);

			}

		}

		fprintf(f, "}");

	}

	for (i = 0; i < charsets_size; i++) {

		for (j = 0; j < sizeof(mm) / sizeof(mm[0]); j++) {

			lth = strlen(mm[j]);

			if (!strncmp(charsets[i].charset, mm[j], lth))

				goto nxti;

		}

		fprintf(f, ",%s", charsets[i].charset);

	nxti:;

	}

	fprintf(f, "\n");

}

const char *

lk_get_charset(struct lk_ctx *ctx)

{

	if (!ctx || ctx->charset >= charsets_size)

		return NULL;

	return charsets[ctx->charset].charset;

}

int lk_set_charset(struct lk_ctx *ctx, const char *charset)

{

	unsigned int i;

	for (i = 0; i < charsets_size; i++) {

		if (!strcasecmp(charsets[i].charset, charset)) {

			ctx->charset = i;

			return 0;

		}

	}

	return 1;

}

unsigned int

get_sym_size(struct lk_ctx *ctx, unsigned int ktype)

{

	if (ktype >= syms_size) {

		ERR(ctx, _("unable to get symbol by wrong type: %d"), ktype);

		return 0;

	}

	return syms[ktype].size;

}

const char *

get_sym(struct lk_ctx *ctx, unsigned int ktype, unsigned int index)

{

	if (!get_sym_size(ctx, ktype))

		return NULL;

	if (index >= syms[ktype].size) {

		ERR(ctx, _("unable to get symbol of %d type by wrong index: %d"), ktype, index);

		return NULL;

	}

	return syms[ktype].table[index];

}

char *

lk_get_sym(struct lk_ctx *ctx, unsigned int ktype, unsigned int index)

{

	const char *ksym = get_sym(ctx, ktype, index);

	return (ksym ? strdup(ksym) : NULL);

}

const char *

codetoksym(struct lk_ctx *ctx, int code)

{

	unsigned int i;

	int j;

	sym *p;

	if (code < 0)

		return NULL;

	if (code < 0x1000) { /* "traditional" keysym */

		if (code < 0x80)

			return get_sym(ctx, KT_LATIN, code);

		if (KTYP(code) == KT_META)

			return NULL;

		if (KTYP(code) == KT_LETTER)

			code = K(KT_LATIN, KVAL(code));

		if (KTYP(code) > KT_LATIN)

			return get_sym(ctx, KTYP(code), KVAL(code));

		i = ctx->charset;

		p = (sym *)charsets[i].charnames;

		if (p && (KVAL(code) >= charsets[i].start)) {

			p += KVAL(code) - charsets[i].start;

			if (p->name[0])

				return p->name;

		}

	}

	else { /* Unicode keysym */

		code ^= 0xf000;

		if (code < 0x80)

			return get_sym(ctx, KT_LATIN, code);

		for (i = 0; i < charsets_size; i++) {

			p = (sym *)charsets[i].charnames;

			if (p) {

				for (j = charsets[i].start; j < 256; j++, p++) {

					if (p->uni == code && p->name[0])

						return p->name;

				}

			}

		}

	}

	return NULL;

}

char *

lk_code_to_ksym(struct lk_ctx *ctx, int code)

{

	const char *s;

	s = codetoksym(ctx, code);

	if (!s)

		return NULL;

	return strdup(s);

}

/* Functions for loadkeys. */

static int

kt_latin(struct lk_ctx *ctx, const char *s, int direction)

{

	unsigned int i, max;

	sym *p = (sym *)charsets[ctx->charset].charnames;

	max = (direction == TO_UNICODE ? 128 : 256); // TODO(dmage): is 256 valid for ethiopic charset?

	for (i = charsets[ctx->charset].start; i < max; i++, p++) {

		if (p->name[0] && !strcmp(s, p->name))

			return K(KT_LATIN, i);

	}

	max = (direction == TO_UNICODE ? 128 : syms[KT_LATIN].size);

	for (i = 0; i < max; i++) {

		if (!strcmp(s, get_sym(ctx, KT_LATIN, i)))

			return K(KT_LATIN, i);

	}

	return -1;

}

int ksymtocode(struct lk_ctx *ctx, const char *s, int direction)

{

	unsigned int i, j;

	int n;

	int keycode;

	sym *p;

	if (direction == TO_AUTO)

		direction = (ctx->flags & LK_FLAG_PREFER_UNICODE)

		                ? TO_UNICODE

		                : TO_8BIT;

	if (!strncmp(s, "Meta_", 5)) {

		keycode = ksymtocode(ctx, s + 5, TO_8BIT);

		if (KTYP(keycode) == KT_LATIN)

			return K(KT_META, KVAL(keycode));

		/* Avoid error messages for Meta_acute with UTF-8 */

		else if (direction == TO_UNICODE)

			return (0);

		/* fall through to error printf */

	}

	if ((n = kt_latin(ctx, s, direction)) >= 0) {

		return n;

	}

	for (i = 1; i < syms_size; i++) {

		for (j = 0; j < syms[i].size; j++) {

			if (!strcmp(s, get_sym(ctx, i, j)))

				return K(i, j);

		}

	}

	for (i = 0; i < syn_size; i++)

		if (!strcmp(s, synonyms[i].synonym))

			return ksymtocode(ctx, synonyms[i].official_name, direction);

	if (direction == TO_UNICODE) {

		i = ctx->charset;

		p = (sym *)charsets[i].charnames;

		if (p) {

			for (j = charsets[i].start; j < 256; j++, p++) {

				if (!strcmp(s, p->name))

					return (p->uni ^ 0xf000);

			}

		}

		/* not found in the current charset, maybe we'll have good luck in others? */

		for (i = 0; i < charsets_size; i++) {

			if (i == ctx->charset) {

				continue;

			}

			p = (sym *)charsets[i].charnames;

			if (p) {

				for (j = charsets[i].start; j < 256; j++, p++) {

					if (!strcmp(s, p->name))

						return (p->uni ^ 0xf000);

				}

			}

		}

	} else /* if (!chosen_charset[0]) */ {

		/* note: some keymaps use latin1 but with euro,

		   so set_charset() would fail */

		/* note: some keymaps with charset line still use

		   symbols from more than one character set,

		   so we cannot have the  `if (!chosen_charset[0])'  here */

		for (i = 0; i < 256 - 160; i++)

			if (!strcmp(s, latin1_syms[i].name)) {

				INFO(ctx, _("assuming iso-8859-1 %s"), s);

				return K(KT_LATIN, 160 + i);

			}

		for (i = 0; i < 256 - 160; i++)

			if (!strcmp(s, iso8859_15_syms[i].name)) {

				INFO(ctx, _("assuming iso-8859-15 %s"), s);

				return K(KT_LATIN, 160 + i);

			}

		for (i = 0; i < 256 - 160; i++)

			if (!strcmp(s, latin2_syms[i].name)) {

				INFO(ctx, _("assuming iso-8859-2 %s"), s);

				return K(KT_LATIN, 160 + i);

			}

		for (i = 0; i < 256 - 160; i++)

			if (!strcmp(s, latin3_syms[i].name)) {

				INFO(ctx, _("assuming iso-8859-3 %s"), s);

				return K(KT_LATIN, 160 + i);

			}

		for (i = 0; i < 256 - 160; i++)

			if (!strcmp(s, latin4_syms[i].name)) {

				INFO(ctx, _("assuming iso-8859-4 %s"), s);

				return K(KT_LATIN, 160 + i);

			}

	}

	ERR(ctx, _("unknown keysym '%s'\n"), s);

	return CODE_FOR_UNKNOWN_KSYM;

}

int lk_ksym_to_unicode(struct lk_ctx *ctx, const char *s)

{

	return ksymtocode(ctx, s, TO_UNICODE);

}

int convert_code(struct lk_ctx *ctx, int code, int direction)

{

	const char *ksym;

	int unicode_forced   = (direction == TO_UNICODE);

	int input_is_unicode = (code >= 0x1000);

	int result;

	if (direction == TO_AUTO)

		direction = (ctx->flags & LK_FLAG_PREFER_UNICODE)

		                ? TO_UNICODE

		                : TO_8BIT;

	if (KTYP(code) == KT_META)

		return code;

	else if (!input_is_unicode && code < 0x80)

		/* basic ASCII is fine in every situation */

		return code;

	else if (input_is_unicode && (code ^ 0xf000) < 0x80)

		/* so is Unicode "Basic Latin" */

		return code ^ 0xf000;

	else if ((input_is_unicode && direction == TO_UNICODE) ||

	         (!input_is_unicode && direction == TO_8BIT))

		/* no conversion necessary */

		result = code;

	else {

		/* depending on direction, this will give us either an 8-bit

		 * K(KTYP, KVAL) or a Unicode keysym xor 0xf000 */

		ksym = codetoksym(ctx, code);

		if (ksym)

			result = ksymtocode(ctx, ksym, direction);

		else

			result = code;

		if (direction == TO_UNICODE && KTYP(code) == KT_LETTER && (result ^ 0xf000) < 0x100) {

			/* Unicode Latin-1 Supplement */

			result = K(KT_LETTER, result ^ 0xf000);

		}

	}

	/* if direction was TO_UNICODE from the beginning, we return the true

	 * Unicode value (without the 0xf000 mask) */

	if (unicode_forced && result >= 0x1000)

		return result ^ 0xf000;

	else

		return result;

}

int add_capslock(struct lk_ctx *ctx, int code)

{

	if (KTYP(code) == KT_LATIN && (!(ctx->flags & LK_FLAG_PREFER_UNICODE) || code < 0x80))

		return K(KT_LETTER, KVAL(code));

	else if ((code ^ 0xf000) < 0x100)

		/* Unicode Latin-1 Supplement */

		/* a bit dirty to use KT_LETTER here, but it should work */

		return K(KT_LETTER, code ^ 0xf000);

	else

		return convert_code(ctx, code, TO_AUTO);

}