// GAME MASTER 2
//
// This is a 1 megabit ROM cartridge with 8 Kb SRAM. Because of the SRAM,
// the mappers have special features.
//
// Since the size of the mapper is 8Kb, the memory banks are:
//   Bank 1: 4000h - 5FFFh
//   Bank 2: 6000h - 7FFFh
//   Bank 3: 8000h - 9FFFh
//   Bank 4: A000h - BFFFh
//
// And the addresses to change banks:
//   Bank 1: <none>
//   Bank 2: 6000h - 6FFFh (6000h used)
//   Bank 3: 8000h - 8FFFh (8000h used)
//   Bank 4: A000h - AFFFh (A000h used)
//   SRAM write: B000h - BFFFh
//
// If SRAM is selected in bank 4, you can write to it in the memory area
// B000h - BFFFh.
//
// The value you write to change banks also determines whether you select ROM
// or SRAM. SRAM can be in any memory bank (except bank 1 which can't be
// modified) but it can only be written too in bank 4.
//
//   bit      |  0 |  1 |  2 |  3 |      4       |  5 | 6 | 7 |
//   ----------------------------------------------------------
//   function | R0 | R1 | R2 | R3 | 1=SRAM/0=ROM | S0 | X | X |
//
// If bit 4 is reset, bits 0 - 3 select the ROM page as you would expect them
// to do. Bits 5 - 7 are ignored now. If bit 4 is set, bit 5 selects the SRAM
// page (first or second 4Kb of the 8Kb). Bits 6 - 7 and bits 0 - 3 are
// ignored now.
//
// Since you can only select 4Kb of the SRAM at once in a memory bank and a
// memory bank is 8Kb in size, the first and second 4Kb of the memory bank
// read the same 4Kb of SRAM if SRAM is selected.

#include "RomGameMaster2.hh"
#include "SRAM.hh"
#include "serialize.hh"
#include "xrange.hh"
#include <memory>

namespace openmsx {

RomGameMaster2::RomGameMaster2(const DeviceConfig& config, Rom&& rom_)
	: Rom4kBBlocks(config, std::move(rom_), 1)
{
	sram = std::make_unique<SRAM>(getName() + " SRAM", 0x2000, config);
	reset(EmuTime::dummy());
}

void RomGameMaster2::reset(EmuTime::param /*time*/)
{
	for (auto i : xrange(4)) {
		setUnmapped(i);
	}
	for (auto i : xrange(4, 12)) {
		setRom(i, i - 4);
	}
	for (auto i : xrange(12, 16)) {
		setUnmapped(i);
	}
	sramOffset = 0;
	sramEnabled = false;
}

void RomGameMaster2::writeMem(word address, byte value, EmuTime::param /*time*/)
{
	if ((0x6000 <= address) && (address < 0xB000)) {
		if (!(address & 0x1000)) {
			auto region = address >> 12; // 0x6, 0x8 or 0xA
			if (region == 0x0A) {
				sramEnabled = (value & 0x10) != 0;
				invalidateDeviceWCache(0xB000, 0x1000); // 'R' is handled below
			}
			if (value & 0x10) {
				// switch SRAM
				sramOffset = (value & 0x20) ? 0x1000: 0x0000;
				setBank(region,     &(*sram)[sramOffset], value);
				setBank(region + 1, &(*sram)[sramOffset], value);
			} else {
				// switch ROM
				setRom(region,     2 * (value & 0x0F));
				setRom(region + 1, 2 * (value & 0x0F) + 1);
			}
		}
	} else if ((0xB000 <= address) && (address < 0xC000)) {
		// write SRAM
		if (sramEnabled) {
			sram->write(sramOffset | (address & 0x0FFF), value);
		}
	}
}

byte* RomGameMaster2::getWriteCacheLine(word address) const
{
	if ((0x6000 <= address) && (address < 0xB000)) {
		if (!(address & 0x1000)) {
			return nullptr;
		} else {
			return unmappedWrite.data();
		}
	} else if ((0xB000 <= address) && (address < 0xC000) && sramEnabled) {
		// write SRAM
		return nullptr;
	} else {
		return unmappedWrite.data();
	}
}

template<typename Archive>
void RomGameMaster2::serialize(Archive& ar, unsigned /*version*/)
{
	ar.template serializeBase<Rom4kBBlocks>(*this);
	ar.serialize("sramOffset",  sramOffset,
	             "sramEnabled", sramEnabled);
}
INSTANTIATE_SERIALIZE_METHODS(RomGameMaster2);
REGISTER_MSXDEVICE(RomGameMaster2, "RomGameMaster2");

} // namespace openmsx
