#ifndef IMGUI_MANAGER_HH
#define IMGUI_MANAGER_HH

#include "ImGuiPartInterface.hh"
#include "ImGuiUtils.hh"
#include "Shortcuts.hh"
#include "freetype_utils.hh"

#include "EmuTime.hh"
#include "EventListener.hh"
#include "FilenameSetting.hh"
#include "IntegerSetting.hh"
#include "Reactor.hh"
#include "RomTypes.hh"
#include "TclObject.hh"

#include "Observer.hh"
#include "StringReplacer.hh"
#include "strCat.hh"

#include <algorithm>
#include <functional>
#include <optional>
#include <string_view>
#include <vector>

struct ImFont;
struct ImGuiTextBuffer;

namespace openmsx {

class CliComm;
class ImGuiBreakPoints;
class ImGuiCheatFinder;
class ImGuiConnector;
class ImGuiConsole;
class ImGuiDebugger;
class ImGuiDiskManipulator;
class ImGuiHelp;
class ImGuiIoPorts;
class ImGuiKeyboard;
class ImGuiMachine;
class ImGuiMedia;
class ImGuiMessages;
class ImGuiMsxMusicViewer;
class ImGuiOpenFile;
class ImGuiOsdIcons;
class ImGuiPalette;
class ImGuiPlotterViewer;
class ImGuiRasterViewer;
class ImGuiReverseBar;
class ImGuiSCCViewer;
class ImGuiSettings;
class ImGuiSlotMap;
class ImGuiSoundChip;
class ImGuiSymbols;
class ImGuiTools;
class ImGuiTraceViewer;
class ImGuiTrainer;
class ImGuiVdpRegs;
class ImGuiWatchExpr;
class ImGuiWaveViewer;
class RomInfo;
class SettingsConfig;

class ImGuiManager final : public ImGuiPartInterface, private EventListener, private Observer<Setting>
{
public:
	explicit ImGuiManager(Reactor& reactor_);
	ImGuiManager(const ImGuiManager&) = delete;
	ImGuiManager(ImGuiManager&&) = delete;
	ImGuiManager& operator=(const ImGuiManager&) = delete;
	ImGuiManager& operator=(ImGuiManager&&) = delete;
	~ImGuiManager();

	void   registerPart(ImGuiPartInterface* part);
	void unregisterPart(ImGuiPartInterface* part);

	[[nodiscard]] Reactor& getReactor() { return reactor; }
	[[nodiscard]] Shortcuts& getShortcuts() { return reactor.getShortcuts(); }
	[[nodiscard]] Interpreter& getInterpreter();
	[[nodiscard]] CliComm& getCliComm();
	std::optional<TclObject> execute(TclObject command);
	void executeDelayed(std::function<void()> action);
	void executeDelayed(TclObject command,
	                    const std::function<void(const TclObject&)>& ok,
	                    const std::function<void(const std::string&)>& error);
	void executeDelayed(TclObject command,
	                    const std::function<void(const TclObject&)>& ok = {});

	void printError(std::string_view message);
	template<typename... Ts> void printError(Ts&&... ts) {
		printError(static_cast<std::string_view>(tmpStrCat(std::forward<Ts>(ts)...)));
	}

	void preNewFrame();
	void paintImGui(bool msxDisplayAreaFocused);

	void storeWindowPosition(gl::ivec2 pos) { windowPos = pos; }
	[[nodiscard]] gl::ivec2 retrieveWindowPosition() const { return windowPos; }

	void configStatusBarVisibilityItems();

	std::string getFontDisplayName(const std::span<const uint8_t>& fontData, long faceIndex,
	                               std::string_view fontFile)
	{
		return openmsx::getFontDisplayName(freeTypeLibrary, fontData, faceIndex, fontFile);
	}

private:
	void initializeImGui();
	[[nodiscard]] std::tuple<ImFont*, std::string> addFont(
		zstring_view filename, int fontSize, int faceIndex);
	void loadFont();
	void reloadFont();
	void drawStatusBar(MSXMotherBoard* motherBoard);

