#include "ImGuiBitmapViewer.hh"

#include "ImGuiCpp.hh"

#include "ImGuiManager.hh"

#include "ImGuiPalette.hh"

#include "ImGuiUtils.hh"

#include "DisplayMode.hh"

#include "VDP.hh"

#include "VDPVRAM.hh"

#include "MemBuffer.hh"

#include <imgui.h>

namespace openmsx {

using namespace std::literals;

using Point = VDPCmdEngine::Point;

using Rect = VDPCmdEngine::Rect;

// Given a VDPCmdEngine-rectangle and a point, split that rectangle in a 'done'

// and a 'todo' part.

//

// The VDPCmdEngine walks over this rectangle line by line. But the direction

// can still vary ('dix' and 'diy'). These directions are implicit: the first

// 'Point' in 'Rect' is the start point, the second is the end point. (Start and

// end points are inclusive).

//

// The given point is assumed to be 'done' (in reality we can make a small error

// here, but that's just a few dozen VDP cycles, so just a few Z80

// instructions). If the point lies outside the rectangle, the result will be

// shown as fully 'done'.

//

// The full result contains 1 or 2 'done' parts, and 0, 1 or 2 'todo' parts. So

// e.g. a top rectangle of fully processed lines, a middle line that's in

// progress (split over two lines (represented as a rectangle with height=1)),

// and a bottom rectangle of still todo lines.

//

// All the sub-rectangles in the result have their corners in 'natural' order:

// left-to-right and top-to-bottom (this simplifies drawing later). This is

// explicitly not the case for the input rectangle(s) (those are ordered

// according to 'dix' and 'diy').

//

// The order of the sub-rectangles in the output is no longer guaranteed to be

// in VDP command processing order, and for drawing the overlay that doesn't

// matter.

// TODO unittest

struct DoneTodo {

	static_vector<Rect, 2> done, todo;

};

[[nodiscard]] static DoneTodo splitRect(const Rect& r, int x, int y)

{

	DoneTodo result;

	auto& done = result.done;

	auto& todo = result.todo;

	auto minX = std::min(r.p1.x, r.p2.x);

	auto maxX = std::max(r.p1.x, r.p2.x);

	auto minY = std::min(r.p1.y, r.p2.y);

	auto maxY = std::max(r.p1.y, r.p2.y);

	if ((x < minX) || (x > maxX) || (y < minY) || (y > maxY)) {

		// outside rect

		done.emplace_back(Point{minX, minY}, Point{maxX, maxY});

		return result;

	}

	bool diy = r.p1.y > r.p2.y;

	if (minY < y) {

		// top part (either done or todo), full lines

		auto& res = diy ? todo : done;

		res.emplace_back(Point{minX, minY}, Point{maxX, y - 1});

	}

	if (r.p1.x <= r.p2.x) {

		// left-to-right

		assert(r.p1.x <= x);

		done.emplace_back(Point{r.p1.x, y}, Point{x, y});

		if (x < r.p2.x) {

			todo.emplace_back(Point{x + 1, y}, Point{r.p2.x, y});

		}

	} else {

		// right to-left

		assert(x <= r.p1.x);

		done.emplace_back(Point{x, y}, Point{r.p1.x, y});

		if (r.p2.x < x) {

			todo.emplace_back(Point{r.p2.x, y}, Point{x - 1, y});

		}

	}

	if (y < maxY) {

		// bottom part (either done or todo), full lines

		auto& res = diy ? done : todo;

		res.emplace_back(Point{minX, y + 1}, Point{maxX, maxY});

	}

	return result;

}

ImGuiBitmapViewer::ImGuiBitmapViewer(ImGuiManager& manager_, size_t index)

	: ImGuiPart(manager_)

