// Commander X16 Emulator — ImGui "Performance" panel.

//

// Answers the question a program author actually has: at 60 fps (or 30, or

// whatever they are targeting) how much of the frame is their code using, and

// how much room is left?

//

// The accounting is not done here. src/perf_budget.c owns the cycle budget and

// src/vera_bandwidth.c owns the VRAM bus figures, because the same numbers are

// served over DAP and neither surface should have its own idea of what a frame

// cost. This file is a reader and a control panel.

//

// CPU CYCLES AND VERA BANDWIDTH SHARE THIS PANEL on purpose. They are two

// halves of "what is eating my frame?", and the frames worth looking at are the

// ones where they disagree.

//

// PROFILING IS ARMED BY THE PANEL BEING OPEN, and disarmed by closing it. This

// panel ships open and docked with the other bottom-row views, so a normal

// `-imgui` session profiles from boot -- which is the point: the numbers are

// only useful if they are already there when you go looking, and a panel that

// starts empty and fills over the next minute answers nothing about the frame

// that made you open it.

//

// What that costs the running machine is an add, one array index and a couple

// of branches per instruction, in the same class as the

// code_map_record_current() call `-imgui` already makes on every instruction.

// Close the tab and it stops; System > Settings has the reverse (keep profiling

// with the panel shut, for feeding a DAP client).

#include "imgui.h"

#include "debug_ui_panels.h"

#include "debug_ui_bridge.h"

#include "debug_ui_widgets.h"

#include "debug_ui_settings.h"

#include <stdint.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

namespace {

// The windows the statistics table reports, matching what the DAP surface

// offers so that the panel and a client never disagree about what "30s" means.

struct Window {

	const char *name;