	// ImGuiPartInterface
	[[nodiscard]] zstring_view iniName() const override { return "manager"; }
	void save(ImGuiTextBuffer& buf) override;
	void loadLine(std::string_view name, zstring_view value) override;
	void loadEnd() override;

	// EventListener
	bool signalEvent(const Event& event) override;

	// Observer<Setting>
	void update(const Setting& setting) noexcept override;

	// ini handler callbacks
	void iniReadInit();
	void* iniReadOpen(std::string_view name);
	void loadLine(void* entry, const char* line) const;
	void iniApplyAll();
	void iniWriteAll(ImGuiTextBuffer& buf);

	void updateParts();

private:
	Reactor& reactor;
	std::vector<ImGuiPartInterface*> parts;
	std::vector<ImGuiPartInterface*> toBeAddedParts;
	bool removeParts = false;

public:
	FreeTypeLibrary freeTypeLibrary;
	FilenameSetting fontPropFilename;
	FilenameSetting fontMonoFilename;
	IntegerSetting fontPropIndex;
	IntegerSetting fontMonoIndex;
	IntegerSetting fontPropSize;
	IntegerSetting fontMonoSize;
	ImFont* fontProp = nullptr;
	ImFont* fontMono = nullptr;
	std::string fontPropName; // calculated via getFontDisplayName()
	std::string fontMonoName;

	std::unique_ptr<ImGuiMachine> machine;
	std::unique_ptr<ImGuiDebugger> debugger;
	std::unique_ptr<ImGuiBreakPoints> breakPoints;
	std::unique_ptr<ImGuiSymbols> symbols;
	std::unique_ptr<ImGuiWatchExpr> watchExpr;
	std::unique_ptr<ImGuiTraceViewer> traceViewer;
	std::unique_ptr<ImGuiIoPorts> ioPorts;
	std::unique_ptr<ImGuiVdpRegs> vdpRegs;
	std::unique_ptr<ImGuiPalette> palette;
	std::unique_ptr<ImGuiPlotterViewer> plotterViewer;
	std::unique_ptr<ImGuiRasterViewer> rasterViewer;
	std::unique_ptr<ImGuiReverseBar> reverseBar;
	std::unique_ptr<ImGuiHelp> help;
	std::unique_ptr<ImGuiOsdIcons> osdIcons;
	std::unique_ptr<ImGuiOpenFile> openFile;
	std::unique_ptr<ImGuiMedia> media;
	std::unique_ptr<ImGuiConnector> connector;
	std::unique_ptr<ImGuiTools> tools;
	std::unique_ptr<ImGuiTrainer> trainer;
	std::unique_ptr<ImGuiSCCViewer> sccViewer;
	std::unique_ptr<ImGuiMsxMusicViewer> msxMusicViewer;
	std::unique_ptr<ImGuiWaveViewer> waveViewer;
	std::unique_ptr<ImGuiCheatFinder> cheatFinder;
	std::unique_ptr<ImGuiSlotMap> slotMap;
	std::unique_ptr<ImGuiDiskManipulator> diskManipulator;
	std::unique_ptr<ImGuiSettings> settings;
	std::unique_ptr<ImGuiSoundChip> soundChip;
	std::unique_ptr<ImGuiKeyboard> keyboard;
	std::unique_ptr<ImGuiConsole> console;
	std::unique_ptr<ImGuiMessages> messages;

	bool menuFade = true;
	bool needReloadFont = false;
	bool statusBarVisible = false;
	bool statusBarItemVisibilityFps = true;
	bool statusBarItemVisibilityScreenModeInfo = true;
	bool statusBarItemVisibilityTime = true;
	bool statusBarItemVisibilityActualSpeed = true;
	bool statusBarItemVisibilityMachine = true;
	bool statusBarItemVisibilityRunningSoftware = true;

	std::string loadIniFile;

private:
	std::vector<std::function<void()>> delayedActionQueue;
	std::vector<std::function<void()>> delayedActionQueue2;
	float menuAlpha = 1.0f;

