//#define DEBUG

#include <iostream>
#include <cmath>

// Generate a .snd file
// 44100 samples = 1 second

constexpr uint32_t sample_rate = 44100;		// CD quality

// A table of frequencies indexed by the MIDI note numbers 
float notes[128];

void init_notes()
{
	for (int i=0; i<128; ++i)
		notes[i] = pow(2, (i-69)/12.0) * 440.0;
}

// Some handy macros for hardcoded notes
#define C4 (60)
#define C4s (61)
#define D4 (62)
#define D4s (63)
#define E4 (64)
#define F4 (65)
#define F4s (66)
#define G4 (67)
#define G4s (68)
#define A4 (69)
#define A4s (70)
#define B4 (71)
#define C5 (72)
#define C5s (73)
#define D5 (74)
#define D5s (75)
#define E5 (76)
#define F5 (77)
#define F5s (78)
#define G5 (79)
#define G5s (80)
#define A5 (81)
#define A5s (82)
#define B5 (83)
#define C6 (84)




/**
* Create a .snd file header for a 16-bit, linear PCM, mono
* soundfile with a sample rate of 44100 Hz  (CD quality)
******************************************************************************/
void write_header()
{
	// send the following values in big-endian format
	uint32_t magic = htobe32(0x2e736e64);		// ".snd"
	uint32_t data_offset = htobe32(24);			// minimal header
	uint32_t data_size = htobe32(0xffffffff);	// length unknown
	uint32_t encoding = htobe32(3);				// 16-bit linear PCM
	uint32_t rate = htobe32(sample_rate);		// samples/sec, 44100 = CD quality
	uint32_t channels = htobe32(1);				// 1 channel = mono

	std::cout.write((char *)&magic, sizeof(magic));
	std::cout.write((char *)&data_offset, sizeof(data_offset));
	std::cout.write((char *)&data_size, sizeof(data_size));
	std::cout.write((char *)&encoding, sizeof(encoding));
	std::cout.write((char *)&rate, sizeof(rate));
	std::cout.write((char *)&channels, sizeof(channels));
}






/**
* Write a mono square wave to stdout.
*
* @param duration in seconds
* @param frequency in Hz
* @param amplitude 0 to 1
*****************************************************************************/
void square_wave(float duration, float frequency, float amplitude)
{
	uint32_t num_samples = sample_rate * duration;		// total number of samples to generate
	float period = 1.0/frequency;						// time-period of each cycle in seconds
	float samples_per_period = sample_rate * period;	// the number of samples per cycle

#ifdef DEBUG
	std::cerr << "num_samples=" << num_samples << std::endl;
	std::cerr << "period=" << period << std::endl;
	std::cerr << "samples_per_period=" << samples_per_period << std::endl;
#endif

	for (uint32_t i=0; i<num_samples; ++i)
	{
		constexpr int16_t max_sample = 0x7fff;
		float angle = fmodf(i, samples_per_period)/samples_per_period;		// [0..1]
		int16_t sample = ((angle<.5) ? max_sample : -max_sample) * amplitude;

#ifdef DEBUG
		std::cerr << "i=" << i << ", angle=" << angle << ", sample=" << sample << std::endl;
#endif
		sample = htobe16(sample);
		std::cout.write((char *)&sample, sizeof(sample));		// write out one sample
	}
}

/**
* Write a mono sine wave to stdout.
*
* @param duration in seconds
* @param frequency in Hz
* @param amplitude 0 to 1
*****************************************************************************/
void sine_wave(float duration, float frequency, float amplitude)
{
	uint32_t num_samples = sample_rate * duration;		// total number of samples to generate
	float period = 1.0/frequency;						// time-period of each cycle in seconds
	float samples_per_period = sample_rate * period;	// the number of samples per cycle

#ifdef DEBUG
	std::cerr << "num_samples=" << num_samples << std::endl;
	std::cerr << "period=" << period << std::endl;
	std::cerr << "samples_per_period=" << samples_per_period << std::endl;
#endif

	for (uint32_t i=0; i<num_samples; ++i)
	{
		constexpr int16_t max_sample = 0x7fff;
		float angle = fmodf(i, samples_per_period)/samples_per_period * 2*M_PI;	// [0..2PI]
		int16_t sample = sinf(angle)*max_sample*amplitude;

#ifdef DEBUG
		std::cerr << "i=" << i << ", angle=" << angle << ", sample=" << sample << std::endl;
#endif
		sample = htobe16(sample);
		std::cout.write((char *)&sample, sizeof(sample));		// write out one sample
	}
}


/**
* Write a mono sawtooth wave to stdout.
*
* @param duration in seconds
* @param frequency in Hz
* @param amplitude 0 to 1
*****************************************************************************/
void sawtooth_wave(float duration, float frequency, float amplitude)
{
	uint32_t num_samples = sample_rate * duration;		// total number of samples to generate
	float period = 1.0/frequency;						// time-period of each cycle in seconds
	float samples_per_period = sample_rate * period;	// the number of samples per cycle
#ifdef DEBUG
	std::cerr << "num_samples=" << num_samples << std::endl;
	std::cerr << "period=" << period << std::endl;
	std::cerr << "samples_per_period=" << samples_per_period << std::endl;
#endif

	for (uint32_t i=0; i<num_samples; ++i)
	{
		constexpr int16_t max_sample = 0x7fff;
		float angle = fmodf(i, samples_per_period)/samples_per_period;		// [0..1]
		int16_t sample = (angle-.5)*2 * max_sample * amplitude;

#ifdef DEBUG
		std::cerr << "i=" << i << ", angle=" << angle << ", sample=" << sample << std::endl;
#endif
		sample = htobe16(sample);
		std::cout.write((char *)&sample, sizeof(sample));		// write out one sample
	}
}

