//////////////////////////////////////////////////////////////////////
// This file is part of Remere's Map Editor
//////////////////////////////////////////////////////////////////////
// Remere's Map Editor is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Remere's Map Editor 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//////////////////////////////////////////////////////////////////////

#include "main.h"

#include "brush.h"
#include "graphics.h"
#include "gui.h"
#include "tile.h"
#include "complexitem.h"
#include "iomap.h"
#include "item.h"

#include "ground_brush.h"
#include "carpet_brush.h"
#include "table_brush.h"
#include "wall_brush.h"

Item* Item::Create(uint16_t _type, uint16_t _subtype /*= 0xFFFF*/) {
	if (_type == 0) {
		return nullptr;
	}
	Item* newItem = nullptr;

	const ItemType& it = g_items[_type];

	if (it.id != 0) {
		if (it.isDepot()) {
			newItem = newd Depot(_type);
		} else if (it.isContainer()) {
			newItem = newd Container(_type);
		} else if (it.isTeleport()) {
			newItem = newd Teleport(_type);
		} else if (it.isDoor()) {
			newItem = newd Door(_type);
		} else if (it.isPodium()) {
			newItem = newd Podium(_type);
		} else if (_subtype == 0xFFFF) {
			if (it.isFluidContainer()) {
				newItem = newd Item(_type, LIQUID_NONE);
			} else if (it.isSplash()) {
				newItem = newd Item(_type, LIQUID_WATER);
			} else if (it.charges > 0) {
				newItem = newd Item(_type, it.charges);
			} else {
				newItem = newd Item(_type, 1);
			}
		} else {
			newItem = newd Item(_type, _subtype);
		}
	} else {
		newItem = newd Item(_type, _subtype);
	}

	return newItem;
}

Item::Item(unsigned short _type, unsigned short _count) :
	id(_type),
	subtype(1),
	selected(false),
	frame(0) {
	if (hasSubtype()) {
		subtype = _count;
	}
}

Item::~Item() {
	////
}

Item* Item::deepCopy() const {
	Item* copy = Create(id, subtype);
	if (copy) {
		copy->selected = selected;
		if (attributes) {
			copy->attributes = newd ItemAttributeMap(*attributes);
		}
	}
	return copy;
}

Item* transformItem(Item* old_item, uint16_t new_id, Tile* parent) {
	if (old_item == nullptr) {
		return nullptr;
	}

	old_item->setID(new_id);
	// Through the magic of deepCopy, this will now be a pointer to an item of the correct type.
	Item* new_item = old_item->deepCopy();
	if (parent) {
		// Find the old item and remove it from the tile, insert this one instead!
		if (old_item == parent->ground) {
			delete old_item;
			parent->ground = new_item;
			return new_item;
		}

		std::queue<Container*> containers;
		for (ItemVector::iterator item_iter = parent->items.begin(); item_iter != parent->items.end(); ++item_iter) {
			if (*item_iter == old_item) {
				delete old_item;
				item_iter = parent->items.erase(item_iter);
				parent->items.insert(item_iter, new_item);
				return new_item;
			}

			Container* c = dynamic_cast<Container*>(*item_iter);
			if (c) {
				containers.push(c);
			}
		}

		while (containers.size() != 0) {
			Container* container = containers.front();
			ItemVector& v = container->getVector();
			for (ItemVector::iterator item_iter = v.begin(); item_iter != v.end(); ++item_iter) {
				Item* i = *item_iter;
				Container* c = dynamic_cast<Container*>(i);
				if (c) {
					containers.push(c);
				}

				if (i == old_item) {
					// Found it!
					item_iter = v.erase(item_iter);
					v.insert(item_iter, new_item);
					return new_item;
				}
			}
			containers.pop();
		}
	}

	delete new_item;
	return nullptr;
}

uint32_t Item::memsize() const {
	uint32_t mem = sizeof(*this);
	return mem;
}

void Item::setID(uint16_t newid) {
	id = newid;
}

void Item::setSubtype(uint16_t n) {
	subtype = n;
}

bool Item::hasSubtype() const {
	const ItemType& it = g_items[id];
	return (it.isFluidContainer() || it.isSplash() || isCharged() || it.stackable || it.charges != 0);
}

uint16_t Item::getSubtype() const {
	if (hasSubtype()) {
		return subtype;
	}
	return 0;
}

