/*
 * Copyright 2014 (c) Anna Schumaker.
 */
#include <core/queue.h>
#include <core/random.h>
#include <core/tags/tags.h>
#include <tests/test.h>


unsigned int count_destroyed = 0;
unsigned int count_add = 0;
unsigned int count_del = 0;
unsigned int count_updated = 0;
unsigned int last_update = 0;
unsigned int expected = 0;
Track *TRACK_NULL = NULL;


static class TestNotifier : public QNotifier {
public:
	TestNotifier() : QNotifier() {}
	void on_remove() { count_destroyed++; }
	void on_track_added(unsigned int i)   { count_add++; }
	void on_track_removed(unsigned int i) { count_del++; }
	void on_track_updated(unsigned int i) { count_updated++; last_update = i; }
} test_notifier;


class TestQueue : public Queue {
public:
	TestQueue() : Queue() { set_notifier(&test_notifier); }
	TestQueue(unsigned int f) : Queue(f) { set_notifier(&test_notifier); }
	~TestQueue() {}
	unsigned int get_cur()    { return _cur;    }
	unsigned int get_flags()  { return _flags;  }
	QNotifier   *get_notify() { return _notify; }
	std::vector <sort_info> get_sorder() { return _sort_order; };
};

TestQueue *Q = NULL, *R = NULL;


void test_default()
{
	TestQueue q;

	test_equal(q.get_cur(),    (unsigned)-1);
	test_equal(q.get_flags(),  (unsigned)0);
	test_equal(q.length(),     (unsigned)0);
	test_equal(q.get_sorder().size(), (size_t)0);
	test_equal(q.next(), (Track *)NULL);
	test_equal(q.get_notify(), &test_notifier);
}

void test_constructor()
{
	unsigned int flags = Q_ENABLED | Q_RANDOM;
	TestQueue q(flags);

	test_equal(q.get_cur(),    (unsigned)-1);
	test_equal(q.get_flags(),  flags);
	test_equal(q.length(),     (unsigned)0);
	test_equal(q.get_sorder().size(), (size_t)0);
	test_equal(q.next(), (Track *)NULL);
	test_equal(q.get_notify(), &test_notifier);
}

void test_flags()
{
	TestQueue q(0);

	test_equal(q.get_flags(), (unsigned)0);

	q.set_flag(Q_ENABLED);
	test_equal(q.get_flags(), (unsigned)Q_ENABLED);

	q.unset_flag(Q_ENABLED);
	test_equal(q.get_flags(), (unsigned)0);

	q.set_flag(Q_REPEAT);
	q.set_flag(Q_RANDOM);
	test_equal(q.has_flag(Q_ENABLED), false);
	test_equal(q.has_flag(Q_RANDOM), true);
	test_equal(q.has_flag(Q_REPEAT), true);
	test_equal(q.has_flag(Q_NO_SORT), false);
	test_equal(q.has_flag(Q_NOTIFY_REMOVE), false);
}


unsigned int _test_destructor_null(unsigned int i)
{
	TestQueue *q = new TestQueue(0);
	delete q;
	return (count_destroyed == 0) ? LOOP_PASSED : LOOP_FAILED;
}

unsigned int _test_destructor_flag(unsigned int i)
{
	TestQueue *q = new TestQueue(Q_NOTIFY_REMOVE);
	delete q;
	return (count_destroyed == (i + 1)) ? LOOP_PASSED : LOOP_FAILED;
}

void test_destructor()
{
	test_for_each(0, 10, 1, _test_destructor_null);
	test_for_each(0, 10, 1, _test_destructor_flag);
}


unsigned int _test_add_loop(unsigned int i)
{
	Track *track = tags :: get_track(i % 24);
	unsigned int index = Q->add(track);
	expected += track->length();
	if (index != i)
		return LOOP_FAILED;
	if ((index + 1) != count_add)
		return LOOP_FAILED;
	return LOOP_PASSED;
}

unsigned int _test_del_loop(unsigned int i)
{
	Track *track = tags :: get_track(i);
	unsigned int j = (i + 1) * 2;

	Q->del(track);
	expected -= track->length() * 2;
	if (count_del != j)
		return LOOP_FAILED;
	return LOOP_PASSED;
}

