#include "UI.h"
#include "UIScene_SettingsAudioMenu.h"
#include "../../Windows64/KeyboardMouseInput.h"

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

#include "RmlManager.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 ToggleEntry { const char* id; eGameSetting setting; };
struct SliderEntry { const char* id; int* value; int idsString; int setting; };

static const ToggleEntry s_toggles[] =
{
	{ "CaveSounds", eGameSetting_CaveSounds },
};

static const char* s_sliderIds[] = { "Music", "Sound" };

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

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

	m_document->Show();

	for (size_t i = 0; i < sizeof(s_toggles) / sizeof(s_toggles[0]); i++)
		setToggleChecked(s_toggles[i].id, app.GetGameSettings(m_iPad, s_toggles[i].setting) != 0);

	m_musicValue = app.GetGameSettings(m_iPad, eGameSetting_MusicVolume);
	m_soundValue = app.GetGameSettings(m_iPad, eGameSetting_SoundFXVolume);

	setSliderValue("Music", utils.WideToUtf8(app.GetString(IDS_SLIDER_MUSIC)), m_musicValue, 1, 100);
	setSliderValue("Sound", utils.WideToUtf8(app.GetString(IDS_SLIDER_SOUND)), m_soundValue, 1, 100);

	registerEvents();

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


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

void UIScene_SettingsAudioMenu::registerEvents()
{
	for (size_t i = 0; i < sizeof(s_toggles) / sizeof(s_toggles[0]); i++)
	{
		Rml::Element* el = m_document->GetElementById(Rml::String(s_toggles[i].id));
		if (el)
		{
			el->AddEventListener(Rml::EventId::Click, this);
			el->AddEventListener(Rml::EventId::Mouseover, this);
		}
	}

	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_SettingsAudioMenu::deregisterEvents()
{
	for (size_t i = 0; i < sizeof(s_toggles) / sizeof(s_toggles[0]); i++)
	{
		Rml::Element* el = m_document->GetElementById(Rml::String(s_toggles[i].id));
		if (el)
		{
			el->RemoveEventListener(Rml::EventId::Click, this);
			el->RemoveEventListener(Rml::EventId::Mouseover, this);
		}
	}

	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_SettingsAudioMenu::setToggleChecked(const Rml::String& id, bool checked)
{
	Rml::Element* el = m_document->GetElementById(id);
	if (!el) return;
	el->SetClass("checked", checked);
}

bool UIScene_SettingsAudioMenu::isToggleChecked(const Rml::String& id)
{
	Rml::Element* el = m_document->GetElementById(id);
	return el && el->IsClassSet("checked");
}

void UIScene_SettingsAudioMenu::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_SettingsAudioMenu::getSliderValue(const Rml::String& id)
{
	if (id == "Music")
		return m_musicValue;
	if (id == "Sound")
		return m_soundValue;
	return 0;
}

void UIScene_SettingsAudioMenu::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 * 99.0f + 0.5f);
		if (newValue < 1) newValue = 1;
		if (newValue > 100) newValue = 100;

		handleSliderMove(sliderIndex, newValue);
	}
}

void UIScene_SettingsAudioMenu::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_SettingsAudioMenu::ProcessEvent(Rml::Event& event)
{
	if (event.GetId() == Rml::EventId::Click)
	{
		Rml::Element* el = event.GetCurrentElement();
		const Rml::String& id = el->GetId();

		for (size_t i = 0; i < sizeof(s_toggles) / sizeof(s_toggles[0]); i++)
		{
			if (id == Rml::String(s_toggles[i].id))
			{
				el->SetClass("checked", !el->IsClassSet("checked"));
				ui.PlayUISFX(eSFX_Press);
				return;
			}
		}
	}
	else 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);
}

static void saveToggle(Rml::ElementDocument* doc, int iPad, const ToggleEntry& t)
{
	Rml::Element* el = doc->GetElementById(t.id);
	bool checked = el && el->IsClassSet("checked");
	app.SetGameSettings(iPad, t.setting, checked ? 1 : 0);
}

void UIScene_SettingsAudioMenu::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:
		for (size_t i = 0; i < sizeof(s_toggles) / sizeof(s_toggles[0]); i++)
			saveToggle(m_document, m_iPad, s_toggles[i]);

		navigateBack();
		handled = true;
		break;
	default:
		break;
	}
}


void UIScene_SettingsAudioMenu::handleSliderMove(int sliderIndex, int value)
{
	int* member = (sliderIndex == 0) ? &m_musicValue : &m_soundValue;
	const char* id = s_sliderIds[sliderIndex];
	int idsString = (sliderIndex == 0) ? IDS_SLIDER_MUSIC : IDS_SLIDER_SOUND;
	eGameSetting setting = (sliderIndex == 0) ? eGameSetting_MusicVolume : eGameSetting_SoundFXVolume;

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

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