/*
  Copyright (c) 2021 Alex Diener
  
  This software is provided 'as-is', without any express or implied
  warranty. In no event will the authors be held liable for any damages
  arising from the use of this software.
  
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
  
  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
  
  Alex Diener alex@ludobloom.com
*/

#include "audiosynth/AudioSamplerParameters_generalSynth.h"
#include "audiosynth/GeneralSynthConfiguration.h"
#include "utilities/IOUtilities.h"
#include "utilities/lookup3.h"
#include <stdarg.h>

#define stemobject_implementation AudioSamplerParameters_generalSynth

stemobject_vtable_begin();
stemobject_vtable_entry(dispose);
stemobject_vtable_entry(copy);
stemobject_vtable_entry(isEqual);
stemobject_vtable_entry(hash);
stemobject_vtable_end();

AudioSamplerParameters_generalSynth * AudioSamplerParameters_generalSynth_create(compat_type(WaveSampler *) waveSampler,
                                                                                 compat_type(FrequencyCurve *) frequencyCurve,
                                                                                 compat_type(AmplitudeEnvelope *) amplitudeEnvelope,
                                                                                 FilterChain filterChain,
                                                                                 SynthPropertyControllerList controllerList,
                                                                                 SamplerTimingMode timingMode,
                                                                                 float length,
                                                                                 bool amplitudeTimeAbsolute,
                                                                                 bool frequencyTimeAbsolute) {
	stemobject_create_implementation(init, waveSampler, frequencyCurve, amplitudeEnvelope, filterChain, controllerList, timingMode, length, amplitudeTimeAbsolute, frequencyTimeAbsolute)
}

bool AudioSamplerParameters_generalSynth_init(AudioSamplerParameters_generalSynth * self,
                                              compat_type(WaveSampler *) waveSampler,
                                              compat_type(FrequencyCurve *) frequencyCurve,
                                              compat_type(AmplitudeEnvelope *) amplitudeEnvelope,
                                              FilterChain filterChain,
                                              SynthPropertyControllerList controllerList,
                                              SamplerTimingMode timingMode,
                                              float length,
                                              bool amplitudeTimeAbsolute,
                                              bool frequencyTimeAbsolute) {
	call_super(init, self);
	self->waveSampler = waveSampler;
	self->frequencyCurve = frequencyCurve;
	self->amplitudeEnvelope = amplitudeEnvelope;
	self->filterChain = filterChain;
	self->controllerList = controllerList;
	self->timingMode = timingMode;
	self->length = length;
	self->amplitudeTimeAbsolute = amplitudeTimeAbsolute;
	self->frequencyTimeAbsolute = frequencyTimeAbsolute;
	return true;
}

void AudioSamplerParameters_generalSynth_dispose(AudioSamplerParameters_generalSynth * self) {
	call_virtual(dispose, self->waveSampler);
	call_virtual(dispose, self->frequencyCurve);
	call_virtual(dispose, self->amplitudeEnvelope);
	for (unsigned int filterIndex = 0; filterIndex < self->filterChain.signalFilterCount; filterIndex++) {
		call_virtual(dispose, self->filterChain.signalFilters[filterIndex]);
	}
	free(self->filterChain.signalFilters);
	for (unsigned int controllerIndex = 0; controllerIndex < self->controllerList.controllerCount; controllerIndex++) {
		call_virtual(dispose, self->controllerList.controllers[controllerIndex]);
	}
	free(self->controllerList.controllers);
	call_super_virtual(dispose, self);
}

AudioSamplerParameters_generalSynth * AudioSamplerParameters_generalSynth_copy(AudioSamplerParameters_generalSynth * self) {
	stemobject_copy_implementation(initCopy)
}

void AudioSamplerParameters_generalSynth_initCopy(AudioSamplerParameters_generalSynth * self, AudioSamplerParameters_generalSynth * original) {
	call_super(initCopy, self, (AudioSamplerParameters *) original);
	self->waveSampler = call_virtual(copy, original->waveSampler);
	self->frequencyCurve = call_virtual(copy, original->frequencyCurve);
	self->amplitudeEnvelope = call_virtual(copy, original->amplitudeEnvelope);
	self->filterChain.signalFilterCount = original->filterChain.signalFilterCount;
	self->filterChain.signalFilters = memdup(original->filterChain.signalFilters, original->filterChain.signalFilterCount * sizeof(*original->filterChain.signalFilters));
	for (unsigned int filterIndex = 0; filterIndex < self->filterChain.signalFilterCount; filterIndex++) {
		self->filterChain.signalFilters[filterIndex] = call_virtual(copy, original->filterChain.signalFilters[filterIndex]);
	}
	self->controllerList.controllerCount = original->controllerList.controllerCount;
	self->controllerList.controllers = memdup(original->controllerList.controllers, original->controllerList.controllerCount * sizeof(*original->controllerList.controllers));
	for (unsigned int controllerIndex = 0; controllerIndex < self->controllerList.controllerCount; controllerIndex++) {
		self->controllerList.controllers[controllerIndex] = call_virtual(copy, original->controllerList.controllers[controllerIndex]);
	}
	self->timingMode = original->timingMode;
	self->length = original->length;
	self->amplitudeTimeAbsolute = original->amplitudeTimeAbsolute;
	self->frequencyTimeAbsolute = original->frequencyTimeAbsolute;
}

