#include "chirp.h"
#include <stdlib.h>
#include <string.h>
#include <SDL2/SDL.h>
//1 2 3 4 6 8 12 16 24 32
//f s   c   n    b     r

#define SILENCE 		128
#define	NOISE			129

#define AUDIO_NONE		0
#define AUDIO_PLAY		1

#define MAX_CHANNELS	5

typedef void (*waveform_t)(const uint16_t, const uint32_t, uint8_t*, const uint8_t, const uint8_t);
static waveform_t waveforms[6];

const static uint16_t lengths[10] = { 313, 625, 938, 1250, 1875, 2500, 3750, 5000, 7500, 10000 };
const static uint16_t tempos[10] = { 13230, 8820, 6615, 5292, 4410, 3780, 3308, 2940, 2646, 2406 };
const float periods[108] = { 1348.49207, 1272.80688, 1201.37, 1133.94214, 1070.29871, 1010.22772, 953.527893, 900.010376, 849.496887, 801.818176, 756.815613, 714.338745, 674.246033, 636.403564, 600.684875, 566.971069, 535.149475, 505.11377, 476.763947, 450.005249, 424.748352, 400.909088, 378.407806, 357.169373, 337.123016, 318.201782, 300.342438, 283.485535, 267.574738, 252.556885, 238.381973, 225.002625, 212.374176, 200.454544, 189.203888, 178.584702, 168.561508, 159.100876, 150.171234, 141.742767, 133.787354, 126.278458, 119.190987, 112.501305, 106.187096, 100.227272, 94.6019516, 89.2923508, 84.2807541, 79.5504379, 75.0856171, 70.8713837, 66.8936768, 63.139225, 59.5954933, 56.2506561, 53.0935478, 50.113636, 47.3009758, 44.6461754, 42.140377, 39.775219, 37.5428085, 35.4356918, 33.4468384, 31.5696125, 29.7977467, 28.1253281, 26.5467739, 25.056818, 23.650486, 22.3230877, 21.0701885, 19.8876095, 18.7714043, 17.7178459, 16.7234192, 15.7848072, 14.8988733, 14.0626631, 13.273387, 12.528409, 11.8252439, 11.1615429, 10.5350943, 9.94380569, 9.38570118, 8.85892296, 8.36171055, 7.89240265, 7.44943666, 7.03133202, 6.636693, 6.2642045, 5.91262197, 5.58077145, 5.26754713, 4.97190285, 4.69285059, 4.42946148, 4.18085527, 3.94620132, 3.72471833, 3.51566601, 3.3183465, 3.13210225, 2.95631051, 2.7903862 };

SDL_AudioDeviceID audio_device;
uint8_t audio_state = AUDIO_NONE;

#define RELATIVE	0
#define SEQUENTIAL	1

struct instrument_t {
	uint8_t		waveform	= 0;
	int8_t		volume[8]	= {0,0,0,0,0,0,0,0};
	uint8_t		volume_data = RELATIVE;
	int8_t		pitch[8]	= {0,0,0,0,0,0,0,0};
	uint8_t		pitch_data  = RELATIVE;
};

