#include <StdInc.h>

#include <catch_amalgamated.hpp>
#include <filesystem>

#include <lua.hpp>
#include <LuaFXLib.h>
#include <lua_cmsgpacklib.h>
#include <lua_rapidjsonlib.h>

#include "LuaScriptRuntime.h"
#include "RelativeDevice.h"
#include "ResourceManager.h"
#include "VFSManager.h"

#ifdef IS_FXSERVER
// vfs manager
#include "Manager.h"
#endif

//#undef LuaScriptRuntime
#define LUA_LIB

#if LUA_VERSION_NUM == 504
#define LUA_INTERNAL_LINKAGE "C++"
#else
#define LUA_INTERNAL_LINKAGE "C"
#endif

// Utility macro for the constexpr if statement
#define LUA_IF_CONSTEXPR if constexpr

// Inline utility
#if !defined(LUA_INLINE)
#ifdef _MSC_VER
#ifndef _DEBUG
#define LUA_INLINE __forceinline
#else
#define LUA_INLINE
#endif
#elif __has_attribute(__always_inline__)
#define LUA_INLINE inline __attribute__((__always_inline__))
#else
#define LUA_INLINE inline
#endif
#endif

#if LUA_VERSION_NUM >= 504 && defined(_WIN32)
#define LUA_USE_RPMALLOC
#endif

// tests have to use lua54 because it gets linked second so the LuaScriptRuntime is for lua54

namespace
{
// lua is static linked, lualibs array from script runtime won't work
static const luaL_Reg lualibs[] = {
	{"_G", luaopen_base},
	{LUA_TABLIBNAME, luaopen_table},
	{LUA_STRLIBNAME, luaopen_string},
	{LUA_MATHLIBNAME, luaopen_math},
	{LUA_DBLIBNAME, luaopen_debug},
	{LUA_COLIBNAME, luaopen_coroutine},
	{LUA_UTF8LIBNAME, luaopen_utf8},
#ifdef IS_FXSERVER
	{LUA_FX_IOLIBNAME, fx::lua_fx_openio},
	{LUA_FX_OSLIBNAME, fx::lua_fx_openos},
#endif
	{"msgpack", luaopen_cmsgpack},
	{"json", luaopen_rapidjson},
	{nullptr, nullptr}
};

// todo: add method to execute lua code from inside LuaScriptRuntime to prevent static link issues

void RuntimeSetup(fx::LuaStateHolder& state)
{
	// safe_openlibs
	const luaL_Reg* lib = lualibs;
	for (; lib->func; lib++)
	{
		luaL_requiref(state, lib->name, lib->func, 1);
		lua_pop(state, 1);
	}

	/*{
		// 0
		lua_getglobal(m_state, "debug");

		// 1
		lua_getfield(m_state, -1, "traceback");

		// 2
		m_dbTraceback = lua_tocfunction(m_state, -1);
		lua_pop(m_state, 2);

		// 0
	}*/

	// register the 'Citizen' library
	lua_newtable(state);
	luaL_setfuncs(state, fx::LuaScriptRuntime::GetCitizenLibs(), 0);
	lua_setglobal(state, "Citizen");

	// load the system scheduler script
	/*result_t hr;

	if (FX_FAILED(hr = LoadNativesBuild(nativesBuild)))
	{
		return hr;
	}

	if (FX_FAILED(hr = LoadSystemFile("citizen:/scripting/lua/deferred.lua")))
	{
		return hr;
	}

	if (FX_FAILED(hr = LoadSystemFile("citizen:/scripting/lua/scheduler.lua")))
	{
		return hr;
	}

	// Graph script loaded into Citizen.Graph
	// @TODO: Only load graphing utility on Lua_Require
	if (FX_FAILED(hr = LoadSystemFile("citizen:/scripting/lua/graph.lua")))
	{
		return hr;
	}*/

	lua_pushnil(state);
	lua_setglobal(state, "dofile");

	lua_pushnil(state);
	lua_setglobal(state, "loadfile");

	// todo: add print and require support

	//lua_pushcfunction(state, Lua_Print);
	//lua_setglobal(state, "print");

	//lua_pushcfunction(state, Lua_Require);
	//lua_setglobal(state, "require");
}

//void RuntimeDestroy()
//{
// we need to push the environment before closing as items may have __gc callbacks requiring a current runtime to be set
// in addition, we can't do this in the destructor due to refcounting oddities (PushEnvironment adds a reference, causing infinite deletion loops)
//LuaPushEnvironment pushed(this);
//	m_state.Close();
//}

void LoadAndRunCode(fx::LuaStateHolder& state, const std::string&& fileName, const std::string&& code,
                    bool expectExecutionError = false)
{
	// create a chunk name prefixed with @ (suppresses '[string "..."]' formatting)
	fwString chunkName("@");
	chunkName.append(fileName);

	if (luaL_loadbuffer(state, code.c_str(), code.size(), chunkName.c_str()) != 0)
	{
		// seemingly, it failed...
		trace(std::string("Could not parse lua code") + luaL_checkstring(state, -1));
		lua_pop(state, 1);
		REQUIRE((std::string("Could not parse lua code") + luaL_checkstring(state, -1)).empty());
	}

	if (lua_pcall(state, 0, 0, 0) != LUA_OK)
	{
		if (!expectExecutionError)
		{
			trace(std::string("Error executing Lua code: ") + lua_tostring(state, -1));
			REQUIRE((std::string("Error executing Lua code: ") + lua_tostring(state, -1)).empty());
			REQUIRE(false);
		}
		lua_pop(state, 1);
	}
	else
	{
		REQUIRE(!expectExecutionError);
	}
}
}