unsigned int _test_del_middle_loop(unsigned int i)
{
	unsigned int j = 23 - i;
	expected -= (*Q)[j]->length();
	Q->del(j);
	return (count_del == (i + 1)) ? LOOP_PASSED : LOOP_FAILED;
}

unsigned int _test_del_front_loop(unsigned int i)
{
	expected -= (*Q)[0]->length();
	Q->del((unsigned int)0);
	return (count_del == (i + 1)) ? LOOP_PASSED : LOOP_FAILED;
}

void test_add_remove()
{
	TestQueue q(0);
	Q = &q;

	test_equal(q.length(), expected);
	test_equal(q.size(), (unsigned)0);

	/* Add tracks */
	test_for_each(0, 24, 1, _test_add_loop);
	test_equal(q.length(), expected);
	test_equal(q.size(), (unsigned)24);


	/* Add everything again */
	test_for_each(24, 48, 1, _test_add_loop);
	test_equal(q.length(), expected);
	test_equal(q.size(), (unsigned)48);


	/* Test removing multiple tracks at once */
	count_del = 0;
	test_for_each(0, 12, 1, _test_del_loop);
	test_equal(q.length(), expected);
	test_equal(q.size(), (unsigned)24);


	/* Test removing tracks one at a time */
	count_del = 0;
	test_for_each(0, 12, 1, _test_del_middle_loop);
	test_equal(q.length(), expected);
	test_equal(q.size(), (unsigned)12);


	/* Remove remaining tracks */
	count_del = 0;
	test_for_each(0, 12, 1, _test_del_front_loop);
	test_equal(q.length(), (unsigned)0);
	test_equal(q.size(), (unsigned)0);
}

static void test_fill_q()
{
	for (unsigned int i = 0; i < 24; i++)
		Q->add(tags :: get_track(i));
}

unsigned int _test_update_loop(unsigned int i)
{
	Q->updated(tags :: get_track(i));
	if (last_update != i)
		return LOOP_FAILED;
	return ((i+1) == count_updated) ? LOOP_PASSED : LOOP_FAILED;
}

void test_updated()
{
	Track *track;
	TestQueue q(0);

	Q = &q;

	test_fill_q();
	test_for_each(0, 24, 1, _test_update_loop);

	track = tags :: get_track(0);
	q.add(track);
	q.add(track);
	q.updated(track);
	test_equal(count_updated, (unsigned)24 + 3);
}

unsigned int expected_rand[] = { 1, 4,  8, 13, 19, 3, 14, 16, 20,  2, 11, 17,
				23, 6, 12, 18,  0, 5,  9, 10, 15, 21, 22,  7 };


unsigned int _test_next_loop(unsigned int i)
{
	Track *track = Q->next();
	if (track == TRACK_NULL)
		return LOOP_FAILED;
	return (track->index() == (i %  24)) ? LOOP_PASSED : LOOP_FAILED;
}

unsigned int _test_next_rand_loop(unsigned int i)
{
	Track *track = Q->next();
	if (track == TRACK_NULL)
		return LOOP_FAILED;
	return (track->index() == expected_rand[i]) ? LOOP_PASSED : LOOP_FAILED;
}

void test_next()
{
	TestQueue q(0);

	Q = &q;
	test_fill_q();

	test_for_each(0, 24, 1, _test_next_loop);
	test_equal(q.size(), (unsigned)0);
	test_equal(q.length(), 0);
	test_equal(q.next(), TRACK_NULL);


	q.set_flag(Q_RANDOM);
	random_seed(0);
	test_fill_q();

	test_for_each(0, 24, 1, _test_next_rand_loop);
	test_equal(q.size(), (unsigned)0);
	test_equal(q.length(), 0);
	test_equal(q.next(), TRACK_NULL);


	q.set_flag(Q_REPEAT);
	q.unset_flag(Q_RANDOM);
	test_fill_q();

	test_for_each(0, 48, 1, _test_next_loop);
	test_equal(q.size(), (unsigned)24);
}

