// TODO:

// - improve consistency when a reset occurs: tape is removed when you were

//   recording, but it is not removed when you were playing

// - specify prefix for auto file name generation when recording (setting?)

// - append to existing wav files when recording (record command), but this is

//   basically a special case (pointer at the end) of:

// - (partly) overwrite an existing wav file from any given time index

// - seek in cassette images for the next and previous file (using empty space?)

// - (partly) overwrite existing wav files with new tape data (not very hi prio)

// - handle read-only cassette images (e.g.: CAS images or WAV files with a RO

//   flag): refuse to go to record mode when those are selected

// - smartly auto-set the position of tapes: if you insert an existing WAV

//   file, it will have the position at the start, assuming PLAY mode by

//   default.  When specifying record mode at insert (somehow), it should be

//   at the back.

//   Alternatively, we could remember the index in tape images by storing the

//   index in some persistent data file with its SHA1 sum as it was as we last

//   saw it. When there are write actions to the tape, the hash has to be

//   recalculated and replaced in the data file. An optimization would be to

//   first simply check on the length of the file and fall back to SHA1 if that

//   results in multiple matches.

#include "CassettePlayer.hh"

#include "CasImage.hh"

#include "CassettePort.hh"

#include "TsxImage.hh"

#include "WavImage.hh"

#include "CommandController.hh"

#include "CommandException.hh"

#include "Connector.hh"

#include "DeviceConfig.hh"

#include "DynamicClock.hh"

#include "EmuDuration.hh"

#include "File.hh"

#include "FileContext.hh"

#include "FileOperations.hh"

#include "FilePool.hh"

#include "GlobalSettings.hh"

#include "HardwareConfig.hh"

#include "MSXCliComm.hh"

#include "MSXMotherBoard.hh"

#include "Reactor.hh"

#include "ReverseManager.hh"

#include "TclObject.hh"

#include "WavWriter.hh"

#include "XMLElement.hh"

#include "checked_cast.hh"

#include "narrow.hh"

#include "serialize.hh"

#include "unreachable.hh"

#include "xrange.hh"

#include <algorithm>

#include <cassert>

#include <memory>

namespace openmsx {

using namespace std::literals;

// TODO: this description is not entirely accurate, but it is used

// as an identifier for this audio device in e.g. Catapult. We should

// use another way to identify audio devices A.S.A.P.!

static constexpr zstring_view DESCRIPTION = "Cassetteplayer, use to read .cas or .wav files.";

static constexpr unsigned DUMMY_INPUT_RATE = 44100; // actual rate depends on .cas/.wav file

static constexpr unsigned RECORD_FREQ = 44100;

static constexpr double RECIP_RECORD_FREQ = 1.0 / RECORD_FREQ;

static constexpr double OUTPUT_AMP = 60.0;

static zstring_view getCassettePlayerName()

{

	return "cassetteplayer";

}

CassettePlayer::CassettePlayer(HardwareConfig& hwConf)

	: ResampledSoundDevice(

		hwConf.getMotherBoard(), getCassettePlayerName(),

		static_string_view{static_string_view::lifetime_ok_tag{}, DESCRIPTION},

		1, DUMMY_INPUT_RATE, false)

	, syncEndOfTape(hwConf.getMotherBoard().getScheduler())

	, syncAudioEmu (hwConf.getMotherBoard().getScheduler())

	, motherBoard(hwConf.getMotherBoard())

	, cassettePlayerCommand(

		this,

		motherBoard.getCommandController(),

		motherBoard.getStateChangeDistributor(),

		motherBoard.getScheduler())

	, loadingIndicator(

		motherBoard.getReactor().getGlobalSettings().getThrottleManager())