// todo: emulate threading

TEST_CASE("lua run")
{
	REQUIRE(LUA_VERSION_NUM == 504);
	fx::LuaStateHolder state;
	RuntimeSetup(state);

	LoadAndRunCode(state, "main.lua", R""""(
		local test = {}
		msgpack.pack(test)
		print("Hello Test")
		globalTest = {}
		globalTest.arg1 = "123"
		--Citizen.CreateThread(function()
		--    Citizen.Wait(1000)
		--end)
		
)"""");

	{
		// 0
		lua_getglobal(state, "globalTest");
		REQUIRE(lua_istable(state, -1) == true);
		// 1
		lua_getfield(state, -1, "arg1");
		REQUIRE(lua_isstring(state, -1) == true);
		// 2
		size_t l{0};
		const char* str = lua_tolstring(state, -1, &l);
		REQUIRE(l == 3);
		REQUIRE(std::string_view(str, l) == "123");
		lua_pop(state, 2);
	}
}

TEST_CASE("read none existing file")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);

	// todo: emulate file system

	// todo: switch to resource api for file reads

	LoadAndRunCode(state, "main.lua", R""""(
		local file = io.open("test.txt", "rb")
		if not file then 
			result = "noFile"
			return
		end
		result = file:read "*a"
		file:close()
)"""");

	{
		lua_getglobal(state, "result");
		REQUIRE(lua_isstring(state, -1) == true);
		size_t l{0};
		const char* str = lua_tolstring(state, -1, &l);
		REQUIRE(std::string_view(str, l) == "noFile");
	}
}

TEST_CASE("remove a file")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);

	// todo: emulate file system

	// todo: switch to resource api for file reads

	// todo: allow removes for files inside the resource directory

	LoadAndRunCode(state, "main.lua", R""""(
		noResult, errMessage, errNumber = os.remove("test.txt")
)"""");

	{
		lua_getglobal(state, "errNumber");
		REQUIRE(lua_isnumber(state, -1) == true);
		int isNum{0};
		lua_Number num = lua_tonumberx(state, -1, &isNum);
		REQUIRE(isNum);
		REQUIRE(static_cast<uint8_t>(num) == fx::Lua_EACCES);
	}
}

