#ifndef IMGUI_MEDIA_HH
#define IMGUI_MEDIA_HH

#include "ImGuiPart.hh"

#include "CartridgeSlotManager.hh"
#include "HD.hh"
#include "IDECDROM.hh"
#include "RealDrive.hh"
#include "RomTypes.hh"
#include "TclObject.hh"

#include "circular_buffer.hh"
#include "function_ref.hh"
#include "stl.hh"
#include "zstring_view.hh"

#include <array>
#include <functional>
#include <string>
#include <vector>

namespace openmsx {

class CassettePlayer;
class HardwareConfig;
class RomInfo;

class ImGuiMedia final : public ImGuiPart
{
public:
	struct ExtensionInfo {
		std::string configName;
		std::string displayName;
		std::vector<std::pair<std::string, std::string>> configInfo;
		std::optional<std::string> testResult; // lazily initialized
	};

public:
	using ImGuiPart::ImGuiPart;

	[[nodiscard]] zstring_view iniName() const override { return "media"; }
	void save(ImGuiTextBuffer& buf) override;
	void loadLine(std::string_view name, zstring_view value) override;
	void showMenu(MSXMotherBoard* motherBoard) override;
	void paint(MSXMotherBoard* motherBoard) override;

	[[nodiscard]] std::string displayNameForExtension(std::string_view config);
	[[nodiscard]] std::string displayNameForRom(const std::string& filename, bool compact = false);
	[[nodiscard]] std::string displayNameForHardwareConfig(const HardwareConfig& config, bool compact = false);
	[[nodiscard]] std::string displayNameForSlotContent(const CartridgeSlotManager& slotManager, unsigned slotNr, bool compact = false);
	[[nodiscard]] std::string slotAndNameForHardwareConfig(const CartridgeSlotManager& slotManager, const HardwareConfig& config);
	[[nodiscard]] std::string displayNameForDriveContent(unsigned drive, bool compact = false);

	std::vector<ExtensionInfo>& getAllExtensions();
	void resetExtensionInfo();
	ExtensionInfo* findExtensionInfo(std::string_view config);
	void extensionTooltip(ExtensionInfo& info);
	[[nodiscard]] const std::string& getTestResult(ExtensionInfo& info);

	void addRecent(const TclObject& cmd);

	static void printRomInfo(ImGuiManager& manager, const TclObject& mediaTopic, std::string_view filename, RomType romType);

	void paintLaserDiscMenuContent(std::string_view mediaSlotName, std::string_view slotDisplayName, const TclObject& currentImage);
	void paintCDROMMenuContent(std::string_view mediaSlotName, std::string_view slotDisplayName, const TclObject& currentImage);
	void paintHardDiskMenuContent(std::string_view mediaSlotName, std::string_view slotDisplayName, const TclObject& currentImage, const MSXMotherBoard& motherBoard);

public:
	enum class SelectDiskType : int {
		IMAGE, DIR_AS_DISK, RAMDISK, EMPTY,
		NUM
	};
	enum class SelectCartridgeType : int {
		IMAGE, EXTENSION, EMPTY,
		NUM
	};

	struct MediaItem {
		std::string name;
		std::vector<std::string> ipsPatches; // only used for disk and rom images
		RomType romType = RomType::UNKNOWN; // only used for rom images

		[[nodiscard]] bool isEject() const { return romType == RomType::NUM; } // hack
		[[nodiscard]] bool operator==(const MediaItem&) const = default;
	};

	struct ItemGroup { // MediaItem + history
		static constexpr size_t HISTORY_SIZE = 8;

		MediaItem edit;
		int patchIndex = -1; // only used for IPSItem
		circular_buffer<MediaItem> recent{HISTORY_SIZE};
	};

