#include "UI.h"

#pragma push_macro("byte")
#pragma push_macro("GetNextSibling")
#pragma push_macro("GetFirstChild")
#undef byte
#undef GetNextSibling
#undef GetFirstChild

#include "UIScene_SettingsControlMenu.h"
#include "RmlManager.h"
#include "../../Windows64/KeyboardMouseInput.h"
#include <RmlUi/Core/Input.h>
#include <RmlUi/Core/Context.h>
#include <RmlUi/Core/Box.h>
#include <RmlUi/Core/Element.h>

#pragma pop_macro("GetFirstChild")
#pragma pop_macro("GetNextSibling")
#pragma pop_macro("byte")

struct SliderEntry { const char* id; int* value; int idsString; int setting; };

static const char* s_sliderIds[] = { "GameSensitivity", "InterfaceSensitivity" };

UIScene_SettingsControlMenu::UIScene_SettingsControlMenu(int iPad, void *initData, UILayer *parentLayer)
	: UIScene_RmlBase(iPad, parentLayer)
	, m_gameSensitivityValue(100)
	, m_interfaceSensitivityValue(100)
	, m_dragSliderIndex(-1)
{
	Rml::Context* ctx = RmlManager::Get().GetContext();
	if (!ctx)
	{
		app.DebugPrintf("[RmlSettingsMenu] No RmlUi context available\n");
		return;
	}

	m_document = ctx->LoadDocument("SettingsControlMenu.rml");
	if (!m_document)
	{
		app.DebugPrintf("[RmlSettingsMenu] Failed to load SettingsMenu.rml\n");
		return;
	}

	m_document->Show();

	m_gameSensitivityValue = app.GetGameSettings(m_iPad, eGameSetting_Sensitivity_InGame);
	m_interfaceSensitivityValue = app.GetGameSettings(m_iPad, eGameSetting_Sensitivity_InMenu);

	setSliderValue("GameSensitivity", utils.WideToUtf8(app.GetString(IDS_SLIDER_SENSITIVITY_INGAME)), m_gameSensitivityValue, 1, 200);
	setSliderValue("InterfaceSensitivity", utils.WideToUtf8(app.GetString(IDS_SLIDER_SENSITIVITY_INMENU)), m_interfaceSensitivityValue, 1, 200);

	registerEvents();

	updateComponents();
	ui.HidePressStart();
	TelemetryManager->RecordMenuShown(m_iPad, eUIScene_SettingsControlMenu, 0);
}

UIScene_SettingsControlMenu::~UIScene_SettingsControlMenu()
{
	if (m_document)
	{
		deregisterEvents();
		m_document->Close();
		m_document = nullptr;
	}
}

void UIScene_SettingsControlMenu::registerEvents()
{
	for (size_t i = 0; i < sizeof(s_sliderIds) / sizeof(s_sliderIds[0]); i++)
	{
		Rml::Element* elTrack = m_document->GetElementById(Rml::String(s_sliderIds[i]) + "_track");
		if (elTrack)
		{
			elTrack->AddEventListener(Rml::EventId::Mousedown, this);
			elTrack->AddEventListener(Rml::EventId::Mouseover, this);
		}

		Rml::Element* elThumb = m_document->GetElementById(Rml::String(s_sliderIds[i]) + "_thumb");
		if (elThumb)
		{
			elThumb->AddEventListener(Rml::EventId::Mousedown, this);
			elThumb->AddEventListener(Rml::EventId::Mouseover, this);
		}
	}

	m_document->AddEventListener(Rml::EventId::Mousemove, this);
	m_document->AddEventListener(Rml::EventId::Mouseup, this);
}

void UIScene_SettingsControlMenu::deregisterEvents()
{
	for (size_t i = 0; i < sizeof(s_sliderIds) / sizeof(s_sliderIds[0]); i++)
	{
		Rml::Element* elTrack = m_document->GetElementById(Rml::String(s_sliderIds[i]) + "_track");
		if (elTrack)
		{
			elTrack->RemoveEventListener(Rml::EventId::Mousedown, this);
			elTrack->RemoveEventListener(Rml::EventId::Mouseover, this);
		}

		Rml::Element* elThumb = m_document->GetElementById(Rml::String(s_sliderIds[i]) + "_thumb");
		if (elThumb)
		{
			elThumb->RemoveEventListener(Rml::EventId::Mousedown, this);
			elThumb->RemoveEventListener(Rml::EventId::Mouseover, this);
		}
	}

	m_document->RemoveEventListener(Rml::EventId::Mousemove, this);
	m_document->RemoveEventListener(Rml::EventId::Mouseup, this);
}

void UIScene_SettingsControlMenu::setSliderValue(const Rml::String& id, const Rml::String& labelPrefix, int value, int min, int max)
{
	Rml::Element* label = m_document->GetElementById(id + "_label");
	if (label)
	{
		char buf[64];
		snprintf(buf, sizeof(buf), "%s: %d%%", labelPrefix.c_str(), value);
		label->SetInnerRML(Rml::String(buf));
	}

	Rml::Element* thumb = m_document->GetElementById(id + "_thumb");
	if (thumb)
	{
		float fraction = (max > min) ? (float)(value - min) / (float)(max - min) : 0.0f;
		char buf[16];
		snprintf(buf, sizeof(buf), "%.0f%%", fraction * 100.0f);
		thumb->SetProperty("left", Rml::String(buf));
	}
}

int UIScene_SettingsControlMenu::getSliderValue(const Rml::String& id)
{
	if (id == "GameSensitivity")
		return m_gameSensitivityValue;
	if (id == "InterfaceSensitivity")
		return m_interfaceSensitivityValue;

	return 0;
}

