#pragma once

#include "Lp1.h"
#include "ModulatedDelay.h"
#include "AllpassDiffuser.h"
#include "Biquad.h"

namespace ReverbHallRoom
{
	template<unsigned int N>
	class CircularBuffer
	{
		float buffer[N];
		int idxRead;
		int idxWrite;
		int count;
	public:
		CircularBuffer()
		{
			Reset();
		}

		void Reset()
		{
			for (int i = 0; i < N; i++)
				buffer[i] = 0.0f;
			idxRead = 0;
			idxWrite = 0;
			count = 0;
		}

		int GetCount()
		{
			return count;
		}

		int PushZeros(float* data, int bufSize)
		{
			int countBefore = count;
			for (int i = 0; i < bufSize; i++)
			{
				buffer[idxWrite] = 0.0f;
				idxWrite = (idxWrite + 1) % N;
				count++;
				if (count >= N)
					break; // overflow
			}

			return count - countBefore;
		}

		int Push(float* data, int bufSize)
		{
			int countBefore = count;
			for (int i = 0; i < bufSize; i++)
			{
				buffer[idxWrite] = data[i];
				idxWrite = (idxWrite + 1) % N;
				count++;
				if (count >= N)
					break; // overflow
			}

			return count - countBefore;
		}

		int Pop(float* destination, int bufSize)
		{
			int countBefore = count;
			for (int i = 0; i < bufSize; i++)
			{
				if (count > 0)
				{
					destination[i] = buffer[idxRead];
					idxRead = (idxRead + 1) % N;
					count--;
				}
				else
				{
					destination[i] = 0.0f;
				}
			}

			return countBefore - count;
		}

	};

	class DelayLine
	{
	private:
		ModulatedDelay delay;
		AllpassDiffuser diffuser;
		Biquad lowShelf;
		Biquad highShelf;
		Lp1 lowPass;
		CircularBuffer<2*BUFFER_SIZE> feedbackBuffer;
		float feedback;

	public:
		bool DiffuserEnabled;
		bool LowShelfEnabled;
		bool HighShelfEnabled;
		bool CutoffEnabled;
		bool TapPostDiffuser;

		DelayLine() :
			lowShelf(Biquad::FilterType::LowShelf, 48000),
			highShelf(Biquad::FilterType::HighShelf, 48000)
		{
			feedback = 0;

			lowShelf.SetGainDb(-20);
			lowShelf.Frequency = 20;

			highShelf.SetGainDb(-20);
			highShelf.Frequency = 19000;

			lowPass.SetCutoffHz(1000);
			lowShelf.Update();
			highShelf.Update();
			SetSamplerate(48000);
			SetDiffuserSeed(1, 0.0);
		}

		void SetSamplerate(int samplerate)
		{
			diffuser.SetSamplerate(samplerate);
			lowPass.SetSamplerate(samplerate);
			lowShelf.SetSamplerate(samplerate);
			highShelf.SetSamplerate(samplerate);
		}

		void SetDiffuserSeed(int seed, float crossSeed)
		{
			diffuser.SetSeed(seed);
			diffuser.SetCrossSeed(crossSeed);
		}

		void SetDelay(int delaySamples)
		{
			delay.SampleDelay = delaySamples;
		}

		void SetFeedback(float feedb)
		{
			feedback = feedb;
		}

		void SetDiffuserDelay(int delaySamples)
		{
			diffuser.SetDelay(delaySamples);
		}

		void SetDiffuserFeedback(float feedb)
		{
			diffuser.SetFeedback(feedb);
		}

		void SetDiffuserStages(int stages)
		{
			diffuser.Stages = stages;
		}

		void SetLowShelfGain(float gainDb)
		{
			lowShelf.SetGainDb(gainDb);
			lowShelf.Update();
		}

		void SetLowShelfFrequency(float frequency)
		{
			lowShelf.Frequency = frequency;
			lowShelf.Update();
		}

		void SetHighShelfGain(float gainDb)
		{
			highShelf.SetGainDb(gainDb);
			highShelf.Update();
		}

		void SetHighShelfFrequency(float frequency)
		{
			highShelf.Frequency = frequency;
			highShelf.Update();
		}

		void SetCutoffFrequency(float frequency)
		{
			lowPass.SetCutoffHz(frequency);
		}

		void SetLineModAmount(float amount)
		{
			delay.ModAmount = amount;
		}

		void SetLineModRate(float rate)
		{
			delay.ModRate = rate;
		}

		void SetDiffuserModAmount(float amount)
		{
			diffuser.SetModulationEnabled(amount > 0.0);
			diffuser.SetModAmount(amount);
		}

		void SetDiffuserModRate(float rate)
		{
			diffuser.SetModRate(rate);
		}

		void SetInterpolationEnabled(bool value)
		{
			diffuser.SetInterpolationEnabled(value);
		}

		void Process(float* input, float* output, int bufSize)
		{
			float tempBuffer[BUFFER_SIZE];
			feedbackBuffer.Pop(tempBuffer, bufSize);

			for (int i = 0; i < bufSize; i++)
				tempBuffer[i] = input[i] + tempBuffer[i] * feedback;

			delay.Process(tempBuffer, tempBuffer, bufSize);
			
			if (!TapPostDiffuser)
				Utils::Copy(output, tempBuffer, bufSize);
			if (DiffuserEnabled)
				diffuser.Process(tempBuffer, tempBuffer, bufSize);
			if (LowShelfEnabled)
				lowShelf.Process(tempBuffer, tempBuffer, bufSize);
			if (HighShelfEnabled)
				highShelf.Process(tempBuffer, tempBuffer, bufSize);
			if (CutoffEnabled)
				lowPass.Process(tempBuffer, tempBuffer, bufSize);

			feedbackBuffer.Push(tempBuffer, bufSize);

			if (TapPostDiffuser)
				Utils::Copy(output, tempBuffer, bufSize);
		}

		void ClearDiffuserBuffer()
		{
			diffuser.ClearBuffers();
		}

		void ClearBuffers()
		{
			delay.ClearBuffers();
			diffuser.ClearBuffers();
			lowShelf.ClearBuffers();
			highShelf.ClearBuffers();
			lowPass.Output = 0;
			feedbackBuffer.Reset();
		}
	};
}