	struct CartridgeMediaInfo {
		CartridgeMediaInfo() {
			groups[SelectCartridgeType::EMPTY].edit.romType = RomType::NUM; // hack: indicates "eject"
		}
		array_with_enum_index<SelectCartridgeType, ItemGroup> groups;
		SelectCartridgeType select = SelectCartridgeType::IMAGE;
		bool show = false;
		bool filterOpen = false;
		std::string filterType;
		std::string filterString;
	};
	struct DiskMediaInfo {
		DiskMediaInfo() {
			groups[SelectDiskType::RAMDISK].edit.name = "ramdsk";
			groups[SelectDiskType::EMPTY].edit.romType = RomType::NUM; // hack: indicates "eject"
		}
		array_with_enum_index<SelectDiskType, ItemGroup> groups;
		SelectDiskType select = SelectDiskType::IMAGE;
		bool show = false;
	};
	struct CassetteMediaInfo {
		ItemGroup group;
		bool show = false;
	};

public:
	bool resetOnCartChanges = true;

	bool showExtensionSelector(int cartNum, std::optional<std::string> itemToShowAsSelected = std::nullopt);

	static void printDatabase(const RomInfo& romInfo, const char* buf);
	static bool selectMapperType(const char* label, RomType& romType);

	static std::string diskFilter();

	void showMediaWindow(std::string_view mediaName);

private:
	bool selectRecent(ItemGroup& group, function_ref<std::string(const std::string&)> displayFunc, float width) const;
	bool selectImage(ItemGroup& group, const std::string& title,
	                 function_ref<std::string()> createFilter, zstring_view current,
	                 function_ref<std::string(const std::string&)> displayFunc = std::identity{},
	                 const std::function<void()>& createNewCallback = {});
	bool selectDirectory(ItemGroup& group, const std::string& title, zstring_view current,
	                     const std::function<void()>& createNewCallback);
	bool selectPatches(MediaItem& item, int& patchIndex);
	bool insertMediaButton(std::string_view mediaName, const ItemGroup& group, bool* showWindow);
	TclObject showDiskInfo(std::string_view mediaName, DiskMediaInfo& info);
	TclObject showCartridgeInfo(std::string_view mediaName, CartridgeMediaInfo& info, int slot);
	void diskMenu(int i);
	void cartridgeMenu(int cartNum);
	void cassetteMenu(CassettePlayer& cassettePlayer);
	void insertMedia(std::string_view mediaName, const MediaItem& item, bool delayed = true);
	void paintCurrent(const TclObject& current, std::string_view type);
	void paintRecent(std::string_view mediaName, ItemGroup& group,
		function_ref<std::string(const std::string&)> displayFunc = std::identity{},
		const std::function<void(const std::string&)>& toolTip = {},
		std::function<void()>* actionToSet = nullptr);

	void printExtensionInfo(ExtensionInfo& info);
	bool drawExtensionFilter(std::string& filterType, std::string& filterString, bool& theFilterOpen, int id = 0);

private:
	std::array<DiskMediaInfo, RealDrive::MAX_DRIVES> diskMediaInfo;
	std::array<CartridgeMediaInfo, CartridgeSlotManager::MAX_SLOTS> cartridgeMediaInfo;
	ItemGroup extensionMediaInfo;
	CassetteMediaInfo cassetteMediaInfo;
	std::array<ItemGroup, HD::MAX_HD> hdMediaInfo;
	std::array<ItemGroup, IDECDROM::MAX_CD> cdMediaInfo;
	ItemGroup laserdiscMediaInfo;

	// for the generic extension selector (slot independent)
	std::string genericFilterType;
	std::string genericFilterString;
	bool genericFilterOpen = false;
	bool hideNonWorking = false;
	std::function<void(void)> switchHdAction;

	std::vector<ExtensionInfo> extensionInfo;

	static constexpr auto persistentElements = std::tuple{
		PersistentElement{"resetOnCartChanges", &ImGuiMedia::resetOnCartChanges},
		PersistentElement{"hideNonWorkingExtensions", &ImGuiMedia::hideNonWorking},
		// most media stuff is handled elsewhere
	};
};

} // namespace openmsx

#endif