/* 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 2
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#include "common/scummsys.h"
#include "mads/mads.h"
#include "mads/compression.h"
#include "mads/user_interface.h"
#include "mads/nebular/game_nebular.h"

namespace MADS {

UISlot::UISlot() {
	_flags = IMG_STATIC;
	_segmentId = 0;
	_spritesIndex = 0;
	_frameNumber = 0;
	_width = _height = 0;
}

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

void UISlots::fullRefresh() {
	UISlot slot;
	slot._flags = IMG_REFRESH;
	slot._segmentId = -1;

	push_back(slot);
}

void UISlots::add(const Common::Rect &bounds) {
	assert(size() < 50);

	UISlot ie;
	ie._flags = IMG_OVERPRINT;
	ie._segmentId = IMG_TEXT_UPDATE;
	ie._position = Common::Point(bounds.left, bounds.top);
	ie._width = bounds.width();
	ie._height = bounds.height();

	push_back(ie);
}

void UISlots::add(const AnimFrameEntry &frameEntry) {
	assert(size() < 50);

	UISlot ie;
	ie._flags = IMG_UPDATE;
	ie._segmentId = frameEntry._seqIndex;
	ie._spritesIndex = frameEntry._spriteSlot._spritesIndex;
	ie._frameNumber = frameEntry._spriteSlot._frameNumber;
	ie._position = frameEntry._spriteSlot._position;

	push_back(ie);
}

void UISlots::draw(bool updateFlag, bool delFlag) {
	Scene &scene = _vm->_game->_scene;
	UserInterface &userInterface = scene._userInterface;
	DirtyArea *dirtyAreaPtr = nullptr;

	// Loop through setting up the dirty areas
	for (uint idx = 0; idx < size(); ++idx) {
		DirtyArea &dirtyArea = userInterface._dirtyAreas[idx];
		UISlot &slot = (*this)[idx];

		if (slot._flags >= IMG_STATIC) {
			dirtyArea._active = false;
		} else {
			dirtyArea.setUISlot(&slot);
			dirtyArea._textActive = true;
			if (slot._segmentId == IMG_SPINNING_OBJECT && slot._flags == IMG_FULL_UPDATE) {
				dirtyArea._active = false;
				dirtyAreaPtr = &dirtyArea;
			}
		}
	}

	userInterface._dirtyAreas.merge(1, userInterface._uiSlots.size());
	if (dirtyAreaPtr)
		dirtyAreaPtr->_active = true;

	// Copy parts of the user interface background that need to be erased
	for (uint idx = 0; idx < size(); ++idx) {
		DirtyArea &dirtyArea = userInterface._dirtyAreas[idx];
		UISlot &slot = (*this)[idx];

		if (dirtyArea._active && dirtyArea._bounds.width() > 0
				&& dirtyArea._bounds.height() > 0 && slot._flags > -20) {

			if (slot._flags >= IMG_ERASE) {
				// Merge area
				userInterface.mergeFrom(&userInterface._surface, dirtyArea._bounds,
					Common::Point(dirtyArea._bounds.left, dirtyArea._bounds.top));
			} else {
				// Copy area
				userInterface._surface.copyTo(&userInterface, dirtyArea._bounds,
					Common::Point(dirtyArea._bounds.left, dirtyArea._bounds.top));
			}
		}
	}

	for (uint idx = 0; idx < size(); ++idx) {
		DirtyArea &dirtyArea = userInterface._dirtyAreas[idx];
		UISlot &slot = (*this)[idx];

		int slotType = slot._flags;
		if (slotType >= IMG_STATIC) {
			dirtyArea.setUISlot(&slot);
			if (!updateFlag)
				slotType &= ~0x40;

			dirtyArea._textActive = slotType > 0;
			slot._flags &= 0x40;
		}
	}

	userInterface._dirtyAreas.merge(1, userInterface._uiSlots.size());

	for (uint idx = 0; idx < size(); ++idx) {
		DirtyArea *dirtyArea = &userInterface._dirtyAreas[idx];
		UISlot &slot = (*this)[idx];

		if (slot._flags >= IMG_STATIC && !(slot._flags & 0x40)) {
			if (!dirtyArea->_active) {
				do {
					dirtyArea = dirtyArea->_mergedArea;
				} while (!dirtyArea->_active);
			}

			if (dirtyArea->_textActive) {
				SpriteAsset *asset = scene._sprites[slot._spritesIndex];

				// Get the frame details
				int frameNumber = ABS(slot._frameNumber);
				bool flipped = slot._frameNumber < 0;

				if (slot._segmentId == IMG_SPINNING_OBJECT) {
					MSprite *sprite = asset->getFrame(frameNumber);
					sprite->copyTo(&userInterface, slot._position,
						sprite->getTransparencyIndex());
				} else {
					MSprite *sprite = asset->getFrame(frameNumber - 1);

					if (flipped) {
						MSurface *spr = sprite->flipHorizontal();
						userInterface.mergeFrom(spr, spr->getBounds(), slot._position,
							sprite->getTransparencyIndex());
						delete spr;
					} else {
						userInterface.mergeFrom(sprite, sprite->getBounds(), slot._position,
							sprite->getTransparencyIndex());
					}
				}
			}
		}
	}

	// Mark areas of the screen surface for updating
	if (updateFlag) {
		for (uint idx = 0; idx < size(); ++idx) {
			DirtyArea &dirtyArea = userInterface._dirtyAreas[idx];

			if (dirtyArea._active && dirtyArea._textActive &&
				dirtyArea._bounds.width() > 0 && dirtyArea._bounds.height() > 0) {
				// Flag area of screen as needing update
				Common::Rect r = dirtyArea._bounds;
				r.translate(0, scene._interfaceY);
				_vm->_screen.copyRectToScreen(r);
			}
		}
	}

	// Post-processing to remove slots no longer needed
	for (int idx = (int)size() - 1; idx >= 0; --idx) {
		UISlot &slot = (*this)[idx];

		if (slot._flags < IMG_STATIC) {
			if (delFlag || updateFlag)
				remove_at(idx);
			else if (slot._flags > -20)
				slot._flags -= 20;
		} else {
			if (updateFlag)
				slot._flags &= ~0x40;
			else
				slot._flags |= 0x40;
		}
	}
}

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

MADSEngine *Conversation::_vm;

void Conversation::init(MADSEngine *vm) {
	_vm = vm;
}

void Conversation::setup(int globalId, ...) {
	va_list va;
	va_start(va, globalId);

	// Load the list of conversation quotes
	_quotes.clear();
	int quoteId = va_arg(va, int);
	while (quoteId > 0) {
		_quotes.push_back(quoteId);
		quoteId = va_arg(va, int);
	}
	va_end(va);

	if (quoteId < 0) {
		// For an ending value of -1, also initial the bitflags for the global
		// associated with the conversation entry, which enables all the quote Ids
		_vm->_game->globals()[globalId] = (int16)0xffff;
	}

	_globalId = globalId;
}

void Conversation::set(int quoteId, ...) {
	_vm->_game->globals()[_globalId] = 0;

	va_list va;
	va_start(va, quoteId);

	// Loop through handling each quote
	while (quoteId > 0) {
		for (uint idx = 0; idx < _quotes.size(); ++idx) {
			if (_quotes[idx] == quoteId) {
				// Found index, so set that bit in the global keeping track of conversation state
				_vm->_game->globals()[_globalId] |= 1 << idx;
				break;
			}
		}

		quoteId = va_arg(va, int);
	}
	va_end(va);
}

int Conversation::read(int quoteId) {
	uint16 flags = _vm->_game->globals()[_globalId];
	int count = 0;

	for (uint idx = 0; idx < _quotes.size(); ++idx) {
		if (flags & (1 << idx))
			++count;

		if (_quotes[idx] == quoteId)
			return flags & (1 << idx);
	}

	// Could not find it, simply return number of active quotes
	return count;
}

void Conversation::write(int quoteId, bool flag) {
	for (uint idx = 0; idx < _quotes.size(); ++idx) {
		if (_quotes[idx] == quoteId) {
			// Found index, so set or clear the flag
			if (flag) {
				// Set bit
				_vm->_game->globals()[_globalId] |= 1 << idx;
			} else {
				// Clear bit
				_vm->_game->globals()[_globalId] &= ~(1 << idx);
			}
			return;
		}
	}
}

void Conversation::start() {
	UserInterface &userInterface = _vm->_game->_scene._userInterface;
	userInterface.emptyConversationList();

	// Loop through each of the quotes loaded into the conversation
	for (uint idx = 0; idx < _quotes.size(); ++idx) {
		// Check whether the given quote is enabled or not
		if (_vm->_game->globals()[_globalId] & (1 << idx)) {
			// Quote enabled, so add it to the list of talk selections
			Common::String msg = _vm->_game->getQuote(_quotes[idx]);
			userInterface.addConversationMessage(_quotes[idx], msg);
		}
	}

	userInterface.setup(kInputConversation);
}

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

UserInterface::UserInterface(MADSEngine *vm) : _vm(vm), _dirtyAreas(vm),
		_uiSlots(vm) {
	_invSpritesIndex = -1;
	_invFrameNumber = 1;
	_scrollMilli = 0;
	_scrollFlag = false;
	_category = CAT_NONE;
	_inventoryTopIndex = 0;
	_selectedInvIndex = -1;
	_selectedActionIndex = 0;
	_selectedItemVocabIdx = -1;
	_scrollbarActive = SCROLLBAR_NONE;
	_scrollbarOldActive = SCROLLBAR_NONE;
	_scrollbarStrokeType = SCROLLBAR_NONE;
	_scrollbarQuickly = false;
	_scrollbarMilliTime = 0;
	_scrollbarElevator = _scrollbarOldElevator = 0;
	_highlightedCommandIndex = -1;
	_highlightedInvIndex = -1;
	_highlightedItemVocabIndex = -1;
	_dirtyAreas.resize(50);
	_inventoryChanged = false;
	Common::fill(&_categoryIndexes[0], &_categoryIndexes[7], 0);

	// Map the user interface to the bottom of the game's screen surface
	byte *pData = _vm->_screen.getBasePtr(0, MADS_SCENE_HEIGHT);
	setPixels(pData, MADS_SCREEN_WIDTH, MADS_INTERFACE_HEIGHT);

	_surface.setSize(MADS_SCREEN_WIDTH, MADS_INTERFACE_HEIGHT);
}

void UserInterface::load(const Common::String &resName) {
	File f(resName);
	MadsPack madsPack(&f);

	// Load in the palette
	Common::SeekableReadStream *palStream = madsPack.getItemStream(0);

	uint32 *gamePalP = &_vm->_palette->_palFlags[0];
	byte *palP = &_vm->_palette->_mainPalette[0];

	for (int i = 0; i < 16; ++i, gamePalP++, palP += 3) {
		RGB6 rgb;
		rgb.load(palStream);
		palP[0] = rgb.r;
		palP[1] = rgb.g;
		palP[2] = rgb.b;
		*gamePalP |= 1;
	}
	delete palStream;

	// Read in the surface data
	Common::SeekableReadStream *pixelsStream = madsPack.getItemStream(1);
	pixelsStream->read(_surface.getData(), MADS_SCREEN_WIDTH * MADS_INTERFACE_HEIGHT);
	delete pixelsStream;
}

void UserInterface::setup(InputMode inputMode) {
	Scene &scene = _vm->_game->_scene;

	if (_vm->_game->_screenObjects._inputMode != inputMode) {
		Common::String resName = _vm->_game->_aaName;

		// Strip off any extension
		const char *p = strchr(resName.c_str(), '.');
		if (p) {
			resName = Common::String(resName.c_str(), p);
		}

		// Add on suffix if necessary
		if (inputMode != kInputBuildingSentences)
			resName += "A";

		resName += ".INT";

		load(resName);
		_surface.copyTo(this);
	}
	_vm->_game->_screenObjects._inputMode = inputMode;

	scene._userInterface._uiSlots.clear();
	scene._userInterface._uiSlots.fullRefresh();
	_vm->_game->_screenObjects._baseTime = _vm->_events->getFrameCounter();
	_highlightedCommandIndex = -1;
	_highlightedItemVocabIndex = -1;
	_highlightedInvIndex = -1;

	if (_vm->_game->_kernelMode == KERNEL_ACTIVE_CODE)
		scene._userInterface._uiSlots.draw(false, false);

	scene._action.clear();
	drawTextElements();
	loadElements();
	scene._dynamicHotspots.refresh();
}

void UserInterface::drawTextElements() {
	if (_vm->_game->_screenObjects._inputMode) {
		drawConversationList();
	} else {
		// Draw the actions
		drawActions();
		drawInventoryList();
		drawItemVocabList();
	}
}

void UserInterface::mergeFrom(MSurface *src, const Common::Rect &srcBounds,
	const Common::Point &destPos, int transparencyIndex) {
	// Validation of the rectangle and position
	int destX = destPos.x, destY = destPos.y;
	if ((destX >= w) || (destY >= h))
		return;

	Common::Rect copyRect = srcBounds;
	if (destX < 0) {
		copyRect.left += -destX;
		destX = 0;
	} else if (destX + copyRect.width() > w) {
		copyRect.right -= destX + copyRect.width() - w;
	}
	if (destY < 0) {
		copyRect.top += -destY;
		destY = 0;
	} else if (destY + copyRect.height() > h) {
		copyRect.bottom -= destY + copyRect.height() - h;
	}

	if (!copyRect.isValidRect())
		return;

	// Copy the specified area

	byte *data = src->getData();
	byte *srcPtr = data + (src->getWidth() * copyRect.top + copyRect.left);
	byte *destPtr = (byte *)this->pixels + (destY * getWidth()) + destX;

	for (int rowCtr = 0; rowCtr < copyRect.height(); ++rowCtr) {
		// Process each line of the area
		for (int xCtr = 0; xCtr < copyRect.width(); ++xCtr) {
			// Check for the range used for the user interface background, 
			// which are the only pixels that can be replaced
			if ((destPtr[xCtr] >= 8 && destPtr[xCtr] <= 15) && (int)srcPtr[xCtr] != transparencyIndex)
				destPtr[xCtr] = srcPtr[xCtr];
		}

		srcPtr += src->getWidth();
		destPtr += getWidth();
	}
}

void UserInterface::drawActions() {
	for (int idx = 0; idx < 10; ++idx) {
		writeVocab(CAT_COMMAND, idx);
	}
}

void UserInterface::drawInventoryList() {
	int endIndex = MIN((int)_vm->_game->_objects._inventoryList.size(), _inventoryTopIndex + 5);
	for (int idx = _inventoryTopIndex; idx < endIndex; ++idx) {
		writeVocab(CAT_INV_LIST, idx);
	}
}

void UserInterface::drawItemVocabList() {
	if (_selectedInvIndex >= 0) {
		InventoryObject &io = _vm->_game->_objects[
			_vm->_game->_objects._inventoryList[_selectedInvIndex]];
		for (int idx = 0; idx < io._vocabCount; ++idx) {
			writeVocab(CAT_INV_VOCAB, idx);
		}
	}
}

void UserInterface::drawScrolller() {
	if (_scrollbarActive)
		writeVocab(CAT_INV_SCROLLER, _scrollbarActive);
	writeVocab(CAT_INV_SCROLLER, 4);
}

void UserInterface::updateInventoryScroller() {
	ScreenObjects &screenObjects = _vm->_game->_screenObjects;
	Common::Array<int> &inventoryList = _vm->_game->_objects._inventoryList;

	if (screenObjects._inputMode != kInputBuildingSentences)
		return;

	_scrollbarActive = SCROLLBAR_NONE;

	if ((screenObjects._category == CAT_INV_SCROLLER) || (screenObjects._category != CAT_INV_SCROLLER 
			&& _scrollbarOldActive == SCROLLBAR_ELEVATOR && _vm->_events->_mouseStatusCopy)) {
		if (_vm->_events->_mouseStatusCopy || _vm->_easyMouse) {
			if ((_vm->_events->_mouseClicked || (_vm->_easyMouse && !_vm->_events->_mouseStatusCopy))
					&& (screenObjects._category == CAT_INV_SCROLLER))
				_scrollbarStrokeType = (ScrollbarActive)screenObjects._spotId;

			if (screenObjects._spotId == _scrollbarStrokeType || _scrollbarOldActive == SCROLLBAR_ELEVATOR) {
				_scrollbarActive = _scrollbarStrokeType;
				uint32 currentMilli = g_system->getMillis();
				uint32 timeInc = _scrollbarQuickly ? 100 : 380;

				if (_vm->_events->_mouseStatus && (_scrollbarMilliTime + timeInc) <= currentMilli) {
					_scrollbarQuickly = _vm->_events->_vD2 < 1;
					_scrollbarMilliTime = currentMilli;

					switch (_scrollbarStrokeType) {
					case SCROLLBAR_UP:
						// Scroll up
						if (_inventoryTopIndex > 0 && inventoryList.size() > 0) {
							--_inventoryTopIndex;
							_inventoryChanged = true;
						}
						break;

					case SCROLLBAR_DOWN:
						// Scroll down
						if (_inventoryTopIndex < ((int)inventoryList.size() - 1) && inventoryList.size() > 1) {
							++_inventoryTopIndex;
							_inventoryChanged = true;
						}
						break;

					case SCROLLBAR_ELEVATOR: {
						// Inventory slider
						int newIndex = CLIP((int)_vm->_events->currentPos().y - 170, 0, 17)
							* inventoryList.size() / 10;
						if (newIndex >= (int)inventoryList.size())
							newIndex = inventoryList.size() - 1;

						if (inventoryList.size() > 0) {
							_inventoryChanged = newIndex != _inventoryTopIndex;
							_inventoryTopIndex = newIndex;
						}
						break;
					}

					default:
						break;
					}

					if (_inventoryChanged) {
						int dummy;
						updateSelection(CAT_INV_LIST, 0, &dummy);
					}
				}
			}
		}
	}

	if (_scrollbarActive != _scrollbarOldActive || _scrollbarElevator != _scrollbarOldElevator)
		scrollbarChanged();

	_scrollbarOldActive = _scrollbarActive;
	_scrollbarOldElevator = _scrollbarElevator;
}

void UserInterface::scrollbarChanged() {
	Common::Rect r(73, 4, 73 + 9, 4 + 38);
	_uiSlots.add(r);
	_uiSlots.draw(false, false);
	drawScrolller();
	updateRect(r);
}

void UserInterface::writeVocab(ScrCategory category, int id) {
	Common::Rect bounds;
	if (!getBounds(category, id, bounds))
		return;

	Scene &scene = _vm->_game->_scene;
	Font *font = nullptr;

	int vocabId;
	Common::String vocabStr;
	switch (category) {
	case CAT_COMMAND:
		font = _vm->_font->getFont(FONT_INTERFACE);
		vocabId = scene._verbList[id]._id;
		if (id == _highlightedCommandIndex) {
			_vm->_font->setColorMode(SELMODE_HIGHLIGHTED);
		} else {
			_vm->_font->setColorMode(id == _selectedActionIndex ? SELMODE_SELECTED : SELMODE_UNSELECTED);
		}
		vocabStr = scene.getVocab(vocabId);
		vocabStr.setChar(toupper(vocabStr[0]), 0);
		font->writeString(this, vocabStr, Common::Point(bounds.left, bounds.top));
		break;

	case CAT_INV_LIST:
		font = _vm->_font->getFont(FONT_INTERFACE);
		vocabId = _vm->_game->_objects.getItem(id)._descId;
		if (id == _highlightedInvIndex) {
			_vm->_font->setColorMode(SELMODE_HIGHLIGHTED);
		} else {
			_vm->_font->setColorMode(id == _selectedInvIndex ? SELMODE_SELECTED : SELMODE_UNSELECTED);
		}

		vocabStr = scene.getVocab(vocabId);
		vocabStr.setChar(toupper(vocabStr[0]), 0);
		font->writeString(this, vocabStr, Common::Point(bounds.left, bounds.top));
		break;

	case CAT_TALK_ENTRY:
		font = _vm->_font->getFont(FONT_INTERFACE);
		font->setColorMode(id == _highlightedCommandIndex ? SELMODE_HIGHLIGHTED : SELMODE_UNSELECTED);
		font->writeString(this, _talkStrings[id], Common::Point(bounds.left, bounds.top));
		break;

	case CAT_INV_SCROLLER:
		font = _vm->_font->getFont(FONT_MISC);

		switch (id) {
		case 1:
			vocabStr = "a";
			break;
		case 2:
			vocabStr = "b";
			break;
		case 3:
			vocabStr = "d";
			break;
		case 4:
			vocabStr = "c";
			break;
		default:
			break;
		}

		font->setColorMode((id == 4) || (_scrollbarActive == SCROLLBAR_ELEVATOR) ?
			SELMODE_HIGHLIGHTED : SELMODE_UNSELECTED);
		font->writeString(this, vocabStr, Common::Point(bounds.left, bounds.top));
		break;
	default:
		// Item specific verbs
		font = _vm->_font->getFont(FONT_INTERFACE);
		vocabId = _vm->_game->_objects.getItem(_selectedInvIndex)._vocabList[id]._vocabId;
		if (id == _highlightedItemVocabIndex) {
			_vm->_font->setColorMode(SELMODE_HIGHLIGHTED);
		} else {
			_vm->_font->setColorMode(id == _selectedInvIndex ? SELMODE_SELECTED : SELMODE_UNSELECTED);
			vocabStr = scene.getVocab(vocabId);
			vocabStr.setChar(toupper(vocabStr[0]), 0);
			font->writeString(this, vocabStr, Common::Point(bounds.left, bounds.top));
			break;
		}
		break;
	}
}

void UserInterface::loadElements() {
	Scene &scene = _vm->_game->_scene;
	Common::Rect bounds;
	_vm->_game->_screenObjects.clear();

	if (_vm->_game->_screenObjects._inputMode == kInputBuildingSentences) {
		// Set up screen objects for the inventory scroller
		for (int idx = 1; idx <= 3; ++idx) {
			getBounds(CAT_INV_SCROLLER, idx, bounds);
			moveRect(bounds);

			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_INV_SCROLLER, idx);
		}

		// Set up actions
		_categoryIndexes[CAT_COMMAND - 1] = _vm->_game->_screenObjects.size() + 1;
		for (int idx = 0; idx < 10; ++idx) {
			getBounds(CAT_COMMAND, idx, bounds);
			moveRect(bounds);

			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_COMMAND, idx);
		}

		// Set up inventory list
		_categoryIndexes[CAT_INV_LIST - 1] = _vm->_game->_screenObjects.size() + 1;
		for (int idx = 0; idx < 5; ++idx) {
			getBounds(CAT_INV_LIST, idx, bounds);
			moveRect(bounds);

			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_INV_LIST, idx);
		}

		// Set up the inventory vocab list
		_categoryIndexes[CAT_INV_VOCAB - 1] = _vm->_game->_screenObjects.size() + 1;
		for (int idx = 0; idx < 5; ++idx) {
			getBounds(CAT_INV_VOCAB, idx, bounds);
			moveRect(bounds);

			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_INV_VOCAB, idx);
		}

		// Set up the inventory item picture
		_categoryIndexes[CAT_INV_ANIM - 1] = _vm->_game->_screenObjects.size() + 1;
		_vm->_game->_screenObjects.add(Common::Rect(160, 159, 231, 194), LAYER_GUI,
			CAT_INV_ANIM, 0);
	}

	if (_vm->_game->_screenObjects._inputMode == kInputBuildingSentences ||
			_vm->_game->_screenObjects._inputMode == kInputLimitedSentences) {
		_categoryIndexes[CAT_HOTSPOT - 1] = _vm->_game->_screenObjects.size() + 1;
		for (int hotspotIdx = scene._hotspots.size() - 1; hotspotIdx >= 0; --hotspotIdx) {
			Hotspot &hs = scene._hotspots[hotspotIdx];
			_vm->_game->_screenObjects.add(hs._bounds, LAYER_GUI, CAT_HOTSPOT, hotspotIdx);
		}
	}

	if (_vm->_game->_screenObjects._inputMode == kInputConversation) {
		// setup areas for talk entries
		_categoryIndexes[CAT_TALK_ENTRY - 1] = _vm->_game->_screenObjects.size() + 1;
		for (int idx = 0; idx < 5; ++idx) {
			getBounds(CAT_TALK_ENTRY, idx, bounds);
			moveRect(bounds);

			_vm->_game->_screenObjects.add(bounds, LAYER_GUI, CAT_TALK_ENTRY, idx);
		}
	}

	// Store the number of UI elements loaded for easy nuking/refreshing hotspots added later
	_vm->_game->_screenObjects._uiCount = _vm->_game->_screenObjects.size();
}

bool UserInterface::getBounds(ScrCategory category, int v, Common::Rect &bounds) {
	int heightMultiplier, widthMultiplier;
	int leftStart, yOffset, widthAmt;

	switch (category) {
	case CAT_COMMAND:
		heightMultiplier = v % 5;
		widthMultiplier = v / 5;
		leftStart = 2;
		yOffset = 3;
		widthAmt = 32;
		break;

	case CAT_INV_LIST:
		if (v < _inventoryTopIndex || v >= (_inventoryTopIndex + 5))
			return false;

		heightMultiplier = v - _inventoryTopIndex;
		widthMultiplier = 0;
		leftStart = 90;
		yOffset = 3;
		widthAmt = 69;
		break;

	case CAT_TALK_ENTRY:
		heightMultiplier = v;
		widthMultiplier = 0;
		leftStart = 2;
		yOffset = 3;
		widthAmt = 310;
		break;

	case CAT_INV_SCROLLER:
		heightMultiplier = 0;
		widthMultiplier = 0;
		yOffset = 0;
		widthAmt = 9;
		leftStart = (v != 73) ? 73 : 75;
		break;

	default:
		heightMultiplier = v;
		widthMultiplier = 0;
		leftStart = 240;
		yOffset = 3;
		widthAmt = 80;
		break;
	}

	bounds.left = (widthMultiplier > 0) ? widthMultiplier * widthAmt + leftStart : leftStart;
	bounds.setWidth(widthAmt);
	bounds.top = heightMultiplier * 8 + yOffset;
	bounds.setHeight(8);

	if (category == CAT_INV_SCROLLER) {
		switch (v) {
		case SCROLLBAR_UP:
			// Arrow up
			bounds.top = 4;
			bounds.setHeight(7);
			break;
		case SCROLLBAR_DOWN:
			// Arrow down
			bounds.top = 35;
			bounds.setHeight(7);
			break;
		case SCROLLBAR_ELEVATOR:
			// Scroller
			bounds.top = 12;
			bounds.setHeight(22);
			break;
		case SCROLLBAR_THUMB:
			// Thumb
			bounds.top = _scrollbarElevator + 14;
			bounds.setHeight(1);
			break;
		default:
			break;
		}
	}

	return true;
}

void UserInterface::moveRect(Common::Rect &bounds) {
	bounds.translate(0, MADS_SCENE_HEIGHT);
}

void UserInterface::drawConversationList() {
	for (uint idx = 0; idx < _talkStrings.size(); ++idx) {
		writeVocab(CAT_TALK_ENTRY, idx);
	}
}

void UserInterface::emptyConversationList() {
	_talkStrings.clear();
	_talkIds.clear();
}

void UserInterface::addConversationMessage(int vocabId, const Common::String &msg) {
	assert(_talkStrings.size() < 5);

	_talkStrings.push_back(msg);
	_talkIds.push_back(vocabId);
}

void UserInterface::loadInventoryAnim(int objectId) {
	Scene &scene = _vm->_game->_scene;
	noInventoryAnim();

	if (_vm->_invObjectsAnimated) {
		Common::String resName = Common::String::format("*OB%.3dI", objectId);
		SpriteAsset *asset = new SpriteAsset(_vm, resName, 8);
		_invSpritesIndex = scene._sprites.add(asset, 1);
		if (_invSpritesIndex >= 0) {
			_invFrameNumber = 1;
		}
	}
}

void UserInterface::noInventoryAnim() {
	Scene &scene = _vm->_game->_scene;

	if (_invSpritesIndex >= 0) {
		scene._sprites.remove(_invSpritesIndex);
		_vm->_game->_screenObjects._baseTime = _vm->_events->getFrameCounter();
		_invSpritesIndex = -1;
	}

	if (_vm->_game->_screenObjects._inputMode == kInputBuildingSentences)
		refresh();
}

void UserInterface::refresh() {
	_uiSlots.clear();
	_uiSlots.fullRefresh();
	_uiSlots.draw(false, false);

	drawTextElements();
}

void UserInterface::inventoryAnim() {
	Scene &scene = _vm->_game->_scene;
	if (_vm->_game->_screenObjects._inputMode == kInputConversation ||
			_vm->_game->_screenObjects._inputMode == kInputLimitedSentences ||
			_invSpritesIndex < 0)
		return;

	// Move to the next frame number in the sequence, resetting if at the end
	SpriteAsset *asset = scene._sprites[_invSpritesIndex];
	if (++_invFrameNumber > asset->getCount())
		_invFrameNumber = 1;

	// Loop through the slots list for inventory animation entry
	for (uint i = 0; i < _uiSlots.size(); ++i) {
		if (_uiSlots[i]._segmentId == IMG_SPINNING_OBJECT)
			_uiSlots[i]._flags = IMG_FULL_UPDATE;
	}

	// Add a new slot entry for the inventory animation
	UISlot slot;
	slot._flags = IMG_UPDATE;
	slot._segmentId = IMG_SPINNING_OBJECT;
	slot._frameNumber = _invFrameNumber;
	slot._spritesIndex = _invSpritesIndex;
	slot._position = Common::Point(160, 3);

	_uiSlots.push_back(slot);
}

void UserInterface::doBackgroundAnimation() {
	Scene &scene = _vm->_game->_scene;
	Common::Array<AnimUIEntry> &uiEntries = scene._animationData->_uiEntries;
	Common::Array<AnimFrameEntry> &frameEntries = scene._animationData->_frameEntries;

	_noSegmentsActive = !_someSegmentsActive;
	_someSegmentsActive = false;

	for (int idx = 0; idx < (int)uiEntries.size(); ++idx) {
		AnimUIEntry &uiEntry = uiEntries[idx];

		if (uiEntry._counter < 0) {
			if (uiEntry._counter == -1) {
				int probabilityRandom = _vm->getRandomNumber(1, 30000);
				int probability = uiEntry._probability;
				if (uiEntry._probability > 30000) {
					if (_noSegmentsActive) {
						probability -= 30000;
					} else {
						probability = -1;
					}
				}
				if (probabilityRandom <= probability) {
					uiEntry._counter = uiEntry._firstImage;
					_someSegmentsActive = true;
				}
			} else {
				uiEntry._counter = uiEntry._firstImage;
				_someSegmentsActive = true;
			}
		} else {
			for (int idx2 = 0; idx2 < ANIM_SPAWN_COUNT; idx2++) {
				if (uiEntry._spawnFrame[idx2] == (uiEntry._counter - uiEntry._firstImage)) {
					int tempIndex = uiEntry._spawn[idx2];
					if (idx >= tempIndex) {
						uiEntries[tempIndex]._counter = uiEntries[tempIndex]._firstImage;
					} else {
						uiEntries[tempIndex]._counter = -2;
					}
					_someSegmentsActive = true;
				}
			}

			++uiEntry._counter;
			if (uiEntry._counter > uiEntry._lastImage) {
				uiEntry._counter = -1;
			} else {
				_someSegmentsActive = true;
			}
		}
	}

	for (uint idx = 0; idx < uiEntries.size(); ++idx) {
		int imgScan = uiEntries[idx]._counter;
		if (imgScan >= 0) {
			_uiSlots.add(frameEntries[imgScan]);
		}
	}
}

void UserInterface::categoryChanged() {
	_highlightedInvIndex = -1;
	_vm->_events->initVars();
	_category = CAT_NONE;
}

void UserInterface::selectObject(int invIndex) {
	if (_selectedInvIndex != invIndex || _inventoryChanged) {
		int oldVocabCount = _selectedInvIndex < 0 ? 0 : _vm->_game->_objects.getItem(_selectedInvIndex)._vocabCount;
		int newVocabCount = invIndex < 0 ? 0 : _vm->_game->_objects.getItem(invIndex)._vocabCount;
		int maxVocab = MAX(oldVocabCount, newVocabCount);

		updateSelection(CAT_INV_LIST, invIndex, &_selectedInvIndex);
		_highlightedItemVocabIndex = -1;
		_selectedItemVocabIdx = -1;

		if (maxVocab) {
			assert(_uiSlots.size() < 50);
			int vocabHeight = maxVocab * 8;

			Common::Rect bounds(240, 3, 240 + 80, 3 + vocabHeight);
			_uiSlots.add(bounds);
			_uiSlots.draw(false, false);
			drawItemVocabList();
			updateRect(bounds);
		}
	}

	if (invIndex == -1) {
		noInventoryAnim();
	} else {
		loadInventoryAnim(_vm->_game->_objects._inventoryList[invIndex]);
		_vm->_palette->setPalette(_vm->_palette->_mainPalette, 7, 1);
		_vm->_palette->setPalette(_vm->_palette->_mainPalette, 246, 2);
	}
}

void UserInterface::updateSelection(ScrCategory category, int newIndex, int *idx) {
	Game &game = *_vm->_game;
	Common::Array<int> &invList = game._objects._inventoryList;
	Common::Rect bounds;

	if (category == CAT_INV_LIST && _inventoryChanged) {
		*idx = newIndex;
		bounds = Common::Rect(90, 3, 90 + 69, 3 + 40);
		_uiSlots.add(bounds);
		_uiSlots.draw(false, false);
		drawInventoryList();
		updateRect(bounds);
		_inventoryChanged = false;

		if (invList.size() < 2) {
			_scrollbarElevator = 0;
		} else {
			int v = _inventoryTopIndex * 18 / (invList.size() - 1);
			_scrollbarElevator = MIN(v, 17);
		}
	} else {
		int oldIndex = *idx;
		*idx = newIndex;

		if (oldIndex >= 0) {
			writeVocab(category, oldIndex);

			if (getBounds(category, oldIndex, bounds))
				updateRect(bounds);
		}

		if (newIndex >= 0) {
			writeVocab(category, newIndex);

			if (getBounds(category, newIndex, bounds))
				updateRect(bounds);
		}
	}
}

void UserInterface::updateRect(const Common::Rect &bounds) {
	Common::Rect r = bounds;
	r.translate(0, MADS_SCENE_HEIGHT);
	_vm->_screen.copyRectToScreen(r);
}

void UserInterface::scrollerChanged() {
	warning("TODO: scrollerChanged");
}

void UserInterface::scrollInventory() {
	Common::Array<int> &invList = _vm->_game->_objects._inventoryList;

	if (_vm->_events->_mouseButtons) {
		int yp = _vm->_events->currentPos().y;
		if (yp < MADS_SCENE_HEIGHT || yp == (MADS_SCREEN_HEIGHT - 1)) {
			uint32 timeDiff = _scrollFlag ? 100 : 380;
			uint32 currentMilli = g_system->getMillis();
			_vm->_game->_screenObjects._v8332A = -1;

			if (currentMilli >= (_scrollMilli + timeDiff)) {
				_scrollMilli = currentMilli;
				_scrollFlag = true;

				if (yp == (MADS_SCREEN_HEIGHT - 1)) {
					if (_inventoryTopIndex < ((int)invList.size() - 1)) {
						++_inventoryTopIndex;
						_inventoryChanged = true;
					}
				} else {
					if (_inventoryTopIndex > 0) {
						--_inventoryTopIndex;
						_inventoryChanged = true;
					}
				}
			}
		}
	}

	_vm->_game->_screenObjects._v8332A = 0;
}

void UserInterface::synchronize(Common::Serializer &s) {
	InventoryObjects &invObjects = _vm->_game->_objects;

	if (s.isLoading()) {
		_selectedInvIndex = invObjects._inventoryList.empty() ? -1 : 0;
	}

	for (int i = 0; i < 8; ++i)
		s.syncAsSint16LE(_categoryIndexes[i]);
}

} // End of namespace MADS