#include "ReverseManager.hh"

#include "CommandException.hh"

#include "Debugger.hh"

#include "Display.hh"

#include "Event.hh"

#include "EventDelay.hh"

#include "EventDistributor.hh"

#include "FileContext.hh"

#include "FileOperations.hh"

#include "Keyboard.hh"

#include "MSXCliComm.hh"

#include "MSXCommandController.hh"

#include "MSXMixer.hh"

#include "MSXMotherBoard.hh"

#include "Reactor.hh"

#include "StateChange.hh"

#include "StateChangeDistributor.hh"

#include "TclArgParser.hh"

#include "TclObject.hh"

#include "Timer.hh"

#include "XMLException.hh"

#include "serialize.hh"

#include "serialize_meta.hh"

#include "format.hh"

#include "narrow.hh"

#include "one_of.hh"

#include <array>

#include <cassert>

#include <cmath>

#include <ranges>

#include <utility>

#include <variant>

namespace openmsx {

using namespace std::literals;

// Time between two snapshots (in seconds)

static constexpr double SNAPSHOT_PERIOD = 1.0;

// Max number of snapshots in a replay file

static constexpr unsigned MAX_NOF_SNAPSHOTS = 10;

// Min distance between snapshots in replay file

static constexpr auto MIN_PARTITION_LENGTH = EmuDuration::sec(60.0);

// Max distance of one before last snapshot before the end time in replay file

static constexpr auto MAX_DIST_1_BEFORE_LAST_SNAPSHOT = EmuDuration::sec(30.0);

// A replay is a struct that contains a vector of motherboards and an MSX event

// log. Those combined are a replay, because you can replay the events from an

// existing motherboard state: the vector has to have at least one motherboard

// (the initial state), but can have optionally more motherboards, which are

// merely in-between snapshots, so it is quicker to jump to a later time in the

// event log.

struct Replay

{

	explicit Replay(Reactor& reactor_)

		: reactor(reactor_) {}

	Reactor& reactor;

	ReverseManager::Events* events;

	std::vector<Reactor::Board> motherBoards;

	EmuTime currentTime = EmuTime::dummy();

	// this is the amount of times the reverse goto command was used, which

	// is interesting for the TAS community (see tasvideos.org). It's an

	// indication of the effort it took to create the replay. Note that

	// there is no way to verify this number.

	unsigned reRecordCount;

	template<typename Archive>

	void serialize(Archive& ar, unsigned version)

	{

		if (ar.versionAtLeast(version, 2)) {

			ar.serializeWithID("snapshots", motherBoards, std::ref(reactor));

		} else {

			Reactor::Board newBoard = reactor.createEmptyMotherBoard();

			ar.serialize("snapshot", *newBoard);

			motherBoards.push_back(std::move(newBoard));

		}

		ar.serialize("events", *events);

		if (ar.versionAtLeast(version, 3)) {

			ar.serialize("currentTime", currentTime);

		} else {

			assert(Archive::IS_LOADER);

			assert(!events->empty());

			currentTime = getTime(events->back());

		}

		if (ar.versionAtLeast(version, 4)) {

			ar.serialize("reRecordCount", reRecordCount);

		}

	}

};

SERIALIZE_CLASS_VERSION(Replay, 4);

// struct ReverseHistory

void ReverseManager::ReverseHistory::swap(ReverseHistory& other) noexcept

{

	std::swap(chunks, other.chunks);

	std::swap(events, other.events);

}

void ReverseManager::ReverseHistory::clear()

{

	// clear() and free storage capacity

	Chunks().swap(chunks);

	Events().swap(events);

}

// class ReverseManager

ReverseManager::ReverseManager(MSXMotherBoard& motherBoard_)

	: syncNewSnapshot(motherBoard_.getScheduler())

	, syncInputEvent (motherBoard_.getScheduler())

	, motherBoard(motherBoard_)

	, eventDistributor(motherBoard.getReactor().getEventDistributor())

