#ifndef __APPLE__
#ifndef _MSC_VER
#define _XOPEN_SOURCE   600
#define _POSIX_C_SOURCE 1
#endif
#endif
#include "glue.h"
#include "video.h"
#include "timing.h"
#include "cpu/fake6502.h"
#include <SDL.h>
#include <stdio.h>
#include "compat.h"

// Largest real-time deficit (in microseconds) we let the emulator try to make
// up by running unthrottled. Anything bigger is treated as a stall — the host
// was blocked in a modal window move/resize loop, was suspended, or simply
// can't keep up — and is dropped instead of "fast-forwarded" through once the
// stall ends. 250 ms comfortably exceeds normal per-frame scheduling jitter.
#define MAX_CATCHUP_US (250 * 1000)

// Above this much surplus, the throttle sleeps in slices instead of one block,
// so the host stays responsive while the machine is being run slowly. The
// threshold is above a frame's worth of pacing at the machine's own clock, so
// normal-speed behaviour is untouched.
#define THROTTLE_SLICE_THRESHOLD_US (25 * 1000)
#define THROTTLE_SLICE_US           (12 * 1000)

static void timing_update_ex(bool may_sleep);

uint32_t frames;
uint32_t sdlTicks_base;
uint32_t last_perf_update;
uint32_t clockticks6502_old;
int64_t cpu_ticks;
int64_t last_perf_cpu_ticks;
char window_title[255];

// The target clock, or 0 for "not set", meaning run at the machine's own.
static int emu_speed_khz = 0;

int
timing_native_khz(void)
{
	return (int)MHZ * 1000;
}

int
timing_get_speed_khz(void)
{
	return emu_speed_khz > 0 ? emu_speed_khz : timing_native_khz();
}

int
timing_get_speed_percent(void)
{
	const int native = timing_native_khz();
	return native > 0
	           ? (int)(((int64_t)timing_get_speed_khz() * 100 + native / 2) / native)
	           : 100;
}

// Emulated microseconds represented by `ticks`, scaled to the target clock. The
// throttle compares this against wall-clock microseconds, so a lower target
// makes each emulated cycle take proportionally longer in real time. At the
// machine's own clock this reduces exactly to the original ticks / MHZ.
static int64_t
scaled_us(int64_t ticks)
{
	const int khz = timing_get_speed_khz();
	return khz > 0 ? ticks * 1000 / (int64_t)khz : ticks / (MHZ ? MHZ : 1);
}

static int64_t
scaled_emulated_us(void)
{
	return scaled_us(cpu_ticks);
}

void
timing_set_speed_khz(int khz)
{
	if (khz < TIMING_SPEED_MIN_KHZ)
		khz = TIMING_SPEED_MIN_KHZ;
	if (khz > TIMING_SPEED_MAX_KHZ)
		khz = TIMING_SPEED_MAX_KHZ;
	if (khz == emu_speed_khz)
		return;
	emu_speed_khz = khz;
	// Re-base, so changing the scale is not read as a huge surplus or deficit
	// and answered with a sprint or a stall.
	timing_init();
}

// Preset clocks, in kHz. Anchored on speeds real hardware is run at (1 / 8 / 12
// MHz and neighbours) with steps between, so stepping moves through meaningful
// rates rather than arbitrary percentages.
static const int speed_ladder_khz[] = {
	   25,    50,   100,   250,   500,   750,
	 1000,  1500,  2000,  3000,  4000,  6000,
	 8000, 10000, 12000, 14000, 16000, 20000, 24000,
	// Past anything the hardware runs at, but still useful for getting through
	// a slow section without the all-or-nothing of warp mode.
	32000, 40000, 48000, 64000, 80000, 100000,
};
#define SPEED_LADDER_COUNT ((int)(sizeof(speed_ladder_khz) / sizeof(speed_ladder_khz[0])))

// Build the ladder for this machine, splicing its own clock in at the right
// place if it is not already a preset, so normal speed is always a rung.
static int
build_ladder(int *out, int max)
{
	const int native   = timing_native_khz();
	int       n        = 0;
	bool      inserted = false;

	for (int i = 0; i < SPEED_LADDER_COUNT && n < max; i++) {
		const int v = speed_ladder_khz[i];
		if (!inserted && v >= native) {
			out[n++] = native;
			inserted = true;
			if (v == native)
				continue;               // it *is* a preset, do not add it twice
			if (n >= max)
				break;
		}
		out[n++] = v;
	}
	if (!inserted && n < max)
		out[n++] = native;              // native sits above every preset
	return n;
}

void
timing_step_speed(int direction)
{
	int       ladder[SPEED_LADDER_COUNT + 1];
	const int n = build_ladder(ladder, (int)(sizeof(ladder) / sizeof(ladder[0])));
	if (n <= 0)
		return;

	// Find the nearest rung, then move from there.
	const int cur   = timing_get_speed_khz();
	int       best  = 0;
	int       bestd = 1 << 30;
	for (int i = 0; i < n; i++) {
		const int d = ladder[i] > cur ? ladder[i] - cur : cur - ladder[i];
		if (d < bestd) {
			bestd = d;
			best  = i;
		}
	}

	int idx = best;
	if (ladder[best] == cur) {
		idx = best + (direction > 0 ? 1 : (direction < 0 ? -1 : 0));
	} else if (direction > 0 && ladder[best] < cur) {
		idx = best + 1;                 // snap up past the rung we are above
	} else if (direction < 0 && ladder[best] > cur) {
		idx = best - 1;                 // snap down past the rung we are below
	}
	if (idx < 0)
		idx = 0;
	if (idx >= n)
		idx = n - 1;
	timing_set_speed_khz(ladder[idx]);
}