void test_select()
{
	TestQueue q(0);

	Q = &q;
	test_fill_q();

	test_equal(q.size(), (unsigned)24);
	q.track_selected(10);
	test_equal(q.size(), (unsigned)23);
	test_equal(q.next()->index(), (unsigned)11);

	q.set_flag(Q_REPEAT);
	q.track_selected(0);
	test_equal(q.size(), (unsigned)22);
	test_equal(q.next()->index(), (unsigned)1);
}


unsigned int exp_sort_title[] = { 1, 18, 19, 16, 20,  8, 2,  9, 23, 10, 17, 11, 
				  3, 21,  4,  0,  5, 22, 6, 12,  7, 13, 14, 15 };
unsigned int exp_sort_ye_ti[] = {  0,  3,  2,  1,  7,  6,  5,  4, 11, 10,  9,  8,
				  17, 16, 19, 18, 22, 21, 23, 20, 15, 14, 13, 12 };

unsigned int _test_sort_title(unsigned int i)
{
	if ((*Q)[i]->index() == exp_sort_title[i])
		return LOOP_PASSED;
	return LOOP_FAILED;
}

unsigned int _test_sort_title_reverse(unsigned int i)
{
	if ((*Q)[i]->index() == exp_sort_title[23 - i])
		return LOOP_PASSED;
	return LOOP_FAILED;
}

unsigned int _test_sort_index(unsigned int i)
{
	if ((*Q)[i]->index() == i)
		return LOOP_PASSED;
	return LOOP_FAILED;
}

unsigned int _test_sort_ye_ti(unsigned int i)
{
	if ((*Q)[i]->index() != exp_sort_ye_ti[i])
		return LOOP_FAILED;
	return LOOP_PASSED;
}

void test_sorting()
{
	TestQueue q(0);

	Q = &q;
	q.sort(SORT_TITLE, true);
	test_equal(q.get_sorder().size(), (size_t)1);
	test_fill_q();
	test_for_each(0, 24, 1, _test_sort_title);

	q.sort(SORT_TITLE, false);
	test_equal(q.get_sorder().size(), (size_t)1);
	test_for_each(0, 24, 1, _test_sort_title_reverse);

	q.sort(SORT_LENGTH, true);
	test_for_each(0, 1, 24, _test_sort_index);

	q.sort(SORT_YEAR, true);
	q.sort(SORT_TITLE, false);
	q.sort(SORT_TITLE, false);
	test_equal(q.get_sorder().size(), (size_t)2);
	test_for_each(0, 24, 1, _test_sort_ye_ti);
}


unsigned int _test_saving_loop(unsigned int i)
{
	if ((*Q)[i]->index() == (*R)[i]->index())
		return LOOP_PASSED;
	return LOOP_FAILED;
}

void test_saving()
{
	TestQueue q(Q_RANDOM);
	TestQueue r(0);
	File f("test.q", 0);

	Q = &q;
	R = &r;
	test_fill_q();

	f.open(OPEN_WRITE);
	q.write(f);
	f.close();

	f.open(OPEN_READ);
	r.read(f);
	f.close();

	test_equal(r.has_flag(Q_RANDOM), q.has_flag(Q_RANDOM));
	test_equal(r.size(), q.size());
	test_equal(r.length(), q.length());
	test_for_each(0, 24, 1, _test_saving_loop);
}

int main(int argc, char **argv)
{
	test :: cp_data_dir();
	tags :: init();

	test :: run("Queue Default Constructor Test", test_default);
	test :: run("Queue Constructor Test", test_constructor);
	test :: run("Queue Flag Test", test_flags);
	test :: run("Queue Destructor Test", test_destructor);
	test :: run("Queue Add and Remove Test", test_add_remove);
	test :: run("Queue Track Updated Test", test_updated);
	test :: run("Queue Pick Next Test", test_next);
	test :: run("Queue Select Track Test", test_select);
	test :: run("Queue Sorting Test", test_sorting);
	test :: run("Queue Save and Load Test", test_saving);
	return 0;
}