	float       seconds; // <= 0 means the whole ring

};

const Window k_windows[] = {

	{"1s", 1.0f}, {"10s", 10.0f}, {"30s", 30.0f}, {"60s", 60.0f}, {"session", 0.0f},

};

const int k_window_count = (int)(sizeof k_windows / sizeof k_windows[0]);

// Graph history, refilled each frame from the ring.

float  g_graph[1024];

int    g_graph_n = 0;

// Zone editor scratch.

char     g_zone_name[PERF_ZONE_NAME_MAX] = "";

int      g_zone_start                    = 0x0800;

int      g_zone_end                      = 0x0900;

int      g_zone_bank                     = -1;

bool     g_zone_idle                     = false;

int      g_symbol_pick                   = -1;

ImVec4

utilization_color(float pct)

{

	if (pct >= 100.0f)

		return ImVec4(1.00f, 0.35f, 0.35f, 1.0f); // over budget

	if (pct >= 90.0f)

		return ImVec4(1.00f, 0.75f, 0.30f, 1.0f); // no headroom left

	return ImVec4(0.45f, 0.90f, 0.50f, 1.0f);

}

// Cycles as a share of a scanline, which is the unit X16 programs are written

// in far more often than raw cycles.

void

cycles_tooltip(uint32_t cycles)

{

	if (!ImGui::IsItemHovered())

		return;

	const uint32_t per_line = perf_budget_cycles_per_scanline();

	ImGui::BeginTooltip();

	ImGui::Text("%u cycles", (unsigned)cycles);

	if (per_line)

		ImGui::Text("%.1f scanlines", (double)cycles / (double)per_line);

	const uint32_t khz = (uint32_t)MHZ * 1000u;

	if (khz)

		ImGui::Text("%.3f ms", (double)cycles / (double)khz);

	ImGui::EndTooltip();

}

void

draw_budget_header(void)

{

	DebugUiSettings &s = debug_ui_settings();

	const uint32_t per_frame = perf_budget_cycles_per_frame();

	const uint32_t budget    = perf_budget_budget_cycles();

	const int      span      = perf_budget_frames_per_budget();

	ImGui::SetNextItemWidth(dbgui_field_width("000.0"));

	if (ImGui::InputFloat("Target FPS", &s.perf_target_fps, 0.0f, 0.0f, "%.4g")) {

		if (s.perf_target_fps < 1.0f)

			s.perf_target_fps = 1.0f;

		if (s.perf_target_fps > 1000.0f)

			s.perf_target_fps = 1000.0f;

		perf_budget_set_target_fps(s.perf_target_fps);

		debug_ui_settings_mark_dirty();

	}

	if (ImGui::IsItemHovered()) {

		ImGui::SetTooltip(

		    "How many vsyncs your frame work is allowed to span.\n\n"

		    "The frame period is fixed by VERA and asking for a lower rate\n"

		    "does not make frames longer -- it means the work may take more\n"

		    "than one of them, so the budget grows instead.");

	}

	ImGui::SameLine();

	for (int i = 0; i < 3; i++) {

		const float presets[3] = {60.0f, 30.0f, 20.0f};

		char        label[16];

		snprintf(label, sizeof label, "%g", (double)presets[i]);

		if (i)

			ImGui::SameLine();

		if (ImGui::SmallButton(label)) {

			s.perf_target_fps = presets[i];

			perf_budget_set_target_fps(presets[i]);

			debug_ui_settings_mark_dirty();

		}

	}

	ImGui::Text("Machine %u MHz  |  vsync %.2f Hz  |  %u cycles/frame  |  %u/scanline",

	            (unsigned)MHZ, (double)perf_budget_vsync_hz(), (unsigned)per_frame,

	            (unsigned)perf_budget_cycles_per_scanline());

	ImGui::Text("Budget: %u cycles", (unsigned)budget);

	cycles_tooltip(budget);

	if (span > 1) {

		ImGui::SameLine();

		ImGui::TextDisabled("(%d frames' worth)", span);

	}

	if (warp_mode) {

		ImGui::TextColored(ImVec4(1.0f, 0.8f, 0.3f, 1.0f),

		                   "Warp mode: guest cycles are still real, host time is not.");

	}

	if (timing_get_speed_khz() != timing_native_khz()) {

		ImGui::TextDisabled("Speed override active (%d kHz). The budget follows the "

		                    "machine's native %d kHz.",

		                    timing_get_speed_khz(), timing_native_khz());

	}

}

void

draw_current_frame(void)

{

	perf_frame_t f;

	if (!perf_budget_last_frame(&f)) {

		ImGui::TextDisabled("(waiting for the first frame)");

		return;

	}

	const uint32_t budget = perf_budget_budget_cycles();

	const uint32_t work   = f.period_work;

	const float    pct    = budget ? 100.0f * (float)work / (float)budget : 0.0f;

	// A stacked bar: work (of which interrupt) against idle, drawn to the width

	// of the BUDGET rather than the frame, so overrunning visibly runs past the

	// end instead of quietly rescaling.

	const float full   = ImGui::GetContentRegionAvail().x;

	const float height = ImGui::GetFrameHeight();

	const ImVec2 p0    = ImGui::GetCursorScreenPos();

	ImDrawList  *dl    = ImGui::GetWindowDrawList();

	const float scale   = budget ? full / (float)budget : 0.0f;

	const float w_irq   = (float)f.irq * scale;

	const float w_work  = (float)work * scale;

	const float w_total = (float)f.total * scale;

	dl->AddRectFilled(p0, ImVec2(p0.x + full, p0.y + height),

	                  ImGui::GetColorU32(ImGuiCol_FrameBg));

	// Idle first, as the backdrop the work sits on.

	dl->AddRectFilled(p0, ImVec2(p0.x + (w_total < full ? w_total : full), p0.y + height),

	                  ImGui::GetColorU32(ImVec4(0.25f, 0.30f, 0.38f, 1.0f)));

	dl->AddRectFilled(p0, ImVec2(p0.x + (w_work < full ? w_work : full), p0.y + height),

	                  ImGui::GetColorU32(utilization_color(pct)));

	dl->AddRectFilled(p0, ImVec2(p0.x + (w_irq < full ? w_irq : full), p0.y + height),

	                  ImGui::GetColorU32(ImVec4(0.55f, 0.45f, 0.85f, 1.0f)));

	// The budget line, so "how close am I" is readable at a glance.

	dl->AddLine(ImVec2(p0.x + full - 1.0f, p0.y), ImVec2(p0.x + full - 1.0f, p0.y + height),

	            ImGui::GetColorU32(ImVec4(1, 1, 1, 0.7f)), 2.0f);

	char overlay[96];

	snprintf(overlay, sizeof overlay, "%.1f%% of budget   %u / %u cycles", (double)pct,

	         (unsigned)work, (unsigned)budget);

	const ImVec2 ts = ImGui::CalcTextSize(overlay);

	dl->AddText(ImVec2(p0.x + (full - ts.x) * 0.5f, p0.y + (height - ts.y) * 0.5f),

	            ImGui::GetColorU32(ImGuiCol_Text), overlay);

	ImGui::Dummy(ImVec2(full, height));

	const uint32_t idle    = f.idle;

	const uint32_t main_cy = work > f.irq ? work - f.irq : 0;

	const uint32_t per_line = perf_budget_cycles_per_scanline();

	ImGui::Text("work %u", (unsigned)work);

	cycles_tooltip(work);

	ImGui::SameLine();

	ImGui::TextColored(ImVec4(0.55f, 0.45f, 0.85f, 1.0f), " | irq %u", (unsigned)f.irq);

	cycles_tooltip(f.irq);

	ImGui::SameLine();

	ImGui::Text(" | main %u", (unsigned)main_cy);

	cycles_tooltip(main_cy);

	ImGui::SameLine();

	ImGui::TextColored(ImVec4(0.55f, 0.62f, 0.72f, 1.0f), " | idle %u", (unsigned)idle);

	cycles_tooltip(idle);

	if (work < budget) {

		const uint32_t spare = budget - work;

		ImGui::TextColored(utilization_color(pct), "Headroom: %u cycles%s", (unsigned)spare,

		                   per_line ? "" : "");

		if (per_line) {

			ImGui::SameLine();

			ImGui::TextDisabled("(%.1f scanlines)", (double)spare / (double)per_line);

		}

	} else {

		ImGui::TextColored(utilization_color(pct), "OVER BUDGET by %u cycles",

		                   (unsigned)(work - budget));

		if (per_line) {

			ImGui::SameLine();

			ImGui::TextDisabled("(%.1f scanlines)",

			                    (double)(work - budget) / (double)per_line);

		}

	}

	ImGui::Text("Instructions: %u   |   host %.2f ms", (unsigned)f.instructions,

	            (double)f.host_us / 1000.0);

}

void

draw_graph(void)

{

	DebugUiSettings &s = debug_ui_settings();

	int want = s.perf_graph_frames;

	if (want < 30)

		want = 30;

	if (want > (int)(sizeof g_graph / sizeof g_graph[0]))

		want = (int)(sizeof g_graph / sizeof g_graph[0]);

	// perf_budget_frames() would be a second copy of the ring; the panel only

	// needs the work figure, so it walks the window API instead.

	const int have = perf_budget_frame_count();

	int       n    = want < have ? want : have;

	if (n <= 0) {

		ImGui::TextDisabled("(no frames yet)");

		return;

	}

	perf_frame_t f;

	g_graph_n = 0;

	// Oldest to newest, so the graph reads left-to-right like a timeline.

	for (int i = n - 1; i >= 0; i--) {

		if (perf_budget_frame_at(i, &f))

			g_graph[g_graph_n++] = (float)f.period_work;

	}

	if (g_graph_n <= 0) {

		ImGui::TextDisabled("(no frames yet)");

		return;

	}

	const float budget = (float)perf_budget_budget_cycles();

	float       top    = budget * 1.25f;

	for (int i = 0; i < g_graph_n; i++)

		if (g_graph[i] > top)

			top = g_graph[i] * 1.05f;

	const float  height = ImGui::GetTextLineHeight() * 6.0f;

	const ImVec2 p0     = ImGui::GetCursorScreenPos();

	const float  width  = ImGui::GetContentRegionAvail().x;

	ImGui::PlotHistogram("##perfgraph", g_graph, g_graph_n, 0, nullptr, 0.0f, top,

	                     ImVec2(width, height));

	// The budget line over the top: without it the histogram says how much the

	// work varies but not whether any of it mattered.

	if (top > 0.0f) {

		const float y = p0.y + height * (1.0f - budget / top);

		ImGui::GetWindowDrawList()->AddLine(ImVec2(p0.x, y), ImVec2(p0.x + width, y),

		                                    ImGui::GetColorU32(ImVec4(1.0f, 0.4f, 0.4f, 0.9f)),

		                                    1.5f);

	}

	ImGui::TextDisabled("%d frames, oldest left. Red line is the budget.", g_graph_n);

}

void

stat_cell(uint32_t v, uint32_t budget)

{

	const float pct = budget ? 100.0f * (float)v / (float)budget : 0.0f;

	ImGui::TextColored(utilization_color(pct), "%u", (unsigned)v);

	if (ImGui::IsItemHovered()) {

		ImGui::BeginTooltip();

		ImGui::Text("%u cycles (%.1f%% of budget)", (unsigned)v, (double)pct);

		const uint32_t per_line = perf_budget_cycles_per_scanline();

		if (per_line)

			ImGui::Text("%.1f scanlines", (double)v / (double)per_line);

		ImGui::EndTooltip();

	}

}

void

draw_statistics(void)

{

	const uint32_t budget = perf_budget_budget_cycles();

	if (!ImGui::BeginTable("perfstats", 9,

	                       ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerV |

	                           DBGUI_TABLE_FLAGS_RESIZABLE))

		return;

	ImGui::TableSetupColumn("Window", ImGuiTableColumnFlags_WidthFixed,

	                        dbgui_col_width("Window", "session"));

	ImGui::TableSetupColumn("Frames", ImGuiTableColumnFlags_WidthFixed,

	                        dbgui_col_width("Frames", "99999"));

	ImGui::TableSetupColumn("Min", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("Mean", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("p50", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("p95", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("p99", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("Max", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("Over", ImGuiTableColumnFlags_WidthFixed,

	                        dbgui_col_width("Over", "9999 (99%)"));

	ImGui::TableHeadersRow();

	for (int i = 0; i < k_window_count; i++) {

		perf_window_t w;

		if (!perf_budget_window(k_windows[i].seconds, &w))

			continue;

		ImGui::TableNextRow();

		ImGui::TableSetColumnIndex(0);

		ImGui::TextUnformatted(k_windows[i].name);

		ImGui::TableSetColumnIndex(1);

		ImGui::Text("%d", w.frames);

		ImGui::TableSetColumnIndex(2); stat_cell(w.budget_work.min, budget);

		ImGui::TableSetColumnIndex(3); stat_cell(w.budget_work.mean, budget);

		ImGui::TableSetColumnIndex(4); stat_cell(w.budget_work.p50, budget);

		ImGui::TableSetColumnIndex(5); stat_cell(w.budget_work.p95, budget);

		ImGui::TableSetColumnIndex(6); stat_cell(w.budget_work.p99, budget);

		ImGui::TableSetColumnIndex(7); stat_cell(w.budget_work.max, budget);

		ImGui::TableSetColumnIndex(8);

		if (w.overruns > 0) {

			ImGui::TextColored(ImVec4(1.0f, 0.4f, 0.4f, 1.0f), "%d (%.1f%%)", w.overruns,

			                   (double)w.overrun_pct);

			if (ImGui::IsItemHovered())

				ImGui::SetTooltip("Worst was frame %u, %u cycles over budget.",

				                  (unsigned)w.worst_frame, (unsigned)w.worst_overrun);

		} else {

			ImGui::TextDisabled("-");

		}

	}

	ImGui::EndTable();

	ImGui::TextDisabled("Work per budget period, in guest cycles. "

	                    "Colour is share of budget.");

}

void

draw_breakdown(void)

{

	const uint32_t budget = perf_budget_budget_cycles();

	const int      nzones = perf_budget_zone_count();

	if (nzones <= 0) {

		ImGui::TextDisabled("No zones or marker regions yet. Define a zone below, or have "

		                    "the guest write region markers to $9FBC.");

		return;

	}

	if (!ImGui::BeginTable("perfzones", 6,

	                       ImGuiTableFlags_RowBg | ImGuiTableFlags_BordersInnerV |

	                           DBGUI_TABLE_FLAGS_RESIZABLE))

		return;

	ImGui::TableSetupColumn("Zone", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("Range", ImGuiTableColumnFlags_WidthFixed,

	                        dbgui_col_width("Range", "$FFFF-$FFFF"));

	ImGui::TableSetupColumn("Now", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("Mean 30s", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("p95 30s", ImGuiTableColumnFlags_WidthStretch);

	ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed,

	                        dbgui_col_width("", "Remove"));

	ImGui::TableHeadersRow();

	perf_frame_t last;

	const bool   have_last = perf_budget_last_frame(&last);

	for (int i = 0; i < nzones; i++) {

		perf_zone_t z;

		if (!perf_budget_zone_get(i, &z))

			continue;

		ImGui::TableNextRow();

		ImGui::PushID(i);

		ImGui::TableSetColumnIndex(0);

		ImGui::TextUnformatted(z.name);

		if (z.is_idle) {

			ImGui::SameLine();

			ImGui::TextDisabled("(idle)");

		}

		ImGui::TableSetColumnIndex(1);

		if (z.is_marker)

			ImGui::TextDisabled("marker");

		else if (z.bank >= 0)

			ImGui::Text("$%04X-$%04X b%d", z.start, z.end, z.bank);

		else

			ImGui::Text("$%04X-$%04X", z.start, z.end);

		ImGui::TableSetColumnIndex(2);

		if (have_last && i < PERF_RING_ZONES)

			stat_cell(last.zone[i], budget);

		else

			ImGui::TextDisabled("-");

		perf_stat_t st;

		const bool  have_stat = perf_budget_zone_window(i, 30.0f, &st);

		ImGui::TableSetColumnIndex(3);

		if (have_stat)

			stat_cell(st.mean, budget);

		else

			ImGui::TextDisabled("-");

		ImGui::TableSetColumnIndex(4);