// CPU conformance: ADC and SBC in binary mode, and the flags they produce.
//
// Oracle: WDC W65C02S datasheet.
//
// The overflow flag is the interesting part and the one most often got wrong.
// V is about signed arithmetic: it is set when two operands of the same sign
// produce a result of the other sign, which is the only case where the signed
// answer cannot fit in eight bits. Carry, by contrast, is the unsigned answer
// not fitting. The two are independent, so each combination is checked.
//
// Decimal mode is deliberately absent; it has its own scenarios.

#include "support/cpu_fixture.h"
#include "support/harness.h"

#define PROG 0x0200

// CLC ; LDA #a ; ADC #b   (or SEC ; ... for carry in)
static void
add(uint8_t a, uint8_t b, bool carry_in)
{
	const uint8_t prog[] = { (uint8_t)(carry_in ? 0x38 : 0x18), 0xA9, a, 0x69, b };
	cpu_reset_to(CPU_65C02, PROG);
	cpu_load(PROG, prog, sizeof prog);
	cpu_steps(3);
}

// SEC ; LDA #a ; SBC #b   (carry set means "no borrow")
static void
sub(uint8_t a, uint8_t b, bool carry_in)
{
	const uint8_t prog[] = { (uint8_t)(carry_in ? 0x38 : 0x18), 0xA9, a, 0xE9, b };
	cpu_reset_to(CPU_65C02, PROG);
	cpu_load(PROG, prog, sizeof prog);
	cpu_steps(3);
}

static bool c(void) { return (regs.status & FLAG_CARRY) != 0; }
static bool v(void) { return (regs.status & FLAG_OVERFLOW) != 0; }
static bool z(void) { return (regs.status & FLAG_ZERO) != 0; }
static bool n(void) { return (regs.status & FLAG_SIGN) != 0; }

// ---- Addition --------------------------------------------------------------

static void
test_add_basic(void)
{
	add(0x01, 0x01, false);
	check_eq(regs.a, 0x02, "1 + 1 = 2");
	check(!c(), "1 + 1 does not carry");
	check(!v(), "1 + 1 does not overflow");

	add(0x01, 0x01, true);
	check_eq(regs.a, 0x03, "carry in is added");

	add(0xFF, 0x01, false);
	check_eq(regs.a, 0x00, "$FF + 1 wraps to zero");
	check(c(), "$FF + 1 carries");
	check(z(), "the wrapped result sets Z");

	add(0x7F, 0x01, false);
	check_eq(regs.a, 0x80, "$7F + 1 = $80");
	check(n(), "a result with bit 7 set is negative");
}

static void
test_add_overflow(void)
{
	// Same-signed operands crossing into the other sign: V set.
	add(0x50, 0x50, false); // 80 + 80 = 160, too big for a signed byte
	check_eq(regs.a, 0xA0, "$50 + $50 = $A0");
	check(v(), "positive + positive giving a negative sets V");
	check(!c(), "and it does not carry");

	add(0x90, 0x90, false); // -112 + -112 = -224, too small
	check_eq(regs.a, 0x20, "$90 + $90 = $20");
	check(v(), "negative + negative giving a positive sets V");
	check(c(), "and it does carry");

	// Opposite signs can never overflow: the result always fits.
	add(0x50, 0x90, false);
	check(!v(), "positive + negative never sets V");
	check(!c(), "$50 + $90 does not carry");

	add(0xD0, 0x50, false); // -48 + 80 = 32, fits
	check(!v(), "negative + positive never sets V");
	check(c(), "$D0 + $50 carries");
}

// ---- Subtraction -----------------------------------------------------------
// SBC subtracts the carry's complement, so carry set means "no borrow" and is
// the normal way to start a subtraction.

static void
test_sub_basic(void)
{
	sub(0x05, 0x03, true);
	check_eq(regs.a, 0x02, "5 - 3 = 2");
	check(c(), "a subtraction that does not borrow leaves C set");
	check(!v(), "5 - 3 does not overflow");

	sub(0x05, 0x05, true);
	check_eq(regs.a, 0x00, "5 - 5 = 0");
	check(z(), "an exactly zero result sets Z");
	check(c(), "and still does not borrow");

	sub(0x03, 0x05, true);
	check_eq(regs.a, 0xFE, "3 - 5 wraps to $FE");
	check(!c(), "a subtraction that borrows clears C");
	check(n(), "the wrapped result is negative");

	// Carry clear on entry costs an extra one: 5 - 3 - 1.
	sub(0x05, 0x03, false);
	check_eq(regs.a, 0x01, "a clear carry subtracts one more");
}

static void
test_sub_overflow(void)
{
	// Overflow in subtraction needs operands of opposite sign.
	sub(0x50, 0xB0, true); // 80 - (-80) = 160, too big
	check_eq(regs.a, 0xA0, "$50 - $B0 = $A0");
	check(v(), "positive - negative giving a negative sets V");

	sub(0xD0, 0x70, true); // -48 - 112 = -160, too small
	check_eq(regs.a, 0x60, "$D0 - $70 = $60");
	check(v(), "negative - positive giving a positive sets V");

	sub(0x50, 0x30, true);
	check(!v(), "same-signed operands do not overflow");
}

// ---- Timing ----------------------------------------------------------------

static void
test_timing(void)
{
	const uint8_t prog[] = { 0x18, 0xA9, 0x10, 0x69, 0x20 }; // CLC ; LDA # ; ADC #
	cpu_reset_to(CPU_65C02, PROG);
	cpu_load(PROG, prog, sizeof prog);
	cpu_steps(2);
	check_eq(cpu_step(), 2, "ADC immediate costs 2 cycles");

	// CLC ; LDA #$10 ; ADC $30
	const uint8_t zp[] = { 0x18, 0xA9, 0x10, 0x65, 0x30 };
	cpu_reset_to(CPU_65C02, PROG);
	cpu_load(PROG, zp, sizeof zp);
	cpu_mem[0x0030] = 0x05;
	cpu_steps(2);
	check_eq(cpu_step(), 3, "ADC zero page costs 3 cycles");
	check_eq(regs.a, 0x15, "ADC zero page adds the addressed byte");
}

int
main(void)
{
	test_add_basic();
	test_add_overflow();
	test_sub_basic();
	test_sub_overflow();
	test_timing();
	return x16_test_summary("cpu_adc_sbc");
}