#include "SamplePlayer.hh"

#include "DeviceConfig.hh"
#include "FileContext.hh"
#include "MSXCliComm.hh"
#include "MSXException.hh"
#include "serialize.hh"

#include "narrow.hh"
#include "xrange.hh"

#include <cassert>
#include <memory>

namespace openmsx {

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

[[nodiscard]] static auto loadSamples(
	std::string_view name, const DeviceConfig& config,
	std::string_view baseName, std::string_view alternativeName,
	unsigned numSamples)
{
	dynarray<WavData> result(numSamples); // initialize with empty WAVs

	bool alreadyWarned = false;
	const auto& context = systemFileContext();
	for (auto i : xrange(numSamples)) {
		try {
			auto filename = tmpStrCat(baseName, i, ".wav");
			result[i] = WavData(context.resolve(filename));
		} catch (MSXException& e1) {
			try {
				if (alternativeName.empty()) throw;
				auto filename = tmpStrCat(
					alternativeName, i, ".wav");
				result[i] = WavData(context.resolve(filename));
			} catch (MSXException& /*e2*/) {
				if (!alreadyWarned) {
					alreadyWarned = true;
					// print message from the 1st error
					config.getCliComm().printWarning(
						"Couldn't read ", name, " sample data: ",
						e1.getMessage(),
						". Continuing without sample data.");
				}
			}
		}
	}
	return result;
}

SamplePlayer::SamplePlayer(const std::string& name_, static_string_view desc,
                           const DeviceConfig& config,
                           std::string_view samplesBaseName, unsigned numSamples,
                           std::string_view alternativeName)
	: ResampledSoundDevice(config.getMotherBoard(), name_, desc, 1, DUMMY_INPUT_RATE, false)
	, samples(loadSamples(name_, config, samplesBaseName, alternativeName, numSamples))
{
	registerSound(config);
	reset();
}

SamplePlayer::~SamplePlayer()
{
	unregisterSound();
}

void SamplePlayer::reset()
{
	currentSampleNum = unsigned(-1);
	stopRepeat();
}

void SamplePlayer::play(unsigned sampleNum)
{
	assert(sampleNum < samples.size());
	currentSampleNum = sampleNum;
	index = 0;
	setWavParams();
}

void SamplePlayer::setWavParams()
{
	if ((currentSampleNum < samples.size()) &&
	    samples[currentSampleNum].getSize()) {
		const auto& wav = samples[currentSampleNum];
		bufferSize = narrow<unsigned>(wav.getSize());

		unsigned freq = wav.getFreq();
		if (freq != getInputRate()) {
			// this potentially switches resampler, so there might be
			// some dropped samples if this is done in the middle of
			// playing, though this shouldn't happen often (or at all)
			setInputRate(freq);
			createResampler();
		}
	} else {
		reset();
	}
}

void SamplePlayer::repeat(unsigned sampleNum)
{
	assert(sampleNum < samples.size());
	nextSampleNum = sampleNum;
	if (!isPlaying()) {
		doRepeat();
	}
}

void SamplePlayer::generateChannels(std::span<float*> bufs, unsigned num)
{
	// Single channel device: replace content of bufs[0] (not add to it).
	assert(bufs.size() == 1);
	if (!isPlaying()) {
		bufs[0] = nullptr;
		return;
	}

	const auto& wav = samples[currentSampleNum];
	for (auto i : xrange(num)) {
		if (index >= bufferSize) {
			if (nextSampleNum != unsigned(-1)) {
				doRepeat();
			} else {
				currentSampleNum = unsigned(-1);
				// fill remaining buffer with zeros
				do {
					bufs[0][i++] = 0.0f;
				} while (i < num);
				break;
			}
		}
		bufs[0][i] = narrow<float>(3 * wav.getSample(index++));
	}
}

void SamplePlayer::doRepeat()
{
	play(nextSampleNum);
}

template<typename Archive>
void SamplePlayer::serialize(Archive& ar, unsigned /*version*/)
{
	ar.serialize("index",            index,
	             "currentSampleNum", currentSampleNum,
	             "nextSampleNum",    nextSampleNum);
	if constexpr (Archive::IS_LOADER) {
		setWavParams();
	}
}
INSTANTIATE_SERIALIZE_METHODS(SamplePlayer);

} // namespace openmsx