/*

TODO:

- Run more measurements on real MSX to find out how horizontal

  scanning interrupt really works.

  Finish model and implement it.

  Especially test this scenario:

  * IE1 enabled, interrupt occurs

  * wait until matching line is passed

  * disable IE1

  * read FH

  * read FH

  Current implementation would return FH=0 both times.

- Check how Z80 should treat interrupts occurring during DI.

- Bottom erase suspends display even on overscan.

  However, it shows black, not border color.

  How to handle this? Currently it is treated as "overscan" which

  falls outside of the rendered screen area.

*/

#include "VDP.hh"

#include "Display.hh"

#include "RenderSettings.hh"

#include "Renderer.hh"

#include "RendererFactory.hh"

#include "SpriteChecker.hh"

#include "VDPCmdEngine.hh"

#include "VDPVRAM.hh"

#include "EnumSetting.hh"

#include "HardwareConfig.hh"

#include "MSXCPU.hh"

#include "MSXException.hh"

#include "MSXMotherBoard.hh"

#include "Reactor.hh"

#include "TclObject.hh"

#include "serialize_core.hh"

#include "narrow.hh"

#include "one_of.hh"

#include "unreachable.hh"

#include <algorithm>

#include <cassert>

#include <memory>

namespace openmsx {

static uint8_t getDelayCycles(const XMLElement& devices)

{

	if (devices.findChild("T9769")) {

		// See https://github.com/openMSX/openMSX/issues/989:

		// All tested T9769 variants seem to introduce only 1 extra

		// cycle. It is currently unknown what the observable

		// differences are between the subtypes.

		return 1;

	} else if (devices.findChild("S1990")) {

		// this case is purely there for backwards compatibility for

		// turboR configs which do not have the T9769 tag yet.

		return 1;

	}

	return 0;

}

/** The delay between openMSX's port-#98 access timestamp -- the start of T2 of

  * the Z80's I/O machine cycle -- and the moment the V9938 registers the CPU's

  * VRAM request. Measured to 28.9 +- 0.2 cycles, so it could also be 28. */

static constexpr int CPU_REQUEST_DELAY = 29;

/** How far after openMSX's port-#98 read timestamp a pending VRAM read may

  * still have its access slot and be seen by that IN. The Z80 samples the data

  * bus 2.5 T-states after the start of T2 (T2, the I/O wait state, and half of

  * T3): 15 cycles. The V9938 has the byte out of the DRAM about 6 cycles into

  * the access (RAS, CAS, then two cycles to data). The difference is an

  * estimate, not a measurement; the case that matters -- the BIOS's INIR scroll

  * in TEXT2, 138 cycles per byte, where the slot table has gaps of up to 100

  * cycles -- needs 6. */

static constexpr int CPU_READ_SAMPLE_DELAY = 9;

/** A CPU VRAM request that would have been granted a 'tight' slot costs the

  * command engine that slot anyway, to a dummy read, if it arrives this many

  * cycles before it. */

/** The access grid switches to the display tables 162 cycles into the line

  * before the display area, which is 1368 + (202 - 162) cycles before

  * 'displayStartSyncTime', and back 162 cycles into the line after it, which is

  * (202 - 162) cycles before 'vScanSyncTime'. (Both those sync points are at

  * cycle 202 of their line, where VR flips.) */

static constexpr int SLOT_TABLE_START_LEAD = VDP::TICKS_PER_LINE + 202 - 162;

static constexpr int SLOT_TABLE_END_LEAD = 202 - 162;

static constexpr int DUMMY_WINDOW_LO = 18;

static constexpr int DUMMY_WINDOW_HI = 22;

VDP::VDP(const DeviceConfig& config)

	: MSXDevice(config)

	, syncVSync(*this)

	, syncLineCountReset(*this)

	, syncDisplayStart(*this)

	, syncSlotTableStart(*this)

	, syncSlotTableEnd(*this)

	, syncVScan(*this)

	, syncHScan(*this)

	, syncHorAdjust(*this)

	, syncSetMode(*this)

