/*
 * =====================================================================================
 *
 *  OpenMiner
 *
 *  Copyright (C) 2018-2020 Unarelith, Quentin Bazin <openminer@unarelith.net>
 *  Copyright (C) 2019-2020 the OpenMiner contributors (see CONTRIBUTORS.md)
 *
 *  This file is part of OpenMiner.
 *
 *  OpenMiner is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  OpenMiner is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with OpenMiner; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 *
 * =====================================================================================
 */
#include <gk/core/Debug.hpp>

#include "LuaBlockLoader.hpp"
#include "LuaMod.hpp"
#include "Registry.hpp"
#include "ServerBlock.hpp"
#include "ServerConfig.hpp"

void LuaBlockLoader::loadBlock(const sol::table &table) const {
	std::string stringID = m_mod.id() + ":" + table["id"].get<std::string>();

	ServerBlock &block = Registry::getInstance().registerBlock<ServerBlock>(stringID);
	block.setRotatable(table["is_rotatable"].get_or(false));

	block.setOnBlockActivated(table["on_block_activated"]);
	block.setOnTick(table["on_tick"]);
	block.setOnBlockPlaced(table["on_block_placed"]);
	block.setOnBlockDestroyed(table["on_block_destroyed"]);
	block.setTickRandomly(table["tick_randomly"].get_or(false));
	block.setTickProbability(table["tick_probability"].get_or(0.f));

	BlockState &defaultState = block.getState(0);
	loadBlockState(defaultState, table, block);

	Item *item = nullptr;
	if (!defaultState.inventoryImage().empty()) {
		TilesDef tilesDef{block.stringID(), 0, defaultState.inventoryImage()};
		item = &Registry::getInstance().registerItem<Item>(tilesDef, block.stringID(), defaultState.label());
	}
	else {
		item = &Registry::getInstance().registerItem<Item>(defaultState.tiles(), block.stringID(), defaultState.label());
	}

	item->setIsBlock(true);
	item->setMaxStackSize(table["max_stack_size"].get_or(ServerConfig::maxItemStackSize));

	loadGroups(block, table, item);

	loadParams(block);
}

void LuaBlockLoader::loadBlockState(BlockState &state, const sol::table &table, ServerBlock &block) const {
	TilesDef tiles{block.stringID(), state.id()};
	tiles.loadFromLuaTable(table);
	if (!tiles.textureFilenames().empty())
		state.tiles(tiles);

	loadProperties(state, table);
	loadBoundingBox(state, table);
	loadDrawType(state, table, block);
	loadItemDrop(state, table);
	loadColorMultiplier(state, table);

	loadStates(block, state, table);
}

inline void LuaBlockLoader::loadProperties(BlockState &state, const sol::table &table) const {
	if (table["name"].get_type() == sol::type::string)
		state.label(table["name"].get<std::string>());

	if (table["harvest_requirements"].get_type() == sol::type::number)
		state.harvestRequirements(table["harvest_requirements"].get<int>());

	if (table["hardness"].get_type() == sol::type::number)
		state.hardness(table["hardness"].get<float>());

	if (table["is_opaque"].get_type() == sol::type::boolean)
		state.isOpaque(table["is_opaque"].get<bool>());

	if (table["is_light_source"].get_type() == sol::type::boolean)
		state.isLightSource(table["is_light_source"].get<bool>());

	if (table["inventory_image"].get_type() == sol::type::string)
		state.inventoryImage(table["inventory_image"].get<std::string>());

	if (table["fog_depth"].get_type() == sol::type::number)
		state.fogDepth(table["fog_depth"].get<float>());

	if (state.fogDepth()) {
		sol::optional<sol::table> fogColor = table["fog_color"];
		if (fogColor != sol::nullopt) {
			state.fogColor(gk::Color{
				fogColor.value().get<u8>(1),
				fogColor.value().get<u8>(2),
				fogColor.value().get<u8>(3),
			});
		}
	}

	sol::optional<sol::table> drawOffset = table["draw_offset"];
	if (drawOffset != sol::nullopt) {
		state.drawOffset(gk::Vector3f{
			drawOffset.value().get<float>(1),
			drawOffset.value().get<float>(2),
			drawOffset.value().get<float>(3),
		});
	}
}