bool AudioSamplerParameters_generalSynth_isEqual(AudioSamplerParameters_generalSynth * self, compat_type(AudioSamplerParameters_generalSynth *) compareUntyped) {
	AudioSamplerParameters_generalSynth * compare = compareUntyped;
	if (!StemObject_isExactClass(compare, self->vtable)) {
		return false;
	}
	if (self->timingMode != compare->timingMode ||
	    self->length != compare->length ||
	    self->amplitudeTimeAbsolute != compare->amplitudeTimeAbsolute ||
	    self->frequencyTimeAbsolute != compare->frequencyTimeAbsolute) {
		return false;
	}
	if (self->filterChain.signalFilterCount != compare->filterChain.signalFilterCount ||
	    self->controllerList.controllerCount != compare->controllerList.controllerCount ||
	    !call_virtual(isEqual, self->waveSampler, compare->waveSampler) ||
	    !call_virtual(isEqual, self->frequencyCurve, compare->frequencyCurve) ||
	    !call_virtual(isEqual, self->amplitudeEnvelope, compare->amplitudeEnvelope)) {
		return false;
	}
	for (unsigned int filterIndex = 0; filterIndex < self->filterChain.signalFilterCount; filterIndex++) {
		if (!call_virtual(isEqual, self->filterChain.signalFilters[filterIndex], compare->filterChain.signalFilters[filterIndex])) {
			return false;
		}
	}
	for (unsigned int controllerIndex = 0; controllerIndex < self->controllerList.controllerCount; controllerIndex++) {
		if (!call_virtual(isEqual, self->controllerList.controllers[controllerIndex], compare->controllerList.controllers[controllerIndex])) {
			return false;
		}
	}
	return true;
}

uint32_t AudioSamplerParameters_generalSynth_hash(AudioSamplerParameters_generalSynth * self, uint32_t initval) {
	uint32_t result = initval;
	result = hashlittle(&self->timingMode, sizeof(self->timingMode), result);
	result = hashlittle(&self->length, sizeof(self->length), result);
	uint8_t absoluteSettings = self->amplitudeTimeAbsolute | (self->frequencyTimeAbsolute << 1);
	result = hashlittle(&absoluteSettings, 1, result);
	
	GeneralSynthConfiguration_waveType waveType = getWaveType(self->waveSampler);
	result = hashlittle(&waveType, sizeof(waveType), result);
	result = call_virtual(hash, self->waveSampler, result);
	
	GeneralSynthConfiguration_frequencyType frequencyType = getFrequencyType(self->frequencyCurve);
	result = hashlittle(&frequencyType, sizeof(frequencyType), result);
	result = call_virtual(hash, self->frequencyCurve, result);
	
	GeneralSynthConfiguration_amplitudeType amplitudeType = getAmplitudeType(self->amplitudeEnvelope);
	result = hashlittle(&amplitudeType, sizeof(amplitudeType), result);
	result = call_virtual(hash, self->amplitudeEnvelope, result);
	
	for (unsigned int filterIndex = 0; filterIndex < self->filterChain.signalFilterCount; filterIndex++) {
		GeneralSynthConfiguration_signalFilterType filterType = getSignalFilterType(self->filterChain.signalFilters[filterIndex]);
		result = hashlittle(&filterType, sizeof(filterType), result);
		result = call_virtual(hash, self->filterChain.signalFilters[filterIndex], result);
	}
	for (unsigned int controllerIndex = 0; controllerIndex < self->controllerList.controllerCount; controllerIndex++) {
		GeneralSynthConfiguration_synthPropertyControllerType controllerType = getSynthPropertyControllerType(self->controllerList.controllers[controllerIndex]);
		result = hashlittle(&controllerType, sizeof(controllerType), result);
		result = call_virtual(hash, self->controllerList.controllers[controllerIndex], result);
	}
	return result;
}

SamplerObject * AudioSamplerParameters_generalSynth_getSamplerObject(AudioSamplerParameters_generalSynth * self, SynthPropertyRootType rootType, unsigned int index) {
	switch (rootType) {
		case SYNTH_PROPERTY_ROOT_UNDEFINED:
			return NULL;
		
		case SYNTH_PROPERTY_ROOT_AMPLITUDE_ENVELOPE:
			return (SamplerObject *) self->amplitudeEnvelope;
			
		case SYNTH_PROPERTY_ROOT_FREQUENCY_CURVE:
			return (SamplerObject *) self->frequencyCurve;
			
		case SYNTH_PROPERTY_ROOT_WAVE_SAMPLER:
			return (SamplerObject *) self->waveSampler;
			
		case SYNTH_PROPERTY_ROOT_SIGNAL_FILTER:
			if (self->filterChain.signalFilterCount > index) {
				return (SamplerObject *) self->filterChain.signalFilters[index];
			}
			return NULL;
	}
	return NULL;
}