	, syncSetBlank(*this)

	, syncSetSprites(*this)

	, syncCpuVramAccess(*this)

	, syncCpuVramDummy(*this)

	, syncCmdDone(*this)

	, display(getReactor().getDisplay())

	, cmdTiming    (display.getRenderSettings().getCmdTimingSetting())

	, tooFastAccess(display.getRenderSettings().getTooFastAccessSetting())

	, vdpRegDebug      (*this)

	, vdpStatusRegDebug(*this)

	, vdpPaletteDebug  (*this)

	, vramPointerDebug (*this)

	, registerLatchStatusDebug(*this)

	, vramAccessStatusDebug(*this)

	, paletteLatchStatusDebug(*this)

	, dataLatchDebug   (*this)

	, frameCountInfo   (*this)

	, cycleInFrameInfo (*this)

	, lineInFrameInfo  (*this)

	, cycleInLineInfo  (*this)

	, msxYPosInfo      (*this)

	, msxX256PosInfo   (*this)

	, msxX512PosInfo   (*this)

	, frameStartTime(getCurrentTime())

	, irqVertical  (getMotherBoard(), getName() + ".IRQvertical",   config)

	, irqHorizontal(getMotherBoard(), getName() + ".IRQhorizontal", config)

	, lineCountResetSyncTime(getCurrentTime())

	, displayStartSyncTime(getCurrentTime())

	, slotTableStartSyncTime(getCurrentTime())

	, slotTableEndSyncTime(getCurrentTime())

	, vScanSyncTime(getCurrentTime())

	, hScanSyncTime(getCurrentTime())

	, tooFastCallback(

		getCommandController(),

		getName() + ".too_fast_vram_access_callback",

		"Tcl proc called when the VRAM is read or written too fast",

		"",

		Setting::Save::YES)

	, dotClockDirectionCallback(

		getCommandController(),

		getName() + ".dot_clock_direction_callback",

		"Tcl proc called when DLCLK is set as input",

		"default_dot_clock_direction_callback",

		Setting::Save::YES)

	, cpu(getCPU()) // used frequently, so cache it

