/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "audio/audiostream.h"
#include "audio/mixer.h"
#include "common/frac.h"
#include "common/mutex.h"
#include "common/system.h"

#ifndef SCI_SOUND_DRIVERS_MACMIXER_H
#define SCI_SOUND_DRIVERS_MACMIXER_H

namespace Sci {

// Unsigned version of frac_t
typedef uint32 ufrac_t;
static inline ufrac_t uintToUfrac(uint16 value) { return value << FRAC_BITS; }
static inline uint16 ufracToUint(ufrac_t value) { return value >> FRAC_BITS; }

template <typename T>
class Mixer_Mac : public Audio::AudioStream {
public:
	enum {
		kChannels = 4,
		kInterruptFreq = 60
	};

	enum Mode {
		kModeAuthentic,
		kModeHq,
		kModeHqStereo
	};

	Mixer_Mac(Mode mode);
	void startMixer();
	void stopMixer();
	void setMixerVolume(byte volume) { _mixVolume = volume; }
	void resetChannel(uint channel);
	void resetChannels();
	// NOTE: Last sample accessed is data[endOffset + 1] in kModeHq(Stereo)
	void setChannelData(uint channel, const byte *data, uint16 startOffset, uint16 endOffset, uint16 loopLength = 0);
	void setChannelStep(uint channel, ufrac_t step);
	void setChannelVolume(uint channel, byte volume);
	void setChannelPan(uint channel, byte pan);

	// AudioStream
	bool isStereo() const override { return _mode == kModeHqStereo; }
	int getRate() const override { return (_mode == kModeAuthentic ? 11127 : g_system->getMixer()->getOutputRate()); }
	int readBuffer(int16 *data, const int numSamples) override;
	bool endOfData() const override { return false; }

	Common::Mutex _mutex;

private:
	template <Mode mode>
	void generateSamples(int16 *buf, int len);

	struct Channel {
		ufrac_t pos;
		ufrac_t step;
		const byte *data;
		uint16 endOffset;
		uint16 loopLength;
		byte volume;
		int8 pan;
	};

