#include <SDL2/SDL.h>
#include <SDL2/SDL_audio.h>
#include <stdio.h>
/*
 * INFO: I will mark places to look at with INFO:
 */
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;

const int MAX_RECORDING_DEVICES = 10;
const int MAX_RECORDING_SECONDS = 1;
const int RECORDING_BUFFER_SECONDS = MAX_RECORDING_SECONDS + 1;
/*
 * Application
 */
int init();
void destroy();
int select_device(SDL_KeyboardEvent* key_event, int max_index);

typedef enum {
	SELECTING_DEVICE,
	RECORDING,
	RECORDED,
	PLAYBACK,
} application_state;

typedef struct {
	application_state application_state;
	int device_index;
	int recording_device_id;
	int playback_device_id;
} state;

void application_state_to_string(application_state state, char* string);
/*
 * Visual
 */
SDL_Window* window = NULL;
SDL_Renderer* renderer = NULL;
//TTF_Font* global_font = NULL;

typedef struct {
	SDL_Texture* texture;
	int width;
	int height;
} text_texture;

int text_texture_init(text_texture* text_texture);
int text_texture_load(text_texture* text_texture, char* string);
int text_texture_render(text_texture* text_texture, int x, int y);
int text_texture_free(text_texture* text_texture);
/*
 * Audio INFO: audio related declarations and callback here.
 */
int num_devices = 0;
int num_recdevices = 0;
int num_playdevices = 0;

SDL_AudioSpec recording_spec;
SDL_AudioSpec playback_spec;
SDL_AudioSpec received_recording_spec;
SDL_AudioSpec received_playback_spec;
Uint8* recording_buffer = NULL;
unsigned int recording_buffer_size = 0;
unsigned int recording_buffer_position = 0;
unsigned int recording_buffer_position_max = 0;

SDL_AudioDeviceID audio_recording_init(int index, void* userdata);
SDL_AudioDeviceID audio_playback_init(void* userdata);
void audio_buffer_destroy();
void audio_recording_callback( void* userdata, Uint8* stream, int len );
void audio_playback_callback( void* userdata, Uint8* stream, int len );

void handle_input(SDL_Event* event, state* state);
void handle_task(state* state);

//Recording data buffer
Uint8* gRecordingBuffer = NULL;

//Size of data buffer
Uint32 gBufferByteSize = 0;

//Position in data buffer
Uint32 gBufferBytePosition = 0;

void audioRecordingCallback(void* userdata, Uint8* stream, int len )
{
	memcpy(&gRecordingBuffer[ gBufferBytePosition ], stream, len);
	gBufferBytePosition += len;
	printf("recording\n");
}

