#include <stdio.h>
#include <libspotify/api.h>
#include <pthread.h>
#include <assert.h>

#include <mach/clock.h>
#include <mach/mach.h>

#define COMMAND_SP_LOGOUT 1
#define COMMAND_SP_PRINTUSER 2

extern uint8_t g_appkey[];
extern int g_appkey_size;
void notifyMainThread(sp_session* session);
void* spotifyLoop(void*);
void loggedIn(sp_session* session, sp_error error);
void loggedOut(sp_session* session);
void logMessage(sp_session* session, const char* data);

static sp_session* spotifySession;
static int notify_do = 0;
static int command = 0;
static int logged_out = 0;

static pthread_mutex_t notify_mutex;
static pthread_cond_t notify_cond;
static pthread_t spotifyThread;

static sp_session_callbacks sessionCallbacks = {
	.notify_main_thread = &notifyMainThread,
	.logged_in = &loggedIn,
	.logged_out = &loggedOut,
	.log_message = &logMessage,
};

static sp_session_config sessionConfig = {
	.api_version = SPOTIFY_API_VERSION,
	.cache_location = "tmp",
	.settings_location = "tmp",
	.application_key = g_appkey,
	.application_key_size = 0,
	.user_agent = "nodejs-spotify-adapter",
	.callbacks = &sessionCallbacks,
	NULL,
};


void* spotifyLoop(void* nervNicht) {
	sp_error error;
	sp_session* session;

	int next_timeout = 0;
	const char* username = "SET";
	const char* password = "SET";

	sessionConfig.application_key_size = g_appkey_size;

	error = sp_session_create(&sessionConfig, &session);

	if(SP_ERROR_OK != error) {
		fprintf(stderr, "Could not create Spotify session: %s\n", sp_error_message(error));
	}
	
	spotifySession = session;

	pthread_mutex_init(&notify_mutex, NULL);
	pthread_cond_init(&notify_cond, NULL);

	sp_session_login(session, username, password, 0, NULL);
	pthread_mutex_lock(&notify_mutex);
	int log_out_called = 0;
	while(!logged_out) {
		if(log_out_called) fprintf(stdout, "Loop while logout in process, command: %d, notify: %d, timeout: %d\n", command, notify_do, next_timeout);
		if(next_timeout == 0) {
			while(notify_do == 0) {
				pthread_cond_wait(&notify_cond, &notify_mutex);
			}
		} else {
			struct timespec ts;
                        clock_serv_t cclock;
                        mach_timespec_t mts;
	                host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
	                clock_get_time(cclock, &mts);
	                mach_port_deallocate(mach_task_self(), cclock);
	                ts.tv_sec = mts.tv_sec + next_timeout / 1000;
	                ts.tv_nsec = mts.tv_nsec + (next_timeout % 1000) * 1000;
			
			while(!notify_do && !command) {
				if(pthread_cond_timedwait(&notify_cond, &notify_mutex, &ts))
					break;
			}
		}

		if(log_out_called) fprintf(stdout, "2 Loop while logout in process, command: %d, notify: %d, timeout: %d\n", command, notify_do, next_timeout);
		if(command) {
			if(command == COMMAND_SP_LOGOUT) {
				sp_session_logout(spotifySession);
				log_out_called = 1;
			} else if(command == COMMAND_SP_PRINTUSER) {
				sp_user* user = sp_session_user(spotifySession);
				const char* name = sp_user_display_name(user);
				fprintf(stdout, "User: %s\n", name);
			}
		}
		command = 0;
		notify_do = 0;
		pthread_mutex_unlock(&notify_mutex);

		do {
			if(log_out_called) fprintf(stdout, "3 Loop while logout in process, command: %d, notify: %d, timeout: %d\n", command, notify_do, next_timeout);
			sp_session_process_events(session, &next_timeout);
			if(log_out_called) fprintf(stdout, "4 Loop while logout in process, command: %d, notify: %d, timeout: %d\n", command, notify_do, next_timeout);
		} while(next_timeout == 0);

		pthread_mutex_lock(&notify_mutex);
	}
	sp_session_release(session);
	fprintf(stdout, "Exiting spotify main loop\n");
	return 0; 
}

void notifyMainThread(sp_session* session) {
	pthread_mutex_lock(&notify_mutex);
	notify_do = 1;
	pthread_cond_signal(&notify_cond);
	pthread_mutex_unlock(&notify_mutex);
}

void loggedIn(sp_session* session, sp_error error) {
	if(SP_ERROR_OK != error) {
		fprintf(stderr, "Error logging in: %s\n", sp_error_message(error));
	} else {
		fprintf(stdout, "Service is logged in!\n");
	}
}

void loggedOut(sp_session* session) {
	fprintf(stdout, "Service is logged out\n");
	logged_out = 1;
}

void logMessage(sp_session* session, const char* data) {
	fprintf(stdout, "%s\n", data);
}

void printUser() {
	pthread_mutex_lock(&notify_mutex);
	command = COMMAND_SP_PRINTUSER;
	pthread_cond_signal(&notify_cond);
	pthread_mutex_unlock(&notify_mutex);
}

void logout() {
	pthread_t caller =  pthread_self();
	fprintf(stdout, "Logout called by %u\n", (unsigned int)caller);
	pthread_mutex_lock(&notify_mutex);
	command = COMMAND_SP_LOGOUT;
	pthread_cond_signal(&notify_cond);
	pthread_mutex_unlock(&notify_mutex);
}

void login() {
	pthread_t caller =  pthread_self();
	fprintf(stdout, "Login called by %u\n", (unsigned int)caller);
	pthread_create(&spotifyThread, NULL, spotifyLoop, NULL);
}