	std::string droppedFile;
	std::string insertedInfo;
	std::vector<std::string> selectList;
	std::string selectedMedia;
	const RomInfo* romInfo = nullptr;
	RomType selectedRomType = RomType::UNKNOWN;
	float insertedInfoTimeout = 0.0f;
	gl::ivec2 windowPos;
	bool mainMenuBarUndocked = false;
	bool handleDropped = false;
	bool openInsertedInfo = false;
	bool guiActive = false;

	EmuTime prevBoardTime = EmuTime::zero();
	float speedDrawTimeOut = 0.0f;
	float fpsDrawTimeOut = 0.0f;
	float fps = 0.0f;
	float speed = 0.0f;

	static constexpr auto persistentElements = std::tuple{
		PersistentElement{"mainMenuBarUndocked", &ImGuiManager::mainMenuBarUndocked},
		PersistentElement{"mainMenuBarFade",     &ImGuiManager::menuFade},
		PersistentElement{"windowPos",           &ImGuiManager::windowPos},
		PersistentElement{"statusBarVisible",    &ImGuiManager::statusBarVisible},
		PersistentElement{"statusBarItemvisibility.fps",                 &ImGuiManager::statusBarItemVisibilityFps},
		PersistentElement{"statusBarItemVisibility.screenModeInfo",      &ImGuiManager::statusBarItemVisibilityScreenModeInfo},
		PersistentElement{"statusBarItemVisibility.time",                &ImGuiManager::statusBarItemVisibilityTime},
		PersistentElement{"statusBarItemVisibility.actualSpeed",         &ImGuiManager::statusBarItemVisibilityActualSpeed},
		PersistentElement{"statusBarItemVisibility.machine",             &ImGuiManager::statusBarItemVisibilityMachine},
		PersistentElement{"statusBarItemVisibility.runningSoftware",     &ImGuiManager::statusBarItemVisibilityRunningSoftware},
	};
};

// Parse machine or extension config files:
//  store config-name, display-name and meta-data
template<typename InfoType>
std::vector<InfoType> parseAllConfigFiles(ImGuiManager& manager, std::string_view type, std::initializer_list<std::string_view> topics)
{
	static constexpr auto replacer = StringReplacer::create(
		"name",         "Name",
		"manufacturer", "Manufacturer",
		"code",         "Product code",
		"region",       "Region",
		"release_year", "Release year",
		"description",  "Description",
		"type",         "Type");

	std::vector<InfoType> result;

	const auto& configs = Reactor::getHwConfigs(type);
	result.reserve(configs.size());
	for (const auto& config : configs) {
		auto& info = result.emplace_back();
		info.configName = config;

		// get machine meta-data
		auto& configInfo = info.configInfo;
		if (auto r = manager.execute(makeTclList("openmsx_info", type, config))) {
			auto first = r->begin();
			auto last = r->end();
			while (first != last) {
				auto desc = *first++;
				if (first == last) break; // shouldn't happen
				auto value = *first++;
				if (!value.empty()) {
					configInfo.emplace_back(std::string(replacer(desc)),
								std::string(value));
				}
			}
		}

		// Based on the above meta-data, try to construct a more
		// readable name Unfortunately this new name is no
		// longer guaranteed to be unique, we'll address this
		// below.
		auto& display = info.displayName;
		for (const auto topic : topics) {
			if (const auto* value = getOptionalDictValue(configInfo, topic)) {
				if (!value->empty()) {
					if (!display.empty()) strAppend(display, ' ');
					strAppend(display, *value);
				}
			}
		}
		if (display.empty()) display = config;
	}

	std::ranges::sort(result, StringOp::caseless{}, &InfoType::displayName);

	// make 'displayName' unique again
	auto sameDisplayName = [](InfoType& x, InfoType& y) {
		StringOp::casecmp cmp;
		return cmp(x.displayName, y.displayName);
	};
	chunk_by(result, sameDisplayName, [](auto first, auto last) {
		if (std::distance(first, last) == 1) return; // no duplicate name
		for (auto it = first; it != last; ++it) {
			strAppend(it->displayName, " (", it->configName, ')');
		}
		std::ranges::sort(first, last, StringOp::caseless{}, &InfoType::displayName);
	});

	return result;
}

} // namespace openmsx

#endif