#include <inttypes.h>
#include "synth.h"
#include "freq_table.h"
#include <avr/pgmspace.h>
#include <avr/interrupt.h>

// sample rate is 8M / (3 * 64)

enum {
	channel_count = 3,
	//tick_length = 400,
//	tick_length = 256,
	row_length = 4,
	pattern_length = 16
};



static const synth_instrument_t instruments[] = {
	{ 1<<15, 100, 12, 0 },
	{ 0, 100, 12, 0 },
	{ 0, 200, 10, 0 },
	{ 1<<13, 0, 0, 2 },
	{ 1<<13, 0, 5, 2 },
};

static const uint8_t wave_table[][2] = {
	{  0, WAVE_PULSE },
	{  3, WAVE_PULSE },
	{  7, WAVE_PULSE },
	{  12, WAVE_PULSE },
	{  256 - 4, 0xff },

	{  0, WAVE_PULSE },
	{  2, WAVE_PULSE },
	{  7, WAVE_PULSE },
	{  10, WAVE_PULSE },
	{  256 - 4, 0xff },

	{  0, WAVE_NOISE },
	{  0, WAVE_PULSE },
	{  0xff, 0xff },

	{  0, WAVE_PULSE },
	{  0xff, 0xff },

};


static const uint8_t patterns[][pattern_length][2] PROGMEM = {
	{},
	{
		{   33 - 12, 0 },
		{ 0, 0 },
		{ 0xff, 1 },
		{ 0, 0 },
		{   33, 1 },
		{ 0xff, 1 },
		{   33, 1 },
		{ 0xff, 1 },
		{   33, 1 },
		{ 0xff, 1 },
		{   33 - 12, 1 },
		{ 0xff, 1 },
		{   33 - 12, 1 },
		{ 0xff, 1 },
		{   33, 1 },
		{ 0xff, 1 },
	},
	{
		{   28 - 12, 0 },
		{ 0, 0 },
		{ 0xff, 1 },
		{ 0, 0 },
		{   28, 1 },
		{ 0xff, 1 },
		{   28, 1 },
		{ 0xff, 1 },
		{   28, 1 },
		{ 0xff, 1 },
		{   28 - 12, 1 },
		{ 0xff, 1 },
		{   28 - 12, 1 },
		{ 0xff, 1 },
		{   28, 1 },
		{ 0xff, 1 },
	},
	{
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 57, 3 },
	},
	{
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 57, 4 },
	},


	{
		{ 60, 2 },
	},
	{
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 57, 2 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 55, 2 },
		{ 0, 0 },
		{ 57, 2 },
		{ 0, 0 },
	},
	{
		{ 55, 2 },
	},
	{
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 0, 0 },
		{ 57, 2 },
	},
	{
		{ 55-3, 2 },
	},




};

static const uint8_t pattern_table[][channel_count] = {
	{ 1, 0, 5 },
	{ 1, 3, 0 },
	{ 1, 0, 7 },
	{ 1, 3, 6 },
	{ 2, 0, 7 },
	{ 2, 4, 8 },
	{ 2, 0, 9 },
	{ 2, 4, 0 },
};
enum {
	pattern_table_length = sizeof(pattern_table) / sizeof(pattern_table[0])
};


static synth_channel_t channels[channel_count];
static int8_t sample;
static int8_t tick;
static int8_t row;
static int8_t seq;


/* PROTOTYPES */
uint8_t synth_mix(void);

static uint8_t timeslots[SYNTH_BUFSIZE];
static uint8_t timeslots_write; // current write head 
static uint8_t timeslots_read; // current read head 

/*register for atomic ++ and -- */
register uint8_t timeslots_fill asm("r2");


static void enqueue_timeslot(uint8_t synthval);
static uint8_t dequeue_timeslot(void);

void synth_init(void)
{
	sample = 0;
	tick = 0;
	row = 0;
	seq = 0;
	timeslots_fill = 0;
}

inline uint8_t synth_mix(void)
{
	if(sample == 0) { // new tick
		for(int i = 1; i < channel_count; i++) {
			synth_channel_t* chan = &channels[i];

			const synth_instrument_t* inst = &instruments[chan->inst_nr];

			if(chan->level > inst->decay) chan->level -= inst->decay;
			else chan->level = 0;

			chan->pulse_width += inst->pulse_sweep;

			chan->pos++;
			if(wave_table[chan->pos][1] == 0xff) chan->pos += wave_table[chan->pos][0];


			// enter new rol
			// w
			if(tick == 0) {
				uint8_t pattern_nr = pattern_table[seq][i];
				uint8_t note = pgm_read_byte(&patterns[pattern_nr][row][0]);

				if(note) { // new note, maybe?
					if(note == 0xff) {
						chan->level = 0;
					} else {
						chan->level = 80; // TODO: less?
						chan->note = note;
						chan->inst_nr = pgm_read_byte(&patterns[pattern_nr][row][1]);
						inst = &instruments[chan->inst_nr];
						chan->pos = inst->wave_table_pos;
						if(inst->pulse_width) chan->pulse_width = inst->pulse_width;
					}
				}
			}
		}
	}
	if(++sample == 0){
		if(++tick == row_length) {
			tick = 0;
			if(++row == pattern_length) {
				row = 0;
				if(++seq == pattern_table_length) {
					seq = 0;
				}
			}
		}
	}


	uint8_t output = 0;
	for(int i = 0; i < channel_count; i++) {
		synth_channel_t* chan = &channels[i];
	//	const synth_instrument_t* inst = &instruments[chan->inst_nr];

		chan->phase += pgm_read_word(&freq_table[(uint8_t)(chan->note + wave_table[chan->pos][0])]);

		uint8_t amp;
		switch(wave_table[chan->pos][1]) {
		case WAVE_PULSE:
			amp = -(chan->phase < chan->pulse_width);
			break;

		case WAVE_SAW:
			amp = (chan->phase >> 8);
			break;

		case WAVE_NOISE: // shitty noise
			chan->phase = (chan->phase >> 1) ^ (-(chan->phase & 1) & 0xb400);
			amp = (chan->phase >> 8);
			break;

		default:
			amp = 0;
			break;
		}

		output += (((amp & 0xff) * chan->level) >> 8);
	}

	return output;
}


/* fill all the timeslots */
inline void synth_poll(void) {
	/* refill timeslots queue */
//	while (timeslots_fill < (SYNTH_BUFSIZE-1))
	if (timeslots_fill < (SYNTH_BUFSIZE-1))
		enqueue_timeslot(synth_mix());
}

/* timeslot queue handling */
static inline void enqueue_timeslot(uint8_t synthval) {
	timeslots[timeslots_write & SYNTH_BUFMASK] = synthval;
	timeslots_fill++;
	timeslots_write++;
}

static inline uint8_t dequeue_timeslot() {
	uint8_t t = timeslots[timeslots_read & SYNTH_BUFMASK];
	if(timeslots_fill){
		/* buffer not underrun... move forward in readbuffer */

		timeslots_fill --;
		timeslots_read ++;	
	} 

	return t;
}


ISR(TIMER0_COMPA_vect)
{
	/* calculate next analog sample value in synth mixer:*/
	OCR1B = dequeue_timeslot();
}