#ifndef MSXCPUINTERFACE_HH

#define MSXCPUINTERFACE_HH

#include "BreakPoint.hh"

#include "CacheLine.hh"

#include "DebugCondition.hh"

#include "WatchPoint.hh"

#include "InfoTopic.hh"

#include "MSXDevice.hh"

#include "ProfileCounters.hh"

#include "SimpleDebuggable.hh"

#include "narrow.hh"

#include <array>

#include <bitset>

#include <concepts>

#include <cstdint>

#include <memory>

#include <vector>

namespace openmsx {

class BooleanSetting;

class BreakPoint;

class CliComm;

class DummyDevice;

class MSXCPU;

class MSXMotherBoard;

class VDPIODelay;

inline constexpr bool PROFILE_CACHELINES = false;

enum class CacheLineCounters : uint8_t {

	NonCachedRead,

	NonCachedWrite,

	GetReadCacheLine,

	GetWriteCacheLine,

	SlowRead,

	SlowWrite,

	DisallowCacheRead,

	DisallowCacheWrite,

	InvalidateAllSlots,

	InvalidateReadWrite,

	InvalidateRead,

	InvalidateWrite,

	FillReadWrite,

	FillRead,

	FillWrite,

	NUM // must be last

};

std::ostream& operator<<(std::ostream& os, EnumTypeName<CacheLineCounters>);

std::ostream& operator<<(std::ostream& os, EnumValueName<CacheLineCounters> evn);

class MSXCPUInterface : public ProfileCounters<PROFILE_CACHELINES, CacheLineCounters>

{

public:

	explicit MSXCPUInterface(MSXMotherBoard& motherBoard);

	MSXCPUInterface(const MSXCPUInterface&) = delete;

	MSXCPUInterface(MSXCPUInterface&&) = delete;

	MSXCPUInterface& operator=(const MSXCPUInterface&) = delete;

	MSXCPUInterface& operator=(MSXCPUInterface&&) = delete;

	~MSXCPUInterface();

	/**

	 * Devices can register their In ports. This is normally done

	 * in their constructor. Once device are registered, their

	 * readIO() method can get called.

	 */

	void register_IO_In(uint8_t port, MSXDevice* device);

	void unregister_IO_In(uint8_t port, MSXDevice* device);

	/**

	 * Devices can register their Out ports. This is normally done

	 * in their constructor. Once device are registered, their

	 * writeIO() method can get called.

	 */

	void register_IO_Out(uint8_t port, MSXDevice* device);

	void unregister_IO_Out(uint8_t port, MSXDevice* device);

	/** Convenience methods for {un}register_IO_{In,Out}.

	 * At the same time (un)register both In and Out, and/or a range of ports.

	 */

	void register_IO_InOut(uint8_t port, MSXDevice* device);

	void register_IO_In_range(uint8_t port, unsigned num, MSXDevice* device);

	void register_IO_Out_range(uint8_t port, unsigned num, MSXDevice* device);

	void register_IO_InOut_range(uint8_t port, unsigned num, MSXDevice* device);

	void unregister_IO_InOut(uint8_t port, MSXDevice* device);

	void unregister_IO_In_range(uint8_t port, unsigned num, MSXDevice* device);

	void unregister_IO_Out_range(uint8_t port, unsigned num, MSXDevice* device);

	void unregister_IO_InOut_range(uint8_t port, unsigned num, MSXDevice* device);

	/**

	 * These methods replace a previously registered device with a new one.

	 *

	 * This method checks whether the current device is the same as the

	 * 'oldDevice' parameter.

	 * - If it's the same, the current device is replace with 'newDevice'

	 *   and this method returns true.

	 * - If it's not the same, then no changes are made and this method

	 *   returns false.

	 *

	 * The intention is that devices using these methods extend (=wrap) the

	 * functionality of a previously registered device. Typically the

	 * destructor of the wrapping device will perform the inverse

	 * replacement.

	 */

	bool replace_IO_In (uint8_t port, MSXDevice* oldDevice, MSXDevice* newDevice);

