#include "serialization-input.hpp"

#include "compile-time-assert.hpp"
#include "game-settings.hpp"
#include "level.hpp"

#include "pk.h"

#include <cstring>

pk_handle pke_serialize_input_action(srlztn_serialize_helper *h, pke_input_action *action) {
	char *s;
	int len;
	pke_kve kve{};
	pke_kve_container kvec{};

	kvec.srlztn_handle = h->handle_head;
	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_INPUT_ACTION);
	kvec.bkt = h->bkt;
	kvec.arr.bkt = h->bkt;
	kvec.children.bkt = h->bkt;
	kvec.child_handles.bkt = h->bkt;
	h->handle_head.itemIndex++;

	compt_a<40==sizeof(pke_input_action)>();
	{
		kve.key = SRLZTN_INPUT_ACTION_NAME;
		len = strlen(action->name)+1;
		s = pk_new_arr<char>(len, h->bkt);
		sprintf(s, "%s", action->name);
		kve.val = s;
		kve.end = SRLZTN_KVE_END;
		pk_arr_append_t(&kvec.arr, kve);
	}
	for (int i = 0; i < PKE_INPUT_ACTION_MASK_INDEX_COUNT; ++i) {
		if (action->masks[i].computedHash == pke_input_event_hash{0}) {
			continue;
		}
		{
			kve.key = SRLZTN_INPUT_ACTION_MASK_HASH;
			len = snprintf(NULL, 0, "0x%.4hX", static_cast<pke_input_event_hash_T>(action->masks[i].computedHash));
			s = pk_new_arr<char>(len+1, h->bkt);
			sprintf(s, "0x%.4hX", static_cast<pke_input_event_hash_T>(action->masks[i].computedHash));
			kve.val = s;
			kve.end = SRLZTN_KVE_END;
			pk_arr_append_t(&kvec.arr, kve);
		}
		{
			kve.key = SRLZTN_INPUT_ACTION_MASK_BUTTON;
			len = snprintf(NULL, 0, "%i", action->masks[i].button);
			s = pk_new_arr<char>(len+1, h->bkt);
			sprintf(s, "%i", action->masks[i].button);
			kve.val = s;
			kve.end = SRLZTN_KVE_END;
			pk_arr_append_t(&kvec.arr, kve);
		}
		{
			kve.key = SRLZTN_INPUT_ACTION_MASK_MODS;
			len = snprintf(NULL, 0, "%i", action->masks[i].mods);
			s = pk_new_arr<char>(len+1, h->bkt);
			sprintf(s, "%i", action->masks[i].mods);
			kve.val = s;
			kve.end = SRLZTN_KVE_END;
			pk_arr_append_t(&kvec.arr, kve);
		}
	}

	pk_arr_append_t(&h->kvp_containers, kvec);
	return kvec.srlztn_handle;
}

void pke_deserialize_input_action(srlztn_deserialize_helper *h, pke_kve_container *kvec, pke_input_action &action) {
	(void)h;
	uint32_t i;
	int32_t mask_index = -1;
	char *s;
	pke_kve *kve = nullptr;
	PK_STN_RES stn_res = PK_STN_RES(0);

	compt_a<40==sizeof(pke_input_action)>();
	for (i = 0; i < kvec->arr.next; ++i) {
		kve = &kvec->arr[i];
		if (strncmp(kve->key, SRLZTN_INPUT_ACTION_NAME, strlen(SRLZTN_INPUT_ACTION_NAME)) == 0) {
			// TODO specific bkt?
			s = pk_new_arr<char>(strlen(kve->val)+1, NULL);
			sprintf(s, "%s", kve->key);
			action.name = s;
			continue;
		}
		if (strncmp(kve->key, SRLZTN_INPUT_ACTION_MASK_HASH, strlen(SRLZTN_INPUT_ACTION_MASK_HASH)) == 0) {
			mask_index += 1;
			assert(mask_index < PKE_INPUT_ACTION_MASK_INDEX_COUNT);
			pke_input_event_hash_T hash;
			stn_res = pk_stn(&hash, kve->val, NULL, 16);
			if (stn_res != PK_STN_RES_SUCCESS) {
				fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_INPUT_ACTION_MASK_HASH, kve->val);
				continue;
			}
			action.masks[mask_index].computedHash = pke_input_event_hash{hash};
			continue;
		}
		if (strncmp(kve->key, SRLZTN_INPUT_ACTION_MASK_BUTTON, strlen(SRLZTN_INPUT_ACTION_MASK_BUTTON)) == 0) {
			assert(mask_index >= 0);
			assert(mask_index < PKE_INPUT_ACTION_MASK_INDEX_COUNT);
			stn_res = pk_stn(&action.masks[mask_index].button, kve->val, NULL);
			if (stn_res != PK_STN_RES_SUCCESS) {
				fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_INPUT_ACTION_MASK_BUTTON, kve->val);
			}
			continue;
		}
		if (strncmp(kve->key, SRLZTN_INPUT_ACTION_MASK_MODS, strlen(SRLZTN_INPUT_ACTION_MASK_MODS)) == 0) {
			assert(mask_index >= 0);
			assert(mask_index < PKE_INPUT_ACTION_MASK_INDEX_COUNT);
			stn_res = pk_stn(&action.masks[mask_index].mods, kve->val, NULL);
			if (stn_res != PK_STN_RES_SUCCESS) {
				fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_INPUT_ACTION_MASK_MODS, kve->val);
			}
			continue;
		}
	}
}

