#include "vm.h"
#include "util-jn.h"
#include "util-gd.h"
#include "rsrc.h"

#define _safe_wrap(gdt, ct) ({ \
	_Static_assert(sizeof(gdt) == sizeof(ct)); \
	*(typeof(ct)*)v; \
})

void
gdjn_dejanetize_typed
(	GDExtensionTypePtr v,
	GDExtensionVariantType const t,
	Janet val
) {
	switch (t) {
		case GDEXTENSION_VARIANT_TYPE_BOOL:
			assert(janet_type(val) == JANET_BOOLEAN);
			*(bool*)v = janet_unwrap_boolean(val);
			break;
		case GDEXTENSION_VARIANT_TYPE_INT:
			switch (janet_type(val)) {
				case JANET_NUMBER:
					*(int64_t*)v = janet_unwrap_integer(val); break;
				case JANET_INT_S64:
					*(int64_t*)v = janet_unwrap_s64(val); break;
				case JANET_INT_U64:
					*(int64_t*)v = janet_unwrap_u64(val); break;
				default: assert(false);
			}
			break;
		case GDEXTENSION_VARIANT_TYPE_STRING: 
		case GDEXTENSION_VARIANT_TYPE_STRING_NAME: {
			JanetString str;
			switch (janet_type(val)) {
				case JANET_STRING: str = janet_unwrap_string(val); break;
				case JANET_KEYWORD: str = janet_unwrap_keyword(val); break;
				case JANET_SYMBOL: str = janet_unwrap_symbol(val); break;
				default: assert(false);
			}
			size_t len = janet_string_length(str);
			if (t == GDEXTENSION_VARIANT_TYPE_STRING_NAME) {
				_t(stringName).newWithUtf8CharsAndLen(v, (char*)str, len);
			} else {
				_t(string).newWithUtf8CharsAndLen(v, (char*)str, len);
			}
			break;
		}
		case GDEXTENSION_VARIANT_TYPE_ARRAY: {
		}
		case GDEXTENSION_VARIANT_TYPE_DICTIONARY: {
		}
		default: {
			assert(false);
		}
	}
}

Janet
gdjn_janetize_typed
(	GDExtensionTypePtr     const v,
	GDExtensionVariantType const t
) {
	switch (t) {
		case GDEXTENSION_VARIANT_TYPE_NIL:
			return janet_wrap_nil();
		case GDEXTENSION_VARIANT_TYPE_BOOL:
			return janet_wrap_boolean(_safe_wrap(gd_bool, int8_t));
		case GDEXTENSION_VARIANT_TYPE_INT:
			return janet_wrap_s64(_safe_wrap(gd_int, int64_t));
		case GDEXTENSION_VARIANT_TYPE_FLOAT:
			_Static_assert(
				sizeof(gd_float) == sizeof(double) ||
				sizeof(gd_float) == sizeof(float)
			);
			return janet_wrap_number(
				(sizeof(gd_float) == sizeof(double)) ? *(double*)v :
				(sizeof(gd_float) == sizeof(float))  ? *(float*)v  :0);

		case GDEXTENSION_VARIANT_TYPE_STRING: {
			auto str = gdu_string_pdup((gd_string*)v);
			auto j = janet_stringv((void*)str.v, str.sz);
			_free(str.v);
			return j;
		};

		case GDEXTENSION_VARIANT_TYPE_STRING_NAME: {
		   /* we can reasonably assume syms will be small enough
			* to fit on the stack and avoid a pointless malloc */
			auto str = _gdu_stringName_stackp((gd_stringName*)v);
			auto j = janet_keywordv((void*)str.v, str.sz);
			return j;
		};

		case GDEXTENSION_VARIANT_TYPE_ARRAY: {
			auto sz = gd_array_size(v);
			auto ja = janet_array(sz);
			for (size_t i = 0; i < sz; ++i) {
				auto val = _t(array).operatorIndexConst(v, i);
				auto j = gdjn_janetize(val);
				janet_array_push(ja, j);
			}
			return janet_wrap_array(ja);
		};
		default: assert(false);
	}
}


typedef struct jn_closure {
	Janet (*fn)(void* data, int32_t argc, Janet* argv);
	void (*gc)(void* data);
	char alignas(max_align_t) data [];
} jn_closure;

