#ifndef MEGAFLASHROMSCCPLUSSD_HH
#define MEGAFLASHROMSCCPLUSSD_HH

#include "AmdFlash.hh"
#include "MSXMapperIO.hh"

#include "AY8910.hh"
#include "MSXDevice.hh"
#include "SCC.hh"

#include <array>
#include <cstdint>
#include <memory>

namespace openmsx {

class CheckedRam;
class SdCard;

class MegaFlashRomSCCPlusSD final : public MSXDevice
{
public:
	explicit MegaFlashRomSCCPlusSD(DeviceConfig& config);
	~MegaFlashRomSCCPlusSD() override;

	void powerUp(EmuTime time) override;
	void reset(EmuTime time) override;
	[[nodiscard]] byte peekMem(uint16_t address, EmuTime time) const override;
	[[nodiscard]] byte readMem(uint16_t address, EmuTime time) override;
	[[nodiscard]] const byte* getReadCacheLine(uint16_t address) const override;
	void writeMem(uint16_t address, byte value, EmuTime time) override;
	[[nodiscard]] byte* getWriteCacheLine(uint16_t address) override;

	void writeIO(uint16_t port, byte value, EmuTime time) override;

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

private:
	enum SCCEnable : uint8_t { EN_NONE, EN_SCC, EN_SCCPLUS };
	[[nodiscard]] SCCEnable getSCCEnable() const;
	void updateConfigReg(byte value);

	[[nodiscard]] byte getSubSlot(unsigned addr) const;

	/**
	 * Writes to flash only if it was not write protected.
	 */
	void writeToFlash(unsigned addr, byte value, EmuTime time);
	AmdFlash flash;
	byte subslotReg;

	// subslot 0
	[[nodiscard]] byte readMemSubSlot0(uint16_t address, EmuTime time);
	[[nodiscard]] byte peekMemSubSlot0(uint16_t address, EmuTime time) const;
	[[nodiscard]] const byte* getReadCacheLineSubSlot0(uint16_t address) const;
	[[nodiscard]] byte* getWriteCacheLineSubSlot0(uint16_t address);
	void writeMemSubSlot0(uint16_t address, byte value, EmuTime time);

	// subslot 1
	// mega flash rom scc+
	[[nodiscard]] byte readMemSubSlot1(uint16_t address, EmuTime time);
	[[nodiscard]] byte peekMemSubSlot1(uint16_t address, EmuTime time) const;
	[[nodiscard]] const byte* getReadCacheLineSubSlot1(uint16_t address) const;
	[[nodiscard]] byte* getWriteCacheLineSubSlot1(uint16_t address);
	void writeMemSubSlot1(uint16_t address, byte value, EmuTime time);
	[[nodiscard]] unsigned getFlashAddrSubSlot1(unsigned addr) const;

	SCC scc;
	AY8910 psg;

	byte mapperReg;
	[[nodiscard]] bool is64KmapperConfigured()               const { return (mapperReg & 0xC0) == 0x40; }
	[[nodiscard]] bool isKonamiSCCmapperConfigured()         const { return (mapperReg & 0xE0) == 0x00; }
	[[nodiscard]] bool isWritingKonamiBankRegisterDisabled() const { return (mapperReg & 0x08) != 0; }
	[[nodiscard]] bool isMapperRegisterDisabled()            const { return (mapperReg & 0x04) != 0; }
	[[nodiscard]] bool areBankRegsAndOffsetRegsDisabled()    const { return (mapperReg & 0x02) != 0; }
	[[nodiscard]] bool areKonamiMapperLimitsEnabled()        const { return (mapperReg & 0x01) != 0; }
	unsigned offsetReg;

	byte configReg = 3; // avoid UMR
	[[nodiscard]] bool isConfigRegDisabled()           const { return  (configReg & 0x80) != 0; }
	[[nodiscard]] bool isMemoryMapperEnabled()         const { return ((configReg & 0x20) == 0) && checkedRam; }
	[[nodiscard]] bool isDSKmodeEnabled()              const { return  (configReg & 0x10) != 0; }
	[[nodiscard]] bool isPSGalsoMappedToNormalPorts()  const { return  (configReg & 0x08) != 0; }
	[[nodiscard]] bool isSlotExpanderEnabled()         const { return  (configReg & 0x04) == 0; }
	[[nodiscard]] bool isFlashRomBlockProtectEnabled() const { return  (configReg & 0x02) != 0; }
	[[nodiscard]] bool isFlashRomWriteEnabled()        const { return  (configReg & 0x01) != 0; }

	// Note: the bankRegsSubSlot1 registers are actually only 9 bit.
	std::array<uint16_t, 4> bankRegsSubSlot1;
	byte psgLatch;
	byte sccMode;
	std::array<byte, 4> sccBanks;

	// subslot 2
	// 512k memory mapper
	[[nodiscard]] byte readMemSubSlot2(uint16_t address);
	[[nodiscard]] byte peekMemSubSlot2(uint16_t address) const;
	[[nodiscard]] const byte* getReadCacheLineSubSlot2(uint16_t address) const;
	[[nodiscard]] byte* getWriteCacheLineSubSlot2(uint16_t address);
	void writeMemSubSlot2(uint16_t address, byte value);

	[[nodiscard]] unsigned calcMemMapperAddress(uint16_t address) const;
	[[nodiscard]] unsigned calcAddress(uint16_t address) const;

	class MapperIO final : public MSXMapperIOClient {
	public:
		explicit MapperIO(MegaFlashRomSCCPlusSD& mega_)
			: MSXMapperIOClient(mega_.getMotherBoard())
			, mega(mega_)
		{
		}

		[[nodiscard]] byte readIO(uint16_t port, EmuTime time) override;
		[[nodiscard]] byte peekIO(uint16_t port, EmuTime time) const override;
		void writeIO(uint16_t port, byte value, EmuTime time) override;
		[[nodiscard]] byte getSelectedSegment(byte page) const override;

	private:
		MegaFlashRomSCCPlusSD& mega;
	};
	const std::unique_ptr<CheckedRam> checkedRam; // can be nullptr
	const std::unique_ptr<MapperIO> mapperIO; // nullptr iff checkedRam == nullptr
	std::array<byte, 4> memMapperRegs;

	// subslot 3
	[[nodiscard]] byte readMemSubSlot3(uint16_t address, EmuTime time);
	[[nodiscard]] byte peekMemSubSlot3(uint16_t address, EmuTime time) const;
	[[nodiscard]] const byte* getReadCacheLineSubSlot3(uint16_t address) const;
	[[nodiscard]] byte* getWriteCacheLineSubSlot3(uint16_t address);
	void writeMemSubSlot3(uint16_t address, byte value, EmuTime time);
	[[nodiscard]] unsigned getFlashAddrSubSlot3(unsigned addr) const;

	std::array<byte, 4> bankRegsSubSlot3;

	byte selectedCard;
	std::array<std::unique_ptr<SdCard>, 2> sdCard;
};

} // namespace openmsx

#endif