void UIScene_SettingsControlMenu::handleSliderMouseEvent(int sliderIndex, const Rml::Event& event)
{
	if (!m_document) return;

	Rml::String trackId = Rml::String(s_sliderIds[sliderIndex]) + "_track";
	Rml::Element* track = m_document->GetElementById(trackId);
	if (!track) return;

	float mouseX = event.GetParameter<float>("mouse_x", 0.0f);
	Rml::Box box = track->GetBox();
	float boxLeft = track->GetAbsoluteOffset().x;
	float boxWidth = box.GetSize().x;

	if (boxWidth > 0.0f)
	{
		float fraction = (mouseX - boxLeft) / boxWidth;
		if (fraction < 0.0f) fraction = 0.0f;
		if (fraction > 1.0f) fraction = 1.0f;

		int newValue = 1 + static_cast<int>(fraction * 199.0f + 0.5f);
		if (newValue < 1) newValue = 1;
		if (newValue > 200) newValue = 200;

		handleSliderMove(sliderIndex, newValue);
	}
}

void UIScene_SettingsControlMenu::updateComponents()
{
	bool bNotInGame = (Minecraft::GetInstance()->level == nullptr);
	if (bNotInGame)
	{
		m_parentLayer->showComponent(m_iPad, eUIComponent_Panorama, true);
		m_parentLayer->showComponent(m_iPad, eUIComponent_Logo, true);
	}
	else
	{
		m_parentLayer->showComponent(m_iPad, eUIComponent_Panorama, false);

		if (app.GetLocalPlayerCount() == 1) m_parentLayer->showComponent(m_iPad, eUIComponent_Logo, true);
		else m_parentLayer->showComponent(m_iPad, eUIComponent_Logo, false);
	}
}

void UIScene_SettingsControlMenu::ProcessEvent(Rml::Event& event)
{
	if (event.GetId() == Rml::EventId::Mousedown)
	{
		Rml::Element* el = event.GetCurrentElement();
		const Rml::String& id = el->GetId();

		for (size_t i = 0; i < sizeof(s_sliderIds) / sizeof(s_sliderIds[0]); i++)
		{
			Rml::String trackId = Rml::String(s_sliderIds[i]) + "_track";
			Rml::String thumbId = Rml::String(s_sliderIds[i]) + "_thumb";
			if (id == trackId || id == thumbId)
			{
				m_dragSliderIndex = static_cast<int>(i);
				handleSliderMouseEvent(static_cast<int>(i), event);
				ui.PlayUISFX(eSFX_Scroll);
				return;
			}
		}
	}
	else if (event.GetId() == Rml::EventId::Mousemove)
	{
		if (m_dragSliderIndex >= 0)
		{
			int oldValue = getSliderValue(s_sliderIds[m_dragSliderIndex]);
			handleSliderMouseEvent(m_dragSliderIndex, event);
			if (getSliderValue(s_sliderIds[m_dragSliderIndex]) != oldValue)
				ui.PlayUISFX(eSFX_Scroll);
		}
	}
	else if (event.GetId() == Rml::EventId::Mouseup)
		m_dragSliderIndex = -1;
	else if (event.GetId() == Rml::EventId::Mouseover)
		ui.PlayUISFX(eSFX_Focus);
}

void UIScene_SettingsControlMenu::handleInput(int iPad, int key, bool repeat, bool pressed, bool released, bool &handled)
{
	Rml::Context* ctx = RmlManager::Get().GetContext();
	if (!ctx)
		return;

	if (!pressed)
		return;

	switch (key)
	{
	case ACTION_MENU_UP:
		ctx->ProcessKeyDown(Rml::Input::KI_UP, 0);
		handled = true;
		break;
	case ACTION_MENU_DOWN:
		ctx->ProcessKeyDown(Rml::Input::KI_DOWN, 0);
		handled = true;
		break;
	case ACTION_MENU_LEFT:
		ctx->ProcessKeyDown(Rml::Input::KI_LEFT, 0);
		handled = true;
		break;
	case ACTION_MENU_RIGHT:
		ctx->ProcessKeyDown(Rml::Input::KI_RIGHT, 0);
		handled = true;
		break;
	case ACTION_MENU_OK:
		ctx->ProcessKeyDown(Rml::Input::KI_RETURN, 0);
		handled = true;
		break;
	case ACTION_MENU_CANCEL:
	case ACTION_MENU_PAUSEMENU:
		navigateBack();
		handled = true;
		break;
	default:
		break;
	}
}

void UIScene_SettingsControlMenu::handleSliderMove(int sliderIndex, int value)
{
	int* member = (sliderIndex == 0) ? &m_gameSensitivityValue : &m_interfaceSensitivityValue;
	const char* id = s_sliderIds[sliderIndex];
	int idsString = (sliderIndex == 0) ? IDS_SLIDER_SENSITIVITY_INGAME : IDS_SLIDER_SENSITIVITY_INMENU;
	eGameSetting setting = (sliderIndex == 0) ? eGameSetting_Sensitivity_InGame : eGameSetting_Sensitivity_InMenu;

	*member = value;
	Rml::String prefix = utils.WideToUtf8(app.GetString(idsString));
	setSliderValue(id, prefix, value, 1, 200);

	if (value != app.GetGameSettings(m_iPad, setting))
	{
		app.SetGameSettings(m_iPad, setting, value);
		ui.UpdateSelectedItemPos(m_iPad);
	}
}