void audioPlaybackCallback(void* userdata, Uint8* stream, int len )
{
	memcpy(stream, &gRecordingBuffer[ gBufferBytePosition ], len);
	gBufferBytePosition += len;
	printf("playback\n");
}

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

	SDL_AudioDeviceID recordingDeviceId = 0;
	SDL_AudioDeviceID playbackDeviceId = 0;

	SDL_AudioSpec gReceivedRecordingSpec;
	SDL_AudioSpec gReceivedPlaybackSpec;

	SDL_AudioSpec desiredRecordingSpec;

	SDL_zero(desiredRecordingSpec);
	desiredRecordingSpec.freq = 44100;
	desiredRecordingSpec.format = AUDIO_S16;
	desiredRecordingSpec.channels = 2;
	desiredRecordingSpec.samples = 4096;
	desiredRecordingSpec.callback = audioRecordingCallback;

	SDL_AudioSpec desiredPlaybackSpec;
	SDL_zero(desiredPlaybackSpec);
	desiredPlaybackSpec.freq = 44100;
	desiredPlaybackSpec.format = AUDIO_S16; // AUDIO_F32;
	desiredPlaybackSpec.channels = 2;
	desiredPlaybackSpec.samples = 4096;
	desiredPlaybackSpec.callback = audioPlaybackCallback;

	//Maximum position in data buffer for recording
	Uint32 gBufferByteMaxPosition = 0;

	if (!init()) return 1;

	printf("Audio Driver: %s\n", SDL_GetCurrentAudioDriver());

	num_recdevices = SDL_GetNumAudioDevices(1);
	if(num_recdevices < 1) {
		printf( "Unable to get audio capture device! SDL Error: %s\n", SDL_GetError() );
		return 0;
	}
	printf("Num audio recording devices: %i\n", num_recdevices);
	for(int i = 0; i < num_recdevices; ++i) {
		const char* deviceName = SDL_GetAudioDeviceName(i, 1);
		printf("REC: %d - %s\n", i, deviceName);
	}

	num_playdevices = SDL_GetNumAudioDevices(0);
	if(num_playdevices < 1) {
		printf( "Unable to get audio playback device! SDL Error: %s\n", SDL_GetError() );
		return 0;
	}
	printf("Num audio playback devices: %i\n", num_playdevices);
	for(int i = 0; i < num_recdevices; ++i) {
		const char* deviceName = SDL_GetAudioDeviceName(i, 0);
		printf("PBK: %d - %s\n", i, deviceName);
	}

	recordingDeviceId = SDL_OpenAudioDevice(SDL_GetAudioDeviceName(2, SDL_TRUE), SDL_TRUE, &desiredRecordingSpec, &gReceivedRecordingSpec, SDL_AUDIO_ALLOW_FORMAT_CHANGE);
	if(recordingDeviceId == 0) {
		printf("Failed to open recording device! SDL Error: %s", SDL_GetError() );
		return 1;
	}
	int bytesPerSample = gReceivedRecordingSpec.channels * (SDL_AUDIO_BITSIZE(gReceivedRecordingSpec.format) / 8);
	int bytesPerSecond = gReceivedRecordingSpec.freq * bytesPerSample;
	gBufferByteSize = RECORDING_BUFFER_SECONDS * bytesPerSecond;
	gBufferByteMaxPosition = MAX_RECORDING_SECONDS * bytesPerSecond;
	printf("bytesPerSample %d, bytesPerSecond %d\n", bytesPerSample,bytesPerSecond);
	printf("gBufferByteSize %d, gBufferByteMaxPosition %d\n", gBufferByteSize,gBufferByteMaxPosition);

	playbackDeviceId = SDL_OpenAudioDevice( NULL, 0, &desiredPlaybackSpec, &gReceivedPlaybackSpec, SDL_AUDIO_ALLOW_FORMAT_CHANGE );
	if(playbackDeviceId == 0) {
		printf("Failed to open playback device! SDL Error: %s", SDL_GetError());
		return 1;
	}

	gRecordingBuffer = malloc(gBufferByteSize);
	memset(gRecordingBuffer, 0, gBufferByteSize);
	gBufferBytePosition = 0;

	SDL_Delay(100);
	SDL_PauseAudioDevice( recordingDeviceId, SDL_FALSE );

	while(1) {
		SDL_LockAudioDevice( recordingDeviceId );
		if(gBufferBytePosition > gBufferByteMaxPosition) {
			printf("end\n");
			SDL_UnlockAudioDevice( recordingDeviceId );
			SDL_PauseAudioDevice( recordingDeviceId, SDL_TRUE );
			break;
			//} else {
			//	printf("bufferPos %d\n",gBufferBytePosition);
		}
		SDL_UnlockAudioDevice( recordingDeviceId );
	}

	printf("playback\n");
	gBufferBytePosition = 0;
	SDL_PauseAudioDevice(playbackDeviceId, 0);
	while(1) {
		SDL_LockAudioDevice(playbackDeviceId);
		if(gBufferBytePosition > gBufferByteMaxPosition) {
			printf("end\n");
			SDL_UnlockAudioDevice(playbackDeviceId);
			SDL_PauseAudioDevice(playbackDeviceId, SDL_TRUE);
			break;
		}
		SDL_UnlockAudioDevice(playbackDeviceId);
	}

cleanup:
	printf("1\n");
	free(gRecordingBuffer);
	printf("2\n");
	SDL_CloseAudioDevice(recordingDeviceId);
	printf("3\n");
	destroy();
	printf("4\n");
	return 0;
}