	, fixedVDPIOdelayCycles(getDelayCycles(getMotherBoard().getMachineConfig()->getConfig().getChild("devices")))

{

	// Current general defaults for saturation:

	// - Any MSX with a TMS9x18 VDP: SatPr=SatPb=100%

	// - Other machines with a TMS9x2x VDP and RGB output:

	//   SatPr=SatPr=100%, until someone reports a better value

	// - Other machines with a TMS9x2x VDP and CVBS only output:

	//   SatPr=SatPb=54%, until someone reports a better value

	// At this point we don't know anything about the connector here, so

	// only the first point can be implemented. The default default is

	// still 54, which is very similar to the old palette implementation

	int defaultSaturation = 54;

	const auto& versionString = config.getChildData("version");

	if (versionString == "TMS99X8A") version = TMS99X8A;

	else if (versionString == "TMS9918A") {

		version = TMS99X8A;

		defaultSaturation = 100;

	} else if (versionString == "TMS9928A") version = TMS99X8A;

	else if (versionString == "T6950PAL") version = T6950PAL;

	else if (versionString == "T6950NTSC") version = T6950NTSC;

	else if (versionString == "T7937APAL") version = T7937APAL;

	else if (versionString == "T7937ANTSC") version = T7937ANTSC;

	else if (versionString == "TMS91X8") version = TMS91X8;

	else if (versionString == "TMS9118") {

		version = TMS91X8;

		defaultSaturation = 100;

	} else if (versionString == "TMS9128") version = TMS91X8;

	else if (versionString == "TMS9929A") version = TMS9929A;

	else if (versionString == "TMS9129") version = TMS9129;

	else if (versionString == "V9938") version = V9938;

	else if (versionString == "V9958") version = V9958;

	else if (versionString == "YM2220PAL") version = YM2220PAL;

	else if (versionString == "YM2220NTSC") version = YM2220NTSC;

	else throw MSXException("Unknown VDP version \"", versionString, '"');

	// saturation parameters only make sense when using TMS VDPs

	if (!versionString.starts_with("TMS") &&

	    (config.findChild("saturationPr") || config.findChild("saturationPb") || config.findChild("saturation"))) {

		throw MSXException("Specifying saturation parameters only makes sense for TMS VDPs");

	}

	auto getPercentage = [&](std::string_view name, std::string_view extra, int defaultValue) {

		int result = config.getChildDataAsInt(name, defaultValue);

		if ((result < 0) || (result > 100)) {

			throw MSXException(

				"Saturation percentage ", extra, "is not in range 0..100: ", result);

		}

		return result;

	};

	int saturation = getPercentage("saturation", "", defaultSaturation);

	saturationPr   = getPercentage("saturationPr", "for Pr component ", saturation);

	saturationPb   = getPercentage("saturationPb", "for Pb component ", saturation);

	// Set up control register availability.

	static constexpr std::array<uint8_t, 32> VALUE_MASKS_MSX1 = {

		0x03, 0xFB, 0x0F, 0xFF, 0x07, 0x7F, 0x07, 0xFF  // 00..07

	};

	static constexpr std::array<uint8_t, 32> VALUE_MASKS_MSX2 = {

		0x7E, 0x7F, 0x7F, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, // 00..07

		0xFB, 0xBF, 0x07, 0x03, 0xFF, 0xFF, 0x07, 0x0F, // 08..15

		0x0F, 0xBF, 0xFF, 0xFF, 0x3F, 0x3F, 0x3F, 0xFF, // 16..23

		0,    0,    0,    0,    0,    0,    0,    0,    // 24..31

	};

	controlRegMask = isMSX1VDP() ? 0x07 : 0x3F;

	controlValueMasks = isMSX1VDP() ? VALUE_MASKS_MSX1 : VALUE_MASKS_MSX2;

	if (version == V9958) {

		// Enable V9958-specific control registers.

		controlValueMasks[25] = 0x7F;

		controlValueMasks[26] = 0x3F;

		controlValueMasks[27] = 0x07;

	}

	resetInit(); // must be done early to avoid UMRs

	// Video RAM.

	EmuTime time = getCurrentTime();

	unsigned vramSize =

		(isMSX1VDP() ? 16 : config.getChildDataAsInt("vram", 0));

	if (vramSize != one_of(16u, 64u, 128u, 192u)) {

		throw MSXException(

			"VRAM size of ", vramSize, "kB is not supported!");

	}

	vram = std::make_unique<VDPVRAM>(*this, vramSize * 1024, time);

	// Create sprite checker.

	auto& renderSettings = display.getRenderSettings();

	spriteChecker = std::make_unique<SpriteChecker>(*this, renderSettings, time);

	vram->setSpriteChecker(spriteChecker.get());

	// Create command engine.

	cmdEngine = std::make_unique<VDPCmdEngine>(*this, getCommandController());

	vram->setCmdEngine(cmdEngine.get());

	// Initialise renderer.

	createRenderer();

	// Reset state.

	powerUp(time);

	display      .attach(*this);

	cmdTiming    .attach(*this);

	tooFastAccess.attach(*this);

	update(tooFastAccess); // handles both cmdTiming and tooFastAccess

}

VDP::~VDP()

{

	tooFastAccess.detach(*this);

	cmdTiming    .detach(*this);

	display      .detach(*this);

}

void VDP::preVideoSystemChange() noexcept

{

	renderer.reset();

}

void VDP::postVideoSystemChange() noexcept

{

	createRenderer();

}

void VDP::createRenderer()

{

	renderer = RendererFactory::createRenderer(*this, display);

	// TODO: Is it safe to use frameStartTime,

	//       which is most likely in the past?

	//renderer->reset(frameStartTime.getTime());

	vram->setRenderer(renderer.get(), frameStartTime.getTime());

}

PostProcessor* VDP::getPostProcessor() const

{

	return renderer->getPostProcessor();

}

void VDP::resetInit()

{

	// note: vram, spriteChecker, cmdEngine, renderer may not yet be

	//       created at this point

	std::ranges::fill(controlRegs, 0);

	if (isVDPwithPALonly()) {

		// Boots (and remains) in PAL mode, all other VDPs boot in NTSC.

		controlRegs[9] |= 0x02;

	}

	// According to page 6 of the V9938 data book the color burst registers

	// are loaded with these values at power on.

	controlRegs[21] = 0x3B;

	controlRegs[22] = 0x05;

	// Note: frameStart is the actual place palTiming is written, but it

	//       can be read before frameStart is called.

	//       TODO: Clean up initialisation sequence.

	palTiming = true; // controlRegs[9] & 0x02;

	displayMode.reset();

	vramPointer = 0;

	cpuVramData = 0;

	cpuVramReqIsRead = false; // avoid UMR

	cpuVramReqData = 0;

	dataLatch = 0;

	cpuExtendedVram = false;

	registerDataStored = false;

	writeAccess = false;

	paletteDataStored = false;

	blinkState = false;

	blinkCount = 0;

	horizontalAdjust = 7;

	// Placeholders until the first display line counter reset latches the

	// real values, see execLineCountReset().

	displayStart = (8 + getVerticalAdjust()

	                + ((controlRegs[9] & 0x02) ? 54 : 27)) * TICKS_PER_LINE

	             + 100 + 102;

	horizontalScanOffset = -1000 * TICKS_PER_LINE; // "never"

	// TODO: Real VDP probably resets timing as well.

	isDisplayArea = false;

	isSlotTableDisplayArea = false;

	displayEnabled = false;

	spriteEnabled = true;

	superimposing = nullptr;

	externalVideo = nullptr;

	// Init status registers.

	statusReg0 = 0x00;

	statusReg1 = (version == V9958 ? 0x04 : 0x00);

	statusReg2 = 0x0C;

	// Update IRQ to reflect new register values.

	irqVertical.reset();

	irqHorizontal.reset();

	// From appendix 8 of the V9938 data book (page 148).

	const std::array<uint16_t, 16> V9938_PALETTE = {

		0x000, 0x000, 0x611, 0x733, 0x117, 0x327, 0x151, 0x627,

		0x171, 0x373, 0x661, 0x664, 0x411, 0x265, 0x555, 0x777

	};

	// Init the palette.

	palette = V9938_PALETTE;

}

void VDP::resetMasks(EmuTime time)

{

	updateNameBase(time);

	updateColorBase(time);

	updatePatternBase(time);

	updateSpriteAttributeBase(time);

	updateSpritePatternBase(time);

	// TODO: It is not clear to me yet how bitmapWindow should be used.

	//       Currently it always spans 128K of VRAM.

	//vram->bitmapWindow.setMask(~(~0u << 17), ~0u << 17, time);

}

void VDP::powerUp(EmuTime time)

{

	vram->clear();

	reset(time);

}

void VDP::reset(EmuTime time)

{

	syncVSync        .removeSyncPoint();

	syncLineCountReset.removeSyncPoint();

	syncDisplayStart .removeSyncPoint();

	syncSlotTableStart.removeSyncPoint();

	syncSlotTableEnd .removeSyncPoint();

	syncVScan        .removeSyncPoint();

	syncHScan        .removeSyncPoint();

	syncHorAdjust    .removeSyncPoint();

	syncSetMode      .removeSyncPoint();

	syncSetBlank     .removeSyncPoint();

	syncSetSprites   .removeSyncPoint();

	syncCpuVramAccess.removeSyncPoint();

	syncCpuVramDummy .removeSyncPoint();

	syncCmdDone      .removeSyncPoint();

	pendingCpuAccess = false;

	previousCpuSlot = EmuTime::zero();

	previousCpuSlotIsLate = false;

	secondCpuSlot = EmuTime::infinity();

	// Reset subsystems.

	cmdEngine->sync(time);

	resetInit();

	spriteChecker->reset(time);

	cmdEngine->reset(time);

	renderer->reInit();

	// Tell the subsystems of the new mask values.

	resetMasks(time);

	// Init scheduling.

	frameCount = -1;

	frameStartTime.reset(time); // no previous frame to carry over from

	frameStart(time);

	assert(frameCount == 0);

}

void VDP::execVSync(EmuTime time)

{

	// This frame is finished.

	// Inform VDP subcomponents.

	// TODO: Do this via VDPVRAM?

	renderer->frameEnd(time);

	spriteChecker->frameEnd(time);

	if (isFastBlinkEnabled()) {

		// adjust blinkState and blinkCount for next frame

		auto next = calculateLineBlinkState(getLinesPerFrame());

		blinkState = next.state;

		blinkCount = next.count;

	}

	// Finish the previous frame, because access-slot calculations work within a frame.

	cmdEngine->sync(time);

	// Start next frame.

	frameStart(time);

}

void VDP::setSlotTableDisplayArea(bool enabled, EmuTime time)

{

	if (isSlotTableDisplayArea == enabled) return;

	// A command must not use the new grid for the accesses it still owes on

	// the old one.

	if (displayEnabled) cmdEngine->sync(time);

	isSlotTableDisplayArea = enabled;

}

void VDP::execDisplayStart(EmuTime time)

{

	// The access grid normally switched over a line ago. It can still be off

	// if the display start moved inside that line, because then the sync

	// point that switches it was rescheduled into the past.

	setSlotTableDisplayArea(true, time);

	// Display area starts here, unless we're doing overscan and it

	// was already active.

	if (!isDisplayArea) {

		if (displayEnabled) {

			vram->updateDisplayEnabled(true, time);

		}

		isDisplayArea = true;

	}

}

void VDP::execSlotTableStart(EmuTime time)

{

	// The VDP starts fetching the sprite data of the first display line here,

	// and the access grid follows the fetching rather than the display.

	setSlotTableDisplayArea(true, time);

}

void VDP::execSlotTableEnd(EmuTime time)

{

	setSlotTableDisplayArea(false, time);

}

void VDP::execVScan(EmuTime time)

{

	// Same the other way round: the grid normally switched back 40 cycles

	// ago. (In overscan this is not reached at all, and the grid correctly

	// stays on across the frame boundary.)

	setSlotTableDisplayArea(false, time);

	// VSCAN is the end of display.

	// This will generate a VBLANK IRQ. Typically MSX software will

	// poll the keyboard/joystick on this IRQ. So now is a good

	// time to also poll for host events.

	getReactor().enterMainLoop();

	if (isDisplayEnabled()) {

		vram->updateDisplayEnabled(false, time);

	}

	isDisplayArea = false;

	// Vertical scanning occurs.

	statusReg0 |= 0x80;

	if (controlRegs[1] & 0x20) {

		irqVertical.set();

	}

}

void VDP::execHScan()

{

	// Horizontal scanning occurs.

	if (controlRegs[0] & 0x10) {

		irqHorizontal.set();

	}

}

void VDP::execHorAdjust(EmuTime time)

{

	int newHorAdjust = (controlRegs[18] & 0x0F) ^ 0x07;

	if (controlRegs[25] & 0x08) {

		newHorAdjust += 4;

	}

	renderer->updateHorizontalAdjust(newHorAdjust, time);

	horizontalAdjust = newHorAdjust;

}

int VDP::getScrollBurstTicks(EmuTime time) const

{

	// The new value is used from the first 8-pixel group that starts at

	// least LEAD ticks after the write (the burst for that group is fetched

	// ahead of the beam).

	static constexpr int LEAD = 16;

	static constexpr int GROUP = 8 * 4; // 8 pixels of 4 ticks

	if (!isDisplayEnabled() || !getDisplayMode().isBitmapMode()) return -1;

	int ticks = getTicksThisFrame(time);

	int lineStart = ticks - ticks % TICKS_PER_LINE;

	int x = ticks - lineStart - getLeftSprites(); // ticks into display

	if (x + LEAD <= 0) return -1;

	return lineStart + getLeftSprites() + (x + LEAD + GROUP - 1) / GROUP * GROUP;