#include "ImGuiSlotMap.hh"

#include "ImGuiCpp.hh"

#include "ImGuiManager.hh"

#include "ImGuiMedia.hh"

#include "ImGuiUtils.hh"

#include "CartridgeSlotManager.hh"

#include "Debuggable.hh"

#include "Debugger.hh"

#include "DummyDevice.hh"

#include "MSXCPUInterface.hh"

#include "MSXDevice.hh"

#include "MSXMotherBoard.hh"

#include "MSXMultiMemDevice.hh"

#include "TclObject.hh"

#include "gl_vec.hh"

#include "static_vector.hh"

#include "strCat.hh"

#include "xrange.hh"

#include <imgui.h>

#include <algorithm>

#include <optional>

#include <ranges>

#include <string_view>

#include <utility>

#include <vector>

namespace openmsx {

static constexpr unsigned PAGE_SIZE = 0x4000;

static constexpr unsigned ADDRESS_SPACE = 4 * PAGE_SIZE;

void ImGuiSlotMap::save(ImGuiTextBuffer& buf)

{

	savePersistent(buf, *this, persistentElements);

}

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

{

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

}

// A continuous address range in one slot, covered by a single device.

// 'device' is nullptr for the parts where nothing is mapped.

struct Block {

	unsigned begin;

	unsigned end; // exclusive

	const MSXDevice* device;

};

// Draw 'text' centered in the rectangle, wrapped over as many lines as fit.

// The last line ends in an ellipsis if the whole text doesn't fit, and nothing

// is drawn at all when not even an ellipsis fits - the tooltip is what makes

// those cells readable.

static void drawText(ImDrawList* drawList, std::string_view text,

                     gl::vec2 min, gl::vec2 max, ImU32 color)

{

	const auto& style = ImGui::GetStyle();

	auto [width, height] = (max - min) - 2.0f * gl::vec2(style.CellPadding);

	auto lineHeight = ImGui::GetTextLineHeight();

	if ((height < lineHeight) || (width < ImGui::CalcTextSize("..."sv).x)) return;

	auto draw = [&](std::string_view line, float y) {

		auto lineWidth = ImGui::CalcTextSize(line).x;

		drawList->AddText(gl::vec2(min.x + 0.5f * ((max.x - min.x) - lineWidth), y),

		                  color, line.data(), line.data() + line.size());

	};

	// Wrap at word boundaries for as long as that works, then put what is left

	// on the last line, clipped. Wrapping stops for one of two reasons: there

	// is no room for another line, or the next word doesn't fit on a line of

	// its own. In the latter case CalcWordWrapPosition() would break inside the

	// word, which reads as garbage in a diagram. Both cases end the same way,

	// so a name is either fully wrapped or ends in an ellipsis.

	auto* font = ImGui::GetFont();

	auto fontSize = ImGui::GetFontSize();

	static_vector<std::string_view, 16> lines;

	auto maxLines = std::min(size_t(height / lineHeight), lines.max_size());

	std::string_view rest;

	const char* pos = text.data();

	const char* end = pos + text.size();

	while (pos < end) {

		auto remainder = std::string_view(pos, size_t(end - pos));

		if ((lines.size() + 1) == maxLines) { rest = remainder; break; }

		const char* stop = font->CalcWordWrapPosition(fontSize, pos, end, width);

		if ((stop == pos) ||                     // not even one word fits

		    ((stop != end) && (*stop != ' '))) { // would break inside a word

			rest = remainder;

			break;

		}

		lines.push_back(std::string_view(pos, size_t(stop - pos)));

		pos = stop;

		while ((pos < end) && (*pos == ' ')) ++pos; // eat the wrap point

	}

	auto numLines = lines.size() + (rest.empty() ? 0 : 1);

	auto y = min.y + 0.5f * ((max.y - min.y) - float(numLines) * lineHeight);

	for (auto line : lines) {

		draw(line, y);

		y += lineHeight;

	}

	// rightClip() adds the ellipsis, and returns 'rest' unchanged when it fits.

	if (!rest.empty()) draw(ImGui::rightClip(rest, width), y);

}

namespace {

// What the mouse is over, so that only one tooltip is shown even where blocks

// overlap after being enlarged to a hoverable size.

struct HoveredBlock {

	Block block{0, 0, nullptr};

	std::optional<unsigned> cartridgeSlot; // when it's in an external slot

	float height = 0.0f;

	bool valid = false;

};

// A block that is too small to see, enlarged and drawn on top of its

// neighbours instead of to scale.

struct TinyBlock {

	gl::vec2 min;

	gl::vec2 max;