struct channel_t {
	char* 		song 		= NULL;
	char* 		song_ptr 	= NULL;
	char* 		song_start 	= NULL;
	uint32_t	count		= 0;
	float		length 		= 0.25f;
	uint8_t 	volume 		= 32;
	uint8_t 	octave 		= 4;
	uint32_t	tempo 		= 44100;
	uint8_t 	waveform 	= 0;
	uint8_t		instrument	= 0;
	Uint8* 		play_pos;
	int32_t		play_len;
	Uint8 		play_buffer[132300];
	char*		stack[10]	= {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
	uint8_t		stackpos 	= 0;
	char*		labels[10] 	= {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
	instrument_t instruments[10];
};
static channel_t channels[MAX_CHANNELS];

void chirp_stop_channel(const int c) {
	if (channels[c].song != NULL) {
		free(channels[c].song);
		channels[c].song=NULL;
	}
	for (int i=0;i<MAX_CHANNELS;++i) if (channels[i].song != NULL) return;

	audio_state=AUDIO_NONE;
}

void audioCallback(void * userdata, uint8_t * stream, int len) {
	SDL_memset(stream, 0, len);
    if (audio_state == AUDIO_PLAY) {
		for (int i=0;i<MAX_CHANNELS;++i) if (channels[i].song != NULL) {
			int l_len=len;
			uint8_t *l_stream=stream;
			while( l_len > 0 ) {
				while( channels[i].play_len == 0 ) {
					channels[i].play_len = interpret_next_token(i);

					if (channels[i].play_len == -1) {
						chirp_stop_channel(i);
						break;
					}
					channels[i].play_pos = channels[i].play_buffer;
				}
				if (channels[i].play_len == -1) break;

				const int actual_len = ( l_len > channels[i].play_len ? channels[i].play_len : l_len );
				for (int j=0;j<actual_len;++j) l_stream[j] += channels[i].play_pos[j];

				l_stream += actual_len;
				channels[i].play_pos += actual_len;
				channels[i].play_len -= actual_len;
				l_len -= actual_len;
			}
		}
    }
}

#define COUNT (channels[c].count++ % period)

void square_waveform(const uint16_t period, const uint32_t length, uint8_t* buffer, const uint8_t volume, const uint8_t c) {
	for( uint32_t i = 0; i < length; i++ ) buffer[i] = ( COUNT < (period >> 1) ? volume : -volume );
}
void saw_waveform(const uint16_t period, const uint32_t length, uint8_t* buffer, const uint8_t volume,  const uint8_t c) {
	for( uint32_t i = 0; i < length; i++ ) buffer[i] = -volume + uint16_t( float(COUNT) / float(period) * volume*2 );
}
void triangle_waveform(const uint16_t period, const uint32_t length, uint8_t* buffer, const uint8_t volume,  const uint8_t c) {
	for( uint32_t i = 0; i < length; i++ ) {
		uint16_t pos = COUNT;
		uint16_t half_period = period >> 1;
		if (pos < half_period) {
			buffer[i] = -volume + uint16_t( (float(pos) / float(half_period)) * float(volume*2) );
		} else {
			buffer[i] = volume - uint16_t( (float(pos-half_period) / float(half_period)) * float(volume*2) );
		}
	}
}
void pulse12_waveform(const uint16_t period, const uint32_t length, uint8_t* buffer, const uint8_t volume,  const uint8_t c) {
	for( uint32_t i = 0; i < length; i++ ) buffer[i] = ( COUNT < (period >> 3) ? volume : -volume );
}
void pulse25_waveform(const uint16_t period, const uint32_t length, uint8_t* buffer, const uint8_t volume,  const uint8_t c) {
	for( uint32_t i = 0; i < length; i++ ) buffer[i] = ( COUNT < (period >> 2) ? volume : -volume );
}
void noise_waveform(const uint16_t period, const uint32_t length, uint8_t* buffer, const uint8_t volume,  const uint8_t c) {
	for( uint32_t i = 0; i < length; i++ ) buffer[i] = rand()%2==0 ? volume : -volume;
}

void chirp_init() {
    SDL_AudioSpec audioSpec = {22050, AUDIO_S8, 1, 0, 512, 0, 0, audioCallback, NULL};
    audio_device = SDL_OpenAudioDevice(NULL, 0, &audioSpec, NULL, 0);
    SDL_PauseAudioDevice(audio_device, 0);
	waveforms[0] = &square_waveform;
	waveforms[1] = &saw_waveform;
	waveforms[2] = &triangle_waveform;
	waveforms[3] = &pulse12_waveform;
	waveforms[4] = &pulse25_waveform;
	waveforms[5] = &noise_waveform;
	for (uint8_t i=0;i<MAX_CHANNELS;++i) channels[i].song=NULL;
}

uint32_t interpret_note(const int c, const uint8_t note, const char param ) {
	const uint32_t length = ( param == -1 ? channels[c].length : ((float)lengths[uint8_t(param)])/10000.0f ) * channels[c].tempo;
	if( note == SILENCE ) { memset( channels[c].play_buffer, 0, length ); return length; }
	//if( note == NOISE ) { for( uint32_t i = 0; i < length; i++ ) channels[c].play_buffer[i] = rand()%2==0 ? channels[c].volume : -channels[c].volume; return length; }

	uint32_t l = 0;
	uint8_t envelope_pos=0;
	uint8_t* buffer = channels[c].play_buffer;
	uint32_t min_len = uint32_t(0.0313f * channels[c].tempo);
	uint8_t fullnote = note + channels[c].octave*12;
	uint8_t fullvolume = channels[c].volume;
	while (l<length) {
		uint8_t actualnote = fullnote + channels[c].instruments[channels[c].instrument].pitch[envelope_pos];
		if (channels[c].instruments[channels[c].instrument].pitch_data==SEQUENTIAL) fullnote = actualnote;
		const uint16_t period = periods[actualnote];

		uint8_t actualvolume = fullvolume + (channels[c].instruments[channels[c].instrument].volume[envelope_pos] << 3);
		if (channels[c].instruments[channels[c].instrument].volume_data==SEQUENTIAL) fullvolume = actualvolume;

		waveforms[channels[c].instruments[channels[c].instrument].waveform](period, min_len, buffer, actualvolume, c); //channels[c].play_buffer, channels[c].volume);
		l+=min_len;
		envelope_pos=(envelope_pos+1)&7;
		buffer += min_len;
	}
	return length;
}

int chirp_play(const char* new_song) {
	int c = 0;
	while (c<MAX_CHANNELS && channels[c].song != NULL) c++;
	if (c==MAX_CHANNELS) return -1;
    
	channels[c].play_pos = channels[c].play_buffer;
	channels[c].play_len = 0;

	channels[c].length=0.25f;
	channels[c].volume=32;
	channels[c].octave=4;
	channels[c].tempo=44100;
	channels[c].waveform=0;
	channels[c].stackpos=0;
	channels[c].song = (char*)malloc( strlen( new_song ) + 1 );
	strcpy( channels[c].song, new_song );
    channels[c].song_ptr = channels[c].song_start = channels[c].song;

    audio_state = AUDIO_PLAY;
	return c;
}

int32_t interpret_next_token(const int c) { //uint8_t* buffer) {
    char** token = &channels[c].song_ptr;
	char note = 0;
	char param = -1;
	
	switch( **token ) {
		case 'b': note += 2;
		case 'a': note += 2;
		case 'g': note += 2;
		case 'f': note += 1;
		case 'e': note += 2;
		case 'd': note += 2;
		case 'c':
			param = *++*token;
			if( param == '#' || param == '+' ) { note++; param = *++*token; } else if( param == '-' ) { note--; param = *++*token; }
			if( param >= 48 && param <= 57 ) { param -= 48; ++*token; } else { param = -1; }
			return interpret_note( c, note, param );
		case 'r':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { param -= 48; ++*token; } else { param = -1; }
			return interpret_note( c, SILENCE, param );
		case 'n':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { param -= 48; ++*token; } else { param = -1; }
			return interpret_note( c, NOISE, param );
		case 'o':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { channels[c].octave = (param - 48) % 8; ++*token; }
			return 0;
		case '>':
			channels[c].octave = (channels[c].octave+1) % 8; ++*token;
			return 0;
		case '<':
			channels[c].octave = (channels[c].octave-1) % 8; ++*token;
			return 0;
		case 'l':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { channels[c].length = ((float)lengths[param - 48])/10000.0f; ++*token; }
			return 0;
		case 'v':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { channels[c].volume = (param - 48) << 3; ++*token; }
			return 0;
		case 't':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { channels[c].tempo = tempos[param - 48] * 10; ++*token; }
			return 0;
		case 'i':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { channels[c].instrument = param - 48; ++*token; }
			return 0;
/*		case 'w':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { channels[c].waveform = param - 48; ++*token; }
			return 0;*/
		case '{':
			{
				uint8_t instrument = 0;
				param = *++*token;
				if( param >= 48 && param <= 57 ) { instrument = param - 48; param = *++*token; }
				while (param != '}') {
					switch (param) {
						case 'w':
							param = *++*token;
							if( param >= 48 && param <= 57 ) { channels[c].instruments[instrument].waveform = param - 48; param = *++*token; }
							break;
						case 'v':
							channels[c].instruments[instrument].volume_data = RELATIVE;
							param = *++*token;
							if (param=='r') { channels[c].instruments[instrument].volume_data = RELATIVE; param = *++*token; }
							if (param=='s') { channels[c].instruments[instrument].volume_data = SEQUENTIAL; param = *++*token; }
							for (int i=0;i<8;++i) {
								int8_t sign = 1;
								if (param=='-') { sign=-1; param = *++*token; }
								if( param >= 48 && param <= 57 ) channels[c].instruments[instrument].volume[i] = (param-48)*sign;
								param = *++*token;
							}
							break;
						case 'p':
							channels[c].instruments[instrument].pitch_data = RELATIVE;
							param = *++*token;
							if (param=='r') { channels[c].instruments[instrument].pitch_data = RELATIVE; param = *++*token; }
							if (param=='s') { channels[c].instruments[instrument].pitch_data = SEQUENTIAL; param = *++*token; }
							for (int i=0;i<8;++i) {
								int8_t sign = 1;
								if (param=='-') { sign=-1; param = *++*token; }
								if( param >= 48 && param <= 57 ) channels[c].instruments[instrument].pitch[i] = (param-48)*sign;
								param = *++*token;
							}
							break;
						case '}':
						default:
							param = *++*token;
							break;
					}
					//param = *++*token;
				}
				return 0;
			}
		case '!':
			channels[c].stackpos = 0;
			channels[c].song_start = ++*token;
			return 0;
		case '=':
			channels[c].stackpos = 0;
			channels[c].song_ptr = channels[c].song_start;
			return 0;
		case '[':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { param -= 48; ++*token; } else { param = 0; }
			channels[c].labels[uint8_t(param)] = *token; //channels[c].song_ptr;
			{
				char* nextpos = *token;
				uint8_t innerblocks=0;
				while(innerblocks>0 || *nextpos!=']') {
					if (*nextpos=='[') innerblocks++;
					if (*nextpos==']') innerblocks--;
					nextpos++;
				}
				channels[c].stack[channels[c].stackpos]=nextpos+1;
			}
			channels[c].stackpos++;
			return 0;
		case ']':
			++*token;
			channels[c].stackpos--;
			channels[c].song_ptr=channels[c].stack[channels[c].stackpos];
			return 0;
		case '@':
			param = *++*token;
			if( param >= 48 && param <= 57 ) { param -= 48; ++*token; } else { param = 0; }
			channels[c].stack[channels[c].stackpos]=*token;
			channels[c].stackpos++;
			channels[c].song_ptr=channels[c].labels[uint8_t(param)];
			return 0;
		case '\0':
			return -1;
		default:
			++*token;
			return 0;
	};
}

void chirp_stop() {
	for (int i=0;i<MAX_CHANNELS;++i) {
		if (channels[i].song != NULL) {
			free(channels[i].song);
			channels[i].song=NULL;
		}
	}
	audio_state=AUDIO_NONE;
}