TEST_CASE("rename a file")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);

	std::filesystem::path currentPath = std::filesystem::current_path();
	currentPath = currentPath.append("tests");
	if (!std::filesystem::exists(currentPath))
	{
		if (std::filesystem::create_directory(currentPath))
		{
			REQUIRE(true);
		}
	}

	fwRefContainer relativeDevice = new vfs::RelativeDevice(currentPath.string() + "/");
	std::string mountPath = "@test/";
	vfs::Unmount(mountPath);
	vfs::Mount(relativeDevice, mountPath);

	vfs::Create("@test/rename.txt", false);

	WHEN ("a file is trying to be renamed that does not exists")
	{
		LoadAndRunCode(state, "main.lua", R""""(
		noResult, errMessage, errNumber = os.rename("404.txt", "503.txt")
)"""");

		THEN("EACCES is returned")
		{
			lua_getglobal(state, "errNumber");
			REQUIRE(lua_isnumber(state, -1) == true);
			int isNum{0};
			int64_t num = static_cast<int64_t>(lua_tonumberx(state, -1, &isNum));
			REQUIRE(isNum);
			REQUIRE(num == EACCES);
			lua_pop(state, 1);
		}
	}

	/*WHEN ("a file is being renamed that does exists")
	{
		LoadAndRunCode(state, "main.lua", std::string(R""""(
		noResult, errMessage, errNumber = os.rename("@test/rename.txt", "@test/rename2.txt")
		noResult, errMessage, errNumber = os.rename("@test/rename2.txt", "@test/rename.txt")
)""""));

		THEN("true is returned")
		{
			lua_getglobal(state, "noResult");
			REQUIRE(lua_isnil(state, -1) == true);
			lua_pop(state, 1);
		}
	}*/
}

TEST_CASE("generate temp file name")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);

	LoadAndRunCode(state, "main.lua", R""""(
		result = os.tmpname()
)"""");

	{
		lua_getglobal(state, "result");
		REQUIRE(lua_isstring(state, -1) == true);
		size_t l{0};
		const char* str = lua_tolstring(state, -1, &l);
		REQUIRE(std::string_view(str, l).rfind("tmp_", 0) == 0);
	}
}

TEST_CASE("lua os.getenv")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);

	LoadAndRunCode(state, "main.lua", R""""(
		result = os.getenv("OS")
		noResult = os.getenv("%PATH%")
)"""");

	{
		lua_getglobal(state, "result");
		REQUIRE(lua_isstring(state, -1) == true);
		size_t l{0};
		const char* str = lua_tolstring(state, -1, &l);
#ifdef WIN32
		REQUIRE(std::string_view(str, l) == "Windows");
#else
		REQUIRE(std::string_view(str, l) == "Linux");
#endif
		lua_pop(state, 1);
	}
	
	LoadAndRunCode(state, "main.lua", R""""(
		result = os.getenv("Os")
		noResult = os.getenv("%PATH%")
)"""");

	{
		lua_getglobal(state, "result");
		REQUIRE(lua_isstring(state, -1) == true);
		size_t l{0};
		const char* str = lua_tolstring(state, -1, &l);
#ifdef WIN32
		REQUIRE(std::string_view(str, l) == "Windows");
#else
		REQUIRE(std::string_view(str, l) == "Linux");
#endif
		lua_pop(state, 1);
	}

	{
		lua_getglobal(state, "noResult");
		REQUIRE(lua_isnil(state, -1) == true);
	}
}

TEST_CASE("lua os.setlocale")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);
	LoadAndRunCode(state, "main.lua", R""""(
		result = os.setlocale("en-US", "all")
)"""");

	{
		lua_getglobal(state, "result");
		REQUIRE(lua_isstring(state, -1) == true);
		size_t l{0};
		const char* str = lua_tolstring(state, -1, &l);
		REQUIRE(std::string_view(str, l) == "en-US");
		lua_pop(state, 1);
	}
}

TEST_CASE("lua os.exit")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);
	LoadAndRunCode(state, "main.lua", R""""(
		os.exit(1)
)"""", true);
}