/**
* Write a mono triangle wave to stdout.
*
* @param duration in seconds
* @param frequency in Hz
* @param amplitude 0 to 1
*****************************************************************************/
void triangle_wave(float duration, float frequency, float amplitude)
{
	uint32_t num_samples = sample_rate * duration;		// total number of samples to generate
	float period = 1.0/frequency;						// time-period of each cycle in seconds
	float samples_per_period = sample_rate * period;	// the number of samples per cycle
#ifdef DEBUG
	std::cerr << "num_samples=" << num_samples << std::endl;
	std::cerr << "period=" << period << std::endl;
	std::cerr << "samples_per_period=" << samples_per_period << std::endl;
#endif

	for (uint32_t i=0; i<num_samples; ++i)
	{
		constexpr int16_t max_sample = 0x7fff;
		float angle = fmodf(i, samples_per_period)/samples_per_period;		// [0..1]
		int16_t sample=0;
		if (angle<.25)
			sample = (angle*4.0 * max_sample) * amplitude;
		else if (angle<.5)
			sample = ((1.0-(angle-.25)*4.0) * max_sample) * amplitude;
		else if (angle<.75)
			sample = ((0-(angle-.5)*4.0) * max_sample) * amplitude;
		else
			sample = ((-1.0+(angle-.75)*4.0) * max_sample) * amplitude;

#ifdef DEBUG
		std::cerr << "i=" << i << ", angle=" << angle << ", sample=" << sample << std::endl;
#endif
		sample = htobe16(sample);
		std::cout.write((char *)&sample, sizeof(sample));		// write out one sample
	}
}






constexpr float inter_note_pause = 1.0/32.0;	// time to pause between notes
constexpr float whole_duration = 1.0;				// duration of one bar

constexpr float quarter_duration = whole_duration/4.0;
constexpr float half_duration = whole_duration/2.0;

/**
* Emit silence for the given duration.
*
* @param duration in seconds
************************************************************************/
void silence(float duration)
{
	square_wave(duration, 1.0, 0.0);		// play any note with an amplitude of zero
}

/**
* Emit a MIDI note of thje specified number, duration and amplitude.
************************************************************************/
void render_midi_note(void (*render)(float, float, float), float duration, int m, float amp)
{
	render(duration-inter_note_pause, notes[m], amp);	// play the note
	silence(inter_note_pause);							// skip some silent time
}

/**
* Emit "do re mi fa so la ti do"
************************************************************************/
void do_re_mi(void (*render)(float, float, float), float amp)
{
	render_midi_note(render, quarter_duration, C4, amp);
	render_midi_note(render, quarter_duration, D4, amp);
	render_midi_note(render, quarter_duration, E4, amp);
	render_midi_note(render, quarter_duration, F4, amp);
	render_midi_note(render, quarter_duration, G4, amp);
	render_midi_note(render, quarter_duration, A4, amp);
	render_midi_note(render, quarter_duration, B4, amp);
	render_midi_note(render, quarter_duration, C5, amp);
}


/**
* Emit Mary Had a Little Lamb.
************************************************************************/
void mary_had_a_little_lamb(void (*render)(float, float, float), float amp)
{
	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, quarter_duration, D5, amp);
	render_midi_note(render, quarter_duration, C5, amp);
	render_midi_note(render, quarter_duration, D5, amp);

	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, half_duration, E5, amp);

	render_midi_note(render, quarter_duration, D5, amp);
	render_midi_note(render, quarter_duration, D5, amp);
	render_midi_note(render, half_duration, D5, amp);

	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, half_duration, E5, amp);

	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, quarter_duration, D5, amp);
	render_midi_note(render, quarter_duration, C5, amp);
	render_midi_note(render, quarter_duration, D5, amp);

	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, quarter_duration, E5, amp);

	render_midi_note(render, quarter_duration, D5, amp);
	render_midi_note(render, quarter_duration, D5, amp);
	render_midi_note(render, quarter_duration, E5, amp);
	render_midi_note(render, quarter_duration, D5, amp);

	render_midi_note(render, whole_duration, C5, amp);
}



int main()
{
	init_notes();		// generate table of note frequencies
	write_header();		// emit the .sdn file header
	silence(.5);		// 1/2 second of silence

	//square_wave(1.0, 1000.0, .5);
#if 0
	square_wave(1.0, notes[C4], .5);		// play C4 for 1/2 second
	square_wave(1.0, notes[C5], .5);		// play C5 for 1/2 second
	square_wave(1.0, notes[C6], .5);		// play C6 for 1/2 second
	square_wave(1.0, notes[C5], .5);		// play C5 for 1/2 second

	silence(.5);		// 1/2 second of silence
	square_wave(1.0, notes[G4], .5);		// XXX change to G3 to violate the NBC soundmark
	square_wave(1.0, notes[E4], .5);
	square_wave(1.0, notes[C4], .5);
#endif

#if 1
	do_re_mi(square_wave, 1);
	silence(.5);		// 1/2 second of silence
	do_re_mi(sine_wave, 1);
	silence(.5);		// 1/2 second of silence
	do_re_mi(sawtooth_wave, 1);
	silence(.5);		// 1/2 second of silence
	do_re_mi(triangle_wave, 1);
	silence(.5);		// 1/2 second of silence
#endif

#if 1
	mary_had_a_little_lamb(sine_wave, 1.0);
	//mary_had_a_little_lamb(triangle_wave, 1.0);

	silence(.5);		// 1/2 second of silence
#endif

	return 0;
}