inline void LuaBlockLoader::loadBoundingBox(BlockState &state, const sol::table &table) const {
	sol::optional<sol::table> boundingBox = table["bounding_box"];
	if (boundingBox != sol::nullopt) {
		state.boundingBox(gk::FloatBox{
			boundingBox.value().get<float>(1),
			boundingBox.value().get<float>(2),
			boundingBox.value().get<float>(3),
			boundingBox.value().get<float>(4),
			boundingBox.value().get<float>(5),
			boundingBox.value().get<float>(6),
		});
	}
}

inline void LuaBlockLoader::loadDrawType(BlockState &state, const sol::table &table, const ServerBlock &block) const {
	sol::object drawTypeObject = table["draw_type"];
	if (drawTypeObject.valid()) {
		if (drawTypeObject.get_type() == sol::type::string) {
			static const std::unordered_map<std::string, BlockDrawType> drawTypes = {
				{"solid",  BlockDrawType::Solid},
				{"xshape", BlockDrawType::XShape},
				{"leaves", BlockDrawType::Leaves},
				{"liquid", BlockDrawType::Liquid},
				{"glass",  BlockDrawType::Glass},
				{"cactus", BlockDrawType::Cactus},
				{"boundingbox", BlockDrawType::BoundingBox}, // FIXME: Temporary
			};

			auto it = drawTypes.find(drawTypeObject.as<std::string>());
			if (it != drawTypes.end()) {
				state.drawType(it->second);
			}
			else
				gkError() << "In" << block.stringID() << " definition: Block draw type invalid";
		}
		else
			gkError() << "In" << block.stringID() << " definition: Block draw type must be a string";
	}
}

inline void LuaBlockLoader::loadItemDrop(BlockState &state, const sol::table &table) const {
	sol::optional<sol::table> itemDrop = table["item_drop"];
	if (itemDrop != sol::nullopt) {
		state.itemDrop(itemDrop.value()["id"]);
		state.itemDropAmount(itemDrop.value()["amount"]);
	}
}

inline void LuaBlockLoader::loadColorMultiplier(BlockState &state, const sol::table &table) const {
	sol::optional<sol::table> colorMultiplier = table["color_multiplier"];
	if (colorMultiplier != sol::nullopt) {
		state.colorMultiplier(gk::Color{
			colorMultiplier.value().get<u8>(1),
			colorMultiplier.value().get<u8>(2),
			colorMultiplier.value().get<u8>(3),
			colorMultiplier.value().get<u8>(4)
		});
	}
}

inline void LuaBlockLoader::loadStates(ServerBlock &block, BlockState &state, const sol::table &table) const {
	sol::object statesObject = table["states"];
	if (statesObject.valid()) {
		if (statesObject.get_type() == sol::type::table) {
			sol::table statesTable = statesObject.as<sol::table>();
			for (auto &statesObject : statesTable) {
				unsigned int stateID = statesObject.first.as<unsigned int>();
				if (stateID == block.states().size()) {
					BlockState &state = block.addState();
					loadBlockState(state, statesObject.second.as<sol::table>(), block);
				}
				else {
					gkError() << ("For block '" + block.stringID() + "':").c_str() << "States must be defined in a correct order starting from 1";
					gkError() << "StateID:" << stateID << "| States registered:" << block.states().size();
				}
			}
		}
		else
			gkError() << "For block" << state.block().stringID() << ": 'states' must be a table";
	}
}

inline void LuaBlockLoader::loadGroups(ServerBlock &block, const sol::table &table, Item *item) const {
	sol::object groupsObject = table["groups"];
	if (groupsObject.valid()) {
		if (groupsObject.get_type() == sol::type::table) {
			sol::table groupsTable = groupsObject.as<sol::table>();
			for (auto &groupObject : groupsTable) {
				std::string groupName = "group:" + groupObject.first.as<std::string>();
				u16 groupValue = groupObject.second.as<u16>();

				block.addGroup(groupName, groupValue);
				if (item)
					item->addGroup(groupName, groupValue);
			}
		}
		else
			gkError() << "For block" << block.stringID() << ": 'groups' must be a table";
	}
}

inline void LuaBlockLoader::loadParams(ServerBlock &block) const {
	if (block.isRotatable())
		block.param().allocateBits(BlockParam::Type::Rotation, 5);

	if (block.states().size() > 1) {
		int bits = 0;
		int index = block.states().size();
		while (index >>= 1)
			++bits;
		block.param().allocateBits(BlockParam::Type::State, bits);
	}
}