	ufrac_t _nextTick;
	ufrac_t _samplesPerTick;
	bool _isPlaying;
	const Mode _mode;
	Channel _mixChannels[kChannels];
	byte _mixVolume;
};

template <typename T>
Mixer_Mac<T>::Mixer_Mac(Mode mode) :
	_nextTick(0),
	_samplesPerTick(0),
	_mode(mode),
	_isPlaying(false),
	_mixChannels(),
	_mixVolume(8) {}

template <typename T>
void Mixer_Mac<T>::startMixer() {
	_nextTick = _samplesPerTick = uintToUfrac(getRate() / kInterruptFreq) + uintToUfrac(getRate() % kInterruptFreq) / kInterruptFreq;

	resetChannels();
	_isPlaying = true;
}

template <typename T>
void Mixer_Mac<T>::stopMixer() {
	resetChannels();
	_isPlaying = false;
}

template <typename T>
void Mixer_Mac<T>::setChannelData(uint channel, const byte *data, uint16 startOffset, uint16 endOffset, uint16 loopLength) {
	assert(channel < kChannels);

	Channel &ch = _mixChannels[channel];

	ch.data = data;
	ch.pos = uintToUfrac(startOffset);
	ch.endOffset = endOffset;
	ch.loopLength = loopLength;
}

template <typename T>
void Mixer_Mac<T>::setChannelStep(uint channel, ufrac_t step) {
	assert(channel < kChannels);

	if (_mode == kModeAuthentic) {
		_mixChannels[channel].step = step;
	} else {
		// We could take 11127Hz here, but it appears the original steps were
		// computed for 11000Hz
		// FIXME: One or two more bits of step precision might be nice here
		_mixChannels[channel].step = (ufrac_t)(step * 11000ULL / getRate());
	}
}

template <typename T>
void Mixer_Mac<T>::setChannelVolume(uint channel, byte volume) {
	assert(channel < kChannels);
	_mixChannels[channel].volume = volume;
}

template <typename T>
void Mixer_Mac<T>::setChannelPan(uint channel, byte pan) {
	assert(channel < kChannels);
	_mixChannels[channel].pan = pan;
}

template <typename T>
template <typename Mixer_Mac<T>::Mode mode>
void Mixer_Mac<T>::generateSamples(int16 *data, int len) {
	for (int i = 0; i < len; ++i) {
		int32 mixL = 0;
		int32 mixR = 0;

		for (int ci = 0; ci < kChannels; ++ci) {
			Channel &ch = _mixChannels[ci];

			if (!ch.data)
				continue;

			const uint16 curOffset = ufracToUint(ch.pos);

			if (mode == kModeHq || mode == kModeHqStereo) {
				int32 sample = (ch.data[curOffset] - 0x80) << 8;
				// Since _extraSamples > 0, we can safely access this sample
				const int32 sample2 = (ch.data[curOffset + 1] - 0x80) << 8;
				sample += fracToInt((sample2 - sample) * (ch.pos & FRAC_LO_MASK));
				sample *= ch.volume;

				if (mode == kModeHqStereo) {
					mixL += sample * (127 - ch.pan) / (63 * 64);
					mixR += sample * ch.pan / (63 * 64);
				} else {
					mixL += sample / 63;
				}
			} else {
				mixL += static_cast<T *>(this)->applyChannelVolume(ch.volume, ch.data[curOffset]) << 8;
			}

			ch.pos += ch.step;

			if (ufracToUint(ch.pos) > ch.endOffset) {
				if (ch.loopLength > 0) {
					do {
						ch.pos -= uintToUfrac(ch.loopLength);
					} while (ufracToUint(ch.pos) > ch.endOffset);
				} else {
					static_cast<T *>(this)->onChannelFinished(ci);
					ch.data = nullptr;
				}
			}
		}

		*data++ = (int16)CLIP<int32>(mixL, -32768, 32767) * _mixVolume / 8;
		if (mode == kModeHqStereo)
			*data++ = (int16)CLIP<int32>(mixR, -32768, 32767) * _mixVolume / 8;
	}
}

template <typename T>
int Mixer_Mac<T>::readBuffer(int16 *data, const int numSamples) {
	// Would probably be better inside generateSamples, but let's follow Audio::Paula
	Common::StackLock lock(_mutex);

	if (!_isPlaying) {
		memset(data, 0, numSamples * 2);
		return numSamples;
	}

	const int stereoFactor = isStereo() ? 2 : 1;
	int len = numSamples / stereoFactor;

	do {
		int step = len;
		if (step > ufracToUint(_nextTick))
			step = ufracToUint(_nextTick);

		switch (_mode) {
		case kModeAuthentic:
			generateSamples<kModeAuthentic>(data, step);
			break;
		case kModeHq:
			generateSamples<kModeHq>(data, step);
			break;
		case kModeHqStereo:
			generateSamples<kModeHqStereo>(data, step);
		}

		_nextTick -= uintToUfrac(step);
		if (ufracToUint(_nextTick) == 0) {
			static_cast<T *>(this)->interrupt();
			_nextTick += _samplesPerTick;
		}

		data += step * stereoFactor;
		len -= step;
	} while (len);

	return numSamples;
}

template <typename T>
void Mixer_Mac<T>::resetChannel(uint channel) {
	assert(channel < kChannels);

	Channel &ch = _mixChannels[channel];

	ch.pos = 0;
	ch.step = 0;
	ch.data = nullptr;
	ch.endOffset = 0;
	ch.loopLength = 0;
	ch.volume = 0;
	ch.pan = 64;
}

template <typename T>
void Mixer_Mac<T>::resetChannels() {
	for (uint ci = 0; ci < kChannels; ++ci)
		resetChannel(ci);
}

} // End of namespace Sci

#endif // SCI_SOUND_DRIVERS_MACMIXER_H