typedef struct jn_hnd_dict {
	JanetAbstractHead header;
	GDExtensionVariantType key, val;
	gd_dictionary dict;
} jn_hnd_dict;

typedef struct jn_hnd_array {
	JanetAbstractHead header;
	GDExtensionVariantType ty;
	gd_array array;
} jn_hnd_array;

static int
api_del_closure(void* ptr, size_t sz) {
	jn_closure* c = ptr;
	if (c -> gc != nullptr) {
		(*c -> gc)(c -> data);
	}
	return 0;
}

static Janet
api_call_closure
(	void* ptr,
	int32_t argc,
	Janet* argv
) {
	jn_closure* c = ptr;
	return (c -> fn)(c -> data, argc, argv);
}

static int
api_del_dict(void* ptr, size_t sz) {
	jn_hnd_dict* dict = ptr;
	_t(dictionary).dtor(&dict -> dict);
	printf("drop dict\n");
	return 0;
}
static int
api_del_array(void* ptr, size_t sz) {
	jn_hnd_array* array = ptr;
	_t(array).dtor(&array -> array);
	printf("drop array\n");
	return 0;
}

const JanetAbstractType jn_closure_def = {
	.name = "closure",
	.call = api_call_closure,
	.gc = api_del_closure,
};

const JanetAbstractType jn_hnd_dict_def = {
	.name = "prim/type/dict",
	.gc = api_del_dict,
};

const JanetAbstractType jn_hnd_array_def = {
	.name = "prim/type/array",
	.gc = api_del_array,
};


static Janet
api_new_array(int32_t argc, Janet* argv) {
	auto a = (jn_hnd_array*)janet_abstract(&jn_hnd_array_def, sizeof(jn_hnd_array));
	_t(array).empty(&a -> array, nullptr);
	printf("create array\n");
	return janet_wrap_abstract(a);
}

static Janet
api_new_dict(int32_t argc, Janet* argv) {
	auto a = (jn_hnd_dict*)janet_abstract(&jn_hnd_dict_def, sizeof(jn_hnd_dict));
	_t(dictionary).empty(&a -> dict, nullptr);
	printf("create dict\n");
	return janet_wrap_abstract(a);
}


/* (prim/class-load [<ident> [<ident2>...]])
 * low-level class loader. run at compile time to
 * import a godot class */
static Janet
api_class_load(int32_t argc, Janet* argv) {
	return janet_wrap_nil(); /* FIXME */
}

static const JanetReg reg_core [] = {
	{"class-load", api_class_load,
		"(prim/class-load ident)\n\n"
		"low-level loading function for Godot classes"},
	{"type/array", api_new_array,
		"(prim/type/array [...])\n\n"
		"create a handle to a new godot array object"},
	{"type/dict", api_new_dict,
		"(prim/type/dict <key-type> <val-type> {...})\n\n"
		"create a handle to a new godot dictionary object"},
	{}
};


JanetTable*
gdjn_vm_api_spawnEnv (JanetTable* api) {
	/* create a clean new environment that can be used
	 * and discarded by a script without contaminating
	 * the global environment(s)
	 * yes this is ooky */
	auto env = jnu_table_extend(api, 8);
	auto sym_mc = janet_csymbolv("module/cache");
	auto cleancache = jnu_table_extend(
			janet_unwrap_table(janet_table_get(api, sym_mc)), 8);

	janet_table_put(env, janet_csymbolv("module/cache"), janet_wrap_table(cleancache));
	return env;
}


gdjn_vm_bind
gdjn_vm_meta
(	JanetTable* bind
) {
	gdjn_vm_bind b = {};

	if (gdjn_vm_metaFlag(bind, "private")) goto fail;
	if (!gdjn_vm_metaKey(bind, "value", &b.val)) goto fail;

	if (gdjn_vm_metaFlag(bind, "macro"))
		b.kind = gdjn_vm_bind_mac;
	else {
		if (gdjn_vm_metaKey(bind, "method", &b.meta))
			/* TODO assert callability */
			b.kind = gdjn_vm_bind_method;
		else if (gdjn_vm_metaFlag(bind, "class"))
			b.kind = gdjn_vm_bind_class;
		else if (gdjn_vm_metaKey(bind, "type", &b.meta)) {
			if (gdjn_vm_metaFlag(bind, "prop")) {
				b.kind = gdjn_vm_bind_prop;
			} else /* constant */ {
				b.kind = gdjn_vm_bind_const;
				goto succeed;
			}
			if (gdjn_vm_metaFlag(bind, "share"))
				b.kind |= gdjn_vm_bind_flag_static;
		} else {
			switch (janet_type(b.val)) {
				case JANET_ABSTRACT:
					if ((janet_abstract_type(&b.val)) != &jn_closure_def) {
						b.kind = gdjn_vm_bind_const; break;
					}
				case JANET_FUNCTION:
				case JANET_CFUNCTION:
					b.kind = gdjn_vm_bind_method_static;
					break;
				default: goto fail;
			}
		}
	}
	/* found a valid export, return it */
	succeed: return b;
	/* this binding is not marked correctly for gdexport */
	fail: return (gdjn_vm_bind){gdjn_vm_bind_none};
}

