#include "Rom.hh"

#include "ConfigException.hh"

#include "Debuggable.hh"

#include "Debugger.hh"

#include "DeviceConfig.hh"

#include "EmptyPatch.hh"

#include "File.hh"

#include "FileContext.hh"

#include "FileException.hh"

#include "FilePool.hh"

#include "Filename.hh"

#include "HardwareConfig.hh"

#include "IPSPatch.hh"

#include "MSXCliComm.hh"

#include "MSXMotherBoard.hh"

#include "MemBuffer.hh"

#include "PanasonicMemory.hh"

#include "Reactor.hh"

#include "RomDatabase.hh"

#include "RomInfo.hh"

#include "XMLElement.hh"

#include "narrow.hh"

#include "ranges.hh"

#include "sha1.hh"

#include "stl.hh"

#include <algorithm>

#include <memory>

namespace openmsx {

class RomDebuggable final : public Debuggable

{

public:

	RomDebuggable(Debugger& debugger, Rom& rom);

	RomDebuggable(const RomDebuggable&) = delete;

	RomDebuggable(RomDebuggable&&) = delete;

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

	RomDebuggable& operator=(RomDebuggable&&) = delete;

	~RomDebuggable();

	[[nodiscard]] unsigned getSize() const override;

	[[nodiscard]] std::string_view getDescription() const override;

	[[nodiscard]] uint8_t read(unsigned address) override;

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

	void write(unsigned address, uint8_t value) override;

	void moved(Rom& r);

private:

	Debugger& debugger;

	Rom* rom;

};

Rom::Rom(std::string name_, static_string_view description_,

         DeviceConfig& config, std::string_view id /*= {}*/)

