#include "dl_lua_register.h"

#include "dl_io.h"
#include "render/dl_graphics.h"
#include "system/dl_system.h"
#include "script/dl_lua.h"
#include "ui/dl_ui_manager.h"
#include "render/dl_image.h"
#include "memory/dl_crypto.h"
#include "memory/dl_memory.h"
#include "tool/dl_tool_archiver.h"


namespace luabridge {
	using namespace dl;
	// GC类
	template <class T>
	struct ContainerTraits<GC<T>>
	{
		using Type = T;

		static GC<T> construct(T* c)
		{
			return c;
		}

		static T* get(const GC<T>& c)
		{
			return (T*)c.GetPointer();
		}
	};


	// 枚举类绑定
	template <>
	struct Stack<File::CopyMode> : luabridge::Enum<File::CopyMode,
		File::CopyMode::NONE,
		File::CopyMode::OVERRIDE,
		File::CopyMode::SKIP>
	{
	};
	template <>
	struct Stack<Memory::CompressMode> : luabridge::Enum<Memory::CompressMode,
		Memory::CompressMode::E_NONE,
		Memory::CompressMode::E_ZIP,
		Memory::CompressMode::E_LZ4>
	{
	};
} // namespace luabridge

// Buffer类转换
namespace luabridge {
	using namespace dl;

	template <>
	struct StackConversion<BufferView>
	{
		static constexpr bool enabled = true;
	};

	template <>
	struct StackConverter<BufferView, Buffer>
	{
		static BufferView convert(const Buffer& v)
		{
			return CreateBufferView(v);
		}
	};
	template <size_t N>
	struct StackConverter<BufferView, std::array<std::byte, N>>
	{
		static BufferView convert(const std::array<std::byte, N>& v)
		{
			return CreateBufferView(v);
		}
	};

} // namespace luabridge

namespace dl
{
	void lua_print(luabridge::LuaRef ref)
	{
		Output(fmt::format("[lua-print]: {}\n", ref.tostring()));
	}
	void lua_print_ex(luabridge::LuaRef ref)
	{
		Output(fmt::format("[lua-print]: {}\n", ref.tostring()));
	}

	void lua_delete(Image* img)
	{
		delete img;
	}

	std::string lua_to_string(const luabridge::LuaRef& ref)
	{
		if (ref.isBool())
			return dl::to_string(ref.cast<bool>().valueOr(false));
		if (ref.isLightUserdata())
			return dl::to_string(ref.cast<int64_t>().valueOr(0));
		if (ref.isNumber())
			return dl::to_string(ref.cast<int64_t>().valueOr(0));
		if (ref.isString())
			return ref.cast <std::string>().valueOr("");
		//
		if (ref.isTable())
		{
			luabridge::Range range = luabridge::pairs(ref);
			std::string ret;
			for (auto iter : range)
			{
				if (iter.first.isNumber())
				{
					size_t index = iter.first.cast<size_t>().valueOr(-1);
					ret += std::to_string(index);
					ret += "->";
					ret += lua_to_string(iter.second);
					ret += ", ";
				}
				else if (iter.first.isString())
				{
					std::string key = iter.first.tostring();
					ret += String::AddQuotes(key);
					ret += "->";
					ret += lua_to_string(iter.second);
					ret += ", ";
				}
			}
			return ret;
		}
		if (ref.getClassName() == "Buffer")
		{
			auto result = ref.cast<Buffer>();
			if (!result)
			{
				log_warn("类型转换失败：", result.message());
				return "cast error";
			}
			return dl::to_string_hex(result.value());
		}
		log_warn("未处理lua类型：{}, {}", ref.type(), ref.tostring());
		return {};
	}

	template<typename T, size_t N>
	Array<T, N> lua_Array_op_add(const Array<T, N>& a, const Array<T, N>& b)
	{
		return a + b;
	}
	template<typename T, size_t N>
	Array<T, N> lua_Array_op_sub(const Array<T, N>& a, const Array<T, N>& b)
	{
		return a - b;
	}
	template<typename T, size_t N>
	Array<T, N> lua_Array_op_nag(const Array<T, N>& a)
	{
		return -a;
	}

