#include "ImGuiIoPorts.hh"

#include "ImGuiCpp.hh"
#include "ImGuiManager.hh"
#include "ImGuiUtils.hh"

#include "DummyDevice.hh"
#include "EmuTime.hh"
#include "HardwareConfig.hh"
#include "MSXCPUInterface.hh"
#include "MSXDevice.hh"
#include "MSXMotherBoard.hh"
#include "MSXMultiIODevice.hh"

#include "join.hh"
#include "narrow.hh"
#include "strCat.hh"
#include "xrange.hh"

#include <algorithm>
#include <array>
#include <cstdint>
#include <ranges>
#include <string>
#include <string_view>
#include <vector>

namespace openmsx {

using namespace std::literals;

/** A maximal range of ports with the same device(s) in the same direction(s).
  */
struct Row {
	uint8_t begin; // inclusive
	uint8_t end;   // inclusive
	bool in;
	bool out;
	bool overlap;       // these ports are shared with another device
	std::string device; // comma separated name(s)
};

using Devices = MSXMultiIODevice::Devices;

// Collect the device(s) on one port. This mirrors 'machine_info
// input_port/output_port', on which the 'iomap' script is built: an unused
// port yields an empty list, a port with conflicting devices one entry per
// device.
[[nodiscard]] static Devices getDevices(MSXCPUInterface& cpuInterface, uint8_t port, bool isIn)
{
	auto* device = cpuInterface.getIODevice(port, isIn);
	const MSXDevice* dummy = &cpuInterface.getDummyDevice();
	if (device == dummy) return {}; // unused port
	if (auto* multi = dynamic_cast<MSXMultiIODevice*>(device)) {
		// A sub-device is never the DummyDevice: register_IO() only wraps
		// devices in a MSXMultiIODevice once a real device is registered,
		// and unregister_IO() unwraps again when one device is left.
		return multi->getDevices();
	}
	return {device};
}

struct PortDevices {
	std::array<Devices, 256> in;
	std::array<Devices, 256> out;
};
[[nodiscard]] static PortDevices collectDevices(MSXCPUInterface& cpuInterface)
{
	PortDevices result;
	for (auto port : xrange(256)) {
		result.in [port] = getDevices(cpuInterface, narrow<uint8_t>(port), true);
		result.out[port] = getDevices(cpuInterface, narrow<uint8_t>(port), false);
	}
	return result;
}

[[nodiscard]] static std::string portsText(const Row& row)
{
	if (row.begin == row.end) {
		return strCat(hex_string<2, HexCase::upper>(row.begin));
	}
	return strCat(hex_string<2, HexCase::upper>(row.begin), '-',
	              hex_string<2, HexCase::upper>(row.end));
}

[[nodiscard]] static std::string_view dirText(const Row& row)
{
	return row.in ? (row.out ? "I/O"sv : "I"sv) : "O"sv;
}

static void sortRows(std::vector<Row>& rows)
{
	// Note: unlike the other views in openMSX, 'rows' is rebuilt from scratch
	// every frame. So (re)apply the sort unconditionally instead of only when
	// 'SpecsDirty' is set.
	const auto* sortSpecs = ImGui::TableGetSortSpecs();
	if (!sortSpecs || (sortSpecs->SpecsCount == 0)) return;
	assert(sortSpecs->Specs);

	bool descending = sortSpecs->Specs->SortDirection == ImGuiSortDirection_Descending;
	switch (sortSpecs->Specs->ColumnIndex) {
	case 0: // ports: 'rows' is already generated in ascending port order
		if (descending) std::ranges::reverse(rows);
		break;
	case 2: // device: stable, so each device keeps its ports port-ordered
		sortUpDown_String(rows, sortSpecs, &Row::device);
		break;
	default:
		// 'Dir' and 'Value' are NoSort, but Dear ImGui still restores a sort
		// on such a column from imgui.ini (TableSortSpecsSanitize() only
		// clears it for hidden columns). So don't assume this can't happen,
		// just keep the rows in ascending port order.
		break;
	}
}

[[nodiscard]] static std::vector<Row> getRows(MSXCPUInterface& cpuInterface)
{
	auto devices = collectDevices(cpuInterface);
	const auto& in = devices.in;
	const auto& out = devices.out;

	std::vector<Row> result;
	unsigned port = 0;
	while (port < 256) {
		// coalesce consecutive ports with identical input and output device(s)
		unsigned end = port + 1;
		while ((end < 256) && (in[end] == in[port]) && (out[end] == out[port])) {
			++end;
		}
		auto add = [&](const Devices& devs, bool isIn, bool isOut) {
			if (devs.empty()) return;
			result.push_back(Row{
				.begin = narrow<uint8_t>(port),
				.end = narrow<uint8_t>(end - 1),
				.in = isIn,
				.out = isOut,
				.overlap = devs.size() > 1,
				.device = join(std::views::transform(devs, &MSXDevice::getName), ", ")});
		};
		if (in[port] == out[port]) {
			add(in[port], true, true);
		} else {
			add(in [port], true, false);
			add(out[port], false, true);
		}
		port = end;
	}
	return result;
}

static void drawValue(ImFont* fontMono, MSXCPUInterface& cpuInterface,
                      const Row& row, EmuTime time)
{
	im::ScopedFont sf(fontMono);
	if (!row.in) {
		// Peeking would read the input side, which has nothing to do with
		// the (output-only) device on this row.
		ImGui::TextUnformatted("-"sv);
		return;
	}
	// Draw all values and let Dear ImGui clip them. Only the gfx9000 has more
	// than a handful of ports, and this column is hidden by default anyway.
	std::string values;
	for (auto port : xrange(unsigned(row.begin), unsigned(row.end) + 1)) {
		if (!values.empty()) strAppend(values, ' ');
		strAppend(values, hex_string<2, HexCase::upper>(
			cpuInterface.peekIO(narrow<uint16_t>(port), time)));
	}
	ImGui::TextUnformatted(values);
}

static void drawTable(ImFont* fontMono, MSXCPUInterface& cpuInterface,
                      bool warnOverlap, EmuTime time)
{
	// 'Ports' and 'Dir' have a fixed width, so it must fit both the content
	// and the header. 'Ports' is sortable, and a sorted column also draws a
	// sort arrow next to its name, otherwise that header would be clipped to
	// "..." as soon as you sort on it.
	const auto& style = ImGui::GetStyle();
	auto textWidth = [](std::string_view s) { return ImGui::CalcTextSize(s).x; };
	auto monoWidth = [&](std::string_view s) {
		im::ScopedFont sf(fontMono);
		return ImGui::CalcTextSize(s).x;
	};
	auto columnWidth = [&](float header, float content) {
		return std::max(header, content) + 2.0f * style.CellPadding.x;
	};
	auto arrowWidth = ImGui::GetFontSize() + style.ItemInnerSpacing.x;

	static constexpr int TABLE_FLAGS =
		ImGuiTableFlags_RowBg |
		ImGuiTableFlags_BordersInnerV |
		ImGuiTableFlags_Resizable |
		ImGuiTableFlags_Reorderable |
		ImGuiTableFlags_Hideable |
		ImGuiTableFlags_ContextMenuInBody |
		ImGuiTableFlags_Sortable;
	im::Table("ports", 4, TABLE_FLAGS, [&]{
		// 'Value' is hidden by default: the hex editor on the 'ioports'
		// debuggable already shows these values. Un-hide it via the
		// right-click context menu on the table header.
		// It's also not sortable: the values change while the emulation
		// runs, so sorting on them would reshuffle the rows every frame.
		//
		// 'Ports' and 'Dir' hold at most 5 resp. 3 characters, so resizing
		// them can only take space away from the other two. Those stretch
		// instead, so widening the window widens both.
		ImGui::TableSetupColumn("Ports", ImGuiTableColumnFlags_WidthFixed |
		                                 ImGuiTableColumnFlags_NoResize |
		                                 ImGuiTableColumnFlags_DefaultSort,
		                        columnWidth(textWidth("Ports"sv) + arrowWidth,
		                                    monoWidth("FF-FF"sv)));
		ImGui::TableSetupColumn("Dir", ImGuiTableColumnFlags_WidthFixed |
		                               ImGuiTableColumnFlags_NoResize |
		                               ImGuiTableColumnFlags_NoSort,
		                        columnWidth(textWidth("Dir"sv), textWidth("I/O"sv)));
		ImGui::TableSetupColumn("Device", ImGuiTableColumnFlags_WidthStretch);
		ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch |
		                                 ImGuiTableColumnFlags_DefaultHide |
		                                 ImGuiTableColumnFlags_NoSort);
		ImGui::TableHeadersRow();

		auto rows = getRows(cpuInterface);
		sortRows(rows);
		for (const auto& row : rows) {
			if (ImGui::TableNextColumn()) { // ports
				im::ScopedFont sf(fontMono);
				ImGui::TextUnformatted(portsText(row));
			}
			if (ImGui::TableNextColumn()) { // direction
				ImGui::TextUnformatted(dirText(row));
			}
			if (ImGui::TableNextColumn()) { // device(s)
				bool conflict = row.overlap && warnOverlap;
				im::StyleColor(conflict, ImGuiCol_Text, getColor(imColor::YELLOW), [&]{
					ImGui::TextUnformatted(row.device);
				});
				if (conflict) {
					simpleToolTip(
						"These ports are shared with another device. Reading "
						"such a port returns the bitwise AND of all values, "
						"writing goes to every device."sv);
				}
			}
			if (ImGui::TableNextColumn()) { // value(s)
				drawValue(fontMono, cpuInterface, row, time);
			}
		}
	});
}

