/*
 * Copyright 2013 (c) Anna Schumaker.
 */
#include <core/audio.h>
#include <core/driver.h>
#include <core/library.h>
#include <core/tags/tags.h>
#include <tests/test.h>

Track *TRACK_NULL = NULL;
static unsigned int eos_count = 0;
static unsigned int error_count = 0;

TestDriver :: TestDriver() : playing(false), cur_pos(0), cur_duration(0) {}
TestDriver :: ~TestDriver() {}

void TestDriver :: init(int *argc, char ***argv, void (*eos_cb)(), void (*error_cb)())
	{ on_eos = eos_cb; on_error = error_cb; }
void TestDriver :: load(const std::string &file)
	{ cur_file = file; playing = false; cur_pos = 0; }
bool TestDriver :: play()  { playing = true;  return true; }
bool TestDriver :: pause() { playing = false; return true; }
bool TestDriver :: is_playing() { return playing; }

void TestDriver :: seek_to(long pos) { cur_pos = pos; }
long TestDriver :: position() { return cur_pos;      }
long TestDriver :: duration() { return cur_duration; }

void TestDriver :: eos()   { on_eos();   }
void TestDriver :: error() { on_error(); }


void on_eos()
{
	eos_count++;
}

void on_error()
{
	error_count++;
}

void test_driver()
{
	test_equal(driver :: get_driver(), (Driver *)NULL);
	TestDriver driver;

	const std::string file = "/home/Zelda/Music/Wind Waker/1 - Outset Isle.ogg";

	test_not_equal(driver :: get_driver(), (Driver *)NULL);
	test_equal((Driver *)&driver, driver :: get_driver());

	driver.init(0, NULL, on_eos, on_error);

	driver.load(file);
	test_equal(driver.cur_file, file);

	test_equal(driver.play(),  true);
	test_equal(driver.playing, true);
	test_equal(driver.is_playing(), true);

	test_equal(driver.pause(), true);
	test_equal(driver.playing, false);
	test_equal(driver.is_playing(), false);

	driver.seek_to(4242);
	test_equal(driver.cur_pos, (long)4242);
	test_equal(driver.position(), (long)4242);

	driver.cur_duration = 424242;
	test_equal(driver.duration(), (long)424242);

	driver.eos();
	test_equal(eos_count, (unsigned)1);

	driver.error();
	test_equal(error_count, (unsigned)1);

	driver.play();
	driver.seek_to(4242);
	driver.load(file);
	test_equal(driver.is_playing(), false);
	test_equal(driver.position(), (long)0);
}

void test_pre_init()
{
	TestDriver *driver = (TestDriver *)driver :: get_driver();

	test_equal(audio :: current_track(), TRACK_NULL);

	audio :: play();
	test_equal(driver->playing, false);

	driver->playing = true;
	audio :: pause();
	test_equal(driver->playing, true);
	audio :: stop();
	test_equal(driver->playing, true);
	driver->playing = false;

	audio :: seek_to(4242);
	test_equal(driver->position(), (long)0);

	driver->cur_pos = 4242;
	test_equal(audio :: position(), (long)0);
	driver->cur_pos = 0;

	driver->cur_duration = 4242;
	test_equal(audio :: duration(), (long)0);
	driver->cur_duration = 0;

	audio :: next();
	test_equal(audio :: current_track(), TRACK_NULL);

	audio :: prev();
	test_equal(audio :: current_track(), TRACK_NULL);
}

void test_init(int argc, char **argv)
{
	Track *track;

	test :: cp_data_dir();
	audio :: init(&argc, &argv);

	track = audio :: current_track();
	test_equal(track, TRACK_NULL);

	tags :: init();
	library :: init();
	audio :: init(&argc, &argv);

	track = audio :: current_track();
	test_not_equal(track, TRACK_NULL);
}

void test_playback_controls()
{
	TestDriver *driver = (TestDriver *)driver :: get_driver();

	audio :: play();
	test_equal(driver->playing, true);

	audio :: pause();
	test_equal(driver->playing, false);

	audio :: seek_to(4242);
	test_equal(driver->cur_pos, (long)4242);
	test_equal(audio :: position(), (long)4242);

	audio :: play();
	audio :: stop();
	test_equal(driver->playing, false);
	test_equal(driver->cur_pos, (long)0);

	audio :: seek_to(4242);
	driver->cur_duration = 424242;
	test_equal(audio :: position(), (long)4242);
	test_equal(audio :: duration(), (long)424242);

	audio :: seek_to(83 * O_SECOND);
	test_equal(audio :: position_str(), (std::string)"1:23");
}

void test_track_controls()
{
	Track *track = NULL;

	TestDriver *driver = (TestDriver *)driver :: get_driver();
	library :: get_queue()->unset_flag(Q_RANDOM);

	audio :: pause();
	audio :: next();
	test_not_equal(audio :: current_track()->index(), (unsigned)2);
	test_equal(driver->is_playing(), false);

	audio :: play();
	audio :: next();
	test_equal(driver->is_playing(), true);

	audio :: load_track(track);
	test_not_equal(audio :: current_track(), track);

	track = tags :: get_track(0);
	audio :: seek_to(4242);
	audio :: load_track(track);
	test_equal(driver->is_playing(), true);
	test_equal(audio :: position(), (long)0);

	audio :: seek_to(4242);
	audio :: load_track(track);
	test_equal(driver->is_playing(), true);
	test_equal(audio :: position(), (long)4242);

	driver->error();
	test_not_equal(audio :: current_track(), track);

	track = audio :: current_track();
	driver->eos();
	test_not_equal(audio :: current_track(), track);
}

void test_autopause()
{
	TestDriver *driver = (TestDriver *)driver :: get_driver();

	audio :: play();
	test_equal(audio :: pause_enabled(), false);
	test_equal(audio :: pause_count(), (unsigned)0);

	audio :: pause_after(true, 3);
	test_equal(audio :: pause_enabled(), true);
	test_equal(audio :: pause_count(), (unsigned)3);

	audio :: pause_after(false, 3);
	test_equal(audio :: pause_enabled(), false);
	test_equal(audio :: pause_count(), (unsigned)3);

	audio :: pause_after(false, 5);
	test_equal(audio :: pause_enabled(), true);
	test_equal(audio :: pause_count(), (unsigned)5);

	for (int i = 4; i >= 0; i--) {
		driver->eos();
		test_equal(audio :: pause_enabled(), true);
		test_equal(audio :: pause_count(), (unsigned)i);
		test_equal(driver->is_playing(), true);
	}

	driver->eos();
	test_equal(audio :: pause_enabled(), false);
	test_equal(audio :: pause_count(), (unsigned)0);
	test_equal(driver->is_playing(), false);
}

int main(int argc, char **argv)
{
	run_test("Test Audio Driver", test_driver);

	TestDriver driver;
	run_test("Test Audio Pre-Init", test_pre_init);
	run_test("Test Audio Init", test_init, argc, argv);
	run_test("Test Audio Playback Controls", test_playback_controls);
	run_test("Test Audio Track Controls", test_track_controls);
	run_test("Test Audio Automatic Pausing", test_autopause);
	return 0;
}