bool Item::hasProperty(enum ITEMPROPERTY prop) const {
	const ItemType& it = g_items[id];
	switch (prop) {
		case BLOCKSOLID:
			if (it.unpassable) {
				return true;
			}
			break;

		case MOVEABLE:
			if (it.moveable && getUniqueID() == 0) {
				return true;
			}
			break;
			/*
					case HASHEIGHT:
						if(it.height != 0 )
							return true;
						break;
			*/
		case BLOCKPROJECTILE:
			if (it.blockMissiles) {
				return true;
			}
			break;

		case BLOCKPATHFIND:
			if (it.blockPathfinder) {
				return true;
			}
			break;

		case HOOK_SOUTH:
			if (it.hookSouth) {
				return true;
			}
			break;

		case HOOK_EAST:
			if (it.hookEast) {
				return true;
			}
			break;

		case BLOCKINGANDNOTMOVEABLE:
			if (it.unpassable && (!it.moveable || getUniqueID() != 0)) {
				return true;
			}
			break;

		case HASLIGHT:
			if (hasLight()) {
				return true;
			}
			break;

		default:
			return false;
	}
	return false;
}

std::pair<int, int> Item::getDrawOffset() const {
	ItemType& it = g_items[id];
	if (it.sprite != nullptr) {
		return it.sprite->getDrawOffset();
	}
	return std::make_pair(0, 0);
}

bool Item::hasLight() const {
	const ItemType& type = g_items.getItemType(id);
	if (type.sprite) {
		return type.sprite->hasLight();
	}
	return false;
}

SpriteLight Item::getLight() const {
	const ItemType& type = g_items.getItemType(id);
	if (type.sprite) {
		return type.sprite->getLight();
	}
	return SpriteLight { 0, 0 };
}

double Item::getWeight() const {
	ItemType& it = g_items[id];
	if (it.stackable) {
		return it.weight * std::max(1, (int)subtype);
	}

	return it.weight;
}

void Item::setUniqueID(unsigned short n) {
	setAttribute("uid", n);
}

void Item::setActionID(unsigned short n) {
	setAttribute("aid", n);
}

void Item::setText(const std::string& str) {
	setAttribute("text", str);
}

void Item::setDescription(const std::string& str) {
	setAttribute("desc", str);
}

void Item::setTier(unsigned short n) {
	setAttribute("tier", n);
}

double Item::getWeight() {
	ItemType& it = g_items[id];
	if (it.isStackable()) {
		return it.weight * subtype;
	}
	return it.weight;
}

bool Item::canHoldText() const {
	return isReadable() || canWriteText();
}

bool Item::canHoldDescription() const {
	return g_items[id].allowDistRead;
}

uint8_t Item::getMiniMapColor() const {
	GameSprite* spr = g_items[id].sprite;
	if (spr) {
		return spr->getMiniMapColor();
	}
	return 0;
}

GroundBrush* Item::getGroundBrush() const {
	ItemType& item_type = g_items.getItemType(id);
	if (item_type.isGroundTile() && item_type.brush && item_type.brush->isGround()) {
		return item_type.brush->asGround();
	}
	return nullptr;
}

TableBrush* Item::getTableBrush() const {
	ItemType& item_type = g_items.getItemType(id);
	if (item_type.isTable && item_type.brush && item_type.brush->isTable()) {
		return item_type.brush->asTable();
	}
	return nullptr;
}

CarpetBrush* Item::getCarpetBrush() const {
	ItemType& item_type = g_items.getItemType(id);
	if (item_type.isCarpet && item_type.brush && item_type.brush->isCarpet()) {
		return item_type.brush->asCarpet();
	}
	return nullptr;
}

DoorBrush* Item::getDoorBrush() const {
	ItemType& item_type = g_items.getItemType(id);
	if (!item_type.isWall || !item_type.isBrushDoor || !item_type.brush || !item_type.brush->isWall()) {
		return nullptr;
	}

	DoorType door_type = item_type.brush->asWall()->getDoorTypeFromID(id);
	DoorBrush* door_brush = nullptr;
	// Quite a horrible dependency on a global here, meh.
	switch (door_type) {
		case WALL_DOOR_NORMAL: {
			door_brush = g_gui.normal_door_brush;
			break;
		}
		case WALL_DOOR_LOCKED: {
			door_brush = g_gui.locked_door_brush;
			break;
		}
		case WALL_DOOR_QUEST: {
			door_brush = g_gui.quest_door_brush;
			break;
		}
		case WALL_DOOR_MAGIC: {
			door_brush = g_gui.magic_door_brush;
			break;
		}
		case WALL_DOOR_NORMAL_ALT: {
			door_brush = g_gui.normal_door_alt_brush;
			break;
		}
		case WALL_ARCHWAY: {
			door_brush = g_gui.archway_door_brush;
			break;
		}
		case WALL_WINDOW: {
			door_brush = g_gui.window_door_brush;
			break;
		}
		case WALL_HATCH_WINDOW: {
			door_brush = g_gui.hatch_door_brush;
			break;
		}
		default: {
			break;
		}
	}
	return door_brush;
}

