// Checks for the emulation-speed control in src/timing.c.
//
// The speed is an absolute target clock in kHz, not a percentage of something.
// The machine's own clock comes from -mhz and can be anything from 1 to 40, so
// a percentage says nothing on its own: "50%" is a different speed on a machine
// started with -mhz 1 than on one started with -mhz 12. That makes the
// arithmetic here worth pinning -- particularly that stepping always passes
// through the machine's own clock, so normal speed is reachable however the
// emulator was started.
//
// timing.c reaches for a handful of emulator globals and SDL; the test supplies
// its own so it links nothing else.

#include "timing.h"

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

// ---- Stand-ins for the emulator and SDL ------------------------------------

uint8_t MHZ        = 8;
bool    warp_mode  = false;
bool    log_speed  = false;
bool    mouse_grabbed = false;
uint32_t clockticks6502 = 0;

void video_update_title(const char *t) { (void)t; }

// timing.c only uses these to pace; the tests here never call timing_update().
// Settable, so a check can advance emulated time and wall-clock time
// independently. Never moved backwards: timing.c subtracts it as uint32_t, so a
// backwards step wraps to about 4.29e9 ms rather than reading as negative.
static uint32_t fake_ticks_ms = 0;
uint32_t SDL_GetTicks(void) { return fake_ticks_ms; }
void     SDL_PumpEvents(void) {}
void     video_repaint_only(void) {}

// ---- Harness ---------------------------------------------------------------

static int failures = 0;

static void
check(bool cond, const char *what)
{
	if (!cond) {
		failures++;
		printf("FAIL: %s\n", what);
	} else {
		printf("ok  : %s\n", what);
	}
}

// Step `n` times in a direction and return where we land.
static int
step_n(int direction, int n)
{
	for (int i = 0; i < n; i++) {
		timing_step_speed(direction);
	}
	return timing_get_speed_khz();
}