	, title(strCat("Bitmap viewer", strCat_if(index, " (", index + 1, ')')))

{

}

void ImGuiBitmapViewer::save(ImGuiTextBuffer& buf)

{

	savePersistent(buf, *this, persistentElements);

}

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

{

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

}

void ImGuiBitmapViewer::paint(MSXMotherBoard* motherBoard)

{

	if (!show) return;

	if (!motherBoard) return;

	ImGui::SetNextWindowSize({528, 620}, ImGuiCond_FirstUseEver);

	im::Window(title.c_str(), &show, [&]{

		auto* vdp = dynamic_cast<VDP*>(motherBoard->findDevice("VDP")); // TODO name based OK?

		if (!vdp || vdp->isMSX1VDP()) return;

		auto parseMode = [](DisplayMode mode) {

			auto base = mode.getBase();

			if (base == DisplayMode::GRAPHIC4) return SCR5;

			if (base == DisplayMode::GRAPHIC5) return SCR6;

			if (base == DisplayMode::GRAPHIC6) return SCR7;

			if (base != DisplayMode::GRAPHIC7) return OTHER;

			if (mode.getByte() & DisplayMode::YJK) {

				if (mode.getByte() & DisplayMode::YAE) {

					return SCR11;

				} else {

					return SCR12;

				}

			} else {

				return SCR8;

			}

		};

		int vdpMode = parseMode(vdp->getDisplayMode());

		int vdpPages = vdpMode <= SCR6 ? 4 : 2;

		int vdpPage = vdp->getDisplayPage();

		if (vdpPage >= vdpPages) vdpPage &= 1;

		int vdpLines = (vdp->getNumberOfLines() == 192) ? 0 : 1;

		int vdpColor0 = [&]{

			if (vdpMode == one_of(SCR8, SCR11, SCR12) || !vdp->getTransparency()) {

				return 16; // no replacement

			}

			return vdp->getBackgroundColor() & 15;

		}();

		auto modeToStr = [](int mode) {

			if (mode == SCR5 ) return "screen 5";

			if (mode == SCR6 ) return "screen 6";

			if (mode == SCR7 ) return "screen 7";

			if (mode == SCR8 ) return "screen 8";

			if (mode == SCR11) return "screen 11";

			if (mode == SCR12) return "screen 12";

			if (mode == OTHER) return "non-bitmap";

			assert(false); return "ERROR";

		};

		static const char* const color0Str = "0\0001\0002\0003\0004\0005\0006\0007\0008\0009\00010\00011\00012\00013\00014\00015\000none\000";

		bool manualMode   = overrideAll || overrideMode;

		bool manualPage   = overrideAll || overridePage;

		bool manualLines  = overrideAll || overrideLines;

		bool manualColor0 = overrideAll || overrideColor0;

		im::Group([&]{

			ImGui::AlignTextToFramePadding();

			ImGui::TextUnformatted("VDP settings");

			auto pos = ImGui::GetCursorPos();

			ImGui::Dummy(ImGui::CalcTextSize("Screen mode: non-bitmap"));

			ImGui::SetCursorPos(pos);

			im::Disabled(manualMode, [&]{

				ImGui::AlignTextToFramePadding();

				ImGui::StrCat("Screen mode: ", modeToStr(vdpMode));

			});

			im::Disabled(manualPage, [&]{

				ImGui::AlignTextToFramePadding();

				ImGui::StrCat("Display page: ", vdpPage);

			});

			im::Disabled(manualLines, [&]{

				ImGui::AlignTextToFramePadding();

				ImGui::StrCat("Visible lines: ", vdpLines ? 212 : 192);

			});

			im::Disabled(manualColor0, [&]{

				ImGui::AlignTextToFramePadding();

				ImGui::StrCat("Replace color 0: ", getComboString(vdpColor0, color0Str));

			});

			// TODO interlace

		});

		ImGui::SameLine();

		im::Group([&]{

			ImGui::Checkbox("Manual override", &overrideAll);

			im::Group([&]{

				im::Disabled(overrideAll, [&]{

					ImGui::Checkbox("##mode",   overrideAll ? &overrideAll : &overrideMode);

					ImGui::Checkbox("##page",   overrideAll ? &overrideAll : &overridePage);

					ImGui::Checkbox("##lines",  overrideAll ? &overrideAll : &overrideLines);

					ImGui::Checkbox("##color0", overrideAll ? &overrideAll : &overrideColor0);

				});

			});

			ImGui::SameLine();

			im::Group([&]{

				im::ItemWidth(ImGui::GetFontSize() * 9.0f, [&]{

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

						ImGui::Combo("##Screen mode", &bitmapScrnMode, "screen 5\000screen 6\000screen 7\000screen 8\000screen 11\000screen 12\000");

					});

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

						// note: 'mode', not 'bitmapScrnMode'

						int mode = manualMode ? bitmapScrnMode : vdpMode;

						int numPages = mode <= SCR6 ? 4 : 2; // TODO extended VRAM

						if (bitmapPage >= numPages) bitmapPage = numPages - 1;

						if (bitmapPage < 0) bitmapPage = numPages;

						ImGui::Combo("##Display page", &bitmapPage, numPages == 2 ? "0\0001\000All\000" : "0\0001\0002\0003\000All\000");

						if (bitmapPage == numPages) bitmapPage = -1;

					});

					im::Disabled(!manualLines || bitmapPage < 0, [&]{

						ImGui::Combo("##Visible lines", &bitmapLines, "192\000212\000256\000");

					});

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

						ImGui::Combo("##Color 0 replacement", &bitmapColor0, color0Str);

					});

				});

			});

		});

		ImGui::SameLine();

		ImGui::Dummy(ImVec2(15, 1));

		ImGui::SameLine();

		const auto& vram = vdp->getVRAM();

		int mode   = manualMode   ? bitmapScrnMode : vdpMode;

		int page   = manualPage   ? bitmapPage     : vdpPage;

		int lines  = manualLines  ? bitmapLines    : vdpLines;

		int color0 = manualColor0 ? bitmapColor0   : vdpColor0;

		int divX = mode == one_of(SCR6, SCR7) ? 1 : 2;

		int width  = 512 / divX;

		int height = (lines == 0) ? 192

		           : (lines == 1) ? 212

		           : 256;

		if (page < 0) {

			int numPages = mode <= SCR6 ? 4 : 2;

			height = 256 * numPages;

			page = 0;

		}

		auto rasterBeamPos = vdp->getMSXPos(vdp->getCurrentTime());

		rasterBeamPos.x /= divX;

		im::Group([&]{

			ImGui::SetNextItemWidth(ImGui::GetFontSize() * 10.0f);

			ImGui::Combo("Palette", &manager.palette->whichPalette, "VDP\000Custom\000Fixed\000");

			if (ImGui::Button("Open palette editor")) {

				manager.palette->window.raise();

			}

			ImGui::Separator();

			ImGui::SetNextItemWidth(ImGui::GetFontSize() * 3.0f);

			ImGui::Combo("Zoom", &bitmapZoom, "1x\0002x\0003x\0004x\0005x\0006x\0007x\0008x\000");

			ImGui::Checkbox("grid", &bitmapGrid);

			ImGui::SameLine();

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

				ImGui::ColorEdit4("Grid color", bitmapGridColor.data(),

					ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_AlphaBar);

			});

			ImGui::Separator();

			ImGui::Checkbox("beam", &rasterBeam);

			ImGui::SameLine();

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

				ImGui::ColorEdit4("raster beam color", rasterBeamColor.data(),

					ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_AlphaBar);

				ImGui::SameLine();

				im::Font(manager.fontMono, [&]{

					ImGui::StrCat('(',  dec_string<4>(rasterBeamPos.x),

					              ',', dec_string<4>(rasterBeamPos.y), ')');

				});

			});

			HelpMarker("Position of the raster beam, expressed in MSX coordinates.\n"

			           "Left/top border have negative x/y-coordinates.\n"

			           "Only practically useful when emulation is paused.");

		});

		// VDP block command overlay settings

		auto& cmdEngine = vdp->getCmdEngine();

		bool inProgress = cmdEngine.commandInProgress(motherBoard->getCurrentTime());

		auto regs = cmdEngine.getLastCommand();

		auto formatted = VDPCmdEngine::formatCommand(regs, mode);

		im::TreeNode("Show VDP block command overlay", [&]{

			ImGui::RadioButton("never", &showCmdOverlay, 0);

			HelpMarker("Don't draw any overlay in the bitmap view");

			ImGui::SameLine();

			ImGui::RadioButton("in progress", &showCmdOverlay, 1);

			HelpMarker("Only show overlay for VDP block command that is currently executing");

			ImGui::SameLine();

			ImGui::RadioButton("also finished", &showCmdOverlay, 2);

			HelpMarker("Show overlay for the currently executing VDP block command, but also the last finished block command");

			im::TreeNode("Overlay colors", [&]{

				int colorFlags = ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel |

				                 ImGuiColorEditFlags_AlphaBar;

				im::Group([&]{

					ImGui::AlignTextToFramePadding();

					ImGui::TextUnformatted("Source (done)"sv);

					ImGui::AlignTextToFramePadding();

					ImGui::TextUnformatted("Source (todo)"sv);

				});

				ImGui::SameLine();

				im::Group([&]{

					ImGui::ColorEdit4("src-done", colorSrcDone.data(), colorFlags);

					ImGui::ColorEdit4("src-todo", colorSrcTodo.data(), colorFlags);

				});

				ImGui::SameLine(0.0f, ImGui::GetFontSize() * 3.0f);

				im::Group([&]{

					ImGui::AlignTextToFramePadding();

					ImGui::TextUnformatted("Destination (done)"sv);

					ImGui::AlignTextToFramePadding();

					ImGui::TextUnformatted("Destination (todo)"sv);

				});

				ImGui::SameLine();

				im::Group([&]{

					ImGui::ColorEdit4("dst-done", colorDstDone.data(), colorFlags);

					ImGui::ColorEdit4("dst-todo", colorDstTodo.data(), colorFlags);

				});

			});

			ImGui::TextUnformatted("Last command "sv);

			ImGui::SameLine();

			ImGui::TextUnformatted(inProgress ? "[in progress]"sv : "[finished]"sv);

			// Textual-representation of last command (grayed-out if finished).

			// Note:

			// * The representation _resembles_ to notation in MSX-BASIC, but is (intentionally) not

			//   the same. Here we need to convey more information (e.g. for copy commands we show

			//   both corners of the destination).

			// * For the non-block commands we don't clamp/wrap the coordinates.

			// * For the logical commands we don't mask the color register (e.g. to 4 bits for SCRN5).

			// * For the LINE command, we don't clamp/wrap the end-point.

			// * Src and dst rectangles are _separately_ clamped to left/right borders.

			//   That's different from the real VDP behavior, but maybe less confusing to show in the debugger.

			// * The first coordinate is always the start-corner. The second may be larger or

			//   smaller depending on 'dix' and 'diy'.

			// * The textual representation for commands that wrap around the top/bottom border is

			//   ambiguous (but the drawn overlay should be fine).

			im::DisabledIndent(!inProgress, [&]{

				ImGui::TextUnformatted(formatted.str);

			});

		});

		ImGui::Separator();