	bool replace_IO_Out(uint8_t port, MSXDevice* oldDevice, MSXDevice* newDevice);

	/**

	 * Devices can register themself in the MSX slot structure.

	 * This is normally done in their constructor. Once devices

	 * are registered their readMem() / writeMem() methods can

	 * get called.

	 */

	void registerMemDevice(MSXDevice& device,

	                       int ps, int ss, unsigned base, unsigned size);

	void unregisterMemDevice(MSXDevice& device,

	                         int ps, int ss, unsigned base, unsigned size);

	/** (Un)register global writes.

	  * @see MSXDevice::globalWrite()

	  */

	void   registerGlobalWrite(MSXDevice& device, uint16_t address);

	void unregisterGlobalWrite(MSXDevice& device, uint16_t address);

	/** (Un)register global read.

	  * @see MSXDevice::globalRead()

	  */

	void   registerGlobalRead(MSXDevice& device, uint16_t address);

	void unregisterGlobalRead(MSXDevice& device, uint16_t address);

	/**

	 * Reset (the slot state)

	 */

	void reset();

	/**

	 * This reads a byte from the currently selected device

	 */

	uint8_t readMem(uint16_t address, EmuTime time) {

		tick(CacheLineCounters::SlowRead);

		if (disallowReadCache[address >> CacheLine::BITS]) [[unlikely]] {

			return readMemSlow(address, time);

		}

		return visibleDevices[address >> 14]->readMem(address, time);

	}

	/**

	 * This writes a byte to the currently selected device

	 */

	void writeMem(uint16_t address, uint8_t value, EmuTime time) {

		tick(CacheLineCounters::SlowWrite);

		if (disallowWriteCache[address >> CacheLine::BITS]) [[unlikely]] {

			writeMemSlow(address, value, time);

			return;

		}

		visibleDevices[address>>14]->writeMem(address, value, time);

	}

	/**

	 * This read a byte from the given IO-port

	 * @see MSXDevice::readIO()

	 */

	uint8_t readIO(uint16_t port, EmuTime time) {

		return IO_In[port & 0xFF]->readIO(port, time);

	}

	/**

	 * This writes a byte to the given IO-port

	 * @see MSXDevice::writeIO()

	 */

	void writeIO(uint16_t port, uint8_t value, EmuTime time) {

		IO_Out[port & 0xFF]->writeIO(port, value, time);

	}

	/**

	 * Test that the memory in the interval [start, start +

	 * CacheLine::SIZE) is cacheable for reading. If it is, a pointer to a

	 * buffer containing this interval must be returned. If not, a null

	 * pointer must be returned.

	 * Cacheable for reading means the data may be read directly

	 * from the buffer, thus bypassing the readMem() method, and

	 * thus also ignoring EmuTime.

	 * The default implementation always returns a null pointer.

	 * An interval will never cross a 16KB border.

	 * An interval will never contain the address 0xffff.

	 */

	[[nodiscard]] const uint8_t* getReadCacheLine(uint16_t start) const {

		tick(CacheLineCounters::GetReadCacheLine);

		if (disallowReadCache[start >> CacheLine::BITS]) [[unlikely]] {

			return nullptr;

		}

		return visibleDevices[start >> 14]->getReadCacheLine(start);

	}

	/**

	 * Test that the memory in the interval [start, start +

	 * CacheLine::SIZE) is cacheable for writing. If it is, a pointer to a

	 * buffer containing this interval must be returned. If not, a null

	 * pointer must be returned.

	 * Cacheable for writing means the data may be written directly

	 * to the buffer, thus bypassing the writeMem() method, and

	 * thus also ignoring EmuTime.

	 * The default implementation always returns a null pointer.

	 * An interval will never cross a 16KB border.

	 * An interval will never contain the address 0xffff.

	 */

	[[nodiscard]] uint8_t* getWriteCacheLine(uint16_t start) {

		tick(CacheLineCounters::GetWriteCacheLine);

		if (disallowWriteCache[start >> CacheLine::BITS]) [[unlikely]] {

			return nullptr;

		}

		return visibleDevices[start >> 14]->getWriteCacheLine(start);

	}