	: name(std::move(name_)), description(description_)

{

	// Try all <rom> tags with matching "id" attribute.

	std::string errors;

	for (auto* c : config.getXML()->getChildren("rom")) {

		if (c->getAttributeValue("id", {}) == id) {

			try {

				init(config.getMotherBoard(), *c, config.getFileContext());

				return;

			} catch (MSXException& e) {

				// remember error message, and try next

				if (!errors.empty() && (errors.back() != '\n')) {

					errors += '\n';

				}

				errors += e.getMessage();

			}

		}

	}

	if (errors.empty()) {

		// No matching <rom> tag.

		auto err = strCat("Missing <rom> tag", strCat_if(!id.empty(), " with id=\"", id, '"'));

		throw ConfigException(std::move(err));

	} else {

		// We got at least one matching <rom>, but it failed to load.

		// Report error messages of all failed attempts.

		throw ConfigException(errors);

	}

}

void Rom::init(MSXMotherBoard& motherBoard, XMLElement& config,

               const FileContext& context)

{

	// (Only) if the content of this ROM depends on state that is not part

	// of a savestate, we want to compare the sha1sum of the ROM from the

	// time the savestate was created with the one from the loaded

	// savestate. External state can be a .rom file or a patch file.

	File file;

	bool checkResolvedSha1 = false;

	auto sums      = config.getChildren("sha1");

	auto filenames = config.getChildren("filename");

	const auto* resolvedFilenameElem = config.findChild("resolvedFilename");

	const auto* resolvedSha1Elem     = config.findChild("resolvedSha1");

	if (config.findChild("firstblock")) {

		// part of the TurboR main ROM

		//  If there is a firstblock/lastblock tag, (only) use these to

		//  locate the rom. In the past we would also write add a

		//  resolvedSha1 tag for this type of ROM (before we used

		//  'checkResolvedSha1'). So there are old savestates that have

		//  both type of tags. For such a savestate it's important to

		//  first check firstblock, otherwise it will only load when

		//  there is a file that matches the sha1sums of the

		//  firstblock-lastblock portion of the containing file.

		unsigned first = config.getChildDataAsInt("firstblock", 0);

		unsigned last  = config.getChildDataAsInt("lastblock", 0);

		rom = motherBoard.getPanasonicMemory().getRomRange(first, last);

		assert(rom.data());

		// Part of a bigger (already checked) rom, no need to check.

		checkResolvedSha1 = false;

	} else if (resolvedFilenameElem || resolvedSha1Elem ||

	           !std::ranges::empty(sums) || !std::ranges::empty(filenames)) {

		auto& filePool = motherBoard.getReactor().getFilePool();

		// first try already resolved filename ..

		if (resolvedFilenameElem) {

			try {

				auto fname = resolvedFilenameElem->getData();

				file = File(fname);

				filename = fname;

			} catch (FileException&) {

				// ignore

			}

		}

		// .. then try the actual sha1sum ..

		auto fileType = context.isUserContext()

			? FileType::ROM : FileType::SYSTEM_ROM;

		if (!file.is_open() && resolvedSha1Elem) {

			Sha1Sum sha1(resolvedSha1Elem->getData());

			auto [f, fname] = filePool.getFile(fileType, sha1);

			file = std::move(f);

			if (file.is_open()) {

				// avoid recalculating same sha1 later

				originalSha1 = sha1;

				filename = std::move(fname);

			}

		}

		// .. and then try filename as originally given by user ..

		if (!file.is_open()) {

			for (const auto& f : filenames) {

				try {

					auto fname = context.resolve(f->getData());

					file = File(fname);

					filename = std::move(fname);

					break;

				} catch (FileException&) {

					// ignore

				}

			}

		}

		// .. then try all alternative sha1sums ..

		// (this might retry the actual sha1sum)

		if (!file.is_open()) {

			for (const auto& s : sums) {

				Sha1Sum sha1(s->getData());

				auto [f, fname] = filePool.getFile(fileType, sha1);

				file = std::move(f);

				if (file.is_open()) {

					// avoid recalculating same sha1 later

					originalSha1 = sha1;

					filename = std::move(fname);

					break;

				}

			}

		}

		// .. still no file, then error

		if (!file.is_open()) {

			auto error = strCat(

				"Couldn't find ROM file for \"", name, '"',

				strCat_if(!std::ranges::empty(filenames),

					' ', STRCAT_LAZY((*std::ranges::begin(filenames))->getData())),

				strCat_if(resolvedSha1Elem,

					" (sha1: ", STRCAT_LAZY(resolvedSha1Elem->getData()), ')')

				.else_if(!std::ranges::empty(sums),

					" (sha1: ", STRCAT_LAZY((*std::ranges::begin(sums))->getData()), ')'),

				'.');

			throw MSXException(std::move(error));

		}

		// actually read file content

		if (config.findChild("filesize") ||

		    config.findChild("skip_headerbytes")) {

			throw MSXException(

				"The <filesize> and <skip_headerbytes> tags "

				"inside a <rom> section are no longer "

				"supported.");

		}

		try {

			mmap = file.mmap<uint8_t>();

			rom = *mmap;

		} catch (FileException&) {

			throw MSXException("Error reading ROM image: ", filename);

		}

		// For file-based roms, calc sha1 via File::getSha1Sum(). It can

		// possibly use the FilePool cache to avoid the calculation.

		if (originalSha1.empty()) {

			originalSha1 = filePool.getSha1Sum(file, filename);

		}

		// verify SHA1

		if (!checkSHA1(config)) {

			motherBoard.getMSXCliComm().printWarning(

				"SHA1 sum for '", name,

				"' does not match with sum of '",

				filename, "'.");

		}

		// We loaded an external file, so check.

		checkResolvedSha1 = true;

	} else {

		// for an empty SCC the <size> tag is missing, so take 0

		// for MegaFlashRomSCC the <size> tag is used to specify

		// the size of the mapper (and you don't care about initial

		// content)

		unsigned size = config.getChildDataAsInt("size", 0) * 1024; // in kb

		extendedRom.resize(size);

		std::ranges::fill(std::span{extendedRom}, 0xff);

		rom = std::span{extendedRom};

		// Content does not depend on external files. No need to check

		checkResolvedSha1 = false;

	}

	if (!rom.empty()) {

		if (const auto* patchesElem = config.findChild("patches")) {

			// calculate before content is altered

			(void)getOriginalSHA1(); // fills cache

			std::unique_ptr<PatchInterface> patch =

				std::make_unique<EmptyPatch>(rom);

			for (const auto* p : patchesElem->getChildren("ips")) {

				patch = std::make_unique<IPSPatch>(

					Filename(p->getData(), context),

					std::move(patch));

			}

			auto patchSize = patch->getSize();

			if (patchSize <= rom.size()) {

				patch->copyBlock(0, std::span{const_cast<uint8_t*>(rom.data()), rom.size()});

			} else {

				MemBuffer<uint8_t> extendedRom2(patchSize);

				patch->copyBlock(0, std::span{extendedRom2});

				extendedRom = std::move(extendedRom2);

				rom = std::span{extendedRom};

			}

			// calculated because it's different from original

			actualSha1 = SHA1::calc(rom);

			// Content altered by external patch file -> check.

			checkResolvedSha1 = true;

		}

	}

	// TODO fix this, this is a hack that depends heavily on

	//      HardwareConfig::createRomConfig

	if (name.starts_with("MSXRom")) {

		const auto& db = motherBoard.getReactor().getSoftwareDatabase();

		std::string_view title;

		if (const auto* romInfo = db.fetchRomInfo(getOriginalSHA1())) {

			title = romInfo->getTitle(db.getBufferStart());

		}

		if (!title.empty()) {

			name = title;

		} else {

			// unknown ROM, use file name

			name = file.getOriginalName();

			if (name.empty()) name = filename;

		}

	}

	// Make name unique wrt all registered debuggables.

	auto& debugger = motherBoard.getDebugger();

	if (!rom.empty() && debugger.findDebuggable(name)) {

		unsigned n = 0;

		std::string tmp;

		do {

			tmp = strCat(name, " (", ++n, ')');

		} while (debugger.findDebuggable(tmp));

		name = std::move(tmp);

	}

	if (checkResolvedSha1) {

		auto& doc = motherBoard.getMachineConfig()->getXMLDocument();

		std::array<char, 40> buf;

		auto patchedSha1Str = getSHA1().toString(buf);

		const auto* actualSha1Elem = doc.getOrCreateChild(

			config, "resolvedSha1", doc.allocateString(patchedSha1Str));

		if (actualSha1Elem->getData() != patchedSha1Str) {

			const auto& tmp = file.is_open() ? filename : name;

			// can only happen in case of loadstate

			motherBoard.getMSXCliComm().printWarning(

				"The content of the rom ", tmp, " has "

				"changed since the time this savestate was "

				"created. This might result in emulation "

				"problems.");

		}

	}

	// This must come after we store the 'resolvedSha1', because on

	// loadstate we use that tag to search the complete rom in a filePool.

	if (const auto* windowElem = config.findChild("window")) {

		unsigned windowBase = windowElem->getAttributeValueAsInt("base", 0);

		unsigned windowSize = windowElem->getAttributeValueAsInt("size", narrow_cast<int>(rom.size()));

		if ((windowBase + windowSize) > rom.size()) {

			throw MSXException(

				"The specified window [", windowBase, ',',

				windowBase + windowSize, ") falls outside "

				"the rom (with size ", rom.size(), ").");

		}

		rom = rom.subspan(windowBase, windowSize);

	}

	// Only create the debuggable once all checks succeeded.

	if (!rom.empty()) {

		romDebuggable = std::make_unique<RomDebuggable>(debugger, *this);

	}

}

bool Rom::checkSHA1(const XMLElement& config) const

{

	auto sums = config.getChildren("sha1");

	return std::ranges::empty(sums) ||

	       contains(sums, getOriginalSHA1(),

	                [](const auto* s) { return Sha1Sum(s->getData()); });

}

Rom::Rom(Rom&& r) noexcept

