/**
 * Copyright 2013 (c) Anna Schumaker.
 */
#include <core/audio.h>
#include <core/deck.h>
#include <core/library.h>
#include <core/string.h>


static bool _pause_enabled = false;
static unsigned int _pause_count =  0;

static Track *cur_track = NULL;
static File f_cur_track("cur_track", 0);
static AudioDriver *cur_driver = NULL;


static void save_state()
{
	f_cur_track.open(OPEN_WRITE);
	f_cur_track << cur_track->index() << std::endl;
	f_cur_track.close();
}

static void _load_track(Track *track, bool start_playback)
{
	cur_track = track;
	if (!track)
		return;

	cur_driver->load(track);
	if (start_playback)
		audio :: play();
	else
		audio :: pause();
	save_state();
}

static bool continue_playback()
{
	bool ret = true;

	if (_pause_enabled) {
		if (_pause_count == 0) {
			ret = false;
			_pause_enabled = false;
		} else
			_pause_count--;
	}

	return ret;
}



AudioDriver :: AudioDriver()
{
	cur_driver = this;
}

AudioDriver :: ~AudioDriver()
{
	cur_driver = NULL;
}

void AudioDriver :: eos()
{
	if (cur_track) {
		cur_track->played();
		library :: get_queue()->updated(cur_track);
	}

	_load_track(deck :: next(), continue_playback());
}



void audio :: init()
{
	unsigned int id;

	if (f_cur_track.exists()) {
		f_cur_track.open(OPEN_READ);
		f_cur_track >> id;
		f_cur_track.close();
		audio :: load_track(tags :: get_track(id));
	}
}

void audio :: play()
{
	if (cur_track)
		cur_driver->play();
}

void audio :: pause()
{
	if (cur_track)
		cur_driver->pause();
}

void audio :: seek_to(int64_t pos)
{
	if (cur_track)
		cur_driver->seek_to(pos);
}

void audio :: stop()
{
	pause();
	seek_to(0);
}

int64_t audio :: position()
{
	if (cur_track)
		return cur_driver->position();
	return 0;
}

int64_t audio :: duration()
{
	if (cur_track)
		return cur_driver->duration();
	return 0;
}

void audio :: next()
{
	_load_track(deck :: next(), cur_driver->is_playing());
}

void audio :: prev()
{
	_load_track(deck :: prev(), cur_driver->is_playing());
}

void audio :: load_track(Track *track)
{
	if (!track || track == cur_track)
		return;

	_load_track(track, cur_driver->is_playing());
	deck :: get_queue()->add(cur_track);
}

Track *audio :: current_track()
{
	return cur_track;
}

void audio :: pause_after(bool enabled, unsigned int n)
{
	if (n > _pause_count)
		enabled = true;

	_pause_enabled = enabled;
	_pause_count = n;
}

bool audio :: pause_enabled()
{
	return _pause_enabled;
}

unsigned int audio :: pause_count()
{
	return _pause_count;
}

AudioDriver *audio :: get_driver()
{
	return cur_driver;
}