#include "ImGuiSettings.hh"

#include "ImGuiCpp.hh"

#include "ImGuiManager.hh"

#include "ImGuiMessages.hh"

#include "ImGuiOsdIcons.hh"

#include "ImGuiSoundChip.hh"

#include "ImGuiUtils.hh"

#include "VectorPath.hh"

#include "VectorPathDsl.hh"

#include "AnalogInput.hh"

#include "BooleanInput.hh"

#include "BooleanSetting.hh"

#include "CPUCore.hh"

#include "Display.hh"

#include "EventDistributor.hh"

#include "FileContext.hh"

#include "FilenameSetting.hh"

#include "FloatSetting.hh"

#include "GlobalCommandController.hh"

#include "GlobalSettings.hh"

#include "InputEventFactory.hh"

#include "InputEventGenerator.hh"

#include "IntegerSetting.hh"

#include "JoyMega.hh"

#include "JoyHandle.hh"

#include "KeyCodeSetting.hh"

#include "KeyboardSettings.hh"

#include "MSXCPU.hh"

#include "MSXCommandController.hh"

#include "MSXJoystick.hh"

#include "MSXMotherBoard.hh"

#include "Mixer.hh"

#include "Plotter.hh"

#include "PluggingController.hh"

#include "ProxySetting.hh"

#include "R800.hh"

#include "Reactor.hh"

#include "ReadOnlySetting.hh"

#include "SettingsManager.hh"

#include "StringSetting.hh"

#include "Version.hh"

#include "VideoSourceSetting.hh"

#include "Z80.hh"

#include "StringOp.hh"

#include "checked_cast.hh"

#include "foreach_file.hh"

#include "narrow.hh"

#include "strCat.hh"

#include "zstring_view.hh"

#include <imgui.h>

#include <imgui_impl_opengl3.h>

#include <imgui_stdlib.h>

#include <SDL.h>

#include <algorithm>

#include <functional>

#include <optional>

#include <utility>

using namespace std::literals;

namespace openmsx {

ImGuiSettings::ImGuiSettings(ImGuiManager& manager_)

	: ImGuiPart(manager_)

	, saveLayout("layout", ".ini", "layouts")

	, loadLayout("layout", ".ini", "layouts")