WallBrush* Item::getWallBrush() const {
	ItemType& item_type = g_items.getItemType(id);
	if (item_type.isWall && item_type.brush && item_type.brush->isWall()) {
		return item_type.brush->asWall();
	}
	return nullptr;
}

BorderType Item::getWallAlignment() const {
	ItemType& it = g_items[id];
	if (!it.isWall) {
		return BORDER_NONE;
	}
	return it.border_alignment;
}

BorderType Item::getBorderAlignment() const {
	ItemType& it = g_items[id];
	return it.border_alignment;
}

void Item::animate() {
	ItemType& type = g_items[id];
	GameSprite* sprite = type.sprite;
	if (!sprite || !sprite->animator) {
		return;
	}

	frame = sprite->animator->getFrame();
}

// ============================================================================
// Static conversions

std::string Item::LiquidID2Name(uint16_t id) {
	switch (id) {
		case LIQUID_NONE:
			return "None";
		case LIQUID_WATER:
			return "Water";
		case LIQUID_BLOOD:
			return "Blood";
		case LIQUID_BEER:
			return "Beer";
		case LIQUID_SLIME:
			return "Slime";
		case LIQUID_LEMONADE:
			return "Lemonade";
		case LIQUID_MILK:
			return "Milk";
		case LIQUID_MANAFLUID:
			return "Manafluid";
		case LIQUID_WATER2:
			return "Water";
		case LIQUID_LIFEFLUID:
			return "Lifefluid";
		case LIQUID_OIL:
			return "Oil";
		case LIQUID_SLIME2:
			return "Slime";
		case LIQUID_URINE:
			return "Urine";
		case LIQUID_COCONUT_MILK:
			return "Coconut Milk";
		case LIQUID_WINE:
			return "Wine";
		case LIQUID_MUD:
			return "Mud";
		case LIQUID_FRUIT_JUICE:
			return "Fruit Juice";
		case LIQUID_LAVA:
			return "Lava";
		case LIQUID_RUM:
			return "Rum";
		case LIQUID_SWAMP:
			return "Swamp";
		case LIQUID_INK:
			return "Ink";
		case LIQUID_TEA:
			return "Tea";
		case LIQUID_MEAD:
			return "Mead";
		default:
			return "Unknown";
	}
}

uint16_t Item::LiquidName2ID(std::string liquid) {
	to_lower_str(liquid);
	if (liquid == "none") {
		return LIQUID_NONE;
	}
	if (liquid == "water") {
		return LIQUID_WATER;
	}
	if (liquid == "blood") {
		return LIQUID_BLOOD;
	}
	if (liquid == "beer") {
		return LIQUID_BEER;
	}
	if (liquid == "slime") {
		return LIQUID_SLIME;
	}
	if (liquid == "lemonade") {
		return LIQUID_LEMONADE;
	}
	if (liquid == "milk") {
		return LIQUID_MILK;
	}
	if (liquid == "manafluid") {
		return LIQUID_MANAFLUID;
	}
	if (liquid == "lifefluid") {
		return LIQUID_LIFEFLUID;
	}
	if (liquid == "oil") {
		return LIQUID_OIL;
	}
	if (liquid == "urine") {
		return LIQUID_URINE;
	}
	if (liquid == "coconut milk") {
		return LIQUID_COCONUT_MILK;
	}
	if (liquid == "wine") {
		return LIQUID_WINE;
	}
	if (liquid == "mud") {
		return LIQUID_MUD;
	}
	if (liquid == "fruit juice") {
		return LIQUID_FRUIT_JUICE;
	}
	if (liquid == "lava") {
		return LIQUID_LAVA;
	}
	if (liquid == "rum") {
		return LIQUID_RUM;
	}
	if (liquid == "swamp") {
		return LIQUID_SWAMP;
	}
	if (liquid == "ink") {
		return LIQUID_INK;
	}
	if (liquid == "tea") {
		return LIQUID_TEA;
	}
	if (liquid == "mead") {
		return LIQUID_MEAD;
	}
	return LIQUID_NONE;
}

// ============================================================================
// XML Saving & loading

Item* Item::Create(pugi::xml_node xml) {
	pugi::xml_attribute attribute;

	int16_t id = 0;
	if ((attribute = xml.attribute("id"))) {
		id = attribute.as_ushort();
	}

	int16_t count = 1;
	if ((attribute = xml.attribute("count")) || (attribute = xml.attribute("subtype"))) {
		count = attribute.as_ushort();
	}

	return Create(id, count);
}