TEST_CASE("lua os.time")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);
	
	WHEN ("os.time is called with no args")
	{
		auto timeStart = time(nullptr);
		LoadAndRunCode(state, "main.lua", R""""(
		result = os.time()
)"""");
		auto timeEnd = time(nullptr);

		THEN("it is returning the timestamp")
		{
			lua_getglobal(state, "result");
			REQUIRE(lua_isstring(state, -1) == true);
			size_t l{0};
			const char* str = lua_tolstring(state, -1, &l);
			int ts = std::stoi(str);
			REQUIRE(timeStart <= ts);
			REQUIRE(ts <= timeEnd);
			lua_pop(state, 1);
		}
	}

	WHEN ("os.time is called with args")
	{
		LoadAndRunCode(state, "main.lua", R""""(
		result = os.time({year=2000, month=1, day=1, hour=0, min=0, sec=0, isdst=false})
)"""");

		THEN("it is returning the timestamp for the date")
		{
			lua_getglobal(state, "result");
			REQUIRE(lua_isnil(state, -1) == false);
			REQUIRE(lua_isnumber(state, -1) == true);
			std::time_t timestamp = static_cast<std::time_t>(lua_tonumber(state, -1));
			std::tm tm {};
			static constexpr int64_t yearOffset = 1900;
			static constexpr int64_t monthOffset = 1;
			tm.tm_year = 2000 - yearOffset;
			tm.tm_mon = 1 - monthOffset;
			tm.tm_mday = 1;
			const std::time_t calculatedTimestamp = std::mktime(&tm);
			REQUIRE(calculatedTimestamp == timestamp);
			lua_pop(state, 1);
		}
	}
}

TEST_CASE("lua os.date")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);

	WHEN ("os.date is called with *t")
	{
		LoadAndRunCode(state, "main.lua", R""""(
		result = os.date("*t")
)"""");

		THEN ("result is a table with the date fields in local time")
		{
			// comparison with current time would result in a possible mismatch when time changes in execution
			const time_t t = std::time(nullptr);
			const std::tm* stm = std::localtime(&t);
			
			lua_getglobal(state, "result");
			REQUIRE(lua_istable(state, -1) == true);
			lua_getfield(state, -1, "year");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_year + 1900);
			lua_pop(state, 1);
			lua_getfield(state, -1, "month");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_mon + 1);
			lua_pop(state, 1);
			lua_getfield(state, -1, "day");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_mday);
			lua_pop(state, 1);
			lua_getfield(state, -1, "hour");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_hour);
			lua_pop(state, 1);
			lua_getfield(state, -1, "min");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_min);
			lua_pop(state, 1);
			lua_getfield(state, -1, "sec");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_sec);
			lua_pop(state, 1);
			lua_getfield(state, -1, "wday");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_wday + 1);
			lua_pop(state, 1);
			lua_getfield(state, -1, "yday");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_yday + 1);
			lua_pop(state, 1);
			lua_getfield(state, -1, "isdst");
			REQUIRE(lua_isboolean(state, -1) == true);
			//REQUIRE(lua_toboolean(state, -1) == stm->tm_isdst);
			lua_pop(state, 1);
			lua_pop(state, 1);
		}
	}

	WHEN ("os.date is called with !*t")
	{
		LoadAndRunCode(state, "main.lua", R""""(
		result = os.date("!*t")
)"""");

		THEN ("result is a table with the date fields in gm time")
		{
			// comparison with current time would result in a possible mismatch when time changes in execution
			const time_t t = std::time(nullptr);
			const std::tm* stm = std::gmtime(&t);
			
			lua_getglobal(state, "result");
			REQUIRE(lua_istable(state, -1) == true);
			lua_getfield(state, -1, "year");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_year + 1900);
			lua_pop(state, 1);
			lua_getfield(state, -1, "month");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_mon + 1);
			lua_pop(state, 1);
			lua_getfield(state, -1, "day");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_mday);
			lua_pop(state, 1);
			lua_getfield(state, -1, "hour");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_hour);
			lua_pop(state, 1);
			lua_getfield(state, -1, "min");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_min);
			lua_pop(state, 1);
			lua_getfield(state, -1, "sec");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_sec);
			lua_pop(state, 1);
			lua_getfield(state, -1, "wday");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_wday + 1);
			lua_pop(state, 1);
			lua_getfield(state, -1, "yday");
			REQUIRE(lua_isnumber(state, -1) == true);
			//REQUIRE(static_cast<int64_t>(lua_tonumber(state, -1)) == stm->tm_yday + 1);
			lua_pop(state, 1);
			lua_getfield(state, -1, "isdst");
			REQUIRE(lua_isboolean(state, -1) == true);
			//REQUIRE(lua_toboolean(state, -1) == stm->tm_isdst);
			lua_pop(state, 1);
			lua_pop(state, 1);
		}
	}

	WHEN ("os.date is called without an argument")
	{
		LoadAndRunCode(state, "main.lua", R""""(
		result = os.date()
)"""");

		THEN ("result is using default format %c")
		{
			// example output: "Wed Dec 1 01:23:45 2024"
			lua_getglobal(state, "result");
			REQUIRE(lua_isstring(state, -1) == true);
			size_t l{0};
			const char* str = lua_tolstring(state, -1, &l);
			REQUIRE(str);
			REQUIRE(l > 10);
			lua_pop(state, 1);
		}
	}

	WHEN ("os.date is called with timezone")
	{
		LoadAndRunCode(state, "main.lua", R""""(
		result = os.date("%Z")
)"""");

		THEN ("result is the timezone")
		{
			// example output: "W. Europe Standard Time"
			lua_getglobal(state, "result");
			REQUIRE(lua_isstring(state, -1) == true);
			size_t l{0};
			const char* str = lua_tolstring(state, -1, &l);
			REQUIRE(str);
			REQUIRE(l > 5);
			lua_pop(state, 1);
		}
	}

	WHEN ("os.date is called with Z to indicate zen time")
	{
		LoadAndRunCode(state, "main.lua",
		R""""(
		result = os.date("!%Y-%m-%dT%H:%M:%SZ")
)"""");

		THEN ("result is the formatted time with a Z in the end")
		{
			lua_getglobal(state, "result");
			REQUIRE(lua_isstring(state, -1) == true);
			size_t l{0};
			const char* str = lua_tolstring(state, -1, &l);
			REQUIRE(str);
			REQUIRE(l == std::string_view("0000-00-00T00:00:00Z").size());
			lua_pop(state, 1);
		}
	}
}

TEST_CASE("lua os.difftime")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);

	LoadAndRunCode(state, "main.lua", R""""(
		time1 = os.time({year=2000, month=1, day=1, hour=0, min=0, sec=0, isdst=false})
		time2 = os.time({year=2000, month=1, day=2, hour=0, min=0, sec=0, isdst=false})
		result = os.difftime(time1, time2)
)"""");

	THEN("it is returning the timestamp for the date")
	{
		lua_getglobal(state, "time1");
		REQUIRE(lua_isnumber(state, -1) == true);
		std::time_t timestamp1 = static_cast<std::time_t>(lua_tonumber(state, -1));
		lua_pop(state, 1);
		lua_getglobal(state, "time2");
		REQUIRE(lua_isnumber(state, -1) == true);
		std::time_t timestamp2 = static_cast<std::time_t>(lua_tonumber(state, -1));
		lua_pop(state, 1);
		lua_getglobal(state, "result");
		REQUIRE(lua_isnumber(state, -1) == true);
		double result = lua_tonumber(state, -1);
		REQUIRE(std::fabs(std::difftime(timestamp1, timestamp2) - result) < std::numeric_limits<double>::epsilon());
		lua_pop(state, 1);
	}
}

TEST_CASE("lua os.clock")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);

	auto clockStart = std::clock();
	LoadAndRunCode(state, "main.lua", R""""(
		result = os.clock()
)"""");
	auto clockEnd = std::clock();
	
	lua_getglobal(state, "result");
	REQUIRE(lua_isnumber(state, -1) == true);
	int isNum{0};
	lua_Number clockSeconds = lua_tonumberx(state, -1, &isNum);
	int64_t clock = static_cast<int64_t>(clockSeconds * 1000);
	REQUIRE(isNum);
	// 100 microseconds tolerance
	constexpr clock_t tolerance = 100;
	REQUIRE(clockStart <= clock + tolerance);
	REQUIRE(clock <= clockEnd + tolerance);
	lua_pop(state, 1);
}