	, confirmOverwrite("Confirm##overwrite-layout")

{

	saveLayout.drawAction = [&]{

		saveLayout.drawTable();

		ImGui::TextUnformatted("Enter name:"sv);

		ImGui::InputText("##save-layout-name", &saveLayoutName);

		ImGui::SameLine();

		im::Disabled(saveLayoutName.empty(), [&]{

			if (ImGui::Button("Save as")) {

				(void)manager.getReactor().getDisplay().getWindowPosition(); // to save up-to-date window position

				auto filename = FileOperations::parseCommandFileArgument(

					saveLayoutName, "layouts", "", ".ini");

				auto action = [filename]{

					ImGui::SaveIniSettingsToDisk(filename.c_str());

					ImGui::CloseCurrentPopup();

				};

				if (FileOperations::exists(filename)) {

					confirmOverwrite.open(

						strCat("Overwrite layout: ", saveLayoutName),

						action);

				} else {

					action();

				}

			}

		});

		confirmOverwrite.execute();

	};

	saveLayout.singleClickAction = [&](const FileListWidget::Entry& entry) {

		saveLayoutName = entry.getDefaultDisplayName();

	};

	loadLayout.singleClickAction = [&](const FileListWidget::Entry& entry) {

		manager.loadIniFile = entry.fullName;

		ImGui::CloseCurrentPopup();

	};

}

ImGuiSettings::~ImGuiSettings()

{

	deinitListener();

}

void ImGuiSettings::save(ImGuiTextBuffer& buf)

{

	savePersistent(buf, *this, persistentElements);

}

void ImGuiSettings::loadLine(std::string_view name, zstring_view value)

{

	loadOnePersistent(name, value, *this, persistentElements);

}

void ImGuiSettings::loadEnd()

{

	setStyle();

}

void ImGuiSettings::setStyle() const

{

	switch (selectedStyle) {

	case 0: ImGui::StyleColorsDark();    break;

	case 1: ImGui::StyleColorsLight();   break;

	case 2: ImGui::StyleColorsClassic(); break;

	case 3: ImGui::StyleColorsClassic(); break; // colorblind adjustments

	}

	setColors(selectedStyle);

}

// Returns the currently pressed key-chord, or 'ImGuiKey_None' if no

// (non-modifier) key is pressed.

// If more than (non-modifier) one key is pressed, this returns an arbitrary key

// (in the current implementation the one with lowest index).

[[nodiscard]] static ImGuiKeyChord getCurrentlyPressedKeyChord()

{

	static constexpr auto mods = std::array{

		ImGuiKey_LeftCtrl, ImGuiKey_LeftShift, ImGuiKey_LeftAlt, ImGuiKey_LeftSuper,

		ImGuiKey_RightCtrl, ImGuiKey_RightShift, ImGuiKey_RightAlt, ImGuiKey_RightSuper,

		ImGuiKey_ReservedForModCtrl, ImGuiKey_ReservedForModShift, ImGuiKey_ReservedForModAlt,

		ImGuiKey_ReservedForModSuper, ImGuiKey_MouseLeft, ImGuiKey_MouseRight, ImGuiKey_MouseMiddle,

		ImGuiKey_MouseX1, ImGuiKey_MouseX2, ImGuiKey_MouseWheelX, ImGuiKey_MouseWheelY,

	};

	for (int key = ImGuiKey_NamedKey_BEGIN; key < ImGuiKey_NamedKey_END; ++key) {

		// This is O(M*N), if needed could be optimized to be O(M+N).

		if (contains(mods, key)) continue; // skip: mods can't be primary keys in a KeyChord

		if (ImGui::IsKeyPressed(static_cast<ImGuiKey>(key))) {

			const ImGuiIO& io = ImGui::GetIO();

			return key

			     | (io.KeyCtrl  ? ImGuiMod_Ctrl  : 0)

			     | (io.KeyShift ? ImGuiMod_Shift : 0)

			     | (io.KeyAlt   ? ImGuiMod_Alt   : 0)

			     | (io.KeySuper ? ImGuiMod_Super : 0);

		}

	}

	return ImGuiKey_None;

}

void ImGuiSettings::showMenu(MSXMotherBoard* motherBoard)

{

	im::Menu("Settings", [&]{

		auto& reactor = manager.getReactor();

		auto& globalSettings = reactor.getGlobalSettings();

		auto& renderSettings = reactor.getDisplay().getRenderSettings();

		const auto& settingsManager = reactor.getGlobalCommandController().getSettingsManager();

		const auto& hotKey = reactor.getHotKey();

		im::Menu("Video", [&]{

			im::TreeNode("Look and feel", ImGuiTreeNodeFlags_DefaultOpen, [&]{

				auto& scaler = renderSettings.getScaleAlgorithmSetting();

				ComboBox("Scaler", scaler);

				im::Indent([&]{

					struct AlgoEnable {

						RenderSettings::ScaleAlgorithm algo;

						bool hasScanline;

						bool hasBlur;

					};

					using enum RenderSettings::ScaleAlgorithm;

					static constexpr std::array algoEnables = {

						AlgoEnable{.algo = SIMPLE,     .hasScanline = true,  .hasBlur = true },

						AlgoEnable{.algo = SCALE,      .hasScanline = false, .hasBlur = false},

						AlgoEnable{.algo = HQ,         .hasScanline = false, .hasBlur = false},

						AlgoEnable{.algo = RGBTRIPLET, .hasScanline = true,  .hasBlur = true },

						AlgoEnable{.algo = TV,         .hasScanline = true,  .hasBlur = false},

					};

					auto it = std::ranges::find(algoEnables, scaler.getEnum(), &AlgoEnable::algo);

					assert(it != algoEnables.end());

					im::Disabled(!it->hasScanline, [&]{

						SliderInt("Scanline (%)", renderSettings.getScanlineSetting());

					});

					im::Disabled(!it->hasBlur, [&]{

						SliderInt("Blur (%)", renderSettings.getBlurSetting());

					});

				});

				SliderInt("Scale factor", renderSettings.getScaleFactorSetting());

				Checkbox(hotKey, "Deinterlace", renderSettings.getDeinterlaceSetting());

				Checkbox(hotKey, "Deflicker", renderSettings.getDeflickerSetting());

			});

			im::TreeNode("Colors", ImGuiTreeNodeFlags_DefaultOpen, [&]{

				SliderFloat("Noise (%)", renderSettings.getNoiseSetting());

				SliderFloat("Brightness", renderSettings.getBrightnessSetting());

				SliderFloat("Contrast", renderSettings.getContrastSetting());

				SliderFloat("Gamma", renderSettings.getGammaSetting());

				SliderInt("Glow (%)", renderSettings.getGlowSetting());

				if (auto* monitor = dynamic_cast<Setting*>(settingsManager.findSetting("monitor_type"))) {

					ComboBox("Monitor type", *monitor, [](std::string s) {

						std::ranges::replace(s, '_', ' ');

						return s;

					});

				}

			});

			im::TreeNode("Shape", ImGuiTreeNodeFlags_DefaultOpen, [&]{

				Checkbox(hotKey, "Full Stretch", renderSettings.getFullStretchSetting());

				SliderFloat("Horizontal stretch", renderSettings.getHorizontalStretchSetting(), "%.0f");

				ComboBox("Display deformation", renderSettings.getDisplayDeformSetting());

			});

			im::TreeNode("Misc", ImGuiTreeNodeFlags_DefaultOpen, [&]{

				Checkbox(hotKey, "Full screen", renderSettings.getFullScreenSetting());

				if (motherBoard) {

					ComboBox("Video source to display", motherBoard->getVideoSource());

				}

				Checkbox(hotKey, "VSync", renderSettings.getVSyncSetting());

				SliderInt("Minimum frame-skip", renderSettings.getMinFrameSkipSetting()); // TODO: either leave out this setting, or add a tooltip like, "Leave on 0 unless you use a very slow device and want regular frame skipping");

				SliderInt("Maximum frame-skip", renderSettings.getMaxFrameSkipSetting()); // TODO: either leave out this setting or add a tooltip like  "On slow devices, skip no more than this amount of frames to keep emulation on time.");

			});

			im::TreeNode("Advanced (for debugging)", [&]{ // default collapsed

				Checkbox(hotKey, "Enforce VDP sprites-per-line limit", renderSettings.getLimitSpritesSetting());

				Checkbox(hotKey, "Disable sprites", renderSettings.getDisableSpritesSetting());

				ComboBox("Way to handle too fast VDP access", renderSettings.getTooFastAccessSetting());

				ComboBox("Emulate VDP command timing", renderSettings.getCmdTimingSetting());

				ComboBox("Rendering accuracy", renderSettings.getAccuracySetting());

			});

		});

		im::Menu("Sound", [&]{

			auto& mixer = reactor.getMixer();

			auto& muteSetting = mixer.getMuteSetting();

			im::Disabled(muteSetting.getBoolean(), [&]{

				SliderInt("Master volume", mixer.getMasterVolume());

			});

			Checkbox(hotKey, "Mute", muteSetting);

			ImGui::Separator();

			static constexpr std::array resamplerToolTips = {

				EnumToolTip{.value = "hq",   .tip = "best quality, uses more CPU"},

				EnumToolTip{.value = "blip", .tip = "good speed/quality tradeoff"},

				EnumToolTip{.value = "fast", .tip = "fast but low quality"},

			};

			ComboBox("Resampler", globalSettings.getResampleSetting(), resamplerToolTips);

			ImGui::Separator();

			ImGui::MenuItem("Show sound chip settings", nullptr, &manager.soundChip->showSoundChipSettings);

		});

		im::Menu("Speed", [&]{

			im::TreeNode("Emulation", ImGuiTreeNodeFlags_DefaultOpen, [&]{

				ImGui::SameLine();

				HelpMarker("These control the speed of the whole MSX machine, "

				           "the running MSX software can't tell the difference.");

				auto& speedManager = globalSettings.getSpeedManager();

				auto& fwdSetting = speedManager.getFastForwardSetting();

				int fastForward = fwdSetting.getBoolean() ? 1 : 0;

				ImGui::TextUnformatted("Speed:"sv);

				ImGui::SameLine();

				bool fwdChanged = ImGui::RadioButton("normal", &fastForward, 0);

				ImGui::SameLine();

				fwdChanged |= ImGui::RadioButton("fast forward", &fastForward, 1);

				if (auto fastForwardShortCut = getShortCutForCommand(reactor.getHotKey(), "toggle fastforward");

				    !fastForwardShortCut.empty()) {

					HelpMarker(strCat("Use '", fastForwardShortCut ,"' to quickly toggle between these two"));

				}

				if (fwdChanged) {

					fwdSetting.setBoolean(fastForward != 0);

				}

				im::Indent([&]{

					im::Disabled(fastForward != 0, [&]{

						SliderFloat("Speed (%)", speedManager.getSpeedSetting(), "%.1f", ImGuiSliderFlags_Logarithmic);

					});

					im::Disabled(fastForward != 1, [&]{

						SliderFloat("Fast forward speed (%)", speedManager.getFastForwardSpeedSetting(), "%.1f", ImGuiSliderFlags_Logarithmic);

					});

				});

				Checkbox(hotKey, "Go full speed when loading", globalSettings.getThrottleManager().getFullSpeedLoadingSetting());

			});

			if (motherBoard) {

				im::TreeNode("MSX devices", ImGuiTreeNodeFlags_DefaultOpen, [&]{

					ImGui::SameLine();

					HelpMarker("These control the speed of the specific components in the MSX machine. "

						"So the relative speed between components can change. "

						"And this may lead the emulation problems.");

					MSXCPU& cpu = motherBoard->getCPU();

					auto showFreqSettings = [&](std::string_view name, auto* core) {

						if (!core) return;

						auto& locked = core->getFreqLockedSetting();

						auto& value = core->getFreqValueSetting();

						// Note: GUI shows "UNlocked", while the actual settings is "locked"

						bool unlocked = !locked.getBoolean();

						if (ImGui::Checkbox(tmpStrCat("unlock custom ", name, " frequency").c_str(), &unlocked)) {

							locked.setBoolean(!unlocked);

						}

						simpleToolTip([&]{ return locked.getDescription(); });

						im::Indent([&]{

							im::Disabled(!unlocked, [&]{

								float fval = float(value.getInt()) / 1.0e6f;

								if (ImGui::InputFloat(tmpStrCat("frequency (MHz)##", name).c_str(), &fval, 0.01f, 1.0f, "%.2f")) {

									value.setInt(int(fval * 1.0e6f));

								}

								im::PopupContextItem(tmpStrCat("freq-context##", name).c_str(), [&]{

									const char* F358 = name == "Z80" ? "3.58 MHz (default)"

									                                 : "3.58 MHz";

									if (ImGui::Selectable(F358)) {

										value.setInt(3'579'545);

									}

									if (ImGui::Selectable("5.37 MHz")) {

										value.setInt(5'369'318);

									}

									const char* F716 = name == "R800" ? "7.16 MHz (default)"

									                                  : "7.16 MHz";

									if (ImGui::Selectable(F716)) {

										value.setInt(7'159'090);

									}