pk_handle pke_serialize_input_set(srlztn_serialize_helper *h, pke_input_set *input_set) {
	char *s;
	int len;
	pke_kve kve{};
	pke_kve_container kvec{};

	kvec.srlztn_handle = h->handle_head;
	kvec.type_code = cstring_to_pk_cstr(SRLZTN_OBJ_INPUT_SET);
	kvec.bkt = h->bkt;
	kvec.arr.bkt = h->bkt;
	kvec.children.bkt = h->bkt;
	kvec.child_handles.bkt = h->bkt;
	h->handle_head.itemIndex++;

	for (int i = 0; i < input_set->actionCount; ++i) {
		pk_handle child_handle = pke_serialize_input_action(h, &input_set->actions[i]);
		pk_arr_append_t(&kvec.child_handles, child_handle);
	}

	compt_a<40==sizeof(pke_input_set)>();
	{
		kve.key = SRLZTN_INPUT_SET_TITLE;
		len = strlen(input_set->title)+1;
		s = pk_new_arr<char>(len, h->bkt);
		sprintf(s, "%s", input_set->title);
		kve.val = s;
		kve.end = SRLZTN_KVE_END;
		pk_arr_append_t(&kvec.arr, kve);
	}
	{
		kve.key = SRLZTN_INPUT_SET_FLAGS;
		len = snprintf(NULL, 0, "0x%.04X", static_cast<pke_input_action_set_flag_T>(input_set->flags));
		s = pk_new_arr<char>(len+1, h->bkt);
		sprintf(s, "0x%.04X", static_cast<pke_input_action_set_flag_T>(input_set->flags));
		kve.val = s;
		kve.end = SRLZTN_KVE_END;
		pk_arr_append_t(&kvec.arr, kve);
	}

	pk_arr_append_t(&h->kvp_containers, kvec);
	return kvec.srlztn_handle;
}

void pke_deserialize_input_set(srlztn_deserialize_helper *h, pke_kve_container *kvec) {
	(void)h;
	uint32_t i, k;
	char *s;
	pke_kve *kve = nullptr;
	pke_input_set set{};
	PK_STN_RES stn_res = PK_STN_RES(0);

	// TODO specific bucket
	set.actionCount = kvec->children.next;
	set.bkt = pkeSettings.mem_bkt.game;
	set.actions = pk_new_arr<pke_input_action>(kvec->children.next, set.bkt);
	for (k = 0; k < set.actionCount; ++k) {
		pke_deserialize_input_action(h, kvec->children[k], set.actions[k]);
	}

	compt_a<40==sizeof(pke_input_set)>();
	for (i = 0; i < kvec->arr.next; ++i) {
		kve = &kvec->arr[i];
		if (strncmp(kve->key, SRLZTN_INPUT_SET_TITLE, strlen(SRLZTN_INPUT_SET_TITLE)) == 0) {
			// TODO specific bkt?
			s = pk_new_arr<char>(strlen(kve->val)+1, NULL);
			sprintf(s, "%s", kve->key);
			set.title = s;
			continue;
		}
		if (strncmp(kve->key, SRLZTN_INPUT_SET_FLAGS, strlen(SRLZTN_INPUT_SET_FLAGS)) == 0) {
			pke_input_action_set_flag_T flags;
			stn_res = pk_stn(&flags, kve->val, NULL, 16);
			if (stn_res != PK_STN_RES_SUCCESS) {
				fprintf(stderr, "[%s] Err '%u' parsing '%s' primary from: '%s'\n", __FILE__, stn_res, SRLZTN_INPUT_SET_FLAGS, kve->val);
				continue;
			}
			set.flags = pke_input_action_set_flag{flags};
			continue;
		}
	}

	pke_input_action_set_handle action_set_handle = pke_input_register_set(std::move(set));
	if (pkeSettings.rt.activeLevel != nullptr) {
		pke_level_register_input_action_set(pkeSettings.rt.activeLevel, action_set_handle);
	}
	if (PK_HAS_FLAG(set.flags, PKE_INPUT_ACTION_SET_FLAG_AUTO_ENABLE)) {
		pke_input_activate_set(action_set_handle);
	}
}