	void lua_register_base(lua_State* L)
	{
		luabridge::getGlobalNamespace(L)
			.addFunction("print", lua_print)
			.addFunction("print_ex", lua_print_ex)
			.addFunction("delete", lua_delete)
			.addFunction("to_string", lua_to_string)
			.addFunction("to_string_hex",
			+[](BufferView buf) { return to_string_hex(buf); },
			+[](BufferView buf, bool upper) { return to_string_hex(buf, upper); },
			+[](BufferView buf, bool upper, bool add_tag) { return to_string_hex(buf, upper, add_tag); }
			);


		luabridge::getGlobalNamespace(L)
			.beginClass<Position>("Position")
			.addConstructor<void (*)()>()
			.addPropertyReadWrite("x", &Position::x)
			.addPropertyReadWrite("y", &Position::y);

		luabridge::getGlobalNamespace(L)
			.beginClass<Position4>("Position4")
			.addConstructor<void (*)()>()
			.addPropertyReadWrite("x", &Position4::x)
			.addPropertyReadWrite("y", &Position4::y)
			.addPropertyReadWrite("z", &Position4::z)
			.addPropertyReadWrite("w", &Position4::w);

		luabridge::getGlobalNamespace(L)
			.beginClass<Point>("Point")
			.addConstructor<void (*)()>()
			.addFunction("__add", lua_Array_op_add<int, 2>)
			.addFunction("__sub", lua_Array_op_sub<int, 2>)
			.addFunction("__unm", lua_Array_op_nag<int, 2>)
			.addPropertyReadWrite("x", &Point::x)
			.addPropertyReadWrite("y", &Point::y);

		luabridge::getGlobalNamespace(L)
			.beginClass<Size>("Size")
			.addConstructor<void (*)()>()
			.addPropertyReadWrite("w", &Size::w)
			.addPropertyReadWrite("h", &Size::h);

		luabridge::getGlobalNamespace(L)
			.beginClass<PointU>("PointU")
			.addConstructor<void (*)()>()
			.addPropertyReadWrite("x", &PointU::x)
			.addPropertyReadWrite("y", &PointU::y);

		luabridge::getGlobalNamespace(L)
			.beginClass<RectU>("RectU")
			.addConstructor<void (*)()>()
			.addPropertyReadWrite("lt", &RectU::lt)
			.addPropertyReadWrite("rt", &RectU::rt)
			.addPropertyReadWrite("rb", &RectU::rb)
			.addPropertyReadWrite("lb", &RectU::lb);

		luabridge::getGlobalNamespace(L)
			.beginNamespace("Align")
			.addFunction("GetSize", Align::GetSize<unsigned>)
			.addFunction("GetLT", Align::GetLT<unsigned>)
			.endNamespace();

		luabridge::getGlobalNamespace(L)
			.addFunction("toPoint", toPoint<unsigned, 2>);


		luabridge::getGlobalNamespace(L)
			.beginNamespace("String")
			.addFunction("ErasePath", String::ErasePath)
			.addFunction("GetFileStem", String::GetFileStem)
			.addFunction("toPosition2", String::toPosition2)
			.addFunction("toPoint2", String::toPoint2)
			.addFunction("ReplaceExtension", 
				luabridge::overload<std::string_view, std::string_view>(String::ReplaceExtension))
			.addFunction("EraseFilename",
				luabridge::overload<std::string_view>(String::EraseFilename))
			.endNamespace();
	}

	void lua_register_system(lua_State* L)
	{
#ifndef DL_DISABLE_RENDER
		luabridge::getGlobalNamespace(L)
			.beginClass<ParamWindow>("ParamWindow")
			.addConstructor<void (*)()>() // 忽略这个构造会出错……
			.addProperty("title", &ParamWindow::_strTitle, &ParamWindow::_strTitle)
			.endClass();

		luabridge::getGlobalNamespace(L)
			.beginClass<System>("System")
			.addFunction("SetFuncInit", &System::lua_SetFuncInit)
			.addFunction("SetFuncRun", &System::lua_SetFuncRun)
			.addFunction("Start", (void(System::*)(const ParamWindow&))&System::Start)
			.endClass();

		auto result = luabridge::push(L, g_system);
		lua_setglobal(L, "g_system");
#endif
	}