void handle_input(SDL_Event* event, state* state)
{
	SDL_Keycode keysym = event->key.keysym.sym;
	switch (state->application_state) {
	// INFO: init of recording audio device here
	case SELECTING_DEVICE:
		switch (keysym) {
		case SDLK_y:
		case SDLK_RETURN:
			// INFO: init audio device here and below
			// Here it initialises everytime you press enter or y, and
			// unpauses device immediately. Seems to work mor consistently
			SDL_CloseAudioDevice(state->recording_device_id);
			state->recording_device_id =
			    audio_recording_init(state->device_index, NULL);

			if (state->device_index == -1 || !state->recording_device_id) break;
			recording_buffer_position = 0;
			// INFO: calling this should unpause the device and start calling the callback
			SDL_PauseAudioDevice(state->recording_device_id, 0);
			/*SDL_UnlockAudioDevice(state->recording_device_id);*/
			// INFO: state change looks like this here
			state->application_state = RECORDING;
			break;
		case SDLK_ESCAPE:
			state->device_index = -1;
			SDL_CloseAudioDevice(state->recording_device_id);
			break;
		}
		int device_index_new = select_device(&event->key, num_devices);
		if (device_index_new == -1) break;
		if (state->device_index != -1 && device_index_new == -1) break;
		state->device_index = device_index_new;
		// INFO: inititialising here seems to be less consistent. When I
		// spam enter or y after initialising here, Sometimes I see
		// callback being called sometimes not.
		/*SDL_CloseAudioDevice(state->recording_device_id);*/
		/*state->recording_device_id = audio_recording_init(state->device_index, NULL);*/

		break;

	case RECORDING:
		switch (keysym) {
		case SDLK_y:
			SDL_PauseAudioDevice(state->recording_device_id, 0);
			break;
		case SDLK_q:
		case SDLK_ESCAPE:
			SDL_PauseAudioDevice(state->recording_device_id, 1);
			audio_buffer_destroy();
			state->application_state = SELECTING_DEVICE;
			break;
		}
		break;
	// INFO: init of playback audio device here. Can't seem to get it to play / call callback
	case RECORDED:
		switch (keysym) {
		case SDLK_y:
		case SDLK_RETURN:
			SDL_CloseAudioDevice(state->playback_device_id);
			state->playback_device_id = audio_playback_init(NULL);
			recording_buffer_position = 0;
			SDL_PauseAudioDevice(state->playback_device_id, 0);
			/*SDL_UnlockAudioDevice(state->playback_device_id);*/
			state->application_state = PLAYBACK;
			break;
		case SDLK_q:
		case SDLK_ESCAPE:
			audio_buffer_destroy();
			state->application_state = SELECTING_DEVICE;
			break;
		}
		break;

	case PLAYBACK:
		switch (keysym) {
		case SDLK_q:
		case SDLK_ESCAPE:
			state->application_state = RECORDED;
			break;
		}
		break;

	}
}

void handle_task(state* state)
{
	switch (state->application_state) {

	case SELECTING_DEVICE:
		break;

	case RECORDING:
		// INFO: check buffer position here and stop if reaces the end
		SDL_LockAudioDevice(state->recording_device_id);
		/*printf("buf pos: %u\n", recording_buffer_position);*/
		if (recording_buffer_position >= recording_buffer_position_max) {
			SDL_UnlockAudioDevice(state->recording_device_id);
			SDL_PauseAudioDevice(state->recording_device_id, 1);
			SDL_CloseAudioDevice(state->recording_device_id);
			state->application_state = RECORDED;
			break;
		}
		SDL_UnlockAudioDevice(state->recording_device_id);
		break;

	case RECORDED:
		break;

	case PLAYBACK:
		// INFO:
		SDL_LockAudioDevice(state->playback_device_id);
		if (recording_buffer_position >= recording_buffer_position_max) {
			SDL_UnlockAudioDevice(state->playback_device_id);
			SDL_PauseAudioDevice(state->playback_device_id, 1);
			SDL_CloseAudioDevice(state->playback_device_id);
			state->application_state = RECORDED;
			break;
		}
		SDL_UnlockAudioDevice(state->playback_device_id);
		break;

	}
}

