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

#include "crab/crab.h"
#include "crab/XMLDoc.h"
#include "crab/ui/OptionMenu.h"

namespace Crab {

using namespace pyrodactyl::ui;
using namespace pyrodactyl::image;
using namespace pyrodactyl::music;

void OptionMenu::load(const Common::Path &filename) {
	XMLDoc conf(filename);
	if (conf.ready()) {
		rapidxml::xml_node<char> *node = conf.doc()->first_node("option");
		if (nodeValid(node)) {
			if (nodeValid("bg", node))
				_bg.load(node->first_node("bg"));

			if (nodeValid("state", node)) {
				_menu.load(node->first_node("state"));

				if (!_menu._element.empty())
					_menu._element[0].state(true);
			}

			if (nodeValid("keybind", node))
				_keybind.load(node->first_node("keybind"));

			if (nodeValid("controller", node))
				_conbind.load(node->first_node("controller"));

			if (nodeValid("graphics", node))
				_gfx.load(node->first_node("graphics"));

			if (nodeValid("general", node))
				_general.load(node->first_node("general"));

			if (nodeValid("change", node)) {
				rapidxml::xml_node<char> *chanode = node->first_node("change");

				if (nodeValid("accept", chanode))
					_accept.load(chanode->first_node("accept"));

				if (nodeValid("cancel", chanode))
					_cancel.load(chanode->first_node("cancel"));

				if (nodeValid("message", chanode))
					_noticeRes.load(chanode->first_node("message"));

				if (nodeValid("width", chanode))
					_promptW.load(chanode->first_node("width"));

				if (nodeValid("height", chanode))
					_promptH.load(chanode->first_node("height"));

				if (nodeValid("countdown", chanode)) {
					rapidxml::xml_node<char> *counode = chanode->first_node("countdown");
					_countdown.load(counode);
					_timer.load(counode, "time");
				}

				if (nodeValid("bg", chanode))
					_questionbox.load(chanode->first_node("bg"));
			}
		}
	}
}

void OptionMenu::reset() {
	_keybind.reset();
	_state = STATE_GENERAL;

	for (uint i = 0; i < _menu._element.size(); ++i)
		_menu._element[i].state(i == STATE_GENERAL);
}

void OptionMenu::draw(Button &back) {
	if (_state < STATE_ENTER_W) {
		_bg.draw();

		switch (_state) {
		case STATE_GENERAL:
			_general.draw();
			break;
		case STATE_GRAPHICS:
			_gfx.draw();
			break;
		case STATE_KEYBOARD:
			_keybind.draw();
			break;
		case STATE_CONTROLLER:
			_conbind.draw();
			break;
		default:
			break;
		}

		_menu.draw();
		back.draw();
	} else {
		_questionbox.draw();

		switch (_state) {
		case STATE_ENTER_W:
			_promptW.draw();
			break;
		case STATE_ENTER_H:
			_promptH.draw();
			break;
		case STATE_CONFIRM:
			_noticeRes.draw();
			_countdown.draw(numberToString(_timer.remainingTicks() / 1000));
			break;
		default:
			break;
		}

		_accept.draw();
		_cancel.draw();
	}
}

bool OptionMenu::handleEvents(Button &back, const Common::Event &event) {
	if (_state < STATE_ENTER_W) {
		switch (_state) {
		case STATE_GENERAL:
			_general.handleEvents(event);
			break;
		case STATE_KEYBOARD:
			_keybind.handleEvents(event);
			break;
		case STATE_GRAPHICS: {
			int result = _gfx.handleEvents(event);
			if (result == 1) {
				_state = STATE_CONFIRM;
				_timer.start();
				_gfx.SetInfo();
			} else if (result == 2)
				_state = STATE_ENTER_W;
		} break;
		default:
			break;
		}

		return handleTabs(back, event);
	} else {
		_questionbox.draw();

		switch (_state) {
		case STATE_ENTER_W:
			if (_promptW.handleEvents(event, true) || _accept.handleEvents(event) == BUAC_LCLICK) {
				g_engine->_screenSettings->_cur.w = stringToNumber<int>(_promptW._text);
				_state = STATE_ENTER_H;
			} else if (_cancel.handleEvents(event) == BUAC_LCLICK) {
				_gfx.SetInfo();
				_state = STATE_GRAPHICS;
			}
			break;
		case STATE_ENTER_H:
			if (_promptH.handleEvents(event, true) || _accept.handleEvents(event) == BUAC_LCLICK) {
				g_engine->_screenSettings->_cur.h = stringToNumber<int>(_promptH._text);
				_state = STATE_CONFIRM;
				_timer.start();
				_gfx.SetInfo();
			} else if (_cancel.handleEvents(event) == BUAC_LCLICK) {
				_gfx.SetInfo();
				_state = STATE_GRAPHICS;
			}

			break;
		case STATE_CONFIRM:
			if (_accept.handleEvents(event) != BUAC_IGNORE) {
				_state = STATE_GRAPHICS;
				_timer.stop();
			} else if (_cancel.handleEvents(event) != BUAC_IGNORE) {
				_gfx.SetInfo();
				_state = STATE_GRAPHICS;
			}
			break;
		default:
			break;
		}

		_accept.draw();
		_cancel.draw();
	}

	return false;
}

bool OptionMenu::handleTabs(Button &back, const Common::Event &event) {
	if (back.handleEvents(event) == BUAC_LCLICK) {
		reset();
		return true;
	}

	int choice = _menu.handleEvents(event);
	if (choice >= 0) {
		if (choice < 4)
			for (int i = 0; i < (int)_menu._element.size(); ++i)
				_menu._element[i].state(i == choice);

		switch (choice) {
		case 0:
			_state = STATE_GENERAL;
			break;
		case 1:
			_state = STATE_GRAPHICS;
			break;
		case 2:
			_state = STATE_KEYBOARD;
			break;
		case 3:
			_state = STATE_CONTROLLER;
			break;

		case 4:
			// Save settings to file
			g_engine->_inputManager->save();
			g_engine->_screenSettings->saveState();
			g_engine->_musicManager->saveState();
			saveState();
			//general.CreateBackup();
			//g_engine->_screenSettings->CreateBackup();
			return true;

		case 5:
			// Revert all changes made to settings and exit
			//g_engine->_inputManager->RestoreBackup();
			//keybind.SetCaption();
			//g_engine->_screenSettings->RestoreBackup();
			_general.restoreBackup();
			_general.setUI();
			return true;
		default:
			break;
		}
	}

	return false;
}

#if 0
bool OptionMenu::handleEvents(Button &back, const SDL_Event &Event) {
	if (state < STATE_ENTER_W) {
		bg.draw();

		switch (state) {
		case STATE_GENERAL:
			general.handleEvents(Event);
			break;
		case STATE_KEYBOARD:
			keybind.handleEvents(Event);
			break;
		case STATE_GRAPHICS: {
			int result = gfx.handleEvents(Event);
			if (result == 1) {
				state = STATE_CONFIRM;
				timer.Start();
				g_engine->_screenSettings->SetResolution();
				gfx.SetInfo();
			} else if (result == 2)
				state = STATE_ENTER_W;
		} break;
		default:
			break;
		}

		return HandleTabs(back, Event);
	} else {
		questionbox.draw();

		switch (state) {
		case STATE_ENTER_W:
			if (prompt_w.handleEvents(Event, true) || accept.handleEvents(Event) == BUAC_LCLICK) {
				g_engine->_screenSettings->cur.w = StringToNumber<int>(prompt_w.text);
				state = STATE_ENTER_H;
			} else if (cancel.handleEvents(Event) == BUAC_LCLICK) {
				g_engine->_screenSettings->RestoreBackup();
				gfx.SetInfo();
				state = STATE_GRAPHICS;
			}
			break;
		case STATE_ENTER_H:
			if (prompt_h.handleEvents(Event, true) || accept.handleEvents(Event) == BUAC_LCLICK) {
				g_engine->_screenSettings->cur.h = StringToNumber<int>(prompt_h.text);
				state = STATE_CONFIRM;
				timer.Start();
				g_engine->_screenSettings->SetResolution();
				gfx.SetInfo();
			} else if (cancel.handleEvents(Event) == BUAC_LCLICK) {
				g_engine->_screenSettings->RestoreBackup();
				gfx.SetInfo();
				state = STATE_GRAPHICS;
			}

			break;
		case STATE_CONFIRM:
			if (accept.handleEvents(Event)) {
				state = STATE_GRAPHICS;
				timer.Stop();
			} else if (cancel.handleEvents(Event)) {
				g_engine->_screenSettings->RestoreBackup();
				g_engine->_screenSettings->SetResolution();
				gfx.SetInfo();
				state = STATE_GRAPHICS;
			}
			break;
		default:
			break;
		}

		accept.draw();
		cancel.draw();
	}

	return false;
}


bool OptionMenu::HandleTabs(Button &back, const SDL_Event &Event) {
	if (back.handleEvents(Event) == BUAC_LCLICK) {
		reset();
		return true;
	}

	int choice = menu.handleEvents(Event);
	if (choice >= 0) {
		if (choice < 4)
			for (uint i = 0; i < menu.element.size(); ++i)
				menu.element[i].State(i == choice);

		switch (choice) {
		case 0:
			state = STATE_GENERAL;
			break;
		case 1:
			state = STATE_GRAPHICS;
			break;
		case 2:
			state = STATE_KEYBOARD;
			break;
		case 3:
			state = STATE_CONTROLLER;
			break;

		case 4:
			// Save settings to file
			g_engine->_inputManager->Save();
			saveState();
			general.CreateBackup();
			g_engine->_screenSettings->CreateBackup();
			return true;

		case 5:
			// Revert all changes made to settings and exit
			g_engine->_inputManager->RestoreBackup();
			keybind.SetCaption();
			g_engine->_screenSettings->RestoreBackup();
			general.RestoreBackup();

			SDL_DisplayMode current;
			if (SDL_GetCurrentDisplayMode(0, &current) == 0) {
				if (g_engine->_screenSettings->cur.w != current.w || g_engine->_screenSettings->cur.h != current.h)
					gfx.SetInfo();
			}

			g_engine->_screenSettings->SetResolution();
			return true;
		default:
			break;
		}
	}

	return false;
}
#endif

void OptionMenu::internalEvents() {
	// Since these states can be changed at any time, we just update it regularly
	_gfx.internalEvents();
	_general.internalEvents();

	if (_state == STATE_CONFIRM && _timer.targetReached()) {
		_gfx.SetInfo();
		_state = STATE_GRAPHICS;
	}
}

void OptionMenu::saveState() {
	ConfMan.flushToDisk();

#if 0
	rapidxml::xml_document<char> doc;

	// xml declaration
	rapidxml::xml_node<char> *decl = doc.allocate_node(rapidxml::node_declaration);
	decl->append_attribute(doc.allocate_attribute("version", "1.0"));
	decl->append_attribute(doc.allocate_attribute("encoding", "utf-8"));
	doc.append_node(decl);

	// root node
	rapidxml::xml_node<char> *root = doc.allocate_node(rapidxml::node_element, "settings");
	g_engine->_screenSettings->saveState(doc, root);
	g_engine->_musicManager->saveState(doc, root);

	doc.append_node(root);
	Common::String xml_as_string;
	rapidxml::print(std::back_inserter(xml_as_string), doc);

	Common::String settingpath = g_engine->_filePath->appdata;
	settingpath += "settings.xml";

	std::ofstream save(settingpath, std::ios::out);
	if (save.is_open()) {
		save << xml_as_string;
		save.close();
	}

	doc.clear();
#endif
}

void OptionMenu::setUI() {
	_bg.setUI();
	_menu.setUI();

	_keybind.setUI();
	_conbind.setUI();

	_gfx.setUI();
	_general.setUI();

	_noticeRes.setUI();

	_countdown.setUI();
	_questionbox.setUI();

	_promptW.setUI();
	_promptH.setUI();

	_accept.setUI();
	_cancel.setUI();
}

} // End of namespace Crab