	void lua_register_file(lua_State* L)
	{
		using namespace File::Lua;


		luabridge::getGlobalNamespace(L)
			.beginNamespace("File")
			.beginNamespace("CopyMode")
			.addVariable("NONE", File::CopyMode::NONE)
			.addVariable("OVERRIDE", File::CopyMode::OVERRIDE)
			.addVariable("SKIP",File::CopyMode::SKIP)
			.endNamespace()
			.endNamespace();

		luabridge::getGlobalNamespace(L)
			.beginNamespace("File")
			.addFunction("GetPathFileAll", lua_GetPathFileAll_3, lua_GetPathFileAll_2, lua_GetPathFileAll_1)
			.addFunction("GetAbsolute", File::GetAbsolute)
			.addFunction("GetRelative", File::GetRelative)
			.addFunction("CreateFolder", File::CreateFolder)
			.addFunction("DeleteContent", File::DeleteContent)
			.addFunction("Rename", File::Rename)
			.addFunction("Copy", File::Copy)
			.addFunction("GetBuffer", 
				luabridge::overload<std::ifstream&>(File::GetBuffer),
				luabridge::overload<std::string_view>(File::GetBuffer))
			.addFunction("GetString", File::GetString)
			.addFunction("GetFilePath", File::GetFilePath)
			.addFunction("GetFileName", File::GetFileName)
			.addFunction("GetString", File::GetString)
			.addFunction("IsExist", File::IsExist)
			.addFunction("SaveBuffer", File::SaveBuffer)
			.addFunction("SaveString",
				luabridge::overload<std::string_view, std::string_view>(File::SaveString))
			.endNamespace();
	}

	void lua_register_gfx(lua_State* L)
	{
#ifndef DL_DISABLE_RENDER
		luabridge::getGlobalNamespace(L)
			.beginClass<Graphics>("Graphics")
			.addFunction("Rectangle2D", &Graphics::Rectangle2D)
			.endClass();

		auto result = luabridge::push(L, g_gfx);
		lua_setglobal(L, "g_gfx");
#endif
	}

	void lua_register_ui(lua_State* L)
	{
#ifndef DL_DISABLE_RENDER
		using namespace UI;
		luabridge::getGlobalNamespace(L)
			.beginClass<Panel>("UIPanel")
			.addFunction("Add", (void(Panel::*)(UI::Text*))&Panel::Add)
			.endClass();

		luabridge::getGlobalNamespace(L)
			.beginClass<UI::Text>("UIText")
			.addFunction("SetString", &UI::Text::SetString)
			.addFunction("SetLang", &UI::Text::SetLang)
			.endClass();

		luabridge::getGlobalNamespace(L)
			.beginClass<Manager>("UIManager")
			.addFunction("CreatePanel", (Panel * (Manager::*)())&Manager::lua_CreatePanel)
			.addFunction("CreateText", &Manager::CreateText)
			.addFunction("CreateTextDefault", &Manager::CreateTextDefault)
			.endClass();

		auto result = luabridge::push(L, g_ui);
		lua_setglobal(L, "g_ui");
#endif
	}

	void lua_register_factory(lua_State* L)
	{
		luabridge::getGlobalNamespace(L)
			.beginClass<Factory>("Factory")
			.addFunction("CreateText", &Factory::CreateText)
			.addFunction("CreateTextDefault", &Factory::CreateTextDefault)
			.addFunction("CreateSprite",
				luabridge::overload<std::string_view, size_t>(&Factory::CreateSprite),
				luabridge::overload<const SpriteID&>(&Factory::CreateSprite))
			.addFunction("SetPath", &Factory::SetPath)
			.addFunction("CompressMir2Res", &Factory::CompressMir2Res)
			.endClass();

		auto result = luabridge::push(L, g_factory);
		lua_setglobal(L, "g_factory");

	}