	/**

	 * CPU uses this method to read 'extra' data from the data bus

	 * used in interrupt routines. In MSX this returns always 255.

	 */

	[[nodiscard]] uint8_t readIRQVector() const;

	/*

	 * Should only be used by PPI

	 *  TODO: make private / friend

	 */

	void setPrimarySlots(uint8_t value);

	/** @see MSXCPU::invalidateRWCache() */

	void invalidateRWCache(uint16_t start, unsigned size, int ps, int ss);

	void invalidateRCache (uint16_t start, unsigned size, int ps, int ss);

	void invalidateWCache (uint16_t start, unsigned size, int ps, int ss);

	/** @see MSXCPU::fillRWCache() */

	void fillRWCache(unsigned start, unsigned size, const uint8_t* rData, uint8_t* wData, int ps, int ss);

	void fillRCache (unsigned start, unsigned size, const uint8_t* rData,                 int ps, int ss);

	void fillWCache (unsigned start, unsigned size,                       uint8_t* wData, int ps, int ss);

	/**

	 * Peek memory location

	 * @see MSXDevice::peekMem()

	 */

	[[nodiscard]] uint8_t peekMem(uint16_t address, EmuTime time) const;

	[[nodiscard]] uint8_t peekSlottedMem(unsigned address, EmuTime time) const;

	void peekSlottedMemBlock(unsigned address, std::span<uint8_t> output, EmuTime time) const;

	uint8_t readSlottedMem(unsigned address, EmuTime time);

	void writeSlottedMem(unsigned address, uint8_t value,

	                     EmuTime time);

	void setExpanded(int ps);

	void unsetExpanded(int ps);

	void testUnsetExpanded(int ps,

		               std::span<const std::unique_ptr<MSXDevice>> allowed) const;

	[[nodiscard]] bool isExpanded(int ps) const { return expanded[ps] != 0; }

	void changeExpanded(bool newExpanded);

	[[nodiscard]] auto getPrimarySlot  (int page) const { return primarySlotState[page]; }

	[[nodiscard]] auto getSecondarySlot(int page) const { return secondarySlotState[page]; }

	[[nodiscard]] DummyDevice& getDummyDevice() { return *dummyDevice; }

	void insertBreakPoint(BreakPoint bp);

	void removeBreakPoint(const BreakPoint& bp);

	void removeBreakPoint(unsigned id);

	using BreakPoints = std::vector<BreakPoint>;

	[[nodiscard]] static BreakPoints& getBreakPoints() { return breakPoints; }

	void setWatchPoint(const std::shared_ptr<WatchPoint>& watchPoint);

	void removeWatchPoint(std::shared_ptr<WatchPoint> watchPoint);

	void removeWatchPoint(unsigned id);

	// note: must be shared_ptr (not unique_ptr), see WatchIO::doReadCallback()

	using WatchPoints = std::vector<std::shared_ptr<WatchPoint>>;

	[[nodiscard]] const WatchPoints& getWatchPoints() const { return watchPoints; }

	[[nodiscard]] WatchPoints& getWatchPoints() { return watchPoints; }

	// Temporarily unregister and then re-register a watchpoint. E.g.

	// because you want to change the type or address, and then it needs to

	// be registered in a different way.

	struct ScopedChangeWatchpoint {

		ScopedChangeWatchpoint(const ScopedChangeWatchpoint&) = delete;

		ScopedChangeWatchpoint(ScopedChangeWatchpoint&&) = delete;

		ScopedChangeWatchpoint& operator=(const ScopedChangeWatchpoint&) = delete;

		ScopedChangeWatchpoint& operator=(ScopedChangeWatchpoint&&) = delete;

		ScopedChangeWatchpoint(MSXCPUInterface& interface_, std::shared_ptr<WatchPoint> wp_)

			: interface(interface_), wp(std::move(wp_)) {

			interface.unregisterWatchPoint(*wp);

		}

