// The SNES controller ports: the latch/clock shift register, and the virtual
// joystick that lets automation drive a port with no gamepad attached.
//
// The properties worth pinning are the ones a script driving the machine over
// DAP depends on: that a button it holds actually reaches the data line, on the
// right bit for the right port; that the shift register clocks out LSB-first
// with the upper nibble forced high the way the hardware does; and -- the one
// that is easy to break -- that a port nothing is driving still reads as
// released, forever, rather than draining a shift register to zero and
// reporting every button pressed.
//
// joystick.c reaches SDL's headers and its controller-enumeration functions, so
// this links SDL, but never calls joystick_init(): the virtual path deliberately
// needs no SDL controller, and the test is here to prove that.

#include "support/harness.h"

#include "../src/joystick.h"

#include <string.h>

// Reading a port means latching, then clocking bits out one at a time. The
// latch emits bit 0 itself, so the loop starts at 1. Joystick_data is cleared
// first because the latch path ORs into it without clearing, exactly as it does
// when the VIA drives the line.
static uint16_t
read_slot(int slot, int bits)
{
	const uint8_t slot_bit = 0x80 >> slot;
	uint16_t      out      = 0;

	Joystick_data = 0;
	joystick_set_latch(true);
	if (Joystick_data & slot_bit) {
		out |= 1;
	}
	joystick_set_latch(false);

	for (int i = 1; i < bits; ++i) {
		joystick_set_clock(false);
		joystick_set_clock(true);
		if (Joystick_data & slot_bit) {
			out |= (uint16_t)(1u << i);
		}
	}

	return out;
}

static void
reset_joysticks(void)
{
	for (int i = 0; i < NUM_JOYSTICKS; ++i) {
		joystick_clear_virtual(i);
		Joystick_slots_enabled[i] = false;
	}
}

static void
test_virtual_button_reaches_the_data_line(void)
{
	reset_joysticks();

	// Active low: clearing a bit presses the button.
	joystick_set_virtual(0, (uint16_t)~JOY_BIT_A);
	check_eq(read_slot(0, 16), (uint16_t)(~JOY_BIT_A | 0xF000), "a pressed A clocks out on port 1");

	joystick_set_virtual(0, (uint16_t)~(JOY_BIT_DPAD_LEFT | JOY_BIT_B));
	check_eq(read_slot(0, 16), (uint16_t)(~(JOY_BIT_DPAD_LEFT | JOY_BIT_B) | 0xF000),
	         "two buttons held at once both clock out");
}

static void
test_upper_nibble_is_forced_high(void)
{
	reset_joysticks();

	// Every defined button pressed. Bits 12-15 have no button behind them and
	// the latch forces them high, so the port cannot report them as pressed.
	joystick_set_virtual(1, 0x0000);
	check_eq(read_slot(1, 16), 0xF000, "bits 12-15 read high even with every button held");
}

static void
test_each_port_is_independent(void)
{
	reset_joysticks();

	joystick_set_virtual(0, (uint16_t)~JOY_BIT_A);
	joystick_set_virtual(1, (uint16_t)~JOY_BIT_B);
	joystick_set_virtual(2, (uint16_t)~JOY_BIT_START);
	joystick_set_virtual(3, (uint16_t)~JOY_BIT_DPAD_UP);

	check_eq(read_slot(0, 16), (uint16_t)(~JOY_BIT_A | 0xF000), "port 1 reports only its own buttons");
	check_eq(read_slot(1, 16), (uint16_t)(~JOY_BIT_B | 0xF000), "port 2 reports only its own buttons");
	check_eq(read_slot(2, 16), (uint16_t)(~JOY_BIT_START | 0xF000), "port 3 reports only its own buttons");
	check_eq(read_slot(3, 16), (uint16_t)(~JOY_BIT_DPAD_UP | 0xF000), "port 4 reports only its own buttons");
}

static void
test_a_port_with_no_source_reads_released(void)
{
	reset_joysticks();

	// The compatibility guard, and the reason presence detection works at all.
	// A port nothing drives must keep reporting 1s past the sixteenth clock,
	// because that is how the KERNAL tells an empty port from an occupied one:
	// a real controller's shift register runs out and reads 0, while a floating
	// port stays high. Let this fall through to the shift register and every
	// port would report a controller plugged into it.
	check_eq(read_slot(0, 16), 0xFFFF, "an undriven port reads as nothing pressed");

	Joystick_data = 0;
	joystick_set_latch(true);
	joystick_set_latch(false);
	for (int i = 0; i < 40; ++i) {
		joystick_set_clock(false);
		joystick_set_clock(true);
		if (!(Joystick_data & 0x80)) {
			check(false, "an undriven port stays high past the sixteenth clock");
			return;
		}
	}
	check(true, "an undriven port stays high past the sixteenth clock");
}

