/* 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/>.
 *
 */

/*
 * This code is based on the CRAB engine
 *
 * Copyright (c) Arvind Raja Yadav
 *
 * Licensed under MIT
 *
 */

#ifndef CRAB_PAGEMENU_H
#define CRAB_PAGEMENU_H

#include "crab/ui/menu.h"

namespace Crab {

namespace pyrodactyl {
namespace ui {
// Sometimes we need multiple pages in a menu, this object does that
// Used in save, load, mod and quest menu
template<typename T>
class PageMenu {
	// The buttons for cycling between pages of the menu
	Button _prev, _next;

	// Each page is stored separately in a menu object
	Common::Array<Menu<T>> _menu;

	// Keep track of which page we are at, and how many elements we keep in a page
	uint _currentPage, _elementsPerPage, _rows, _cols;

	// The image used for the elements
	Button _ref;

	// This vector stores the increments in x,y for each new button
	Vector2i _inc;

	// Display "Page 1 of 3" style information for the menu
	TextData _status;
	Common::String _info;

public:
	PageMenu() {
		_currentPage = 0;
		_elementsPerPage = 1;
		_rows = 1;
		_cols = 1;
		clear();
	}
	~PageMenu() {}

	void reset() {
		for (auto &m : _menu)
			m.reset();
	}

	void clear() {
		_menu.resize(1);
		_menu[0].clear();
		_menu[0].useKeyboard(true);
	}

	// Get the elements per page
	uint elementsPerPage() {
		return _elementsPerPage;
	}

	// This is added to the result from handleEvents to calculate the exact position
	uint index() {
		return _currentPage * _elementsPerPage;
	}

	// The end position of the elements
	uint indexPlusOne() {
		return (_currentPage + 1) * _elementsPerPage;
	}

	// Get the current page of the menu
	uint currentPage() {
		return _currentPage;
	}

	void currentPage(int &val) {
		_currentPage = val;
	}

	// Get the index of the hovered element in the menu
	int hoverIndex() {
		if (_menu[_currentPage].hoverIndex() >= 0)
			return (_currentPage * _elementsPerPage) + _menu[_currentPage].hoverIndex();

		return -1;
	}

	// Get the base position of the elements
	int baseX(const int &count) {
		return _ref.x + _inc.x * (count % _cols);
	}

	int baseY(const int &count) {
		return _ref.y + _inc.y * (count / _cols);
	}

	// This is used to get the coordinates of a button
	const int &curX(const int &count) {
		return _menu[_currentPage]._element[count].x;
	}

	const int &curY(const int &count) {
		return _menu[_currentPage]._element[count].y;
	}

	void image(const int &slot, const int &page, ButtonImage &bi) {
		_menu[page]._element[slot].img(bi);
	}

	void assignPaths() {
		for (auto &m : _menu)
			m.assignPaths();
	}

	void useKeyboard(const bool &val) {
		for (auto &m : _menu)
			m.useKeyboard(val);
	}

	void setUI() {
		_prev.setUI();
		_next.setUI();
		_ref.setUI();
		_status.setUI();

		for (auto &m : _menu)
			m.setUI();
	}

	void updateInfo() {
		_info = numberToString(_currentPage + 1);
		_info += " of ";
		_info += numberToString(_menu.size());
	}

	void load(rapidxml::xml_node<char> *node) {
		using namespace pyrodactyl::input;
		if (nodeValid(node)) {
			if (nodeValid("prev", node)) {
				_prev.load(node->first_node("prev"));
				_prev._hotkey.set(IU_PREV);
			}

			if (nodeValid("next", node)) {
				_next.load(node->first_node("next"));
				_next._hotkey.set(IU_NEXT);
			}

			if (nodeValid("reference", node))
				_ref.load(node->first_node("reference"));

			if (nodeValid("inc", node))
				_inc.load(node->first_node("inc"));

			if (nodeValid("status", node))
				_status.load(node->first_node("status"));

			if (nodeValid("dim", node)) {
				rapidxml::xml_node<char> *dimnode = node->first_node("dim");
				loadNum(_rows, "rows", dimnode);
				loadNum(_cols, "cols", dimnode);
				_elementsPerPage = _rows * _cols;
			}
		}
	}

	void add(uint &slot, uint &page) {
		if (slot >= _elementsPerPage) {
			++page;
			slot = 0;
			_menu.resize(page + 1);
			_menu[page].useKeyboard(true);
		}

		T b;
		b.init(_ref, _inc.x * (slot % _cols), _inc.y * (slot / _cols));
		_menu[page]._element.push_back(b);
		++slot;

		assignPaths();
		updateInfo();
	}

	void add() {
		uint page = _menu.size() - 1;
		uint slot = _menu[page]._element.size();
		add(slot, page);
	}

	void erase() {
		uint page = _menu.size() - 1;
		_menu[page]._element.pop_back();
		assignPaths();
		updateInfo();
	}

	int handleEvents(const Common::Event &event) {
		using namespace pyrodactyl::input;

		if (_currentPage > 0 && _prev.handleEvents(event) == BUAC_LCLICK) {
			_currentPage--;
			updateInfo();

			if ((int)_currentPage < 0)
				_currentPage = 0;
		}

		if (_currentPage < _menu.size() - 1 && _next.handleEvents(event) == BUAC_LCLICK) {
			_currentPage++;
			updateInfo();

			if (_currentPage >= _menu.size())
				_currentPage = _menu.size() - 1;
		}

		return _menu[_currentPage].handleEvents(event);
	}

	void draw() {
		_status.draw(_info);
		_menu[_currentPage].draw();

		if (_currentPage > 0)
			_prev.draw();

		if (_currentPage < _menu.size() - 1)
			_next.draw();
	}
};

typedef PageMenu<Button> PageButtonMenu;
} // End of namespace ui
} // End of namespace pyrodactyl

} // End of namespace Crab

#endif // CRAB_PAGEMENU_H