int
main(void)
{
	// ── The state the emulator actually ships in ────────────────────────────
	// Checked before any setter runs, because nothing outside this test calls
	// them: unset is the only path the shipping binary ever takes, and a check
	// placed after a reset exercises a different one and leaves the fallback
	// untested.
	{
		MHZ = 8;
		check(timing_get_speed_khz() == timing_native_khz(),
		      "unset means the machine's own clock");
		check(timing_get_speed_percent() == 100, "which reads as 100%");
	}

	// ── The machine's own clock is the default ──────────────────────────────
	{
		MHZ = 8;

		timing_reset_speed();
		check(timing_native_khz() == 8000, "reports the machine's clock in kHz");
		check(timing_get_speed_khz() == 8000, "starts at the machine's own clock");
		check(timing_get_speed_percent() == 100, "which is 100%");

		MHZ = 1;

		timing_reset_speed();
		check(timing_native_khz() == 1000, "follows -mhz 1");
		check(timing_get_speed_percent() == 100, "and that is still 100%");

		MHZ = 12;

		timing_reset_speed();
		check(timing_native_khz() == 12000, "follows -mhz 12");
		check(timing_get_speed_percent() == 100, "and that is 100% too");
	}

	// ── A percentage alone would be ambiguous ───────────────────────────────
	// The same absolute speed is a different percentage on different machines,
	// which is exactly why the target is held in kHz.
	{
		MHZ = 8;
		timing_set_speed_khz(1000);
		int pct_on_8mhz = timing_get_speed_percent();

		MHZ = 1;
		timing_set_speed_khz(1000);
		int pct_on_1mhz = timing_get_speed_percent();

		check(pct_on_8mhz == 13 && pct_on_1mhz == 100,
		      "1 MHz reads as ~13% of an 8 MHz machine but 100% of a 1 MHz one");
	}

	// ── Clamping ────────────────────────────────────────────────────────────
	{
		MHZ = 8;
		timing_set_speed_khz(0);
		check(timing_get_speed_khz() == TIMING_SPEED_MIN_KHZ, "clamps zero up to the minimum");
		timing_set_speed_khz(-5000);
		check(timing_get_speed_khz() == TIMING_SPEED_MIN_KHZ, "clamps negative up to the minimum");
		timing_set_speed_khz(1 << 30);
		check(timing_get_speed_khz() == TIMING_SPEED_MAX_KHZ, "clamps absurdly high down to the maximum");
		timing_set_speed_khz(4000);
		check(timing_get_speed_khz() == 4000, "keeps a value inside the range");
	}

	// ── Stepping through the presets ────────────────────────────────────────
	{
		MHZ = 8;

		timing_reset_speed();
		int slower = step_n(-1, 1);
		check(slower < 8000, "stepping down leaves the machine's clock");
		check(step_n(1, 1) == 8000, "and stepping back up returns to it exactly");

		// Stepping down repeatedly must bottom out at the minimum, not run off
		// the end of the ladder.

		timing_reset_speed();
		check(step_n(-1, 100) == TIMING_SPEED_MIN_KHZ, "stepping down bottoms out at the minimum");
		check(step_n(1, 200) == TIMING_SPEED_MAX_KHZ, "stepping up tops out at the maximum");

		// Monotonic in both directions, with no repeats or reversals.

		timing_reset_speed();
		bool monotonic = true;
		int  prev      = timing_get_speed_khz();
		for (int i = 0; i < 40; i++) {
			timing_step_speed(-1);
			const int now = timing_get_speed_khz();
			if (now > prev)
				monotonic = false;
			prev = now;
		}
		check(monotonic, "stepping down never speeds up");

		prev = timing_get_speed_khz();
		monotonic = true;
		for (int i = 0; i < 60; i++) {
			timing_step_speed(1);
			const int now = timing_get_speed_khz();
			if (now < prev)
				monotonic = false;
			prev = now;
		}
		check(monotonic, "stepping up never slows down");
	}

	// ── The machine's own clock is always a rung ────────────────────────────
	// However the emulator was started, stepping has to be able to land back on
	// normal speed -- otherwise "back to normal" would be unreachable on a
	// machine whose clock is not one of the presets.
	{
		const uint8_t odd_clocks[] = { 1, 2, 3, 5, 7, 8, 11, 13, 17, 23, 40 };
		bool reachable = true;
		for (unsigned i = 0; i < sizeof(odd_clocks) / sizeof(odd_clocks[0]); i++) {
			MHZ = odd_clocks[i];
	
		timing_reset_speed();
			const int native = timing_native_khz();

			// Walk to the bottom, then back up, and see if we pass through it.
			step_n(-1, 60);
			bool seen = false;
			for (int s = 0; s < 60; s++) {
				timing_step_speed(1);
				if (timing_get_speed_khz() == native) {
					seen = true;
					break;
				}
			}
			if (!seen) {
				printf("      (native %d kHz unreachable from below on -mhz %u)\n",
				       native, odd_clocks[i]);
				reachable = false;
			}
		}
		check(reachable, "the machine's own clock is always reachable by stepping");
	}

	// ── Reset ───────────────────────────────────────────────────────────────
	{
		MHZ = 8;
		timing_set_speed_khz(100);
		check(timing_get_speed_khz() == 100, "runs slow when asked");

		timing_reset_speed();
		check(timing_get_speed_khz() == 8000 && timing_get_speed_percent() == 100,
		      "reset returns to the machine's own clock");
	}

	// ── The scaling itself ──────────────────────────────────────────────────
	// Everything above pins the ladder bookkeeping. This pins the arithmetic
	// that actually changes how the machine runs, which nothing else did: the
	// first version of this feature left timing_lead_us() unscaled and the
	// whole suite still passed. That value alone paces the window-drag path, so
	// an unscaled one lets a slow target run at full speed while a window is
	// being dragged, and freezes a fast one.
	//
	// timing_lead_us() is how far ahead of real time the emulation is. With
	// SDL_GetTicks() stubbed at zero, it is the emulated time accrued since the
	// clock was re-based -- so the counter is zeroed before each re-base, or the
	// delta it measures would be taken against the previous block's value.
	{
		MHZ = 8;
		timing_reset_speed();
		clockticks6502 = 0;
		timing_init();
		clockticks6502 = 8000;            // one millisecond at 8 MHz
		check(timing_lead_us() == 1000,
		      "lead is emulated microseconds at the machine's own clock");

		// A target 320x slower stretches the same emulated work over 320x the
		// real time, so the lead grows by the same factor.
		timing_set_speed_khz(25);
		clockticks6502 = 0;
		timing_init();
		clockticks6502 = 8000;
		check(timing_lead_us() == 320000, "and 320x that at 25 kHz");

		// Faster than the machine's own clock shrinks it.
		timing_set_speed_khz(16000);
		clockticks6502 = 0;
		timing_init();
		clockticks6502 = 8000;
		check(timing_lead_us() == 500, "and half that at twice the clock");

		// The scaling follows the machine's clock, not a fixed constant.
		MHZ = 1;
		timing_reset_speed();
		clockticks6502 = 0;
		timing_init();
		clockticks6502 = 1000;            // one millisecond at 1 MHz
		check(timing_lead_us() == 1000,
		      "a different machine clock still reads as real microseconds");

		MHZ = 8;
		timing_reset_speed();
		clockticks6502 = 0;
		timing_init();
	}
	// ── The wall-clock side of the lead ─────────────────────────────────────
	// The checks above pin the scaling of emulated time, but hold wall-clock
	// time at zero, so they cannot see the term that subtracts it -- nor the
	// accumulated cpu_ticks that the pending delta is added to. Both survive
	// deletion without them.
	//
	// timing_update() is deliberately never called: its slice loop re-reads the
	// clock to decide when to stop, and a stub that does not advance during a
	// sleep would spin forever. timing_update_no_sleep() skips that block.
	{
		MHZ = 8;
		timing_reset_speed();

		// Three milliseconds of real time against one of emulated work: the
		// machine is two milliseconds behind.
		fake_ticks_ms  = 0;
		clockticks6502 = 0;
		timing_init();
		fake_ticks_ms  = 3;
		clockticks6502 = 8000;
		check(timing_lead_us() == -2000, "lead goes negative when real time runs ahead");

		// Only the emulated side is scaled. At 25 kHz the same 8000 ticks are
		// worth 320 ms, against one second of real time.
		timing_set_speed_khz(25);
		fake_ticks_ms  = 0;
		clockticks6502 = 0;
		timing_init();
		fake_ticks_ms  = 1000;
		clockticks6502 = 8000;
		check(timing_lead_us() == 320000 - 1000000,
		      "and the wall-clock side is not scaled with it");

		// Ticks already folded into the running total still count. The wall
		// clock stays at zero across the update, so the catch-up re-base -- which
		// would silently rewrite the base and hide this -- cannot trigger.
		timing_reset_speed();
		fake_ticks_ms  = 0;
		clockticks6502 = 0;
		timing_init();
		clockticks6502 = 8000;
		timing_update_no_sleep();      // folds 8000 into the accumulated total
		clockticks6502 = 16000;        // another 8000 pending
		check(timing_lead_us() == 2000, "accumulated ticks count as well as pending ones");

		fake_ticks_ms  = 0;
		clockticks6502 = 0;
		timing_reset_speed();
		timing_init();
	}

	if (failures) {
		printf("\nFAILED (%d failures)\n", failures);
		return 1;
	}
	printf("\nPASSED (0 failures)\n");
	return 0;
}