static void
test_a_driven_port_runs_out(void)
{
	reset_joysticks();

	// The other half of that contract: a port something *is* driving has a
	// sixteen-bit shift register and nothing behind it, so the seventeenth
	// clock onwards reads 0. That difference is the presence signal, so a
	// virtual joystick has to reproduce it or nothing that checks whether a
	// controller is plugged in would see one.
	joystick_set_virtual(0, 0xFFFF);

	Joystick_data = 0;
	joystick_set_latch(true);
	joystick_set_latch(false);
	for (int i = 1; i < 16; ++i) {
		joystick_set_clock(false);
		joystick_set_clock(true);
	}

	joystick_set_clock(false);
	joystick_set_clock(true);
	check(!(Joystick_data & 0x80), "a driven port reads 0 once its sixteen bits run out");
}

static void
test_releasing_hands_the_port_back(void)
{
	reset_joysticks();

	joystick_set_virtual(2, (uint16_t)~JOY_BIT_Y);
	check_eq(read_slot(2, 16), (uint16_t)(~JOY_BIT_Y | 0xF000), "the held button reads back");

	joystick_clear_virtual(2);
	check(!joystick_virtual_active(2), "clearing deactivates the virtual joystick");
	check_eq(read_slot(2, 16), 0xFFFF, "a released port reads as nothing pressed again");
}

static void
test_holding_persists_across_reads(void)
{
	reset_joysticks();

	// A held direction has to survive being read every frame, or nothing that
	// polls the port more than once could be driven at all.
	joystick_set_virtual(0, (uint16_t)~JOY_BIT_DPAD_RIGHT);
	for (int frame = 0; frame < 3; ++frame) {
		check_eq(read_slot(0, 16), (uint16_t)(~JOY_BIT_DPAD_RIGHT | 0xF000),
		         "a held direction survives repeated reads");
	}
}

static void
test_driving_a_port_enables_it(void)
{
	reset_joysticks();

	check(!Joystick_slots_enabled[3], "the port starts disabled");
	joystick_set_virtual(3, (uint16_t)~JOY_BIT_SELECT);
	check(Joystick_slots_enabled[3], "driving a port enables it, so no -joy4 flag is needed");

	// Releasing leaves the port enabled: that bit is the user's configuration,
	// and a physical pad may bind to it now the virtual one has let go.
	joystick_clear_virtual(3);
	check(Joystick_slots_enabled[3], "releasing leaves the port enabled");
}

static void
test_debug_snapshot_reports_the_virtual_state(void)
{
	reset_joysticks();
	joystick_set_virtual(1, (uint16_t)~JOY_BIT_X);

	joystick_debug_state_t js;
	memset(&js, 0, sizeof(js));
	joystick_debug_get_state(&js);

	check(js.slots[1].virtual_active, "the snapshot reports the virtual joystick");
	check(!js.slots[1].controller_bound, "no controller is bound to a virtual port");
	check_eq(js.slots[1].button_mask, (uint16_t)~JOY_BIT_X, "the snapshot reports the held buttons");
	check(!js.slots[0].virtual_active, "an undriven port is not reported as virtual");
	check_eq(js.slots[0].button_mask, 0xFFFF, "an undriven port reports nothing pressed");
	check_eq(js.slots[0].shift_mask, 0xFFFF, "an undriven port reports the 1s it actually clocks out");
}

static void
test_an_out_of_range_port_is_ignored(void)
{
	reset_joysticks();

	joystick_set_virtual(-1, 0x0000);
	joystick_set_virtual(NUM_JOYSTICKS, 0x0000);
	joystick_clear_virtual(-1);
	joystick_clear_virtual(NUM_JOYSTICKS);

	check(!joystick_virtual_active(-1), "a negative port is not active");
	check(!joystick_virtual_active(NUM_JOYSTICKS), "a port past the last is not active");
	check_eq(read_slot(0, 16), 0xFFFF, "an out-of-range write does not spill onto a real port");
}

int
main(void)
{
	test_virtual_button_reaches_the_data_line();
	test_upper_nibble_is_forced_high();
	test_each_port_is_independent();
	test_a_port_with_no_source_reads_released();
	test_a_driven_port_runs_out();
	test_releasing_hands_the_port_back();
	test_holding_persists_across_reads();
	test_driving_a_port_enables_it();
	test_debug_snapshot_reports_the_virtual_state();
	test_an_out_of_range_port_is_ignored();

	return x16_test_summary("joystick");
}