void ImGuiIoPorts::save(ImGuiTextBuffer& buf)
{
	savePersistent(buf, *this, persistentElements);
}

void ImGuiIoPorts::loadLine(std::string_view name, zstring_view value)
{
	loadOnePersistent(name, value, *this, persistentElements);
}

void ImGuiIoPorts::paint(MSXMotherBoard* motherBoard)
{
	if (!show || !motherBoard) return;

	// Machines can explicitly declare that overlapping I/O ports are
	// intentional, in that case don't flag them.
	const auto* config = motherBoard->getMachineConfig();
	bool warnOverlap = !config ||
		config->getDevicesElem().getAttributeValueAsBool("overlap_warning", true);

	auto fontSize = ImGui::GetFontSize();
	ImGui::SetNextWindowSize(ImVec2(46.0f * fontSize, 26.0f * fontSize), ImGuiCond_FirstUseEver);
	im::Window("I/O ports", &show, [&]{
		// A device doesn't necessarily occupy a contiguous range of ports
		// (e.g. the Philips NMS-1205). Sort on 'Device' to see all ports of
		// one device together instead of ordered by port number.
		drawTable(manager.fontMono, motherBoard->getCPUInterface(),
		          warnOverlap, motherBoard->getCurrentTime());
	});
}

} // namespace openmsx