	, reverseCmd(motherBoard.getCommandController())

{

	eventDistributor.registerEventListener(EventType::TAKE_REVERSE_SNAPSHOT, *this);

	assert(!isCollecting());

	assert(!isReplaying());

}

ReverseManager::~ReverseManager()

{

	stop();

	eventDistributor.unregisterEventListener(EventType::TAKE_REVERSE_SNAPSHOT, *this);

}

bool ReverseManager::isReplaying() const

{

	return replayIndex != history.events.size();

}

void ReverseManager::start()

{

	if (!isCollecting()) {

		// create first snapshot

		collecting = true;

		takeSnapshot(getCurrentTime());

		// schedule creation of next snapshot

		schedule(getCurrentTime());

		// start recording events

		motherBoard.getStateChangeDistributor().registerRecorder(*this);

	}

	assert(isCollecting());

}

void ReverseManager::stop()

{

	if (isCollecting()) {

		motherBoard.getStateChangeDistributor().unregisterRecorder(*this);

		syncNewSnapshot.removeSyncPoint(); // don't schedule new snapshot takings

		syncInputEvent .removeSyncPoint(); // stop any pending replay actions

		history.clear();

		replayIndex = 0;

		collecting = false;

		pendingTakeSnapshot = false;

	}

	assert(!pendingTakeSnapshot);

	assert(!isCollecting());

	assert(!isReplaying());

}

EmuTime ReverseManager::getEndTime(const ReverseHistory& hist) const

{

	if (!hist.events.empty()) {

		if (const auto* ev = std::get_if<EndLogEvent>(&hist.events.back())) {

			// last log element is EndLogEvent, use that

			return ev->getTime();

		}

	}

	// otherwise use current time

	assert(!isReplaying());

	return getCurrentTime();

}

bool ReverseManager::isViewOnlyMode() const

{

	return motherBoard.getStateChangeDistributor().isViewOnlyMode();

}

void ReverseManager::setViewOnlyMode(bool value)

{

	motherBoard.getStateChangeDistributor().setViewOnlyMode(value);

}

double ReverseManager::getBegin() const

{

	EmuTime b(isCollecting() ? begin(history.chunks)->second.time

	                         : EmuTime::zero());

	return b.toDouble();

}

double ReverseManager::getEnd() const

{

	EmuTime end(isCollecting() ? getEndTime(history) : EmuTime::zero());

	return end.toDouble();

}

double ReverseManager::getCurrent() const

{

	EmuTime current(isCollecting() ? getCurrentTime() : EmuTime::zero());

	return current.toDouble();

}

void ReverseManager::status(TclObject& result) const

{

	result.addDictKeyValue("status", !isCollecting() ? "disabled"sv

	                               : isReplaying()   ? "replaying"sv

	                                                 : "enabled"sv);

	result.addDictKeyValue("begin", getBegin());

	result.addDictKeyValue("end", getEnd());

	result.addDictKeyValue("current", getCurrent());

	TclObject snapshots;

	snapshots.addListElements(std::views::transform(history.chunks, [](auto& p) {

		return p.second.time.toDouble();

	}));

	result.addDictKeyValue("snapshots", snapshots);

	auto lastEvent = rbegin(history.events);

	if (lastEvent != rend(history.events) && std::holds_alternative<EndLogEvent>(*lastEvent)) {

		++lastEvent;

	}

	EmuTime le(isCollecting() && (lastEvent != rend(history.events)) ? getTime(*lastEvent) : EmuTime::zero());

	result.addDictKeyValue("last_event", le.toDouble());

}

void ReverseManager::debugInfo(TclObject& result) const

{

	// TODO this is useful during development, but for the end user this

	// information means nothing. We should remove this later.

	std::string res;

	size_t totalSize = 0;

	for (const auto& [idx, chunk] : history.chunks) {

		strAppend(res, idx, ' ',

		          chunk.time.toDouble(), ' ',

		          (chunk.time.toDouble() / getCurrentTime().toDouble()) * 100, "%"

		          " (", chunk.savestate.size(), ")"

		          " (next event index: ", chunk.eventCount, ")\n");

		totalSize += chunk.savestate.size();

	}

	strAppend(res, "total size: ", totalSize, '\n');

	result = res;

}

static std::pair<bool, double> parseGoTo(Interpreter& interp, std::span<const TclObject> tokens)

{

	bool noVideo = false;

	std::array info = {flagArg("-novideo", noVideo)};

	auto args = parseTclArgs(interp, tokens.subspan(2), info);

	if (args.size() != 1) throw SyntaxError();

	double time = args[0].getDouble(interp);

	return {noVideo, time};

}

void ReverseManager::goBack(std::span<const TclObject> tokens)

{

	auto& interp = motherBoard.getReactor().getInterpreter();

	auto [noVideo, t] = parseGoTo(interp, tokens);

	EmuTime now = getCurrentTime();

	EmuTime target(EmuTime::dummy());

	if (t >= 0) {

		EmuDuration d = EmuDuration::sec(t);

		if (d < (now - EmuTime::zero())) {

			target = now - d;

		} else {

			target = EmuTime::zero();

		}

	} else {

		target = now + EmuDuration::sec(-t);

	}

	goTo(target, noVideo);

}

void ReverseManager::goTo(std::span<const TclObject> tokens)

{

	auto& interp = motherBoard.getReactor().getInterpreter();

	auto [noVideo, t] = parseGoTo(interp, tokens);

	EmuTime target = EmuTime::zero() + EmuDuration::sec(t);

	goTo(target, noVideo);

}

void ReverseManager::goTo(EmuTime target, bool noVideo)

{

	if (!isCollecting()) {

		throw CommandException(

			"Reverse was not enabled. First execute the 'reverse "

			"start' command to start collecting data.");

	}

	goTo(target, noVideo, history, true); // move in current time-line

}

// this function is used below, but factored out, because it's already way too long

static void reportProgress(Reactor& reactor, EmuTime targetTime, float fraction)

{

	double targetTimeDisp = targetTime.toDouble();

	std::array<char, 64> buf;

	auto s = format_to_buf(buf,

		"Time warping to {}:{:05.2f}",

		int(targetTimeDisp / 60), std::fmod(targetTimeDisp, 60.0));

	reactor.getCliComm().printProgress(s, fraction);

	reactor.getDisplay().repaint();

}

void ReverseManager::goTo(

	EmuTime target, bool noVideo, ReverseHistory& hist,

	bool sameTimeLine)

{

	auto& mixer = motherBoard.getMSXMixer();

	try {

		// The call to MSXMotherBoard::fastForward() below may take

		// some time to execute. The DirectX sound driver has a problem

		// (not easily fixable) that it keeps on looping the sound

		// buffer on buffer underruns (the SDL driver plays silence on

		// underrun). At the end of this function we will switch to a

		// different active MSXMotherBoard. So we can as well now

		// already mute the current MSXMotherBoard.

		mixer.mute();

		// -- Locate destination snapshot --

		// We can't go back further in the past than the first snapshot.

		assert(!hist.chunks.empty());

		auto it = begin(hist.chunks);

		EmuTime firstTime = it->second.time;

		EmuTime targetTime = std::max(target, firstTime);

		// Also don't go further into the future than 'end time'.

		targetTime = std::min(targetTime, getEndTime(hist));

		// Duration of 2 PAL frames. Possible improvement is to use the

		// actual refresh rate (PAL/NTSC). But it should be the refresh

		// rate of the active video chip (v99x8/v9990) at the target

		// time. This is quite complex to get and the difference between

		// 2 PAL and 2 NTSC frames isn't that big.

		static constexpr double dur2frames = 2.0 * (313.0 * 1368.0) / (3579545.0 * 6.0);

		EmuDuration preDelta = EmuDuration::sec(noVideo ? 0.0 : dur2frames);

		EmuTime preTarget = ((targetTime - firstTime) > preDelta)

		                  ? targetTime - preDelta

		                  : firstTime;

		// find oldest snapshot that is not newer than requested time

		// TODO ATM we do a linear search, could be improved to do a binary search.

		assert(it->second.time <= preTarget); // first one is not newer

		assert(it != end(hist.chunks)); // there are snapshots

		do {

			++it;

		} while (it != end(hist.chunks) &&

			 it->second.time <= preTarget);

		// We found the first one that's newer, previous one is last

		// one that's not newer (thus older or equal).

		assert(it != begin(hist.chunks));

		--it;

		ReverseChunk& chunk = it->second;

		EmuTime snapshotTime = chunk.time;

		assert(snapshotTime <= preTarget);

		// IF current time is before the wanted time AND either

		//   - current time is closer than the closest (earlier) snapshot

		//   - OR current time is close enough (I arbitrarily choose 1s)

		// THEN it's cheaper to start from the current position (and

		//      emulated forward) than to start from a snapshot

		// THOUGH only when we're currently in the same time-line

		//   e.g. OK for a 'reverse goto' command, but not for a

		//   'reverse loadreplay' command.

		auto& reactor = motherBoard.getReactor();

		EmuTime currentTime = getCurrentTime();

		MSXMotherBoard* newBoard;

		Reactor::Board newBoard_; // either nullptr or the same as newBoard

		if (sameTimeLine &&

		    (currentTime <= preTarget) &&

		    ((snapshotTime <= currentTime) ||

		     ((preTarget - currentTime) < EmuDuration::sec(1.0)))) {

			newBoard = &motherBoard; // use current board

			// suppress messages just in case, as we're later going

			// to fast forward to the right time

			newBoard->getMSXCliComm().setSuppressMessages(true);

		} else {

			// Note: we don't (anymore) erase future snapshots

			// -- restore old snapshot --

			newBoard_ = reactor.createEmptyMotherBoard();

			newBoard = newBoard_.get();

			// suppress messages we'd get by deserializing (and

			// thus instantiating the parts of) the new board

			newBoard->getMSXCliComm().setSuppressMessages(true);

			MemInputArchive in(chunk.savestate,

					   chunk.deltaBlocks);

			in.serialize("machine", *newBoard);

			if (eventDelay) {

				// Handle all events that are scheduled, but not yet

				// distributed. This makes sure no events get lost

				// (important to keep host/msx keyboard in sync).

				eventDelay->flush();

			}

			// terminate replay log with EndLogEvent (if not there already)

			if (hist.events.empty() ||

			    !std::holds_alternative<EndLogEvent>(hist.events.back())) {

				hist.events.emplace_back(std::in_place_type_t<EndLogEvent>{},

				                         currentTime);

			}

			// Transfer history to the new ReverseManager.

			// Also we should stop collecting in this ReverseManager,

			// and start collecting in the new one.

			auto& newManager = newBoard->getReverseManager();

			newManager.transferHistory(hist, chunk.eventCount);

			// transfer (or copy) state from old to new machine

			transferState(*newBoard);

			// In case of load-replay it's possible we are not collecting,

			// but calling stop() anyway is ok.

			stop();

		}

		// -- goto correct time within snapshot --

		// Fast forward 2 frames before target time.

		// If we're short on snapshots, create them at intervals that are

		// at least the usual interval, but the later, the more: each

		// time divide the remaining time in half and make a snapshot

		// there.

		auto lastProgress = Timer::getTime();

		auto startMSXTime = newBoard->getCurrentTime();

		auto lastSnapshotTarget = startMSXTime;

		bool everShowedProgress = false;

		syncNewSnapshot.removeSyncPoint(); // don't schedule new snapshot takings during fast forward

		while (true) {

			auto currentTimeNewBoard = newBoard->getCurrentTime();

			auto nextSnapshotTarget = std::min(

				preTarget,

				lastSnapshotTarget + std::max(

					EmuDuration::sec(SNAPSHOT_PERIOD),

					(preTarget - lastSnapshotTarget) / 2

					));

			auto nextTarget = std::min(nextSnapshotTarget, currentTimeNewBoard + EmuDuration::sec(1));

			newBoard->fastForward(nextTarget, true);

			if (auto now = Timer::getTime();

			    ((now - lastProgress) > 1000000) || ((currentTimeNewBoard >= preTarget) && everShowedProgress)) {

				everShowedProgress = true;

				lastProgress = now;

				auto fraction = (currentTimeNewBoard - startMSXTime).toDouble() / (preTarget - startMSXTime).toDouble();

				reportProgress(newBoard->getReactor(), targetTime, float(fraction));

			}

			// note: fastForward does not always stop at