	void lua_register_sprite(lua_State* L)
	{
		luabridge::getGlobalNamespace(L)
			.beginClass<Sprite>("Sprite")
			.addFunction("Render", &Sprite::Render)
			.addFunction("SetColor",
				luabridge::overload<const Color&>(&Sprite::SetColor),
				luabridge::overload<const Color&, size_t>(&Sprite::SetColor))
			.endClass();
	}

	void lua_register_text(lua_State* L)
	{
		luabridge::getGlobalNamespace(L)
			.beginClass<Text>("Text")
			.addFunction("Render", &Text::Render)
			.addFunction("SetString", &Text::SetString)
			.endClass();
	}

	void lua_register_memory(lua_State* L)
	{
		luabridge::getGlobalNamespace(L)
			.beginClass<Buffer>("Buffer")
			.addConverter<BufferView>()
			.endClass()
			.addFunction("CreateBufferHex", CreateBufferHex);
		luabridge::getGlobalNamespace(L)
			.beginClass<BufferView>("BufferView")
			.endClass();

		luabridge::getGlobalNamespace(L)
			.beginNamespace("Memory")
			.beginNamespace("CompressMode")
			.addVariable("NONE", Memory::CompressMode::E_NONE)
			.addVariable("LZ4", Memory::CompressMode::E_LZ4)
			.addVariable("ZIP", Memory::CompressMode::E_ZIP)
			.endNamespace()
			.endNamespace();

		using namespace dl::Crypto;
		luabridge::getGlobalNamespace(L)
			.beginNamespace("Crypto")
			.beginClass<Aes256Key>("Aes256Key")
			.addConstructor<void (*)()>()
			.addProperty("_key", &Aes256Key::_key, &Aes256Key::_key)
			.addProperty("_iv", &Aes256Key::_iv, &Aes256Key::_iv)
			.addProperty("_tag", &Aes256Key::_tag, &Aes256Key::_tag)
			.endClass()
			.addFunction("GenerateKeyAes256", &GenerateKeyAes256)
			.addFunction("EncryptAes256", &EncryptAes256)
			.addFunction("DecryptAes256", &DecryptAes256)
			.addFunction("HashCrc32", &HashCrc32)
			.addFunction("HashMd5", &HashMd5)
			.addFunction("HashSha256", &HashSha256)
			.addFunction("HashSha512", &HashSha512)
			.endNamespace();
	}

