#ifndef VDPACCESSSLOTS_HH

#define VDPACCESSSLOTS_HH

#include "VDP.hh"

#include "narrow.hh"

#include <cassert>

#include <cstdint>

#include <span>

#include <utility>

namespace openmsx::VDPAccessSlots {

inline constexpr int TICKS = VDP::TICKS_PER_LINE;

/** Minimum distance until the next VRAM access. */

enum class Delta : int {

	D0        =  0 * TICKS, // These 2 are internal helpers

	D1        =  1 * TICKS,

	CPU_16    =  2 * TICKS, // These 3 are for CPU access delays (V99x8)

	CPU_28    =  3 * TICKS, //                                   (TMS99x8)

	// Like CPU_16, but without skipping the slots the CPU cannot be served

	// in: the slot it would have been granted, which the VDP spends on a

	// dummy read when the two differ.

	CPU_16_ANY =  4 * TICKS,

	CMD_24    =  5 * TICKS, // The remaining ones are command engine delays

	CMD_32    =  6 * TICKS, //   counted in 'memory cycles' rather than 'VDP cycles'

	CMD_36    =  7 * TICKS, //   see the comment about 'pad' in

	CMD_46    =  8 * TICKS, //   VDPAccessSlots.cc

	CMD_60    =  9 * TICKS,

	CMD_72    = 10 * TICKS,

	CMD_84    = 11 * TICKS,

	CMD_88    = 12 * TICKS,

	CMD_36_68 = 13 * TICKS, // 36+68 = 104

	CMD_46_58 = 13 * TICKS, // 46+58 = 104 (notice: duplicate!)

	CMD_84_36 = 14 * TICKS, // 84+36 = 120

	CMD_60_68 = 15 * TICKS, // 60+68 = 128

	CMD_72_58 = 16 * TICKS, // 72+58 = 130

	// The delay between the write to R#46 that starts a command and the

	// command's first VRAM access. Measured from the rising edge of /CSW as

	// 45, 46, 58, 70, 82 and 94 cycles; the values below are those plus the

	// 18 cycles between openMSX's port-write timestamp and that edge. The

	// startup is a wait like any other, so it is counted in memory cycles

	// and it gets the sprite addend.

	CMD_START_63  = 17 * TICKS, // POINT

	CMD_START_64  = 18 * TICKS, // LMMM

	CMD_START_76  = 19 * TICKS, // LMCM

	CMD_START_88  = 12 * TICKS, // LMMV, LMMC, PSET, SRCH  (= CMD_88!)

	CMD_START_100 = 20 * TICKS, // HMMM, YMMM

	CMD_START_112 = 21 * TICKS, // HMMV, LINE, HMMC

};

static constexpr int NUM_DELTAS = 22;

/** The CPU access delays in the 'Delta' enum: CPU_16, CPU_28 and CPU_16_ANY. */

static constexpr int FIRST_CPU_DELTA = 2;

static constexpr int LAST_CPU_DELTA = 5; // exclusive

/** The one of those that does use the slots the CPU cannot be served in. */

static constexpr int CPU_ANY_DELTA = 4;

/** The command engine delays in the 'Delta' enum: the steps and the startup

  * delays. These get the sprite addend; they and the CPU delays above are all

  * subject to the memory-cycle counting. */

static constexpr int FIRST_CMD_DELTA = 5;

static constexpr int LAST_CMD_DELTA = NUM_DELTAS; // exclusive

/** VDP-VRAM access slot calculator, meant to be used in the inner loops of the

  * VDPCmdEngine commands. Code optimized for the case that:

  *  - timing remains constant (sprites/display enable/disable)

  *  - there are more calls to next() and limitReached() than to getTime()

  */

class Calculator

{

public:

	/** This shouldn't be called directly, instead use getCalculator(). */

	Calculator(EmuTime frame, EmuTime time,

	           EmuTime limit_, std::span<const uint8_t, NUM_DELTAS * TICKS> tab_)

		: ref(frame), tab(tab_)

	{

		assert(frame <= time);

		assert(frame <= limit_);

		// not required that time <= limit

		ticks = narrow<int>(ref.getTicksTill(time));

		limit = narrow<int>(ref.getTicksTill(limit_));

		int lines = ticks / TICKS;

		ticks -= lines * TICKS;

		limit -= lines * TICKS; // might be negative

		ref   += lines * TICKS;

		assert(0 <= ticks); assert(ticks < TICKS);

	}

	/** Has 'time' advanced to or past 'limit'? */

	[[nodiscard]] bool limitReached() const {

		return ticks >= limit;

	}

	/** Get the current time. Initially this will return the 'time'

	  * constructor parameter. Each call to next() will increase this

	  * value. */

	[[nodiscard]] EmuTime getTime() const {

		return ref.getFastAdd(ticks);

	}

	/** Advance time to the earliest access slot that is at least 'delta'

	  * ticks later than the current time. */

	void next(Delta delta) {

		ticks += tab[std::to_underlying(delta) + ticks];

		if (ticks >= TICKS) [[unlikely]] {

			ticks -= TICKS;

			limit -= TICKS;

			ref   += TICKS;

		}

	}

private:

	int ticks;

	int limit;

	VDP::VDPClock ref;

	std::span<const uint8_t, NUM_DELTAS * TICKS> tab;

};

/** Return the time of the next available access slot that is at least 'delta'

  * cycles later than 'time'. The start of the current 'frame' is needed for

  * reference. */

[[nodiscard]] EmuTime getAccessSlot(EmuTime frame, EmuTime time, Delta delta,

                      const VDP& vdp);

/** When many calls to getAccessSlot() are needed, it's more efficient to

  * instead use this function. */

[[nodiscard]] Calculator getCalculator(

	EmuTime frame, EmuTime time, EmuTime limit,

	const VDP& vdp);

/** The largest interval paddingCycles() accepts. */

inline constexpr int MAX_PADDING_SPAN = 8;

/** How many cycles of line padding complete in the interval (t, t + n], where

  * 't' is at position 'tick' in its line: the number of cycles by which that

  * interval is longer in VDP cycles than in the VDP's memory cycles. Only for

  * short intervals; see the comment about 'pad' in VDPAccessSlots.cc. */

[[nodiscard]] int paddingCycles(int tick, int n, const VDP& vdp);

/** Is the CPU slot at line position 'slotTick' a 'late' one? Those hand out

  * their grant 2 cycles later than the rest, and release the CPU's request

  * buffer one cycle before their access instead of one cycle after. */

[[nodiscard]] bool isLateCpuSlot(int slotTick, const VDP& vdp);

} // namespace openmsx::VDPAccessSlots

#endif