	, autoRunSetting(

		motherBoard.getCommandController(),

		"autoruncassettes", "automatically try to run cassettes", true)

{

	static XMLElement* xml = [] {

		auto& doc = XMLDocument::getStaticDocument();

		XMLElement* result = doc.allocateElement("cassetteplayer");

		result->setFirstChild(doc.allocateElement("sound"))

		      ->setFirstChild(doc.allocateElement("volume", "5000"));

		return result;

	}();

	registerSound(DeviceConfig(hwConf, *xml));

	motherBoard.registerMediaProvider(getCassettePlayerName(), *this);

	motherBoard.getMSXCliComm().update(CliComm::UpdateType::HARDWARE, getCassettePlayerName(), "add");

	removeTape(EmuTime::zero());

}

CassettePlayer::~CassettePlayer()

{

	unregisterSound();

	if (auto* c = getConnector()) {

		c->unplug(getCurrentTime());

	}

	motherBoard.unregisterMediaProvider(*this);

	motherBoard.getMSXCliComm().update(CliComm::UpdateType::HARDWARE, getCassettePlayerName(), "remove");

}

void CassettePlayer::getMediaInfo(TclObject& result)

{

	result.addDictKeyValues("target", getImageName().getResolved(),

	                        "state", getStateString(),

	                        "position", getTapePos(getCurrentTime()),

	                        "length", getTapeLength(getCurrentTime()),

	                        "motorcontrol", motorControl);

}

void CassettePlayer::setMedia(const TclObject& info, EmuTime time)

{

	// This restores the tape. It does not restore the position in the tape

	// or the state of the cassetteplayer.

	auto target = info.getOptionalDictValue(TclObject("target"));

	if (!target) return;

	if (auto trgt = target->getString(); trgt.empty()) {

		removeTape(time);

	} else {

		playTape(Filename(trgt), time);

	}

}

void CassettePlayer::autoRun()

{

	if (!playImage) return;

	if (motherBoard.getReverseManager().isReplaying()) {

		// Don't execute the loading commands (keyboard type commands)

		// when we're replaying a recording. Because the recording

		// already contains those commands.

		return;

	}

	// try to automatically run the tape, if that's set

	using enum CassetteImage::FileType;

	auto type = playImage->getFirstFileType();

	if (!autoRunSetting.getBoolean() || type == UNKNOWN) {

		return;

	}

	bool is_SVI = motherBoard.getMachineType() == "SVI"; // assume all other are 'MSX*' (might not be correct for 'Coleco')

	std::string_view H_READ = is_SVI ? "0xFE8E"sv : "0xFF07"sv; // Hook for Ready

	std::string_view H_MAIN = is_SVI ? "0xFE94"sv : "0xFF0C"sv; // Hook for Main Loop

	std::string_view instr1, instr2;

	switch (type) {

		case ASCII:

			instr1 = R"({RUN\"CAS:\"\r})";

			break;

		case BINARY:

			instr1 = R"({BLOAD\"CAS:\",R\r})";

			break;

		case BASIC:

			// Note that CLOAD:RUN won't work: BASIC ignores stuff

			// after the CLOAD command. That's why it's split in two.

			instr1 = "{CLOAD\\r}";

			instr2 = "{RUN\\r}";

			break;

		default:

			UNREACHABLE; // Shouldn't be possible

	}

	std::string command = strCat(

		"namespace eval ::openmsx {\n"

		"  variable auto_run_bp\n"

		"  proc auto_run_cb {args} {\n"

		"    variable auto_run_bp\n"

		"    debug remove_bp $auto_run_bp\n"

		"    unset auto_run_bp\n"

		// Without the 0.2s delay here, the type command gets messed up

		// on MSX1 machines for some reason (starting to type too early?)

		// When using 0.1s delay only, the typing works, but still some

		// things go wrong on some machines with some games (see #1509

		// for instance)

		"    after time 0.2 \"type [lindex $args 0]\"\n"

		"    set next [lrange $args 1 end]\n"

		"    if {[llength $next] == 0} return\n"

		// H_READ is used by some firmwares; we need to hook the

		// H_MAIN that happens immediately after H_READ.

		"    set cmd \"openmsx::auto_run_cb $next\"\n"

		"    set openmsx::auto_run_bp [debug set_bp ", H_MAIN, " 1 \"$cmd\"]\n"

		"  }\n"

		"  if {[info exists auto_run_bp]} {debug remove_bp $auto_run_bp\n}\n"

		"  set auto_run_bp [debug set_bp ", H_READ, " 1 {\n"

		"    openmsx::auto_run_cb {{}} ", instr1, ' ', instr2, "\n"

		"  }]\n"

		// re-trigger hook(s), needed when already booted in BASIC

		"  type_via_keyboard \'\\r\n"

		"}");

	try {

		motherBoard.getCommandController().executeCommand(command);

	} catch (CommandException& e) {

		motherBoard.getMSXCliComm().printWarning(

			"Error executing loading instruction using command \"",

			command, "\" for AutoRun: ",

			e.getMessage(), "\n Please report a bug.");

	}

}

std::string CassettePlayer::getStateString() const

{

	switch (getState()) {

		using enum State;

		case PLAY:   return "play";

		case RECORD: return "record";

		case STOP:   return "stop";

	}

	UNREACHABLE;

}

bool CassettePlayer::isRolling() const

{

	// Is the tape 'rolling'?

	// is true when:

	//  not in stop mode (there is a tape inserted and not at end-of-tape)

	//  AND [ user forced playing (motorControl=off) OR motor enabled by

	//        software (motor=on) ]

	return (getState() != State::STOP) && (motor || !motorControl);

}

double CassettePlayer::getTapePos(EmuTime time)

{

	sync(time);

	if (getState() == State::RECORD) {

		// we record 8-bit mono, so bytes == samples

		return (double(recordImage->getBytes()) + partialInterval) * RECIP_RECORD_FREQ;

	} else {

		return tapePos.toDouble();

	}

}

void CassettePlayer::setTapePos(EmuTime time, double newPos)

{

	assert(getState() != State::RECORD);

	sync(time);

	auto pos = std::clamp(newPos, 0.0, getTapeLength(time));

	tapePos = EmuTime::zero() + EmuDuration::sec(pos);

	wind(time);

}

double CassettePlayer::getTapeLength(EmuTime time)

{

	if (playImage) {

		return playImage->getEndTime().toDouble();

	} else if (getState() == State::RECORD) {

		return getTapePos(time);

	} else {

		return 0.0;

	}

}

void CassettePlayer::checkInvariants() const

{

	switch (getState()) {

	case State::STOP:

		assert(!recordImage);

		if (playImage) {

			// we're at end-of tape

			assert(!getImageName().empty());

		} else {

			// no tape inserted, imageName may or may not be empty

		}

		break;

	case State::PLAY:

		assert(!getImageName().empty());

		assert(!recordImage);

		assert(playImage);

		break;

	case State::RECORD:

		assert(!getImageName().empty());

		assert(recordImage);

		assert(!playImage);

		break;

	default:

		UNREACHABLE;

	}

}

void CassettePlayer::setState(State newState, const Filename& newImage,

                              EmuTime time)

{

	sync(time);

	// set new state if different from old state

	State oldState = getState();

	if (oldState == newState) return;

	// cannot directly switch from PLAY to RECORD or vice-versa,

	// (should always go via STOP)

	assert(!((oldState == State::PLAY)   && (newState == State::RECORD)));

	assert(!((oldState == State::RECORD) && (newState == State::PLAY)));

	// stuff for leaving the old state

	//  'recordImage==nullptr' can happen in case of loadstate.

	if ((oldState == State::RECORD) && recordImage) {

		flushOutput();

		bool empty = recordImage->isEmpty();

		recordImage.reset();

		if (empty) {

			// delete the created WAV file, as it is useless

			FileOperations::unlink(getImageName().getResolved()); // ignore errors

			setImageName(Filename());

		}

	}

	// actually switch state

	state = newState;

	setImageName(newImage);

	// stuff for entering the new state

	if (newState == State::RECORD) {

		partialOut = 0.0;

		partialInterval = 0.0;

		lastX = lastOutput ? OUTPUT_AMP : -OUTPUT_AMP;

		lastY = 0.0;

	}

	motherBoard.getMSXCliComm().update(

		CliComm::UpdateType::STATUS, "cassetteplayer", getStateString());

	updateLoadingState(time); // sets SP for tape-end detection

	checkInvariants();

}

void CassettePlayer::updateLoadingState(EmuTime time)

{

	assert(prevSyncTime == time); // sync() must be called

	// TODO also set loadingIndicator for RECORD?

	// note: we don't use isRolling()

	loadingIndicator.update(motor && (getState() == State::PLAY));

	syncEndOfTape.removeSyncPoint();

	if (isRolling() && (getState() == State::PLAY)) {

		syncEndOfTape.setSyncPoint(time + (playImage->getEndTime() - tapePos));

	}

}

void CassettePlayer::setImageName(const Filename& newImage)

{

	casImage = newImage;

	motherBoard.getMSXCliComm().update(

		CliComm::UpdateType::MEDIA, "cassetteplayer", casImage.getResolved());

}

void CassettePlayer::insertTape(const Filename& filename, EmuTime time)

{

	if (!filename.empty()) {

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

		std::string msgWav, msgCas, msgTsx;

		std::unique_ptr<CassetteImage> newImage;

		if (!newImage) {

			try {

				// first try WAV

				newImage = std::make_unique<WavImage>(filename, filePool);

			} catch (MSXException& e) {

				msgWav = std::move(e).getMessage();

			}

		}

		if (!newImage) {

			try {

				// if that fails use CAS

				newImage = std::make_unique<CasImage>(filename, filePool,

					motherBoard.getMSXCliComm());

			} catch (MSXException& e) {

				msgCas = std::move(e).getMessage();

			}

		}

		if (!newImage) {

			try {

				// if that fails use TSX

				newImage = std::make_unique<TsxImage>(

					filename, filePool,

					motherBoard.getMSXCliComm());

			} catch (MSXException& e) {

				msgTsx = std::move(e).getMessage();

			}

		}

		if (!newImage) {

			throw MSXException(

				"Failed to insert image: "

				"tried WAV: \"", msgWav, "\""

				", CAS: \"", msgCas, "\""

				" and TSX: \"", msgTsx, "\".");

		}

		playImage = std::move(newImage);

	} else {

		// This is a bit tricky, consider this scenario: we switch from

		// RECORD->PLAY, but we didn't actually record anything: The

		// removeTape() call above (indirectly) deletes the empty

		// recorded wav image and also clears imageName. Now because

		// the 'filename' parameter is passed by reference, and because

		// getImageName() returns a reference, this 'filename'

		// parameter now also is an empty string.

	}

	// possibly recreate resampler

	if (unsigned inputRate = playImage ? playImage->getFrequency() : 44100;

	    inputRate != getInputRate()) {

		setInputRate(inputRate);

		createResampler();

	}

	// trigger (re-)query of getAmplificationFactorImpl()

	setSoftwareVolume(1.0f, time);

	setImageName(filename);

}

void CassettePlayer::playTape(const Filename& filename, EmuTime time)

{

	// Temporally go to STOP state:

	// RECORD: First close the recorded image. Otherwise it goes wrong

	//         if you switch from RECORD->PLAY on the same image.

	// PLAY: Go to stop because we temporally violate some invariants

	//       (tapePos can be beyond end-of-tape).

	setState(State::STOP, getImageName(), time); // keep current image

	insertTape(filename, time);

	rewind(time); // sets PLAY mode

}

void CassettePlayer::rewind(EmuTime time)

{

	sync(time); // before tapePos changes

	assert(getState() != State::RECORD);

	tapePos = EmuTime::zero();

	audioPos = 0;

	wind(time);

	autoRun();

}

void CassettePlayer::wind(EmuTime time)

{

	if (getImageName().empty()) {

		// no image inserted, do nothing

		assert(getState() == State::STOP);

	} else {

		// keep current image

		setState(State::PLAY, getImageName(), time);

	}

	updateLoadingState(time);

}

void CassettePlayer::recordTape(const Filename& filename, EmuTime time)

{

	removeTape(time); // flush (possible) previous recording

	recordImage = std::make_unique<Wav8Writer>(filename.getResolved(), 1, RECORD_FREQ);

	tapePos = EmuTime::zero();

	setState(State::RECORD, filename, time);

}

void CassettePlayer::removeTape(EmuTime time)

{

	// first stop with tape still inserted

	setState(State::STOP, getImageName(), time);

	// then remove the tape

	playImage.reset();

	tapePos = EmuTime::zero();

	setImageName({});

}

void CassettePlayer::setMotor(bool status, EmuTime time)

{

	if (status != motor) {

		sync(time);

		motor = status;

		updateLoadingState(time);

	}

}

void CassettePlayer::setMotorControl(bool status, EmuTime time)

{

	if (status != motorControl) {