	ImU32 color;

};

// Everything that only depends on the font and the style, so the same for the

// whole frame.

struct Metrics {

	float rowHeight;

	float headerHeight;

	float labelWidth;

	float minSlotWidth;

	float minMapHeight;

	gl::vec2 gap;

	float overhang;

};

struct DrawContext {

	ImGuiManager& manager;

	MSXCPUInterface& cpuInterface;

	const CartridgeSlotManager& slotManager;

	Debugger& debugger;

	const MSXDevice* dummyDevice;

	Metrics metrics;

	ImDrawList* drawList;

	ImU32 emptyColor;

	ImU32 occupiedColor;

	ImU32 externalColor;

	ImU32 outlineColor;

	ImU32 textColor;

	ImU32 dimTextColor;

	gl::vec2 mouse;

	HoveredBlock hovered;

	std::vector<std::pair<gl::vec2, gl::vec2>> outlines;   // one per primary slot

	std::vector<std::pair<gl::vec2, gl::vec2>> separators; // between the blocks

	std::vector<TinyBlock> tinyBlocks;

	std::vector<Block> blocks;

	std::vector<Block> scratch;

};

}

// Split the address space of one slot into blocks, in 'ctx.blocks'.

// MSXCPUInterface stores a device per 16kB page, and wraps devices that cover

// less than a page in an MSXMultiMemDevice, which knows the exact address

// ranges. Recombining both gives the real extent of every device, so that

// nothing here has to care about page boundaries.

// Note: 'ctx.blocks' and 'ctx.scratch' live in the DrawContext instead of being

//       local variables, so that the (up to) 16 calls in one frame share a

//       single buffer.

static void getBlocks(DrawContext& ctx, int ps, int ss)

{

	auto& scratch = ctx.scratch;

	scratch.clear();

	for (auto page : xrange(4)) {

		auto pageBegin = PAGE_SIZE * unsigned(page);

		const auto* device = ctx.cpuInterface.getMSXDevice(ps, ss, page);

		if (device == ctx.dummyDevice) continue;

		if (const auto* multi = dynamic_cast<const MSXMultiMemDevice*>(device)) {

			// Only these sub-ranges can be out of order: the pages themselves

			// are visited in increasing order, so sorting per page is enough.

			auto first = scratch.size();

			for (const auto& range : multi->getRanges()) {

				auto begin = std::max(range.base, pageBegin);

				auto end = std::min(range.base + range.size, pageBegin + PAGE_SIZE);

				if (begin < end) scratch.emplace_back(begin, end, range.device);

			}

			std::ranges::sort(scratch.begin() + first, scratch.end(), {}, &Block::begin);

		} else {

			scratch.emplace_back(pageBegin, pageBegin + PAGE_SIZE, device);

		}

	}

	// Glue the pieces of a device that spans page boundaries back together,

	// and fill what's left with 'empty' blocks.

	auto& result = ctx.blocks;

	result.clear();

	unsigned pos = 0;

	for (const auto& block : scratch) {

		if (!result.empty() && (result.back().device == block.device) &&

		    (result.back().end == block.begin)) {

			result.back().end = block.end;

		} else {

			if (pos < block.begin) result.emplace_back(pos, block.begin, nullptr);

			result.push_back(block);

		}

		pos = block.end;

	}

	if (pos < ADDRESS_SPACE) result.emplace_back(pos, ADDRESS_SPACE, nullptr);

}

static Metrics getMetrics()

{

	const auto& style = ImGui::GetStyle();

	auto lineHeight = ImGui::GetTextLineHeight();

	auto rowHeight = lineHeight + 2.0f * style.CellPadding.y;

	return {

		.rowHeight = rowHeight,

		.headerHeight = 2.0f * rowHeight, // external slot name, slot number

		// Wide enough for every label on the address axis. Letters and digits

		// don't have the same width, so check both kinds.

		.labelWidth = 2.0f * style.CellPadding.x +

		              std::max({ImGui::CalcTextSize("0000"sv).x,

		                        ImGui::CalcTextSize("C000"sv).x,

		                        ImGui::CalcTextSize("FFFF"sv).x}),

		// A primary slot always gets the same width, expanded or not, so

		// machines with a different slot layout still look alike.

		.minSlotWidth = 4.0f * 3.0f * lineHeight,

		.minMapHeight = 10.0f * rowHeight,

		.gap = 2.0f * gl::vec2(style.ItemSpacing),

		// The labels of the lowest and highest address stick out half a line.

		.overhang = 0.5f * rowHeight,

	};

}

// Below this a block can't be seen, let alone hovered. A single byte is a

// hundredth of a pixel on a 64kB axis, so those are drawn out of scale.

static constexpr float MIN_BLOCK_HEIGHT = 4.0f;

// One slot, drawn as a continuous 0x0000-0xFFFF axis with the highest address

// on top, so a device is a rectangle at its real position and size.

static void drawSlot(DrawContext& ctx, int ps, int ss, bool expanded,

                     float x0, float x1, float headerTop, float top, float bottom)

{

	// The slot number goes directly above the map, there are four times as many

	// of those as external slot names.

	auto cartridge = ctx.slotManager.findSlot(ps, ss, true);

	auto labelHeight = 0.5f * (top - headerTop);

	if (cartridge) {

		drawText(ctx.drawList, tmpStrCat("Slot ", char('A' + *cartridge)),

		         gl::vec2(x0, headerTop), gl::vec2(x1, headerTop + labelHeight),

		         ctx.dimTextColor);

	}

	drawText(ctx.drawList, expanded ? strCat(ps, '-', ss) : strCat(ps),

	         gl::vec2(x0, headerTop + labelHeight), gl::vec2(x1, top), ctx.textColor);

	auto height = bottom - top;

	auto addressToY = [&](unsigned address) {

		return bottom - height * (float(address) * (1.0f / float(ADDRESS_SPACE)));

	};

	getBlocks(ctx, ps, ss);

	// Blocks come in increasing address order, so downwards on screen. Keeps

	// enlarged blocks from covering each other.

	auto lowestEnlarged = bottom;

	for (const auto& block : ctx.blocks) {

		auto blockTop = addressToY(block.end);

		auto blockBottom = addressToY(block.begin);

		auto blockHeight = blockBottom - blockTop;

		auto color = !block.device ? ctx.emptyColor

		                           : (cartridge ? ctx.externalColor : ctx.occupiedColor);

		if (auto grow = 0.5f * (MIN_BLOCK_HEIGHT - blockHeight); grow > 0.0f) {

			// Too small to draw to scale, so draw it out of scale: enlarge it

			// around its real address, stack it on top of an earlier enlarged

			// block if they'd overlap, and paint it over its big neighbours

			// later on.

			blockTop -= grow;

			blockBottom += grow;

			if (blockBottom > lowestEnlarged) {

				blockTop -= blockBottom - lowestEnlarged;

				blockBottom = lowestEnlarged;

			}

			lowestEnlarged = blockTop;

			ctx.tinyBlocks.emplace_back(gl::vec2(x0, blockTop), gl::vec2(x1, blockBottom),

			                            color);

		} else {

			gl::vec2 min{x0, blockTop};

			gl::vec2 max{x1, blockBottom};

			ctx.drawList->AddRectFilled(min, max, color);

			// Only the line towards the next block: the outer edges belong to

			// the outline of the slot as a whole. Drawing a rectangle per block

			// would draw every shared edge twice. See the note on 'separators'

			// for why this stops one pixel short of x1.

			if (block.end != ADDRESS_SPACE) {

				ctx.separators.emplace_back(min, gl::vec2(x1 - 1.0f, blockTop));

			}

			drawText(ctx.drawList, block.device ? std::string_view(block.device->getName())

			                                    : "empty"sv,

			         min, max, ctx.textColor);

		}

		// Hit-test what is actually drawn. The smallest block wins, so an

		// enlarged one stays reachable between its much larger neighbours.

		if ((x0 <= ctx.mouse.x) && (ctx.mouse.x < x1) &&

		    (blockTop <= ctx.mouse.y) && (ctx.mouse.y < blockBottom) &&

		    (!ctx.hovered.valid || (blockHeight < ctx.hovered.height))) {

			ctx.hovered = HoveredBlock{block, cartridge, blockHeight, true};

		}

	}

}

static void drawDeviceToolTip(DrawContext& ctx)

{

	const auto& block = ctx.hovered.block;

	im::Tooltip([&]{

		im::TextWrapPos(ImGui::GetFontSize() * 35.0f, [&]{

			bool header = false;

			// For an external slot, what is plugged into it. That's not the

			// same thing as the device below, which is a part of it, though

			// for a simple extension the two names are the same.

			if (auto slot = ctx.hovered.cartridgeSlot) {

				auto content = ctx.manager.media->displayNameForSlotContent(

					ctx.slotManager, *slot);

				if (block.device && (content == block.device->getName())) {

					ImGui::StrCat("Slot ", char('A' + *slot));

				} else {

					ImGui::StrCat("Slot ", char('A' + *slot), ": ", content);

				}

				header = true;

			}

			if (block.device) {

				ImGui::TextUnformatted(block.device->getName());

				header = true;

			}

			if (header) ImGui::Separator();

			// Below 1kB the size in kB would round down to 0.

			auto printSize = [](std::string_view label, unsigned bytes) {

				auto unit = (bytes == 1) ? " byte"sv : " bytes"sv;

				ImGui::StrCat(label, ": ", (bytes < 1024) ? strCat(bytes, unit)

				                                          : strCat(bytes / 1024, "kB"));

			};

			ImGui::StrCat("address: 0x", hex_string<4, HexCase::upper>(block.begin),

			              " - 0x", hex_string<4, HexCase::upper>(block.end - 1));

			printSize("size", block.end - block.begin);

			if (!block.device) return;

			// Whatever the device wants to tell about itself, e.g. the mapper

			// type of a ROM or the file it was loaded from. Ask the device

			// directly instead of going through the 'machine_info device'

			// command: we already have the MSXDevice here.

			TclObject info;

			block.device->getDeviceInfo(info);

			for (size_t i = 0; (i + 1) < info.size(); i += 2) {

				auto key = info.getListIndexUnchecked(i).getString();

				auto value = info.getListIndexUnchecked(i + 1).getString();

				if (value.empty()) continue;

				ImGui::StrCat(key, ": ", value);

			}

			// Devices with a debuggable of the same name (memory mappers, RAM)

			// can also tell how much memory they actually have.

			if (const auto* debuggable = ctx.debugger.findDebuggable(block.device->getName())) {

				if (auto bytes = debuggable->getSize(); bytes != 0) {

					printSize("total memory", bytes);

				}

			}

		});

	});

}

static void drawSlotMap(DrawContext& ctx)

{

	auto [rowHeight, headerHeight, labelWidth, minSlotWidth, minMapHeight, gap, overhang] =

		ctx.metrics;

	auto avail = gl::vec2(ImGui::GetContentRegionAvail());

	// Reflow: put 4, 2 or 1 primary slots next to each other, whichever fits.

	auto widthFor = [&](int perRow) {

		return labelWidth + float(perRow) * minSlotWidth + float(perRow - 1) * gap.x;

	};

	int perRow = 4;

	if (widthFor(perRow) > avail.x) perRow = 2;

	if ((perRow == 2) && (widthFor(perRow) > avail.x)) perRow = 1;

	int numRows = 4 / perRow;

	auto slotWidth = std::max(minSlotWidth,

		(avail.x - labelWidth - float(perRow - 1) * gap.x) / float(perRow));

	auto mapHeight = std::max(minMapHeight,

		(avail.y - overhang - float(numRows) * headerHeight - float(numRows - 1) * gap.y) /

		float(numRows));

	auto origin = gl::vec2(ImGui::GetCursorScreenPos());

	gl::vec2 size{labelWidth + float(perRow) * slotWidth + float(perRow - 1) * gap.x,

	              float(numRows) * (headerHeight + mapHeight) + float(numRows - 1) * gap.y +

	              overhang};

	ImGui::Dummy(size); // reserve the space, the map itself is positioned absolutely

	for (auto row : xrange(numRows)) {

		auto headerTop = origin.y + float(row) * (headerHeight + mapHeight + gap.y);

		auto top = headerTop + headerHeight;

		auto bottom = top + mapHeight;

		auto addressToY = [&](unsigned address) {

			return bottom - mapHeight * (float(address) * (1.0f / float(ADDRESS_SPACE)));

		};

		// Address axis: one label per page boundary, plus the very top, each

		// centered on the position it marks.

		auto drawTick = [&](unsigned address, std::string_view label) {

			auto y = addressToY(address);

			drawText(ctx.drawList, label,

			         gl::vec2(origin.x, y - 0.5f * rowHeight),

			         gl::vec2(origin.x + labelWidth, y + 0.5f * rowHeight),

			         ctx.textColor);

		};

		for (auto page : xrange(4)) {

			auto address = PAGE_SIZE * unsigned(page);

			drawTick(address, tmpStrCat(hex_string<4, HexCase::upper>(address)));

		}

		drawTick(ADDRESS_SPACE, "FFFF"sv);

		auto x = origin.x + labelWidth;

		for (auto ps : xrange(row * perRow, std::min((row + 1) * perRow, 4))) {

			if (ctx.cpuInterface.isExpanded(ps)) {

				auto width = 0.25f * slotWidth;

				for (auto ss : xrange(4)) {

					auto x0 = x + float(ss) * width;

					drawSlot(ctx, ps, ss, true, x0, x0 + width, headerTop, top, bottom);