/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program 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.
 *
 * This program 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 "sherlock/tattoo/widget_inventory.h"
#include "sherlock/tattoo/tattoo_fixed_text.h"
#include "sherlock/tattoo/tattoo_people.h"
#include "sherlock/tattoo/tattoo_scene.h"
#include "sherlock/tattoo/tattoo_user_interface.h"
#include "sherlock/tattoo/tattoo.h"

namespace Sherlock {

namespace Tattoo {

#define INVENTORY_XSIZE 70			// Width of the box that surrounds inventory items
#define INVENTORY_YSIZE 70			// Height of the box that surrounds inventory items
#define MAX_INV_COMMANDS 10			// Maximum elements in dialog
#define NUM_INV_PER_LINE 4			// Number of inentory items per line in the dialog

WidgetInventoryTooltip::WidgetInventoryTooltip(SherlockEngine *vm, WidgetInventory *owner) :
		WidgetTooltipBase(vm), _owner(owner) {
}

void WidgetInventoryTooltip::setText(const Common::String &str) {
	// If no text specified, erase any previously displayed tooltip and free its surface
	if (str.empty()) {
		erase();
		_surface.free();
		return;
	}

	int width = _surface.stringWidth(str) + 2;
	int height = 0;
	Common::String line1 = str, line2;

	// See if we need to split it into two lines
	if (width > 150) {
		// Yes, we do
		const char *s = str.c_str();
		const char *space = nullptr;
		int dif = 10000;

		while (*s) {
			s = strchr(s, ' ');

			if (!s) {
				if (!space) {
					height = _surface.stringHeight(str) + 2;
				} else {
					line1 = Common::String(str.c_str(), space);
					line2 = Common::String(space + 1);
					height = _surface.stringHeight(line1) + _surface.stringHeight(line2) + 4;
				}
				break;
			} else {
				line1 = Common::String(str.c_str(), s);
				line2 = Common::String(s + 1);
				int width1 = _surface.stringWidth(line1);
				int width2 = _surface.stringWidth(line2);

				if (ABS(width1 - width2) < dif) {
					// Found a split point that results in less overall width
					space = s;
					dif = ABS(width1 - width2);
					width = MAX(width1, width2);
				}

				s++;
			}
		}
	} else {
		height = _surface.stringHeight(str) + 2;
	}

	// Allocate a fresh surface for the new string
	_bounds = Common::Rect(width, height);
	_surface.create(width, height);
	_surface.clear(TRANSPARENCY);

	if (line2.empty()) {
		_surface.writeFancyString(str, Common::Point(0, 0), BLACK, INFO_TOP);
	} else {
		int xp, yp;

		xp = (_bounds.width() - _surface.stringWidth(line1) - 2) / 2;
		_surface.writeFancyString(line1, Common::Point(xp, 0), BLACK, INFO_TOP);

		xp = (_bounds.width() - _surface.stringWidth(line2) - 2) / 2;
		yp = _surface.stringHeight(line2) + 2;
		_surface.writeFancyString(line2, Common::Point(xp, yp), BLACK, INFO_TOP);
	}
}

void WidgetInventoryTooltip::handleEvents() {
	Events &events = *_vm->_events;
	FixedText &fixedText = *_vm->_fixedText;
	Inventory &inv = *_vm->_inventory;
	TattooPeople &people = *(TattooPeople *)_vm->_people;
	Scene &scene = *_vm->_scene;
	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
	Common::Point mousePos = events.mousePos();
	Common::String str;
	int select = -1, oldSelect = 999;
	Common::String strWith = fixedText.getText(kFixedText_With);
	Common::String strUse = fixedText.getText(kFixedText_Use);

	// Register the tooltip for requiring post-rendering drawing, since we draw directly to the screen if a scene
	// mask is active, since the initial draw to the screen will be covered by the mask rendering
	if (ui._mask) {
		ui._postRenderWidgets.push_back(this);
	}

	// If we are using an inventory item on an object in the room, display the appropriate text above the mouse cursor
	if (_owner->_invVerbMode == 3) {
		select = ui._bgFound;
		oldSelect = ui._oldBgFound;

		if (select != -1 && (select != oldSelect || (select != -1 && _surface.empty()))) {
			// See if we're pointing at a shape or a sprite
			if (select < 1000) {
				Object &obj = scene._bgShapes[select];

				if (!obj._description.empty() && !obj._description.hasPrefix(" ")) {
					if (_vm->getLanguage() == Common::EL_GRC) {

						if (!_owner->_swapItems)
							str = Common::String::format("%s %s %s %s", _owner->_action.c_str(), obj._description.c_str(),
								inv[_owner->_invSelect]._name.c_str(), _owner->_verb.c_str());
						else
							str = Common::String::format("%s %s %s %s", _owner->_action.c_str(), inv[_owner->_invSelect]._name.c_str(),
								obj._description.c_str(), _owner->_verb.c_str());
					} else {
						if (_owner->_swapItems)
							str = Common::String::format("%s %s %s %s", _owner->_verb.c_str(), obj._description.c_str(), _owner->_action.c_str(),
								inv[_owner->_invSelect]._name.c_str());
						else
							str = Common::String::format("%s %s %s %s", _owner->_verb.c_str(), inv[_owner->_invSelect]._name.c_str(),
								_owner->_action.c_str(), obj._description.c_str());
					}
				}
			} else {
				Person &person = people[ui._bgFound - 1000];

				if (!person._description.empty() && !person._description.hasPrefix(" ")) {
					if (_vm->getLanguage() == Common::EL_GRC) {
						if (!_owner->_swapItems)
							str = Common::String::format("%s %s %s %s", _owner->_action.c_str(), person._description.c_str(),
								inv[_owner->_invSelect]._name.c_str(), _owner->_verb.c_str());
						else
							str = Common::String::format("%s %s %s %s", _owner->_action.c_str(), inv[_owner->_invSelect]._name.c_str(),
								person._description.c_str(), _owner->_verb.c_str());
					} else {

						if (_owner->_swapItems)
							str = Common::String::format("%s %s %s %s", _owner->_verb.c_str(), person._description.c_str(),
								_owner->_action.c_str(), inv[_owner->_invSelect]._name.c_str());
						else
							str = Common::String::format("%s %s %s %s", _owner->_verb.c_str(),
								inv[_owner->_invSelect]._name.c_str(), _owner->_action.c_str(), person._description.c_str());
					}
				}
			}
		}
	} else {
		const Common::Rect &b = _owner->_bounds;
		Common::Rect r(b.left + 3, b.top + 3, b.right - 3 - BUTTON_SIZE, b.bottom - 3);

		if (r.contains(mousePos)) {
			select = (mousePos.x - r.left) / (INVENTORY_XSIZE + 3) + NUM_INVENTORY_SHOWN / 2 *
				((mousePos.y - r.top) / (INVENTORY_YSIZE + 3)) + inv._invIndex;

			if (select >= inv._holdings) {
				select = -1;
			} else {
				oldSelect = _owner->_invSelect;

				if (select != _owner->_invSelect || _surface.empty()) {

					if (_owner->_invMode == 1) {
						// See if we were pointing at a shapre or sprite
						if (ui._activeObj < 1000) {
							Object &obj = scene._bgShapes[ui._activeObj];

							if (!obj._description.empty() && !obj._description.hasPrefix(" "))
								str = Common::String::format("%s %s %s %s", strUse.c_str(), inv[select]._name.c_str(),
									strWith.c_str(), obj._description.c_str());
						} else {
							Person &person = people[ui._activeObj - 1000];

							if (!person._description.empty() && !person._description.hasPrefix(" "))
								str = Common::String::format("%s %s %s %s", strUse.c_str(), inv[select]._name.c_str(),
									strWith.c_str(), person._description.c_str());
						}
					} else {
						if (_owner->_invVerbMode == 2)
							str = Common::String::format("%s %s %s %s", strUse.c_str(), inv[_owner->_invSelect]._name.c_str(),
								strWith.c_str(), inv[select]._name.c_str());
						else
							str = inv[select]._description.c_str();
					}
				}
			}
		}
	}

	// See if they are pointing at a different inventory object and we need to
	// change the graphics of the Text Tag
	if (select != oldSelect || (select != -1 && _surface.empty())) {
		// Set the text
		setText(str);

		if (_owner->_invVerbMode != 3)
			_owner->_invSelect = select;
		else
			ui._oldBgFound = select;
	} else if (select == -1 && oldSelect != -1) {
		setText(Common::String());
		return;
	}

	if (_owner->_invVerbMode == 3)
		// Adjust tooltip to be above the inventory item being shown above the standard cursor
		mousePos.y -= events._hotspotPos.y;

	// Update the position of the tooltip
	int xs = CLIP(mousePos.x - _bounds.width() / 2, 0, SHERLOCK_SCENE_WIDTH - _bounds.width());
	int ys = CLIP(mousePos.y - _bounds.height(), 0, SHERLOCK_SCREEN_HEIGHT - _bounds.height());
	_bounds.moveTo(xs, ys);
}

/*----------------------------------------------------------------*/

WidgetInventoryVerbs::WidgetInventoryVerbs(SherlockEngine *vm, WidgetInventory *owner) :
		WidgetBase(vm), _owner(owner) {
	_invVerbSelect = _oldInvVerbSelect = -1;
}

void WidgetInventoryVerbs::load() {
	Events &events = *_vm->_events;
	Inventory &inv = *_vm->_inventory;
	People &people = *_vm->_people;
	Scene &scene = *_vm->_scene;
	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
	Common::Point mousePos = events.mousePos();

	// Make the Verb List for this Inventory Item
	_inventCommands.clear();
	_inventCommands.push_back(FIXED(Look));

	// Default the Action word to "with"
	_owner->_action = _vm->getLanguage() == Common::EL_GRC ? "" : FIXED(With);

	// Search all the bgshapes for any matching Target Fields
	for (uint idx = 0; idx < scene._bgShapes.size(); ++idx) {
		Object &obj = scene._bgShapes[idx];

		if (obj._type != INVALID && obj._type != HIDDEN) {
			for (int useNum = 0; useNum < 6; ++useNum) {
				if (!obj._use[useNum]._verb.hasPrefix("*") &&
					!obj._use[useNum]._target.compareToIgnoreCase(inv[_owner->_invSelect]._name)) {
					// Make sure the Verb is not already in the list
					bool found1 = false;
					for (uint cmdNum = 0; cmdNum < _inventCommands.size() && !found1; ++cmdNum) {
						if (!_inventCommands[cmdNum].compareToIgnoreCase(obj._use[useNum]._verb))
							found1 = true;
					}

					if (!found1) {
						_inventCommands.push_back(obj._use[useNum]._verb);

						// Check for any Special Action commands
						for (int nameNum = 0; nameNum < 4; ++nameNum) {
							if (!scumm_strnicmp(obj._use[useNum]._names[nameNum].c_str(), "*V", 2)) {
								if (!scumm_strnicmp(obj._use[useNum]._names[nameNum].c_str(), "*VSWAP", 6))
									_owner->_swapItems = true;
								else
									_owner->_action = Common::String(obj._use[useNum]._names[nameNum].c_str() + 2);
							}
						}
					}
				}
			}
		}
	}

	// Search the NPCs for matches as well
	for (int idx = 1; idx < MAX_CHARACTERS; ++idx) {
		for (int useNum = 0; useNum < 2; ++useNum) {
			if (!people[idx]._use[useNum]._target.compareToIgnoreCase(inv[_owner->_invSelect]._name) &&
				!people[idx]._use[useNum]._verb.empty() && !people[idx]._use[useNum]._verb.hasPrefix(" ")) {
				bool found1 = false;
				for (uint cmdNum = 0; cmdNum < _inventCommands.size() && !found1; ++cmdNum) {
					if (!_inventCommands[cmdNum].compareToIgnoreCase(people[idx]._use[cmdNum]._verb))
						found1 = true;
				}

				if (!found1)
					_inventCommands.push_back(people[idx]._use[useNum]._verb);
			}
		}
	}

	// Finally see if the item itself has a verb
	if (!inv[_owner->_invSelect]._verb._verb.empty()) {
		// Don't add "Solve" to the Foolscap if it's already been "Solved"
		if (inv[_owner->_invSelect]._verb._verb.compareToIgnoreCase(FIXED(Solve)) || !_vm->readFlags(299))
			_inventCommands.push_back(inv[_owner->_invSelect]._verb._verb);
	}

	// Now find the widest command in the _inventCommands array
	int width = 0;
	for (uint idx = 0; idx < _inventCommands.size(); ++idx)
		width = MAX(width, _surface.stringWidth(_inventCommands[idx]));

	// Set up bounds for the menu
	_bounds = Common::Rect(width + _surface.widestChar() * 2 + 6,
		(_surface.fontHeight() + 7) * _inventCommands.size() + 3);
	_bounds.moveTo(mousePos.x - _bounds.width() / 2, mousePos.y - _bounds.height() / 2);

	// Create the surface
	_surface.create(_bounds.width(), _bounds.height());
	_surface.clear(TRANSPARENCY);
	makeInfoArea();

	// Draw the Verb commands and the lines separating them
	ImageFile &images = *ui._interfaceImages;
	for (int idx = 0; idx < (int)_inventCommands.size(); ++idx) {
		_surface.writeString(_inventCommands[idx], Common::Point((_bounds.width() -
			_surface.stringWidth(_inventCommands[idx])) / 2, (_surface.fontHeight() + 7) * idx + 5), INFO_TOP);

		if (idx < (int)_inventCommands.size() - 1) {
			_surface.vLine(3, (_surface.fontHeight() + 7) * (idx + 1), _bounds.right - 4, INFO_TOP);
			_surface.vLine(3, (_surface.fontHeight() + 7) * (idx + 1) + 1, _bounds.right - 4, INFO_MIDDLE);
			_surface.vLine(3, (_surface.fontHeight() + 7) * (idx + 1) + 2, _bounds.right - 4, INFO_BOTTOM);

			_surface.SHtransBlitFrom(images[4], Common::Point(0, (_surface.fontHeight() + 7) * (idx + 1)));
			_surface.SHtransBlitFrom(images[5], Common::Point(_bounds.width() - images[5]._width,
				(_surface.fontHeight() + 7) * (idx + 1) - 1));
		}
	}

	summonWindow();
}

void WidgetInventoryVerbs::handleEvents() {
	Events &events = *_vm->_events;
	Inventory &inv = *_vm->_inventory;
	TattooScene &scene = *(TattooScene *)_vm->_scene;
	Common::Point mousePos = events.mousePos();
	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
	TattooEngine &vm = *(TattooEngine *)_vm;

	// Handle changing highlighted verb entry
	highlightControls();

	// See if they want to close the menu (by clicking outside the menu)
	Common::Rect innerBounds = _bounds;
	innerBounds.grow(-3);

	// Flag is they are pressing outside of the menu
	if (!innerBounds.contains(mousePos))
		_outsideMenu = true;

	if (events._released || events._rightReleased || ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
		ui._scrollHighlight = SH_NONE;
		banishWindow();

		if (_outsideMenu || ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
			_owner->_invVerbMode = 0;
		} else if (innerBounds.contains(mousePos)) {
			_outsideMenu = false;

			// Check if they are trying to solve the Foolscap puzzle, or looking at the completed puzzle
			bool doFoolscap = !inv[_owner->_invSelect]._name.compareToIgnoreCase(FIXED(Inv6)) &&
				!_inventCommands[_invVerbSelect].compareToIgnoreCase(FIXED(Solve));
			doFoolscap |= (!inv[_owner->_invSelect]._name.compareToIgnoreCase(FIXED(Inv6)) || !inv[_owner->_invSelect]._name.compareToIgnoreCase(FIXED(Inv7)))
				&& !_inventCommands[_invVerbSelect].compareToIgnoreCase(FIXED(Look)) && vm.readFlags(299);

			if (doFoolscap) {
				// Close the entire Inventory and return to Standard Mode
				_owner->_invVerbMode = 0;

				_owner->_tooltipWidget.banishWindow();
				_owner->banishWindow();
				inv.freeInv();

				events.clearEvents();
				vm.doFoolscapPuzzle();
			} else if (_invVerbSelect == 0) {
				// They have released the mouse on the Look Verb command, so Look at the inventory item
				ui._invLookFlag = true;
				inv.freeInv();
				ui._windowOpen = false;
				ui._lookPos = mousePos;
				ui.printObjectDesc(inv[_owner->_invSelect]._examine, true);
			} else {
				_owner->_invVerbMode = 3;
				ui._oldBgFound = -1;

				// See if the selected Verb with the selected Iventory Item, is to be used by itself
				if (!_inventCommands[_invVerbSelect].compareToIgnoreCase(inv[_owner->_invSelect]._verb._verb) ||
					!inv[_owner->_invSelect]._verb._target.compareToIgnoreCase("*SELF")) {
					inv.freeInv();

					ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
					events.clearEvents();
					ui.checkAction(inv[_owner->_invSelect]._verb, 2000);
				} else {
					_owner->_verb = _inventCommands[_invVerbSelect];
				}

				// If we are still in Inventory Mode, setup the graphic to float in front of the mouse cursor
				if (ui._menuMode == INV_MODE) {
					// Add the inventory item to the cursor
					ImageFrame &imgFrame = (*inv._invShapes[_owner->_invSelect - inv._invIndex])[0];
					events.setCursor(ARROW, Common::Point(-100, imgFrame._height), imgFrame._frame);

					// Close the inventory dialog without banishing it, so it can keep getting events
					// to handle tooltips and actually making the selection of what object to use them item on
					inv.freeInv();
					_owner->_surface.free();
				}
			}
		}
	}
}

void WidgetInventoryVerbs::highlightControls() {
	Events &events = *_vm->_events;
	Common::Point mousePos = events.mousePos();

	Common::Rect innerBounds = _bounds;
	innerBounds.grow(-3);

	// Set the highlighted verb
	_invVerbSelect = -1;
	if (innerBounds.contains(mousePos))
		_invVerbSelect = (mousePos.y - _bounds.top - 3) / (_surface.fontHeight() + 7);

	// See if the highlighted verb has changed
	if (_invVerbSelect != _oldInvVerbSelect) {
		// Draw the list again, with the new highlighting
		for (int idx = 0; idx < (int)_inventCommands.size(); ++idx) {
			byte color = (idx == _invVerbSelect) ? COMMAND_HIGHLIGHTED : INFO_TOP;
			_surface.writeString(_inventCommands[idx], Common::Point(
				(_bounds.width() - _surface.stringWidth(_inventCommands[idx])) / 2,
				(_surface.fontHeight() + 7) * idx + 5), color);
		}

		_oldInvVerbSelect = _invVerbSelect;
	}
}

/*----------------------------------------------------------------*/

WidgetInventory::WidgetInventory(SherlockEngine *vm) : WidgetBase(vm),
		_tooltipWidget(vm, this), _verbList(vm, this) {
	_invMode = 0;
	_invVerbMode = 0;
	_invSelect = _oldInvSelect = -1;
	_selector = _oldSelector = -1;
	_swapItems = false;
}

void WidgetInventory::load(int mode) {
	Events &events = *_vm->_events;
	Inventory &inv = *_vm->_inventory;
	Screen &screen = *_vm->_screen;
	Common::Point mousePos = events.mousePos();

	if (mode == 3) {
		mode = 2;
		mousePos = Common::Point(screen._currentScroll.x + SHERLOCK_SCREEN_WIDTH / 2, SHERLOCK_SCREEN_HEIGHT / 2);
	}

	if (mode != 0)
		_invMode = mode;
	_invVerbMode = 0;
	_invSelect = _oldInvSelect = -1;
	_selector = _oldSelector = -1;
	_scroll = true;

	if (mode == 0) {
		banishWindow();
	} else {
		_bounds = Common::Rect((INVENTORY_XSIZE + 3) * NUM_INVENTORY_SHOWN / 2 + BUTTON_SIZE + 6,
			(INVENTORY_YSIZE + 3) * 2 + 3);
		_bounds.moveTo(mousePos.x - _bounds.width() / 2, mousePos.y - _bounds.height() / 2);
	}

	// Ensure menu will be on-screen
	restrictToScreen();

	// Load the inventory data
	inv.loadInv();

	// Redraw the inventory menu on the widget surface
	_surface.create(_bounds.width(), _bounds.height());
	_surface.clear(TRANSPARENCY);

	// Draw the window background and then the inventory on top of it
	makeInfoArea(_surface);
	drawBars();
	drawInventory();
}

void WidgetInventory::drawBars() {
	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
	ImageFile &images = *ui._interfaceImages;
	int x;

	_surface.hLine(3, INVENTORY_YSIZE + 3, _bounds.width() - 4, INFO_TOP);
	_surface.hLine(3, INVENTORY_YSIZE + 4, _bounds.width() - 4, INFO_MIDDLE);
	_surface.hLine(3, INVENTORY_YSIZE + 5, _bounds.width() - 4, INFO_BOTTOM);
	_surface.SHtransBlitFrom(images[4], Common::Point(0, INVENTORY_YSIZE + 2));

	for (int idx = 1; idx <= NUM_INVENTORY_SHOWN / 2; ++idx) {
		x = idx * (INVENTORY_XSIZE + 3);

		_surface.vLine(x, 3, _bounds.height() - 4, INFO_TOP);
		_surface.vLine(x + 1, 3, _bounds.height() - 4, INFO_MIDDLE);
		_surface.vLine(x + 2, 3, _bounds.height() - 4, INFO_BOTTOM);

		_surface.SHtransBlitFrom(images[6], Common::Point(x - 1, 1));
		_surface.SHtransBlitFrom(images[7], Common::Point(x - 1, _bounds.height() - 4));
		_surface.SHtransBlitFrom(images[6], Common::Point(x - 1, INVENTORY_YSIZE + 5));
		_surface.SHtransBlitFrom(images[7], Common::Point(x - 1, INVENTORY_YSIZE + 2));
	}

	_surface.vLine(x + 2, INVENTORY_YSIZE + 2, INVENTORY_YSIZE + 8, INFO_BOTTOM);
}

void WidgetInventory::drawInventory() {
	Inventory &inv = *_vm->_inventory;

	// TODO: Refactor _invIndex into this widget class
	for (int idx = 0, itemId = inv._invIndex; idx < NUM_INVENTORY_SHOWN; ++idx, ++itemId) {
		// Figure out the drawing position
		Common::Point pt(3 + (INVENTORY_XSIZE + 3) * (idx % (NUM_INVENTORY_SHOWN / 2)),
			3 + (INVENTORY_YSIZE + 3) * (idx / (NUM_INVENTORY_SHOWN / 2)));

		// Draw the box to serve as the background for the item
		_surface.hLine(pt.x + 1, pt.y, pt.x + INVENTORY_XSIZE - 2, TRANSPARENCY);
		_surface.fillRect(Common::Rect(pt.x, pt.y + 1, pt.x + INVENTORY_XSIZE, pt.y + INVENTORY_YSIZE - 1), TRANSPARENCY);
		_surface.hLine(pt.x + 1, pt.y + INVENTORY_YSIZE - 1, pt.x + INVENTORY_XSIZE - 2, TRANSPARENCY);

		// Draw the item
		if (itemId < inv._holdings) {
			ImageFrame &img = (*inv._invShapes[idx])[0];
			_surface.SHtransBlitFrom(img, Common::Point(pt.x + (INVENTORY_XSIZE - img._width) / 2,
				pt.y + (INVENTORY_YSIZE - img._height) / 2));
		}
	}

	drawScrollBar(inv._invIndex / NUM_INV_PER_LINE, NUM_INVENTORY_SHOWN / NUM_INV_PER_LINE,
		(inv._holdings + NUM_INV_PER_LINE - 1) / NUM_INV_PER_LINE);
}

void WidgetInventory::handleEvents() {
	TattooEngine &vm = *(TattooEngine *)_vm;
	Events &events = *_vm->_events;
	Inventory &inv = *_vm->_inventory;
	People &people = *_vm->_people;
	TattooScene &scene = *(TattooScene *)_vm->_scene;
	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;
	Common::Point mousePos = events.mousePos();

	if (_invVerbMode == 1) {
		checkTabbingKeys(MAX_INV_COMMANDS);
	} else if (_invVerbMode == 0) {
		checkInvTabbingKeys();

		// Handle scrollbar events
		int oldScrollIndex = inv._invIndex / NUM_INV_PER_LINE;
		int invIndex = inv._invIndex / NUM_INV_PER_LINE;

		ScrollHighlight oldHighlight = ui._scrollHighlight;
		handleScrollbarEvents(invIndex, NUM_INVENTORY_SHOWN / NUM_INV_PER_LINE,
			(inv._holdings + NUM_INV_PER_LINE - 1) / NUM_INV_PER_LINE);

		handleScrolling(invIndex, NUM_INVENTORY_SHOWN / NUM_INV_PER_LINE,
			(inv._holdings + NUM_INV_PER_LINE - 1) / NUM_INV_PER_LINE);

		if (oldScrollIndex != invIndex) {
			// Starting visible item index has changed, so set the index and reload inventory graphics
			inv._invIndex = invIndex * NUM_INV_PER_LINE;
			inv.freeGraphics();
			inv.loadGraphics();
		}

		if (ui._scrollHighlight != oldHighlight || oldScrollIndex != invIndex) {
			drawInventory();
			return;
		}
	}

	if (_invVerbMode != 1)
		_tooltipWidget.handleEvents();

	// Flag is they started pressing outside of the menu
	if (events._firstPress && !_bounds.contains(mousePos))
		_outsideMenu = true;

	if (_invVerbMode != 3)
		highlightControls();

	// See if they released a mouse button button
	if (events._released || events._rightReleased || ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
		ui._scrollHighlight = SH_NONE;

		// See if they have a Verb List open for an Inventry Item
		if (_invVerbMode == 1)
			return;

		if (_invVerbMode == 3) {
			// Selecting object after inventory verb has been selected
			_tooltipWidget.banishWindow();
			close();

			if (ui._keyState.keycode != Common::KEYCODE_ESCAPE) {
				// If user pointed at an item, use the selected inventory item with this item
				bool found = false;
				if (ui._bgFound != -1) {
					if (ui._personFound) {
						Person &person = people[ui._bgFound - 1000];

						for (int idx = 0; idx < 2; ++idx) {
							if (!person._use[idx]._verb.compareToIgnoreCase(_verb) &&
								!person._use[idx]._target.compareToIgnoreCase(_invTarget)) {
								ui.checkAction(person._use[idx], ui._bgFound);
								found = true;
							}
						}
					} else {
						for (int idx = 0; idx < 6; ++idx) {
							if (!ui._bgShape->_use[idx]._verb.compareToIgnoreCase(_verb) &&
									!ui._bgShape->_use[idx]._target.compareToIgnoreCase(_invTarget)) {
								ui.checkAction(ui._bgShape->_use[idx], ui._bgFound);
								found = true;
							}
						}
					}
				}

				if (!found)
					ui.putMessage("%s", FIXED(NoEffect));
			}
		} else if ((_outsideMenu && !_bounds.contains(mousePos)) || ui._keyState.keycode == Common::KEYCODE_ESCAPE) {
			// Want to close the window (clicked outside of it). So close the window and return to Standard
			close();

		} else if (_bounds.contains(mousePos)) {
			// Mouse button was released inside the inventory window
			_outsideMenu = false;

			//  See if they are pointing at one of the inventory items
			if (_invSelect != -1) {
				// See if they are in Use Obj with Inv. Mode (they right clicked on an item
				// in the room and selected "Use with Inv.")
				if (_invMode == 1) {
					_tooltipWidget.banishWindow();
					banishWindow();

					// See if the item in the room that they started with was a person
					bool found = false;
					if (ui._activeObj >= 1000) {
						// Object was a person, activate anything in his two verb fields
						for (int idx = 0; idx < 2; ++idx) {
							if (!people[ui._activeObj - 1000]._use[idx]._target.compareToIgnoreCase(inv[_invSelect]._name)) {
								ui.checkAction(people[ui._activeObj - 1000]._use[idx], ui._activeObj);
								found = true;
							}
						}
					} else {
						// Object was a regular object, activate anything in its verb fields
						for (int idx = 0; idx < 6; ++idx) {
							if (!scene._bgShapes[ui._activeObj]._use[idx]._target.compareToIgnoreCase(inv[_invSelect]._name)) {
								ui.checkAction(scene._bgShapes[ui._activeObj]._use[idx], ui._activeObj);
								found = true;
							}
						}
					}
					if (!found)
						ui.putMessage("%s", FIXED(NoEffect));

				} else {
					// See if they right clicked on an item
					if (events._rightReleased) {
						_invVerbMode = 1;
						_verbList._oldInvVerbSelect = -1;
						_tooltipWidget.banishWindow();

						// Keep track of the name of the inventory object so we can check it against the target fields
						// of verbs when we activate it
						_invTarget = inv[_invSelect]._name;
						_swapItems = false;

						_verbList.load();
					} else {
						// They left clicked on an inventory item, so Look at it

						// Check if they are looking at the solved Foolscap
						if ((!inv[_invSelect]._name.compareToIgnoreCase(FIXED(Inv6)) || !inv[_invSelect]._name.compareToIgnoreCase(FIXED(Inv7)))
								&& vm.readFlags(299)) {
							banishWindow();
							_tooltipWidget.erase();

							_invVerbMode = 0;
							inv.freeInv();

							events.clearEvents();
							events.setCursor(ARROW);
							ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;

							scene.doBgAnim();
							vm.doFoolscapPuzzle();
						} else {
							ui._invLookFlag = true;
							inv.freeInv();

							_tooltipWidget.banishWindow();
							ui._windowOpen = false;
							ui._lookPos = mousePos;
							ui.printObjectDesc(inv[_invSelect]._examine, true);
						}
					}
				}
			}
		}
	}
}

void WidgetInventory::checkInvTabbingKeys() {
}

void WidgetInventory::highlightControls() {
	// TODO
}

void WidgetInventory::banishWindow() {
	WidgetBase::banishWindow();

	_verbList.banishWindow();
}

void WidgetInventory::draw() {
	WidgetBase::draw();
	_tooltipWidget.draw();
}

void WidgetInventory::erase() {
	WidgetBase::erase();
	_tooltipWidget.erase();
}

void WidgetInventory::close() {
	Events &events = *_vm->_events;
	Inventory &inv = *_vm->_inventory;
	TattooScene &scene = *(TattooScene *)_vm->_scene;
	TattooUserInterface &ui = *(TattooUserInterface *)_vm->_ui;

	banishWindow();
	inv.freeInv();
	events.clearEvents();

	events.setCursor(ARROW);
	ui._menuMode = scene._labTableScene ? LAB_MODE : STD_MODE;
}

} // End of namespace Tattoo

} // End of namespace Sherlock