int init()
{
	//if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
	int nRet=0;
	nRet = SDL_Init(SDL_INIT_AUDIO);
	if (nRet < 0) {
		printf("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
		return 0;
	}

	printf("SDL initialized: %d %s\n",nRet, SDL_GetError());

	// if (TTF_Init() == -1) {
	// 	printf("TTF could not initialize! TTF Error: %s\n", TTF_GetError());
	// 	return 0;
	// }

	// window = SDL_CreateWindow("SDL record", SDL_WINDOWPOS_UNDEFINED,
	//                           SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH,
	//                           SCREEN_HEIGHT, SDL_WINDOW_SHOWN);

	// if (!window) {
	// 	printf("Window could not be created! SDL Error: %s\n", SDL_GetError());
	// 	return 0;
	// }

	// renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
	// if (!renderer) {
	// 	printf("Renderer could not be created! SDL_Error: %s\n", SDL_GetError());
	// 	return 0;
	// }

	// global_font = TTF_OpenFont("FiraCode-Regular.ttf", 24);
	// if (!global_font) {
	// 	printf("Failed to load font! TTF_Error: %s\n", TTF_GetError());
	// 	return 0;
	// }

	return 1;
}

void destroy()
{
	free(recording_buffer);

	//TTF_CloseFont(global_font);
	//SDL_DestroyRenderer(renderer);
	//SDL_DestroyWindow(window);
	//TTF_Quit();
	SDL_Quit();
}

int select_device(SDL_KeyboardEvent* key_event, int max_index)
{
	SDL_Keycode keycode = key_event->keysym.sym;
	SDL_Keycode mod = key_event->keysym.mod;

	int keycode_is_num = (keycode >= SDLK_0 && keycode <= SDLK_9);
	int no_mod = (mod == 0);
	if (!keycode_is_num || !no_mod) {
		printf("Not number: %c <%u>\n", keycode, keycode);
		return -1;
	} else {
		printf("Is number: %c <%u>\n", keycode, keycode);
	}

	int index = keycode - SDLK_0;
	if (index >= max_index) return -1;

	return index;
}

void application_state_to_string(application_state state, char* string)
{
	switch (state) {
	case SELECTING_DEVICE:
		sprintf(string, "Selecting Device [0-9] -> [y/RET], ");
		break;
	case RECORDING:
		sprintf(string, "Recording");
		break;
	case RECORDED:
		sprintf(string, "Recorded");
		break;
	case PLAYBACK:
		sprintf(string, "Playing");
		break;
	}
}

int text_texture_init(text_texture* text_texture)
{
	text_texture->texture = NULL;
	text_texture->width = 0;
	text_texture->height = 0;
	return 1;
}

// int text_texture_load(text_texture* text_texture, char* string)
// {
// 	if (text_texture->texture) {
// 		SDL_DestroyTexture(text_texture->texture);
// 		text_texture->texture = NULL;
// 	}

// 	SDL_Color text_color = { 255, 255, 255 };
// 	SDL_Surface* text_surface = TTF_RenderText_Solid(global_font, string, text_color);
// 	if (!text_surface) {
// 		printf("Unable to render text surface! TTF_Error: %s\n", TTF_GetError());
// 		return 0;
// 	}

// 	SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, text_surface);
// 	if (!texture) {
// 		printf("Unable to create texture from rendered text! SDL_Error: %s\n", SDL_GetError());
// 		return 0;
// 	}

// 	text_texture->texture = SDL_CreateTextureFromSurface(renderer, text_surface);
// 	text_texture->width = text_surface->w;
// 	text_texture->height = text_surface->h;

// 	SDL_FreeSurface(text_surface);
// 	return 1;
// }

int text_texture_render(text_texture* text_texture, int x, int y)
{
	if (!text_texture) {
		printf("text_texture uninitialized");
		return 0;
	}
	if (!text_texture->texture) {
		printf("text_texture->texture uninitialized");
		return 0;
	}

	int quad_width = text_texture->width;
	int quad_height = text_texture->height;
	SDL_Rect render_quad = { x, y, quad_width, quad_height };
	SDL_RenderCopy(renderer, text_texture->texture, NULL, &render_quad);

	return 1;
}

int text_texture_free(text_texture* text_texture)
{
	if (!text_texture->texture) {
		return 0;
	}
	SDL_DestroyTexture(text_texture->texture);
	return 1;
}
// INFO: device init here
// Most of the audio stuff I copied from an example
SDL_AudioDeviceID audio_recording_init(int index, void* userdata)
{
	// INFO: audio spec and callback
	SDL_zero(recording_spec);
	recording_spec.freq = 44100;
	recording_spec.format = AUDIO_F32;
	recording_spec.channels = 2;
	recording_spec.samples = 4096;
	recording_spec.callback = audio_recording_callback;
	recording_spec.userdata = userdata;

	SDL_AudioDeviceID device_id = SDL_OpenAudioDevice(SDL_GetAudioDeviceName(index, 1), 1, &recording_spec, &received_recording_spec, SDL_AUDIO_ALLOW_FORMAT_CHANGE);
	printf("Recording Device: %s\n", SDL_GetAudioDeviceName(index, 1));
	if (!device_id) {
		printf("Failed to open recording device! SDL Error: %s", SDL_GetError());
		return 0;
	}

	unsigned int bytes_per_sample = received_recording_spec.channels * (SDL_AUDIO_BITSIZE(received_recording_spec.format)/8);
	unsigned int bytes_per_second = received_recording_spec.freq * bytes_per_sample;
	// INFO: I just copied example where they allocated 1 second worth of buffer so it doesn't die
	recording_buffer_size = RECORDING_BUFFER_SECONDS * bytes_per_second;
	recording_buffer_position_max = MAX_RECORDING_SECONDS * bytes_per_second;

	recording_buffer = malloc(recording_buffer_size);
	memset(recording_buffer, 0, recording_buffer_size);

	return device_id;
}
// INFO:
SDL_AudioDeviceID audio_playback_init(void* userdata)
{
	if (!recording_buffer) {
		printf("Audio buffer not initialized");
		return 0;
	}
	// INFO: audio spec and callback
	SDL_zero(playback_spec);
	playback_spec.freq = 44100;
	playback_spec.format = AUDIO_F32;
	playback_spec.channels = 2;
	playback_spec.samples = 4096;
	playback_spec.callback = audio_playback_callback;
	playback_spec.callback = userdata;

	SDL_AudioDeviceID device_id = SDL_OpenAudioDevice(NULL, 0, &playback_spec, &received_playback_spec, SDL_AUDIO_ALLOW_FORMAT_CHANGE);
	if (!device_id) {
		printf("Failed to open playback device! SDL Error: %s", SDL_GetError());
		return 0;
	}

	return device_id;
}

int audio_device_stop(int device_id)
{
	SDL_PauseAudioDevice(device_id, 1);
	SDL_CloseAudioDevice(device_id);
	return 1;
}

void audio_buffer_destroy()
{
	free(recording_buffer);
	recording_buffer = NULL;
	recording_buffer_size = 0;
	recording_buffer_position = 0;
}
// INFO: callback here
void audio_recording_callback(void* userdata, Uint8* stream, int len)
{
	memcpy(&recording_buffer[recording_buffer_position], stream, len);
	recording_buffer_position += len;
	char string[64];
	sprintf(string, "Record pos: %u %u", recording_buffer_position, len);
	printf(string, "Record pos: %u %u\n", recording_buffer_position, len);
}
// INFO:
void audio_playback_callback(void* userdata, Uint8* stream, int len)
{
	memcpy(stream, &recording_buffer[recording_buffer_position], len);
	recording_buffer_position += len;
	char string[64];
	sprintf(string, "Playback pos: %u %u", recording_buffer_position, len);
	printf(string, "Playback pos: %u %u", recording_buffer_position, len);
}