// Based on Starter code in EX 13

#include <iostream>

#ifdef	__STKX__
	#include <StkX/StkX.h>
#else
	#include "Clarinet.h"
	#include "RtAudio.h"
	#include "Chorus.h"
	#include "BiQuad.h"
	#include "Echo.h"
	#include "PRCRev.h"
#endif

struct data{
	Clarinet* clar;
	Chorus* c;
	BiQuad* bq;
	Echo* e;
	PRCRev* r;
	int af[4];
};

int tick_c(char *buffer, int bufferSize, void *dataPointer) {

	data* newdata = (data *) dataPointer;
	StkFloat *samples = (StkFloat *) buffer;
	Clarinet* clar = newdata->clar;
	Chorus* chor = newdata->c;
	BiQuad* biquad = newdata->bq;
	Echo* echo = newdata->e;
	PRCRev* nrev = newdata->r;
	StkFloat temp;

	for ( int i=0; i<bufferSize; i++ ) {
		StkFloat inc = clar->tick();
		
		if(newdata->af[0] == 1){
			temp = chor->tick(inc);
			inc = temp;
		}
		if(newdata->af[1] == 1){
			inc = echo->tick(inc);
		}if(newdata->af[2] == 1){
			inc = biquad->tick(inc);
		}if(newdata->af[3] == 1){
			inc = nrev->tick(inc);
		}
		*samples++ = inc;			// left
		*samples++ = inc;		// right
	}

	return 0;
}

int main (int argc, char* const argv[]) {

	float reverbDelay;
	unsigned long echoDelay;
	float bqfreq;
	float bqrad;
	float effectMix;	// Wet/dry ratio (0.0~1.0)
	float modDepth;	// Modulation depth (0.0~1.0)
	float modFrequency;	// Modulation frequency [Hz]

	int input;
	int num_filters = 4;
	char filters[num_filters];
	int activeFilters[num_filters];
	for(int i = 0; i < num_filters; i++){
		filters[i] = ' ';
		activeFilters[i] = 0;
		
	}
	while(input != 5){
	std::cout << "Please choose filters:\n\n";
	std::cout << " 0. Exit:\n";
	std::cout << filters[0] << "1. Chorus:\n";
	std::cout << filters[1] << "2. Echo:\n";
	std::cout << filters[2] << "3. BiQuad:\n";
	std::cout << filters[3] << "4. Reverb:\n";
	std::cout << " 5. Start!:\n";
	std::cin >> input;
	if(input == 0) return 0;
	if(input == 5) break;
	if(filters[input-1] == '*'){
		filters[input-1] = ' ';
		activeFilters[input-1] = 0;
		continue;
	}
	else if(input == 1){
		activeFilters[0] = 1;
		std::cout << "Enter wet/dry ratio:";
		std::cin >> effectMix;
		std::cout << "\nEnter modulation depth:";
		std::cin >> modDepth;
		std::cout << "\nEnter modulation frequency:";
		std::cin >> modFrequency;
	}

	else if(input == 2){
		activeFilters[1] = 1;
		std::cout << "Enter echo delay time:";
		std::cin >> echoDelay;
	}
	else if(input == 3){
		activeFilters[2] = 1;
		std::cout << "Enter frequency:";
		std::cin >> bqfreq;
		std::cout << "Enter radius:";
		std::cin >> bqrad;
	}
	else if(input == 4){
		activeFilters[3] = 1;
		std::cout << "Enter reverb delay time:";
		std::cin >> reverbDelay;
	}
	filters[input - 1] = '*';
	}

	StkFloat lowest;
	float frequency = 440.0;

	std::cout << "\nEnter starting frequency:";
	std::cin >> frequency;
	float defFreq = frequency;
	std::cout << "\nEnter lowest frequency for clarinet:";
	std::cin >> lowest;

	Stk::setSampleRate( 44100.0 );

	data* newdata = new data();
	newdata->clar = new Clarinet(lowest);
	newdata->clar->noteOn( frequency, 0.7 );

	for(int i = 0; i < 4; i++){
		newdata->af[i] = activeFilters[i];
	}

	if(activeFilters[0] == 1){

	newdata->c = new Chorus();		// Chorus
	newdata->c->setEffectMix(effectMix);	// Wet/dry ratio
	newdata->c->setModDepth(modDepth);		// Mod. depth
	newdata->c->setModFrequency(modFrequency);	// Mod. freq.
	}
	if(activeFilters[1] == 1){
	newdata->e = new Echo();
	newdata->e->setDelay(echoDelay);
	}
	if(activeFilters[2] == 1){
	newdata->bq = new BiQuad();
	newdata->bq->setResonance( bqfreq, bqrad, true );
	}
	if(activeFilters[3] == 1){
	newdata->r = new PRCRev(reverbDelay);
	}
	
	RtAudio* dac;
	RtAudioFormat format = ( sizeof(StkFloat) == 8 ) ? RTAUDIO_FLOAT64 : RTAUDIO_FLOAT32;
	int bufferSize = RT_BUFFER_SIZE;

	try {
		dac = new RtAudio(0, 2, 0, 0, format, (int)Stk::sampleRate(), &bufferSize, 0);
	} 
	catch (RtError& error) {
		error.printMessage();
		exit(0);
	}

	try {
		dac->setStreamCallback(&tick_c, (void *)newdata);
		dac->startStream();
	} 
	catch (RtError& error) {
		error.printMessage();
		goto cleanup;
	}

	while ( frequency != 0 ) {
		std::cout << "\nEnter new frequency (0 to quit): ";
		int p;
		std::cin >> p;
		if(p == 0) break;
		newdata->clar->setFrequency( p );
	}

	try {	
		dac->cancelStreamCallback();
		dac->closeStream();
	} 
	catch (RtError& error) {
		error.printMessage();
	}

	cleanup:
		delete dac;		
		if(newdata->af[0] == 1){
		delete newdata->c;
		}if(newdata->af[1] == 1){
		delete newdata->e;
		}if(newdata->af[2] == 1){
		delete newdata->bq;
		}if(newdata->af[3] == 1){
		delete newdata->r;
		}
		delete newdata;

	return 0;
}