#include "NewPlacement.hpp"
#include "HeapAllocatorGlobal.hpp"

#include "core/scriptsection.h"

using namespace obj;

ScriptSection* gScriptSection = NULL;

struct script_data_head {
	tp::alni refc = 0;
	tp::alni store_adress = 0;
};

void set_script_head_store_adress(Script* in, tp::alni address) {
	((script_data_head*)in - 1)->store_adress = address;
}

tp::alni get_script_head_store_adress(Script* in) {
	return ((script_data_head*)in - 1)->store_adress;
}

Script* ScriptSection::createScript() {
	auto sdhead = (script_data_head*)tp::HeapAllocGlobal::allocate(sizeof(script_data_head) + sizeof(Script));
	auto out = (Script*)(sdhead + 1);

	if (!sdhead) {
		return NULL;
	}

	sdhead->refc = 1;
	sdhead->store_adress = -1;

	mScripts.pushBack(out);

	new (out) Script();
	out->mReadable = obj::StringObject::create("");
	obj::NDO->refinc(out->mReadable);
	return out;
}

void ScriptSection::delete_script(Script* script) {
	script->~Script();
	obj::NDO->destroy(script->mReadable);

	tp::HeapAllocGlobal::deallocate((((script_data_head*)script) - 1));
}

void ScriptSection::reference_script(Script* script) {
	(((script_data_head*)script) - 1)->refc++;
}

void ScriptSection::abandonScript(Script* script) {
	if ((((script_data_head*)script) - 1)->refc > 1) {
		(((script_data_head*)script) - 1)->refc--;
	}
	else {
		// ISSUE : on delete list structure is outdated
		// FIXME : use pool alloc with ref count
		// forwarding to global destruction
		//delete_script(script);
	}
}

void ScriptSection::changeScript(Script** current_script, Script** new_script) {
	abandonScript(*current_script);
	reference_script(*new_script);

	*current_script = *new_script;
}

tp::alni ScriptSection::get_script_file_adress(Script* in) {
	return  get_script_head_store_adress(in);
}

tp::alni ScriptSection::save_script_table_to_file_size(ScriptSection* self, Archiver& file) {
	tp::alni size = 0;
	size += 5; // header
	size += sizeof(tp::alni); // scripts length

	for (auto iter : self->mScripts) {

		set_script_head_store_adress(iter.data(), file.adress + size);

		size += sizeof(tp::alni); // scripts string obj ref
		size += sizeof(tp::alni); // constants length

		for (auto const_obj : iter->mBytecode.mConstants) {
			size += sizeof(tp::alni); // constant object addres
		}

		// instructions
		size += iter->mBytecode.mInstructions.saveSize();
	}

	size += sizeof(tp::alni); // objects mem offset
	size += 5; // header
	return size;
}

void ScriptSection::save_script_table_to_file(ScriptSection* self, Archiver& file) {
	// header
	file.write_bytes("/scr/", 5);

	// scripts length
	tp::alni scripts_count = self->mScripts.length(); 
	file.write<tp::alni>(&scripts_count);

	for (auto iter : self->mScripts) {
		
		// scripts string obj ref
		auto obj_addres = obj::NDO->save(file, iter->mReadable);
		file.write(&obj_addres);

		// constants length
		tp::alni consts_count = iter->mBytecode.mConstants.size();
		file.write<tp::alni>(&consts_count);

		for (auto const_obj : iter->mBytecode.mConstants) {
			// constant object addres
			auto obj_addres = obj::NDO->save(file, const_obj.data());
			file.write(&obj_addres);
		}

		// mInstructions
		iter->mBytecode.mInstructions.save(file);
	}

	// header
	file.write_bytes("/scr/", 5);

	tp::alni objects_mem_offset = file.avl_adress;
	file.write<tp::alni>(&objects_mem_offset);
}

void load_constants(ScriptSection* self, Archiver& file, tp::alni start_addr) {
	auto addres = file.adress;

	file.adress = start_addr;
	file.adress += 5; // header
	
	tp::alni scripts_count;
	file.read<tp::alni>(&scripts_count);

	for (tp::alni i = 0; i < scripts_count; i++) {
		
		auto script = self->get_scritp_from_file_adress(file.adress);

		// script text
		tp::alni str_addr;
		file.read<tp::alni>(&str_addr);
		script->mReadable = NDO_CAST(obj::StringObject, obj::NDO->load(file, str_addr));

		file.adress += sizeof(tp::alni); // constants length

		for (auto const_obj : script->mBytecode.mConstants) {
			tp::alni consts_addr;
			file.read<tp::alni>(&consts_addr);
			const_obj.data() = obj::NDO->load(file, consts_addr);
		}

		// instructions
		file.adress += script->mBytecode.mInstructions.saveSize();
	}

	file.adress = addres;
}

void ScriptSection::load_script_table_from_file(ScriptSection* self, Archiver& file) {
	for (auto iter : self->mScripts) {
		set_script_head_store_adress(iter.data(), -1);
	}

	auto section_start_addr = file.adress;

	// header
	file.adress += 5;

	// scripts length
	tp::alni scripts_count;
	file.read<tp::alni>(&scripts_count);

	for (tp::alni i = 0; i < scripts_count; i++) {

		auto new_script = self->createScript();
		set_script_head_store_adress(new_script, file.adress);

		// scripts text
		file.adress += sizeof(tp::alni);

		// constants length
		tp::alni consts_count;
		file.read<tp::alni>(&consts_count);

		new_script->mBytecode.mConstants.reserve(consts_count);

		for (tp::alni j = 0; j < consts_count; j++) {
			// constant object addres
			tp::alni consts_addr;
			file.read<tp::alni>(&consts_addr);

			// skiping
			//new_script->mBytecode.mConstants[j] = obj::NDO->load(file, consts_addr);
		}

		// mInstructions
		new_script->mBytecode.mInstructions.load(file);
	}

	load_constants(self, file, section_start_addr);

	// header
	file.adress += 5;

	tp::alni objects_mem_offset;
	file.read<tp::alni>(&objects_mem_offset);

	file.adress = objects_mem_offset;
}

Script* ScriptSection::get_scritp_from_file_adress(tp::alni file_adress) {
	for (auto iter : mScripts) {
		if (get_script_head_store_adress(iter.data()) == file_adress) {
			return iter.data();
		}
	}
	return NULL;
}

ScriptSection::~ScriptSection() {
	for (auto iter : mScripts) {
		delete_script(iter.data());
	}
}

obj::save_load_callbacks ScriptSection::slcb_script_section = {
	.self = gScriptSection,
	.pre_save = (obj::pre_save_callback*)ScriptSection::save_script_table_to_file,
	.size = (obj::slcb_size_callback*)ScriptSection::save_script_table_to_file_size,
	.pre_load = (obj::pre_load_callback*)ScriptSection::load_script_table_from_file,
	.post_save = NULL,
	.post_load = NULL,
};


void ScriptSection::initialize() {
	ASSERT(!gScriptSection);
	gScriptSection = new ScriptSection();

	ASSERT(obj::NDO && "Forgot to initialize objects?");

	slcb_script_section.self = gScriptSection;
	obj::NDO->add_sl_callbacks(&slcb_script_section);
}

void ScriptSection::uninitialize() {
	ASSERT(gScriptSection);
	delete gScriptSection;
}

ScriptSection* ScriptSection::globalHandle() {
	return gScriptSection;
}