#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <glib-object.h>
#include <ltdl.h>

#include "module.h"
#include "avl.h"

static unsigned initialized;
static struct avl_table *package_tree;

static char *str_cpy_lower(char *dst, const char *src)
{
	size_t i;

	for (i = 0; src[i]; i++)
		dst[i] = tolower(src[i]);
	dst[i] = 0;

	return dst;
}

G_DEFINE_TYPE(UPkgModule, upkg_module, G_TYPE_TYPE_MODULE);

static void dl_print_errors(const char *prefix)
{
	const char *err;
	while (err = lt_dlerror()) {
		if (prefix) fprintf(stderr, "%s: ", prefix);
		puts(err);
	}
}

static gboolean module_load(GTypeModule *m)
{
	UPkgModule *mod = UPKG_MODULE(m);
	int (*init_func)(GTypeModule *);

	mod->dl = lt_dlopenext(G_TYPE_MODULE(m)->name);
	if (!mod->dl) {
		dl_print_errors(__func__);
		return FALSE;
	}

	init_func = lt_dlsym(mod->dl, "init");
	if (!init_func || init_func(m) != 0) {
		dl_print_errors(__func__);
		lt_dlclose(mod->dl);
		return FALSE;
	}

	return TRUE;
}

static void module_unload(GTypeModule *m)
{
	UPkgModule *mod = UPKG_MODULE(m);

	if (lt_dlclose(mod->dl) != 0) {
		dl_print_errors(__func__);
	}
}

static void upkg_module_init(UPkgModule *mod)
{
}

static void upkg_module_class_init(UPkgModuleClass *class)
{
	GTypeModuleClass *modclass = G_TYPE_MODULE_CLASS(class);

	modclass->load   = module_load;
	modclass->unload = module_unload;
}

UPkgModule *upkg_module_new(const char *name)
{
	char *name2;

	if (!name) {
		return NULL;
	}

	name2 = malloc(strlen(name)+1);
	if (!name2) {
		return NULL;
	}

	UPkgModule *mod = g_object_new(UPKG_MODULE_TYPE, NULL);
	if (!mod) {
		free(name2);
		return NULL;
	}

	G_TYPE_MODULE(mod)->name = str_cpy_lower(name2, name);
	return mod;
}

static int modcmp(const void *a, const void *b, void *_data)
{
	const GTypeModule *ma = a;
	const GTypeModule *mb = b;

	return strcmp(ma->name, mb->name);
}

int module_init(void)
{
	if (!initialized) {
		package_tree = avl_create(modcmp, NULL, NULL);
		if (!package_tree) {
			fprintf(stderr, "%s: failed to create package tree.\n", __func__);
			return -1;
		}

		if (lt_dlinit() != 0) {
			avl_destroy(package_tree, NULL);
			dl_print_errors(__func__);
			return -1;
		}

		g_type_init();
	}

	initialized++;
	return 0;
}

int module_exit(void)
{
	if (--initialized)
		return 0;

	if (lt_dlexit() != 0) {
		dl_print_errors(__func__);
		return -1;
	}

	return 0;
}

GType module_get_class(const char *package, const char *class)
{
	char buf[strlen(package) + strlen(class) + 1];
	GTypeModule search = { .name = str_cpy_lower(buf, package) };

	GTypeModule *mod = avl_find(package_tree, &search);
	if (!mod) {
		void **p;

		mod = G_TYPE_MODULE(upkg_module_new(package));
		if (!mod) {
			return 0;
		}

		p = avl_probe(package_tree, mod);
		if (!p) {
			g_object_unref(mod);
			return 0;
		}
	}

	if (!g_type_module_use(mod))
		return 0;

	str_cpy_lower(buf+strlen(package), class);
	buf[0] = toupper(buf[0]);
	buf[strlen(package)] = toupper(buf[strlen(package)]);
	return g_type_from_name(buf);
}