#ifndef REVERB_H
#define REVERB_H

#include <cstdlib>
#include <common/mix.hpp>
#include <initializer_list>
#include <sys/types.h>
#include <vector>
#include "diffusor.hpp"




template<typename T, uint numCh>
class Reverb
{
	std::vector<Diffusor<T, numCh>> m_diffusors;
	MultiDelay<T, numCh> m_feedbackDly;
	std::vector<T> m_earlyGain;
	T fb_dly_out[numCh];
	T fb_gain;

	public:
	Reverb(std::initializer_list<Diffusor<T, numCh>> maxDelay, uint fb_maxDelay, uint fb_minDelay)
	: m_diffusors(maxDelay)
	, m_feedbackDly(fb_maxDelay, fb_minDelay)
	, m_earlyGain(maxDelay.size())
	, fb_gain(0)
	{
		for (int c=0; c < numCh; c++)
		{
			fb_dly_out[c] = 0;
		}
	}

	void resize(uint maxDelay)
	{
		for (auto diffusor: m_diffusors)
		{
			diffusor.resize(maxDelay);
		}
	}

	uint getNumDiffusionSteps()
	{
		return m_diffusors.size();
	}
	
	void setDelay(uint index, uint delay)
	{
		m_diffusors[index].setDelay(delay);
	}

	uint getDelay(uint index)
	{
		return m_diffusors[index].getDelay();
	}

	void setFeedbackGain(T value)
	{
		fb_gain = value;
	}

	T getFeedbackGain()
	{
		return fb_gain;
	}

	void setEarlyGain(uint index, T gain)
	{
		m_earlyGain[index] = gain;
	}

	T getEarlyGain(uint index)
	{
		return m_earlyGain[index];
	}

	void setFeedbackDelay(uint delay_min, uint delay_max)
	{
		m_feedbackDly.setDelay(delay_max, delay_min);
	}

	void process_multi(float *in, float *out, unsigned numPoints)
	{
		for (int i=0; i < numPoints; i++)
		{
			T temp[numCh];
			Mix<T, numCh>::split(in[i], temp);
			T earlySum = 0;
			int k=0;
			for (auto diffusor: m_diffusors)
			{
				diffusor.process_multi(temp);
				earlySum += m_earlyGain[k]*temp[0];
				k++;
			}

			// Sum
			Householder<T, numCh>::inPlace(fb_dly_out);
			for (int c=0; c < numCh; c++)
			{
				temp[c] += fb_gain*fb_dly_out[c];
			}
			m_feedbackDly.process(temp, fb_dly_out);

			// Mix
			for (int c=0; c < numCh; c++)
			{
				out[i] = temp[0] + earlySum;
			}
		}
	}
};

#endif