		~ScopedChangeWatchpoint() {

			interface.registerWatchPoint(*wp);

		}

	private:

		MSXCPUInterface& interface;

		std::shared_ptr<WatchPoint> wp;

	};

	[[nodiscard]] auto getScopedChangeWatchpoint(std::shared_ptr<WatchPoint> wp) {

		return ScopedChangeWatchpoint(*this, std::move(wp));

	}

	void setCondition(DebugCondition cond);

	void removeCondition(const DebugCondition& cond);

	void removeCondition(unsigned id);

	using Conditions = std::vector<DebugCondition>;

	[[nodiscard]] static Conditions& getConditions() { return conditions; }

	[[nodiscard]] static bool isBreaked() { return breaked; }

	void doBreak();

	void doStep();

	void doContinue();

	// breakpoint methods used by CPUCore

	[[nodiscard]] static bool anyBreakPoints()

	{

		return !breakPoints.empty() || !conditions.empty();

	}

	[[nodiscard]] bool checkBreakPoints(unsigned pc);

	// cleanup global variables

	static void cleanup();

	// In fast-forward mode, breakpoints, watchpoints and conditions should

	// not trigger.

	void setFastForward(bool fastForward_) { fastForward = fastForward_; }

	[[nodiscard]] bool isFastForward() const { return fastForward; }

	/** The device in this slot and page. Never returns nullptr: a slot

	  * without a device has the DummyDevice. */

	[[nodiscard]] MSXDevice* getMSXDevice(int ps, int ss, int page);

	[[nodiscard]] MSXDevice* getVisibleMSXDevice(int page) { return visibleDevices[page]; }

	/** Returns the device registered on the given IO port, looking through

	  * the watchpoint and VDP-delay wrapper devices. Returns the

	  * DummyDevice when no device is registered on this port.

	  */

	[[nodiscard]] MSXDevice* getIODevice(uint8_t port, bool isIn) {

		return getDevicePtr(port, isIn);

	}

	/**

	 * Read a byte from the given IO-port without side effects.

	 * @see MSXDevice::peekIO()

	 */

	[[nodiscard]] uint8_t peekIO(uint16_t port, EmuTime time) const {

		return IO_In[port & 0xFF]->peekIO(port, time);

	}

	template<typename Archive>

	void serialize(Archive& ar, unsigned version);

private:

	uint8_t readMemSlow(uint16_t address, EmuTime time);

	void writeMemSlow(uint16_t address, uint8_t value, EmuTime time);

	MSXDevice*& getDevicePtr(uint8_t port, bool isIn);

	void register_IO  (int port, bool isIn,

	                   MSXDevice*& devicePtr, MSXDevice* device);

	void unregister_IO(MSXDevice*& devicePtr, MSXDevice* device);

	void testRegisterSlot(const MSXDevice& device,

	                      int ps, int ss, unsigned base, unsigned size);

	void registerSlot(MSXDevice& device,

	                  int ps, int ss, unsigned base, unsigned size);

	void unregisterSlot(MSXDevice& device,

	                    int ps, int ss, unsigned base, unsigned size);

	void registerWatchPoint(WatchPoint& wp);

	void unregisterWatchPoint(WatchPoint& wp);

	void removeAllWatchPoints();

	void updateMemWatch(WatchPoint::Type type);

	void executeMemWatch(WatchPoint::Type type, unsigned address,

	                     unsigned value = ~0u);

	struct MemoryDebug final : SimpleDebuggable {

		explicit MemoryDebug(MSXMotherBoard& motherBoard);

		[[nodiscard]] uint8_t read(unsigned address, EmuTime time) override;

		void write(unsigned address, uint8_t value, EmuTime time) override;

	} memoryDebug;

	struct SlottedMemoryDebug final : SimpleDebuggable {

		explicit SlottedMemoryDebug(MSXMotherBoard& motherBoard);

		[[nodiscard]] uint8_t read(unsigned address, EmuTime time) override;

		void readBlock(unsigned start, std::span<uint8_t> output) override;

