#include "config.h"

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

#include "keymap.h"

#include "kbd.h"
#include "nls.h"
#include "contextP.h"

void __attribute__((format(printf, 6, 7)))
lk_log(struct lk_ctx *ctx, int priority,
       const char *file, int line, const char *fn,
       const char *fmt, ...)
{
	va_list args;
	if (ctx->log_fn == NULL)
		return;
	va_start(args, fmt);
	ctx->log_fn(ctx->log_data, priority, file, line, fn, fmt, args);
	va_end(args);
}

#ifndef DEBUG
#define log_unused __attribute__((unused))
#else
#define log_unused
#endif

static void __attribute__((format(printf, 6, 0)))
log_file(void *data,
         int priority log_unused,
         const char *file log_unused,
         const int line log_unused,
         const char *fn log_unused,
         const char *format, va_list args)
{
	FILE *fp = data;
#ifdef DEBUG
	char buf[16];
	const char *priname;

	switch (priority) {
		case LOG_EMERG:
			priname = "EMERGENCY";
			break;
		case LOG_ALERT:
			priname = "ALERT";
			break;
		case LOG_CRIT:
			priname = "CRITICAL";
			break;
		case LOG_ERR:
			priname = "ERROR";
			break;
		case LOG_WARNING:
			priname = "WARNING";
			break;
		case LOG_NOTICE:
			priname = "NOTICE";
			break;
		case LOG_INFO:
			priname = "INFO";
			break;
		case LOG_DEBUG:
			priname = "DEBUG";
			break;
		default:
			snprintf(buf, sizeof(buf), "L:%d", priority);
			priname = buf;
	}
	fprintf(fp, "libkeymap: %s %s:%d %s: ", priname, file, line, fn);
#endif
	vfprintf(fp, format, args);
	fprintf(fp, "\n");
}

#undef log_unused

int lk_set_log_fn(struct lk_ctx *ctx,
                  void (*log_fn)(void *data, int priority,
                                 const char *file, int line, const char *fn,
                                 const char *format, va_list args),
                  const void *data)
{
	if (!ctx)
		return -1;

	ctx->log_fn   = log_fn;
	ctx->log_data = (void *)data;

	return 0;
}

int lk_get_log_priority(struct lk_ctx *ctx)
{
	if (!ctx)
		return -1;

	return ctx->log_priority;
}

int lk_set_log_priority(struct lk_ctx *ctx, int priority)
{
	if (!ctx)
		return -1;

	ctx->log_priority = priority;
	return 0;
}

lk_flags
lk_get_parser_flags(struct lk_ctx *ctx)
{
	if (!ctx)
		return -1;

	return ctx->flags;
}

int lk_set_parser_flags(struct lk_ctx *ctx, lk_flags flags)
{
	if (!ctx)
		return -1;

	ctx->flags = flags;
	return 0;
}

static int
init_array(struct lk_ctx *ctx, struct lk_array **arr, size_t size)
{
	int rc;
	void *ptr;

	ptr = malloc(sizeof(struct lk_array));
	if (!ptr) {
		ERR(ctx, _("out of memory"));
		return -1;
	}

	rc = lk_array_init(ptr, size, 0);
	if (rc < 0) {
		ERR(ctx, _("unable to initialize array: %s"), strerror(rc));
		return -1;
	}

	*arr = ptr;

	return 0;
}

struct lk_ctx *
lk_init(void)
{
	struct lk_ctx *ctx;

	ctx = malloc(sizeof(struct lk_ctx));
	if (!ctx)
		return NULL;

	memset(ctx, 0, sizeof(struct lk_ctx));

	lk_set_log_fn(ctx, log_file, stderr);
	lk_set_log_priority(ctx, LOG_ERR);

	if (init_array(ctx, &ctx->keymap, sizeof(void *)) < 0 ||
	    init_array(ctx, &ctx->func_table, sizeof(void *)) < 0 ||
	    init_array(ctx, &ctx->accent_table, sizeof(void *)) < 0 ||
	    init_array(ctx, &ctx->key_constant, sizeof(char)) < 0 ||
	    init_array(ctx, &ctx->key_line, sizeof(int)) < 0) {
		lk_free(ctx);
		return NULL;
	}

	return ctx;
}

int lk_free(struct lk_ctx *ctx)
{
	unsigned int i; //, j;

	if (!ctx)
		return -1;

	if (ctx->keymap) {
		for (i = 0; i < ctx->keymap->total; i++) {
			struct lk_array *map;

			map = lk_array_get_ptr(ctx->keymap, i);
			if (!map)
				continue;

			lk_array_free(map);
			free(map);
		}
		lk_array_free(ctx->keymap);
		free(ctx->keymap);

		ctx->keymap = NULL;
	}

	if (ctx->func_table) {
		for (i = 0; i < ctx->func_table->total; i++) {
			char *ptr;

			ptr = lk_array_get_ptr(ctx->func_table, i);
			if (!ptr)
				continue;

			free(ptr);
		}
		lk_array_free(ctx->func_table);
		free(ctx->func_table);

		ctx->func_table = NULL;
	}

	if (ctx->accent_table) {
		for (i = 0; i < ctx->accent_table->total; i++) {
			struct lk_array *ptr;

			ptr = lk_array_get_ptr(ctx->accent_table, i);
			if (!ptr)
				continue;

			free(ptr);
		}
		lk_array_free(ctx->accent_table);
		free(ctx->accent_table);

		ctx->accent_table = NULL;
	}

	if (ctx->key_constant) {
		lk_array_free(ctx->key_constant);
		free(ctx->key_constant);
		ctx->key_constant = NULL;
	}

	if (ctx->key_line) {
		lk_array_free(ctx->key_line);
		free(ctx->key_line);
		ctx->key_line = NULL;
	}

	return 0;
}