	luabridge::LuaRef lua_json_to_lua(lua_State* L, const json& j)
	{
		switch (j.type())
		{
		case json::value_t::null:
			return luabridge::LuaRef(L, luabridge::LuaNil());
		case json::value_t::object:
		{
			luabridge::LuaRef ret = luabridge::newTable(L);

			for (auto iter = j.begin(); iter != j.end(); ++iter)
			{
				std::string key = iter.key();
				json value = iter.value();
				//log_info("{}, {}", key, value.dump());
				ret[key] = lua_json_to_lua(L, value);
			}
			return ret;
		}
		case json::value_t::array:
		{
			luabridge::LuaRef ret = luabridge::newTable(L);

			for (size_t i = 0; i < j.size(); ++i) 
			{
				ret[i + 1] = lua_json_to_lua(L, j[i]);
			}
			return ret;
		}
		case json::value_t::string:
			return luabridge::LuaRef(L, j.get<std::string>());
		case json::value_t::number_integer:
			return luabridge::LuaRef(L, j.get<int64_t>());
		case json::value_t::number_unsigned:
			return luabridge::LuaRef(L, j.get<uint64_t>());
		case json::value_t::number_float:
			return luabridge::LuaRef(L, j.get<double>());
		case json::value_t::binary:
		default:
			break;
		}
		log_warn("未处理json类型：{}, {}", j.type_name(), j.dump());
		return luabridge::LuaRef(L, luabridge::LuaNil());
	}
	json lua_lua_to_json(lua_State* L, const luabridge::LuaRef& ref)
	{
		if (ref.isBool())
			return ref.cast<bool>().valueOr(false);
		if (ref.isLightUserdata())
			return ref.cast<int64_t>().valueOr(0);
		if (ref.isNumber())
			return ref.cast<int64_t>().valueOr(0);
		if (ref.isString())
			return ref.cast <std::string>().valueOr("");
		//
		if (ref.isTable())
		{
			int type = 0; // 0.初始化 1.array 2.object -1.错误
			luabridge::Range range = luabridge::pairs(ref);
			for (auto iter : range)
			{
				if (iter.first.isNumber())
				{
					if (type == 0)
						type = 1;
					else if (type != 1)
					{
						type = -1;
						break;
					}
				}
				else if (iter.first.isString())
				{
					if (type == 0)
						type = 2;
					else if (type != 2)
					{
						type = -1;
						break;
					}
				}
			}
			if (type == 0)
				return {};
			else if (type == 1)
			{
				json j;
				for (auto iter : range)
				{
					size_t index = iter.first.cast<size_t>().valueOr(-1);
					j[index - 1] = lua_lua_to_json(L, iter.second);
				}
				return j;
			}
			else if (type == 2)
			{
				json j;
				for (auto iter : range)
				{
					std::string key = iter.first.tostring();
					j[key] = lua_lua_to_json(L, iter.second);
				}
				return j;
			}
			else
				return json();
		}
		log_warn("未处理lua类型：{}, {}", ref.type(), ref.tostring());
		return json();
	}

	std::string lua_json_encode(luabridge::LuaRef ref, int indent)
	{
		json j = lua_lua_to_json(ref.state(), ref);
		return j.dump(indent);
	}
	luabridge::LuaRef lua_json_decode(std::string str)
	{
		json j = Json::ParseString(str);
		return lua_json_to_lua(g_lua->GetL(), j);
	}

	void lua_register_json(lua_State* L)
	{
		luabridge::getGlobalNamespace(L)
			.beginNamespace("json")
			.addFunction("encode", luabridge::bind_back(lua_json_encode, 4))
			.addFunction("decode", lua_json_decode)
			.endNamespace();
	}
	
	std::string_view lua_lang(std::string_view str)
	{
		return lang(str);
	}

	void lua_register_other(lua_State* L)
	{
		luabridge::getGlobalNamespace(L)
			.beginNamespace("ToolArchiver")
			.addFunction("Compress", &Tool::Archiver::Compress)
			.addFunction("Decompress",
				luabridge::overload<BufferView, std::string_view>(&Tool::Archiver::Decompress),
				luabridge::overload<std::string_view, std::string_view>(&Tool::Archiver::Decompress))
			.endNamespace();

		luabridge::getGlobalNamespace(L)
			.beginClass<Tool::Archiver::Param>("ToolArchiverParam")
			.addConstructor<void (*)()>()
			.addProperty("_src", &Tool::Archiver::Param::_src, &Tool::Archiver::Param::_src)
			.addProperty("_out", &Tool::Archiver::Param::_out, &Tool::Archiver::Param::_out)
			.addProperty("_compressMode", &Tool::Archiver::Param::_compressMode, &Tool::Archiver::Param::_compressMode)
			.addProperty("_bCrc", &Tool::Archiver::Param::_bCrc, &Tool::Archiver::Param::_bCrc)
			.endClass();

		luabridge::getGlobalNamespace(L)
			.beginClass<Language>("Language")
			.addFunction("GetTagVector", &Language::GetTagVector)
			.addFunction("GetTagMap", &Language::GetTagMap)
			.addFunction("GetTagNameVector", &Language::GetTagNameVector)
			.addFunction("GetTagNameMap", &Language::GetTagNameMap)
			.endClass();

		luabridge::getGlobalNamespace(L)
			.addFunction("lang", lua_lang);

		auto result = luabridge::push(L, g_lang);
		lua_setglobal(L, "g_lang");
	}