		void write(unsigned address, uint8_t value, EmuTime time) override;

	} slottedMemoryDebug;

	struct IODebug final : SimpleDebuggable {

		explicit IODebug(MSXMotherBoard& motherBoard);

		[[nodiscard]] uint8_t read(unsigned address, EmuTime time) override;

		void write(unsigned address, uint8_t value, EmuTime time) override;

	} ioDebug;

	struct SlotInfo final : InfoTopic {

		explicit SlotInfo(InfoCommand& machineInfoCommand);

		void execute(std::span<const TclObject> tokens,

			     TclObject& result) const override;

		[[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;

	} slotInfo;

	struct SubSlottedInfo final : InfoTopic {

		explicit SubSlottedInfo(InfoCommand& machineInfoCommand);

		void execute(std::span<const TclObject> tokens,

			     TclObject& result) const override;

		[[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;

	} subSlottedInfo;

	struct ExternalSlotInfo final : InfoTopic {

		explicit ExternalSlotInfo(InfoCommand& machineInfoCommand);

		void execute(std::span<const TclObject> tokens,

			     TclObject& result) const override;

		[[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;

	} externalSlotInfo;

	struct IOInfo : InfoTopic {

		IOInfo(InfoCommand& machineInfoCommand, const char* name);

		void helper(std::span<const TclObject> tokens,

		            TclObject& result, std::span<MSXDevice*, 256> devices) const;

		[[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;

	protected:

		~IOInfo() = default;

	};

	struct IInfo final : IOInfo {

		explicit IInfo(InfoCommand& machineInfoCommand)

			: IOInfo(machineInfoCommand, "input_port") {}

		void execute(std::span<const TclObject> tokens,

		             TclObject& result) const override;

	} inputPortInfo;

	struct OInfo final : IOInfo {

		explicit OInfo(InfoCommand& machineInfoCommand)

			: IOInfo(machineInfoCommand, "output_port") {}

		void execute(std::span<const TclObject> tokens,

		             TclObject& result) const override;

	} outputPortInfo;

	/** Updated visibleDevices for a given page and clears the cache

	  * on changes.

	  * Should be called whenever PrimarySlotState or SecondarySlotState

	  * was modified.

	  * @param page page [0..3] to update visibleDevices for.

	  */

	void updateVisible(uint8_t page);

	inline void updateVisible(uint8_t page, uint8_t ps, uint8_t ss);

	void setSubSlot(uint8_t primSlot, uint8_t value);

	std::unique_ptr<DummyDevice> dummyDevice;

	MSXCPU& msxcpu;

	CliComm& cliComm;

	MSXMotherBoard& motherBoard;

	BooleanSetting& pauseSetting;

	std::unique_ptr<VDPIODelay> delayDevice; // can be nullptr

	std::array<uint8_t, CacheLine::NUM> disallowReadCache;

	std::array<uint8_t, CacheLine::NUM> disallowWriteCache;

	std::array<std::bitset<CacheLine::SIZE>, CacheLine::NUM> readWatchSet;

	std::array<std::bitset<CacheLine::SIZE>, CacheLine::NUM> writeWatchSet;

	struct GlobalRwInfo {

		MSXDevice* device;

		uint16_t addr;

		[[nodiscard]] constexpr bool operator==(const GlobalRwInfo&) const = default;

	};

	std::vector<GlobalRwInfo> globalReads;

	std::vector<GlobalRwInfo> globalWrites;

	std::array<MSXDevice*, 256> IO_In;

	std::array<MSXDevice*, 256> IO_Out;

	std::array<std::array<std::array<MSXDevice*, 4>, 4>, 4> slotLayout;

	std::array<MSXDevice*, 4> visibleDevices;

	std::array<uint8_t, 4> subSlotRegister;

	std::array<uint8_t, 4> primarySlotState;

	std::array<uint8_t, 4> secondarySlotState;

	uint8_t initialPrimarySlots;

	std::array<unsigned, 4> expanded;

	bool fastForward = false; // no need to serialize