TEST_CASE("lua os.execute")
{
	fx::LuaStateHolder state;
	RuntimeSetup(state);
	
	WHEN ("os.execute is called with no args")
	{
		LoadAndRunCode(state, "main.lua", R""""(
		result = os.execute()
)"""");
		THEN ("it checks if a system shell exists which is always true")
		{
			lua_getglobal(state, "result");
			REQUIRE(lua_isboolean(state, -1) == true);
			REQUIRE(lua_toboolean(state, -1) == true);
		}
	}

	WHEN ("os.execute is called with an unsupported command")
	{
		LoadAndRunCode(state, "main.lua", R""""(
		result, what, code = os.execute("rd /s /q D:\\")
)"""");

		THEN ("result is nil")
		{
			lua_getglobal(state, "result");
			REQUIRE(lua_isnil(state, -1) == true);
			lua_pop(state, 1);
		}

		THEN ("what is strerror(EACCES)")
		{
			// REQUIRE(std::string(strerror(EACCES)) == "Permission denied");
			lua_getglobal(state, "what");
			REQUIRE(lua_isstring(state, -1) == true);
			size_t l{0};
			const char* str = lua_tolstring(state, -1, &l);
			REQUIRE(std::string_view(str, l) == "Permission denied");
			lua_pop(state, 1);
		}

		THEN ("code is EACCES")
		{
			lua_getglobal(state, "code");
			REQUIRE(lua_isnumber(state, -1) == true);
			REQUIRE(static_cast<uint8_t>(lua_tonumber(state, -1)) == fx::Lua_EACCES);
			lua_pop(state, 1);
		}
	}
}

TEST_CASE("vfs")
{
#ifdef IS_FXSERVER
	// check if vfs:impl:server is loaded
	REQUIRE(Instance<vfs::Manager>::Get() != nullptr);
#endif
	std::filesystem::path currentPath = std::filesystem::current_path();
	currentPath = currentPath.append("tests");
	if (!std::filesystem::exists(currentPath))
	{
		if (std::filesystem::create_directory(currentPath))
		{
			REQUIRE(true);
		}
	}

	fwRefContainer relativeDevice = new vfs::RelativeDevice(currentPath.string() + "/");
	std::string mountPath = "@test/";
	vfs::Unmount(mountPath);
	vfs::Mount(relativeDevice, mountPath);

	WHEN ("an relative path is converted to an absolute path")
	{
		std::filesystem::path relativePath("tests");
		THEN ("it matches the std::filesystem::current_path")
		{
			std::filesystem::path absolutePath = std::filesystem::absolute(relativePath);
			REQUIRE(absolutePath.string() == currentPath.string());
		}
	}

	// tests the absolute function used inside FindDevice

	WHEN ("an absolute path is converted to an absolute path")
	{
		THEN ("it stays the same")
		{
			std::filesystem::path absolutePath = std::filesystem::absolute(currentPath);
			REQUIRE(absolutePath.string() == currentPath.string());
		}
	}

	THEN ("the relative device is findable with the absolute path")
	{
		std::string transformedPath;
		REQUIRE(vfs::FindDevice(currentPath.append("test.txt").string(), transformedPath).GetRef() == relativeDevice.GetRef());
		REQUIRE(transformedPath == "@test/test.txt");
	}

	REQUIRE(vfs::GetDevice("@test/").GetRef() == relativeDevice.GetRef());

	// create test.txt if not exists
	vfs::Create("@test/test.txt", false);

	WHEN ("vfs open read is used")
	{
		fwRefContainer<vfs::Stream> stream = vfs::OpenRead("@test/test.txt");
		REQUIRE(stream.GetRef() != nullptr);
		THEN ("write is returning an error")
		{
			std::string test = "test";
			REQUIRE(stream->Write(test.data(), test.size()) == 0xFFFFFFFF);
		}

		stream->Close();
	}

	WHEN ("io.open is used instead of vfs open")
	{
		fx::LuaStateHolder state;
		RuntimeSetup(state);

		LoadAndRunCode(state, "main.lua", R""""(
		file = io.open("@test/test.txt")
		result = file:close()
)"""");
		THEN ("it runs without errors")
		{
			lua_getglobal(state, "file");
			REQUIRE(lua_isuserdata(state, -1) == true);
			const luaL_Stream* userData =  static_cast<luaL_Stream*>(lua_touserdata(state, -1));
			REQUIRE(userData != nullptr);
			REQUIRE(userData->closef == nullptr);
			//fwRefContainer<vfs::Stream> stream = static_cast<vfs::Stream*>(userData);
			//REQUIRE(stream.GetRef() == nullptr);
			// todo: split open and close run to check ref count
			//REQUIRE(stream.GetRefCount() == 2);
			lua_pop(state, 1);
			lua_getglobal(state, "result");
			REQUIRE(lua_isboolean(state, -1) == true);
			REQUIRE(lua_toboolean(state, -1) == true);
			lua_pop(state, 1);
		}
	}
	
	WHEN ("io.lines")
	{
		fx::LuaStateHolder state;
		RuntimeSetup(state);

		LoadAndRunCode(state, "main.lua", R""""(
		file = io.open("@test/lines.txt")
		local i = 1
		lineArray = {}
		for line in file:lines() do
			lineArray[i] = line
			i += 1
		end

		file:close()
)"""");
		THEN ("it runs without errors")
		{
			// todo: generate lines.txt in test if it does not exists
			lua_getglobal(state, "file");
			REQUIRE(lua_isuserdata(state, -1) == true);
			const luaL_Stream* userData =  static_cast<luaL_Stream*>(lua_touserdata(state, -1));
			REQUIRE(userData != nullptr);
			REQUIRE(userData->closef == nullptr);
			lua_pop(state, 1);
			lua_getglobal(state, "lineArray");
			REQUIRE(lua_istable(state, -1) == true);
			uint32_t i = 0;
			std::vector<std::string> expected = {"test", "test2", "test3"};
			lua_pushnil(state); // First key
			while (lua_next(state, -2) != 0)
			{
				if (lua_isstring(state, -1))
				{
					const char* value = lua_tostring(state, -1);
					REQUIRE(expected[i++] == value);
				}

				lua_pop(state, 1);
			}

			lua_pop(state, 1);
		}
	}

	WHEN ("vfs open write is used")
	{
		fwRefContainer<vfs::Stream> stream = vfs::OpenWrite("@test/test.txt");
		REQUIRE(stream.GetRef() != nullptr);
		THEN ("write is returning the amount of bytes that got written")
		{
			std::string test = "test";
			REQUIRE(stream->Write(test.data(), test.size()) == test.size());
			// seek back to start after write
			stream->Seek(0, SEEK_SET);
			// start the read from the beginning of the file
			std::vector<uint8_t> testBuffer(4);
			stream->ReadToEndBuffered(testBuffer);
			REQUIRE(std::string_view(reinterpret_cast<const char*>(testBuffer.data()), testBuffer.size()) == "test");
		}

		stream->Close();
	}

	WHEN ("vfs open write is used")
	{
		fwRefContainer<vfs::Stream> stream = vfs::OpenWrite("@test/test.txt");
		REQUIRE(stream.GetRef() != nullptr);
		THEN ("read can still be used")
		{
			std::vector<uint8_t> test(4);
			REQUIRE(stream->Read(test.data(), test.size()) == test.size());
			REQUIRE(std::string_view(reinterpret_cast<const char*>(test.data()), test.size()) == "test");
		}

		stream->Close();
	}

	WHEN ("vfs rename is used")
	{
		REQUIRE(vfs::RenameFile("@test/test.txt", "@test/test2.txt") == true);
		REQUIRE(vfs::RenameFile("@test/test2.txt", "@test/test.txt") == true);
	}
}

TEST_CASE("debug namespace")
{
	WHEN ("debug.getinfo is used")
	{
		fx::LuaStateHolder state;
		RuntimeSetup(state);

		LoadAndRunCode(state, "main.lua", R""""(
		func = function() print("hello, world!") end
		di = debug.getinfo(func)
)"""");

		lua_getglobal(state, "di");
		REQUIRE(lua_istable(state, -1) == true);
		lua_getfield(state, -1, "short_src");
		REQUIRE(lua_isstring(state, -1) == true);
		size_t l{0};
		const char* str = lua_tolstring(state, -1, &l);
		REQUIRE(std::string_view(str, l) == "main.lua");
		lua_pop(state, 1);
		lua_getfield(state, -1, "linedefined");
		REQUIRE(lua_isstring(state, -1) == true);
		l = 0;
		str = lua_tolstring(state, -1, &l);
		REQUIRE(std::string_view(str, l) == "2");
		lua_pop(state, 1);
		lua_getfield(state, -1, "lastlinedefined");
		REQUIRE(lua_isstring(state, -1) == true);
		l = 0;
		str = lua_tolstring(state, -1, &l);
		REQUIRE(std::string_view(str, l) == "2");
		lua_pop(state, 1);
		lua_pop(state, 1);
	}

	WHEN ("debug.setmetatable is used")
	{
		fx::LuaStateHolder state;
		RuntimeSetup(state);

		LoadAndRunCode(state, "main.lua", R""""(
		meta = {
			__metatable = function()
				return "The metatable is locked"
			end,
			__index = function(mytable, key)
				if key == "key2" then
					return 42
				else
					return nil
				end
			end
		}
		table = {key1 = "value1"}
		debug.setmetatable(table, meta)
		result = table.key2
)"""");
		THEN ("the metatable works as expected")
		{
			lua_getglobal(state, "result");
			REQUIRE(lua_isnumber(state, -1) == true);
			REQUIRE(static_cast<uint32_t>(lua_tonumber(state, -1)) == 42);
			lua_pop(state, 1);
		}
	}
}