	: rom          (r.rom)

	, extendedRom  (std::move(r.extendedRom))

	, filename     (std::move(r.filename))

	, mmap         (std::move(r.mmap))

	, originalSha1 (r.originalSha1)

	, actualSha1   (r.actualSha1)

	, name         (std::move(r.name))

	, description  (r.description)

	, romDebuggable(std::move(r.romDebuggable))

{

	if (romDebuggable) romDebuggable->moved(*this);

}

Rom::~Rom() = default;

const Sha1Sum& Rom::getOriginalSHA1() const

{

	if (originalSha1.empty()) {

		originalSha1 = SHA1::calc(rom);

	}

	return originalSha1;

}

const Sha1Sum& Rom::getSHA1() const

{

	if (actualSha1.empty())

	{

		actualSha1 = getOriginalSHA1();

	}

	return actualSha1;

}

void Rom::addPadding(size_t newSize, uint8_t filler)

{

	assert(newSize >= rom.size());

	if (newSize == rom.size()) return;

	MemBuffer<uint8_t> tmp(newSize);

	copy_to_range(rom, std::span{tmp});

	std::ranges::fill(tmp.subspan(rom.size()), filler);

	rom = std::span{tmp};

	extendedRom = std::move(tmp);

}

void Rom::getInfo(TclObject& result) const

{

	std::array<char, 40> buf1;

	std::array<char, 40> buf2;

	result.addDictKeyValues("actualSHA1", getSHA1().toString(buf1),

	                        "originalSHA1", getOriginalSHA1().toString(buf2),

	                        "filename", getFilename());

}

RomDebuggable::RomDebuggable(Debugger& debugger_, Rom& rom_)

	: debugger(debugger_), rom(&rom_)

{

	debugger.registerDebuggable(rom->getName(), *this);

}

RomDebuggable::~RomDebuggable()

{

	debugger.unregisterDebuggable(rom->getName(), *this);

}

unsigned RomDebuggable::getSize() const

{

	return narrow<unsigned>(rom->size());

}

std::string_view RomDebuggable::getDescription() const

{

	return rom->getDescription();

}

uint8_t RomDebuggable::read(unsigned address)

{

	assert(address < getSize());

	return (*rom)[address];

}

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

{

	copy_to_range(std::span{*rom}.subspan(start, output.size()), output);

}

void RomDebuggable::write(unsigned /*address*/, uint8_t /*value*/)

{

	// ignore

}

void RomDebuggable::moved(Rom& r)

{

	rom = &r;

}

} // namespace openmsx