gdjn_vm_bind
gdjn_vm_resv
(	JanetTable* env,
	Janet       key
) {
	auto gchnd = janet_gclock();
	Janet def = janet_table_get(env, key);
	if (janet_type(def) == JANET_NIL)
		return (gdjn_vm_bind){};
	auto m = gdjn_vm_meta(janet_unwrap_table(def));
	janet_gcunlock(gchnd);
	return m;
}

void gdjn_vm_api_installCommon (JanetTable* tgt) {
	/* install primitives */
	janet_cfuns(tgt, "prim", reg_core);
	auto idmap = janet_env_lookup(tgt);
	int gc = janet_gclock();

	/* unpack API image */
	Janet apiEnv = janet_unmarshal(
		gdjn_rsrc_api_jimage,
		sizeof gdjn_rsrc_api_jimage,
		0,
		idmap,
		nullptr);
	printf("apienv type is %s\n",
			janet_type_names[janet_type(apiEnv)]);

	JanetTable* apiTbl = janet_unwrap_table(apiEnv);
	/* call the init function to precache base modules */
	Janet initDef = janet_table_get(apiTbl, janet_csymbolv("init"));
	if (janet_type(initDef) == JANET_NIL) {
		_err("no init fn in api envtbl");
		goto fail;
	}
	auto initFn = janet_unwrap_function(
			janet_table_get(janet_unwrap_table(initDef), 
				janet_ckeywordv("value")));
	Janet ret;
	auto e = janet_pcall(initFn, 1,
			(Janet[]) {janet_wrap_table(tgt)},
			&ret, nullptr);
	if (e == JANET_SIGNAL_ERROR) {
		_errMsg("failed to unpack the janet environment",
			(char*)janet_unwrap_string(ret));
		goto fail;
	}
	/* janet_table_merge_table(tgt, janet_unwrap_table(ret)); */
	printf("environment load complete\n");
fail:
	janet_gcunlock(gc);
	/* janet_collect(); */
}

JanetTable* gdjn_vm_api_build_compTime(void) {
	auto core = janet_core_env(nullptr);
	auto api = jnu_table_extend(core,32);
	gdjn_vm_api_installCommon(api);
	return api;
}

JanetTable* gdjn_vm_api_build_core(void) {
	auto core = janet_core_env(nullptr);
	auto api = jnu_table_extend(core,32);
	gdjn_vm_api_installCommon(api);
	return api;
}

JanetTable*
gdjn_vm_compile
(	pstr const  body,
	JanetTable* api,
	const char* ctx
) {
	if (!ctx) ctx = "<anon>";
	if (!api) api = gdjn_ctx -> jn.api;

	auto cls = jnu_table_extend(api, 8);
	janet_gcroot(janet_wrap_table(cls));
	/* printf("janet: doing bytes %d %s\n", (int)me -> src.sz, me -> src.v); */
	int e = janet_dobytes(cls,
		(uint8_t const*)body.v, body.sz,
		ctx, nullptr);
	/* we discard the return value; the environment is what
	 * we're really interested in here */
	/* printf("janet: bytes done, got %d\n",e); */
	if (e != 0) {
		_err("janet module could not be loaded");
		/* TODO capture parse error */
		janet_gcunroot(janet_wrap_table(cls));
		cls = nullptr;
	}
	return cls;
}


pstr
gdjn_vm_image
(	JanetTable* env,
	JanetTable* binds
) {
	return (pstr){}; //TODO
}