void
timing_reset_speed(void)
{
	timing_set_speed_khz(timing_native_khz());
}

void
timing_init() {
	frames = 0;
	sdlTicks_base = SDL_GetTicks();
	last_perf_update = 0;
	last_perf_cpu_ticks = 0;
	clockticks6502_old = clockticks6502;
	cpu_ticks = 0;
}

void
timing_update()
{
	timing_update_ex(true);
}

// As timing_update(), but never sleeps. The window-drag path runs inside the
// OS modal message loop, which cannot deliver mouse input while we are in the
// window procedure; sleeping there shows up directly as a jerky drag. That
// caller paces itself with timing_lead_us() instead.
void
timing_update_no_sleep()
{
	timing_update_ex(false);
}

// Microseconds of emulated time we are ahead of the wall clock; negative means
// behind. Lets a caller pace itself without blocking.
int64_t
timing_lead_us()
{
	int64_t ticks = cpu_ticks + (int64_t)(clockticks6502 - clockticks6502_old);
	uint32_t sdlTicks = SDL_GetTicks() - sdlTicks_base;
	// Scaled the same way the throttle is, or the two would disagree by exactly
	// native/target: the drag path is paced by this alone, so an unscaled lead
	// would let a slow target run at full speed while dragging, and freeze the
	// machine outright for a fast one.
	return scaled_us(ticks) - sdlTicks * 1000LL;
}

static void
timing_update_ex(bool may_sleep)
{
	frames++;
	cpu_ticks += clockticks6502 - clockticks6502_old;
	clockticks6502_old = clockticks6502;
	uint32_t sdlTicks = SDL_GetTicks() - sdlTicks_base;
	int64_t diff_time = scaled_emulated_us() - sdlTicks * 1000LL;

	// If we've fallen far behind real time, don't sprint to catch up (that
	// burst is the "fast-forward" artifact seen after dragging/resizing the
	// window, resuming from suspend, or on a host that can't keep up). Re-base
	// the wall-clock reference to now so the accumulated deficit is discarded
	// and emulation simply resumes at real speed.
	if (!warp_mode && diff_time < -(int64_t)MAX_CATCHUP_US) {
		uint32_t now = SDL_GetTicks();
		uint32_t new_base = now - (uint32_t)(scaled_emulated_us() / 1000);
		last_perf_update -= new_base - sdlTicks_base; // keep perf timer aligned
		sdlTicks_base = new_base;
		sdlTicks = now - sdlTicks_base;
		diff_time = scaled_emulated_us() - sdlTicks * 1000LL;
	}

	if (may_sleep && !warp_mode && diff_time > 0) {
		// A slower target multiplies the per-frame surplus by native/target.
		// At the machine's own clock that surplus is at most one frame, but at
		// the slowest setting it is seconds, and sleeping it in a single call
		// leaves the window unrepainted and unable to answer the OS -- which
		// marks it "not responding" -- for the whole of it. So break a long
		// wait into slices and let the host breathe between them.
		//
		// SDL_PumpEvents() dispatches the OS message queue without dequeuing
		// anything, and video_repaint_only() re-presents the existing frame
		// without touching the event queue or the recorder, so input still
		// arrives intact at the next real poll. The threshold is above one
		// frame's worth, so pacing
		// at the machine's own clock takes the single-sleep path exactly as
		// before.
		//
		// The wait is re-derived from the clock on every slice rather than
		// counted down from a snapshot. Sleeping may overshoot, the repaint
		// between slices costs real time, and SDL_PumpEvents() can hand the
		// thread to the OS -- on Windows a title-bar drag enters a modal loop
		// that runs the emulator itself and re-bases this very clock. Counting
		// down a local would then sleep off a surplus that had already been
		// spent, freezing the machine for seconds just after a drag: the exact
		// artefact this loop exists to avoid.
		if (diff_time > THROTTLE_SLICE_THRESHOLD_US) {
			for (;;) {
				const int64_t left = scaled_emulated_us()
				                   - (int64_t)(SDL_GetTicks() - sdlTicks_base) * 1000;
				if (left <= 0)
					break;

				usleep(left > THROTTLE_SLICE_US ? THROTTLE_SLICE_US : left);

				SDL_PumpEvents();
				video_repaint_only();
			}
			diff_time = 0;
		} else {
			if (diff_time >= 1000000) {
				sleep(diff_time / 1000000);
				diff_time %= 1000000;
			}
			usleep(diff_time);
		}
	}

	if (sdlTicks - last_perf_update > 5000) {
		uint32_t perf = (cpu_ticks - last_perf_cpu_ticks) / (MHZ * 50000);

		if (perf < 100 || warp_mode) {
			sprintf(window_title, WINDOW_TITLE " (%d%%)%s", perf, mouse_grabbed ? MOUSE_GRAB_MSG : "");
		} else {
			sprintf(window_title, WINDOW_TITLE "%s", mouse_grabbed ? MOUSE_GRAB_MSG : "");
		}

		video_update_title(window_title);

		last_perf_cpu_ticks = cpu_ticks;
		last_perf_update = sdlTicks;
	}

	if (log_speed) {
		float frames_behind = -((float)diff_time * 6e-5);
		int load = (int)((1 + frames_behind) * 100);
		printf("Load: %d%%\n", load > 100 ? 100 : load);

		if ((int)frames_behind > 0) {
			printf("Rendering is behind %d frames.\n", -(int)frames_behind);
		} else {
		}
	}
}