#include "fake_devices.h"

#include <stddef.h>

#include <string.h>

#include "glue.h"

#include "cartridge.h"

#include "wav_recorder.h"

#include "memory.h"

extern uint32_t clockticks6502;

fake_dev_log_t fake_dev[FAKE_DEV_COUNT];

const char *

fake_dev_name(fake_dev_t dev)

{

	switch (dev) {

		case FAKE_VIA1: return "VIA1";

		case FAKE_VIA2: return "VIA2";

		case FAKE_VERA: return "VERA";

		case FAKE_YM:   return "YM";

		case FAKE_MIDI: return "MIDI";

		case FAKE_CART: return "cartridge";

		default:        return "?";

	}

}

static uint8_t

note_read(fake_dev_t dev, uint8_t reg, bool debug)

{

	fake_dev_log_t *d = &fake_dev[dev];

	d->reads++;

	d->last_reg = reg;

	if (debug) {

		d->debug_reads++;

	} else {

		// What a debug read is not allowed to cause.

		d->state++;

	}

	return (uint8_t)(0xD0 | (reg & 0x0F));

}

static void

note_write(fake_dev_t dev, uint8_t reg, uint8_t value)

{

	fake_dev_log_t *d = &fake_dev[dev];

	d->writes++;

	d->last_reg = reg;

	d->last_value = value;

	d->state++;

}

void

fake_devices_reset(void)

{

	// memory.c allocates RAM and BRAM lazily, so the first reset has to bring

	// the memory system up before anything reads through it.

	static bool memory_ready = false;

	if (!memory_ready) {

		memory_init();

		memory_ready = true;

	}

	memset(fake_dev, 0, sizeof fake_dev);

	clockticks6502 = 0;

}

uint32_t

fake_devices_state_sum(void)

{

	uint32_t sum = 0;

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

		sum += fake_dev[i].state;

	}

	return sum;

}

int

fake_devices_total_reads(void)

{

	int n = 0;

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

		n += fake_dev[i].reads;

	}

	return n;

}

int

fake_devices_total_writes(void)

{

	int n = 0;

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

		n += fake_dev[i].writes;

	}

	return n;

}

// ---- The devices memory.c routes to --------------------------------------

uint8_t via1_read(uint8_t reg, bool debug)  { return note_read(FAKE_VIA1, reg, debug); }

uint8_t via2_read(uint8_t reg, bool debug)  { return note_read(FAKE_VIA2, reg, debug); }

uint8_t video_read(uint8_t reg, bool debug) { return note_read(FAKE_VERA, reg, debug); }

uint8_t midi_serial_read(uint8_t reg, bool debug) { return note_read(FAKE_MIDI, reg, debug); }

void via1_write(uint8_t reg, uint8_t value)  { note_write(FAKE_VIA1, reg, value); }

void via2_write(uint8_t reg, uint8_t value)  { note_write(FAKE_VIA2, reg, value); }

void video_write(uint8_t reg, uint8_t value) { note_write(FAKE_VERA, reg, value); }

void midi_serial_write(uint8_t reg, uint8_t value) { note_write(FAKE_MIDI, reg, value); }

void YM_write_reg(uint8_t reg, uint8_t value) { note_write(FAKE_YM, reg, value); }

// memory.c brackets its VERA writes with this so the bandwidth accounting can

// tell a debugger's poke from a store the guest made. There is no accounting

// here to tell, and the flag is not part of what these tests assert about, so

// it is swallowed rather than recorded -- noting it would put an extra event in

// every trace the write tests compare against.

void video_set_debug_write(bool debug) { (void)debug; }

// YM_read_status() has no debug parameter, so this cannot behave differently

// for a debug read. Recorded as a real read, which is the honest reading of a

// signature that carries no way to say otherwise.

uint8_t

YM_read_status(void)

{

	return note_read(FAKE_YM, 0, false);

}

uint8_t

cartridge_read(uint16_t address, uint8_t bank)

{

	(void)bank;

	return note_read(FAKE_CART, (uint8_t)(address & 0x0F), false);

}

void

cartridge_write(uint16_t address, uint8_t bank, uint8_t value)

{

	(void)bank;

	note_write(FAKE_CART, (uint8_t)(address & 0x0F), value);

}

// ---- Everything else memory.c reaches for --------------------------------

// Inert on purpose: none of it is what these tests are about, and a stub that

// does nothing cannot quietly become part of the result.

void audio_render(void) {}

void print_iso8859_15_char(char c) { (void)c; }

void dbg_load_note_debugger(bool on) { (void)on; }

uint8_t wav_recorder_get_state(void) { return 0; }

void wav_recorder_set(wav_recorder_command_t command) { (void)command; }

// Counted rather than ignored: whether a watchpoint reported a break is the one

// thing a watchpoint is allowed to change.

int fake_break_count = 0;

void DEBUGBreakOnWatchpoint(void) { fake_break_count++; }

// The CPU core signals a halt (STP) through this. memory.c already provides

// vp6502(), the vector-pull callback.

void stop6502(uint16_t address, uint8_t bank) { (void)address; (void)bank; }

// SDL is reachable from memory.c only through memory_save() and the usage-count

// dump, neither of which these tests call. Defining them here keeps the test

// free of an SDL runtime.

size_t SDL_RWwrite(SDL_RWops *c, const void *p, size_t s, size_t n)

{

	(void)c; (void)p; (void)s;

	return n;

}

SDL_RWops *SDL_RWFromFile(const char *f, const char *m) { (void)f; (void)m; return NULL; }

int SDL_RWclose(SDL_RWops *c) { (void)c; return 0; }

// ---- Machine configuration -----------------------------------------------

// A Gen1 machine with both VIAs and no MIDI card, which is what the X16 is.

//

// Every one of these is initialised deliberately. An uninitialised global is a

// tentative definition, which some linkers quietly merge with a real one

// elsewhere and others reject; initialising them means a clash with a linked

// module is a hard error everywhere rather than only on GCC.

uint8_t *CART = NULL;

uint8_t  keymap = 0;

bool     is_gen2 = false;

bool     has_via2 = true;

bool     has_midi_card = false;

uint16_t midi_card_addr = 0x9f60;

uint16_t num_banks = 1;

uint16_t num_ram_banks = 64;

// opcode_addr belongs to the CPU core, which is linked here for real.

bool debugger_enabled = false;

bool imgui_debugger_enabled = false;

bool disable_emu_cmd_keys = false;

bool log_keyboard = false;

bool log_video = false;

bool save_on_exit = false;

echo_mode_t echo_mode = ECHO_MODE_NONE;

gif_recorder_state_t record_gif = RECORD_GIF_PAUSE;