	void lua_register_image(lua_State* L)
	{
		luabridge::getGlobalNamespace(L)
			.beginNamespace("Img")
			.addVariable("REGEX_FORMAT", Img::REGEX_FORMAT)
			.addFunction("Create",
				luabridge::overload<const Size&, const Color&>(&Img::Create),
				luabridge::overload<std::string_view>(&Img::Create))
			.addFunction("CreateSvg", &Img::CreateSvg)
			.addFunction("CreateWebp",
				luabridge::overload<std::string_view>(&Img::CreateWebp),
				luabridge::overload<BufferView>(&Img::CreateWebp))
			.addFunction("Save", &Img::Save)
			.addFunction("CalcLeastRect", &Img::CalcLeastRect)
			.addFunction("SetAlphaZero",
				luabridge::overload<Image*>(&Img::SetAlphaZero),
				luabridge::overload<Image*, uint8_t, uint32_t>(&Img::SetAlphaZero))
			.addFunction("Resize",
				luabridge::overload<const Image*, const Size&>(&Img::Resize),
				luabridge::overload<const Image*, Float>(&Img::Resize))
			.addFunction("AddRect", Img::AddRect)
			.addFunction("SetAlphaZero",
				luabridge::overload<Image*>(Img::SetAlphaZero),
				luabridge::overload<Image*, uint8_t, uint32_t>(Img::SetAlphaZero))
			.addFunction("Save", Img::Save)
			.endNamespace();
		luabridge::getGlobalNamespace(L)
			.beginClass<Image>("Image")
			.endClass();

		luabridge::getGlobalNamespace(L)
			.beginNamespace("ColorDef")
			.addVariable("NONE", ColorDef::NONE)
			.addVariable("WHITE", ColorDef::WHITE)
			.addVariable("BLACK", ColorDef::BLACK)
			.addVariable("RED", ColorDef::RED)
			.addVariable("GREEN", ColorDef::GREEN)
			.addVariable("BLUE", ColorDef::BLUE)
			.addVariable("YELLOW", ColorDef::YELLOW)
			.addVariable("PURPLE", ColorDef::PURPLE)
			.addVariable("CYAN", ColorDef::CYAN)
			.addVariable("ORANGE", ColorDef::ORANGE)
			.addVariable("GREEN_DARK", ColorDef::GREEN_DARK)
			.addVariable("DISABLE", ColorDef::DISABLE)
			.addVariable("TEXT_BG", ColorDef::TEXT_BG)
			.addVariable("FACTOR_GRAY", ColorDef::FACTOR_GRAY)
			.addVariable("GRAY", ColorDef::GRAY)
			.addVariable("GRAY_LIGHT", ColorDef::GRAY_LIGHT)
			.addVariable("GRAY_DARK", ColorDef::GRAY_DARK)
			.addVariable("CLEAR_SCREEN", ColorDef::CLEAR_SCREEN)
			.addVariable("AXIS_X", ColorDef::AXIS_X)
			.addVariable("AXIS_Y", ColorDef::AXIS_Y)
			.addVariable("AXIS_Z", ColorDef::AXIS_Z)
			.endNamespace();
	}
#if DL_PLATFORM == DL_PLATFORM_WIN32
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#endif

	void lua_pause()
	{
#if DL_PLATFORM == DL_PLATFORM_WIN32
		system("pause");
#else
	printf("输入任意字符并按回车继续：");
	char b;
	std::cin >> b;
#endif
	}
	void lua_register_platform(lua_State* L)
	{
		luabridge::getGlobalNamespace(L)
					.addFunction("system", system);

		luabridge::getGlobalNamespace(L)
					.addFunction("pause", lua_pause);		
	}


	void lua_register_all(lua_State* L)
	{
		lua_register_base(L);
		lua_register_system(L);
		lua_register_file(L);
		lua_register_gfx(L);
		lua_register_ui(L);
		lua_register_factory(L);
		lua_register_sprite(L);
		lua_register_text(L);
		lua_register_memory(L);
		lua_register_other(L);
		lua_register_json(L);
		lua_register_image(L);
		lua_register_platform(L);
	}

}