#ifndef CPUCLOCK_HH
#define CPUCLOCK_HH

#include "DynamicClock.hh"
#include "Scheduler.hh"
#include "narrow.hh"
#include <cassert>

namespace openmsx {

class CPUClock
{
public:
	unsigned getFreq() const { return clock.getFreq(); }

protected:
	CPUClock(EmuTime time, Scheduler& scheduler);

// benchmarking showed a slowdown of ~3% on AMD64
// when using the following code:
#if 0
	// 64-bit addition is cheap
	void add(unsigned ticks) { clock += ticks; }
	void sync() const { }
#else
	// 64-bit addition is expensive
	// (if executed several million times per second)
	void add(unsigned ticks) { remaining -= narrow_cast<int>(ticks); }
	void sync() const {
		clock.fastAdd(limit - remaining);
		limit = remaining;
	}
#endif

	// These are similar to the corresponding methods in DynamicClock.
	[[nodiscard]] EmuTime getTime() const { sync(); return clock.getTime(); }
	[[nodiscard]] EmuTime getTimeFast() const { return clock.getFastAdd(limit - remaining); }
	[[nodiscard]] EmuTime getTimeFast(int cc) const {
		return clock.getFastAdd(limit - remaining + cc);
	}
	void setTime(EmuTime time) { sync(); clock.reset(time); }
	void setFreq(unsigned freq) { sync(); disableLimit(); clock.setFreq(freq); }
	void advanceTime(EmuTime time);
	[[nodiscard]] EmuTime calcTime(EmuTime time, unsigned ticks) const {
		return clock.add(time, ticks);
	}

	/** Implementation of the HALT instruction timing.
	  * Advances the clock with an integer multiple of 'hltStates' cycles
	  * so that it equal or bigger than 'time'. Returns the number of times
	  * 'hltStates' needed to be added.
	  */
	unsigned advanceHalt(unsigned hltStates, EmuTime time) {
		sync();
		unsigned ticks = clock.getTicksTillUp(time);
		unsigned halts = (ticks + hltStates - 1) / hltStates; // round up
		clock += halts * hltStates;
		return halts;
	}

	/** R800 runs at 7MHz, but I/O is done over a slower 3.5MHz bus. So
	  * sometimes right before I/O it's needed to wait for one cycle so
	  * that we're at the start of a clock cycle of the slower bus.
	  */
	void waitForEvenCycle(int cc)
	{
		sync();
		auto totalTicks = clock.getTotalTicks() + cc;
		if (totalTicks & 1) {
			add(1);
		}
	}

	// The following 3 methods are used in the innermost CPU loop. It
	// allows to implement this loop with just one test. This loop must
	// be exited on the following three conditions:
	//   1) a Synchronization Point is reached
	//   2) a 'slow' instruction must be executed (ei, di, ..)
	//   3) another thread has requested to exit the loop
	// The limitReached() method indicates whether the loop should be
	// exited.
	// The earliest SP must always be kept up-to-date with the setLimit()
	// method, so after every action that might change SP. The Scheduler
	// class is responsible for this.
	// In 'slow' mode the limit mechanism can be disabled with the
	// disableLimit() method. In disabled mode, the limitReached() method
	// always returns true.
	// When another thread requests to exit the loop, it's not needed to
	// already exit at the next instruction. If we exit soon that's good
	// enough. This is implemented by simply regularly exiting the loop
	// (outside the inner loop, the real exit condition should be tested).

	void setLimit(EmuTime time) {
		if (limitEnabled) {
			sync();
			assert(remaining == limit);
			limit = narrow_cast<int>(clock.getTicksTillUp(time) - 1);
			remaining = limit;
		} else {
			assert(limit < 0);
		}
	}
	void enableLimit() {
		limitEnabled = true;
		setLimit(scheduler.getNext());
	}
	void disableLimit() {
		limitEnabled = false;
		int extra = limit - remaining;
		limit = -1;
		remaining = limit - extra;
	}
	[[nodiscard]] bool limitReached() const {
		return remaining < 0;
	}

	template<typename Archive>
	void serialize(Archive& ar, unsigned version);

private:
	mutable DynamicClock clock;
	Scheduler& scheduler;
	int remaining = -1;
	mutable int limit = -1;
	bool limitEnabled = false;
};

} // namespace openmsx

#endif