/*
 * Copyright 2013 (c) Anna Schumaker.
 */
#include <core/collection.h>
#include <core/filter.h>
#include <core/idle.h>
#include <core/playlist.h>
#include <core/tags/tags.h>
#include <tests/test.h>
#include <errno.h>

static void test_init()
{
	struct queue *q = collection_get_queue();
	GSList *list;

	idle_init_sync();
	filter_init();
	tags_init();
	playlist_init(NULL);
	collection_init(NULL);

	test_not_equal((void *)q, NULL);
	test_equal(queue_has_flag(q, Q_ENABLED),    (bool)true);
	test_equal(queue_has_flag(q, Q_REPEAT),     (bool)true);
	test_equal(queue_has_flag(q, Q_SAVE_SORT),  (bool)false);
	test_equal(queue_has_flag(q, Q_SAVE_FLAGS), (bool)false);
	test_equal(queue_has_flag(q, Q_ADD_FRONT),  (bool)true);

	while (idle_run_task()) {};
	test_equal(queue_has_flag(q, Q_ENABLED),    (bool)true);
	test_equal(queue_has_flag(q, Q_REPEAT),     (bool)true);
	test_equal(queue_has_flag(q, Q_SAVE_SORT),  (bool)true);
	test_equal(queue_has_flag(q, Q_SAVE_FLAGS), (bool)true);
	test_equal(queue_has_flag(q, Q_ADD_FRONT),  (bool)false);
	test_equal(queue_size(q), 0);

	list = q->q_sort;
	test_equal(g_slist_length(q->q_sort), 3);
	test_equal(GPOINTER_TO_INT(list->data), COMPARE_ARTIST);
	list = g_slist_next(list);
	test_equal(GPOINTER_TO_INT(list->data), COMPARE_YEAR);
	list = g_slist_next(list);
	test_equal(GPOINTER_TO_INT(list->data), COMPARE_TRACK);
}

static void test_add()
{
	struct queue *q = collection_get_queue();
	struct library *lib;

	test_equal((void *)collection_add("tests/Invalid"), NULL);

	lib = collection_add("tests/Music");
	test_not_equal((void *)lib, NULL);
	test_equal(lib->li_size,    0);
	test_equal(lib->li_enabled, (bool)true);
	test_equal(lib->li_path, "tests/Music");

	test_equal(queue_size(q), 0);
	while (idle_run_task()) {};
	test_equal(track_db_get()->db_size, 48);
	test_equal(lib->li_size,  48);
	test_equal(queue_size(q), 48);
}

static void test_update()
{
	struct queue *q = collection_get_queue();
	struct library *lib = library_get(0);

	collection_update(NULL);
	test_equal(track_db_get()->db_size, 48);
	test_equal(lib->li_size,  48);
	test_equal(queue_size(q), 48);

	g_rename("tests/Music/Hyrule Symphony/", "tests/Music/symphony/");
	collection_update(lib);

	/* Collection validation removes tests/Music/Hyrule Symphony/ */
	test_equal(idle_run_task(), (bool)true);
	test_equal(track_db_get()->db_size, 35);
	test_equal(lib->li_size,  35);
	test_equal(queue_size(q), 35);

	/* tests/Music and tests/Music/Ocarina of Time/ have not changed */
	test_equal(idle_run_task(), (bool)true);
	test_equal(idle_run_task(), (bool)true);
	test_equal(track_db_get()->db_size, 35);
	test_equal(lib->li_size,  35);
	test_equal(queue_size(q), 35);

	/* Scan tests/Music/symphony/ */
	test_equal(idle_run_task(), (bool)false);
	test_equal(track_db_get()->db_size, 48);
	test_equal(lib->li_size,  48);
	test_equal(queue_size(q), 48);

	g_rename("tests/Music/symphony", "tests/Music/Hyrule Symphony/");
	collection_update_all();

	/*
	 * Collection validation removes tests/Music/symphony/,
	 * and tests/Music has not changed
	 */
	test_equal(idle_run_task(), (bool)true);
	test_equal(idle_run_task(), (bool)true);
	test_equal(track_db_get()->db_size, 35);
	test_equal(lib->li_size,  35);
	test_equal(queue_size(q), 35);

	/* tests/Music/Hyrule Symphony exists again */
	test_equal(idle_run_task(), (bool)true);
	test_equal(idle_run_task(), (bool)false);
	test_equal(track_db_get()->db_size, 48);
	test_equal(lib->li_size,  48);
	test_equal(queue_size(q), 48);

	/* tests/Music/Ocarina of Time/ has not changed */
	test_equal(idle_run_task(), (bool)false);
	test_equal(track_db_get()->db_size, 48);
	test_equal(lib->li_size,  48);
	test_equal(queue_size(q), 48);
}

static void test_ban()
{
	const struct database *track_db = track_db_get();
	struct queue *q = collection_get_queue();
	struct db_entry *dbe, *next;
	struct track *track;
	unsigned int i = 0;

	db_for_each(dbe, next, track_db) {
		track = TRACK(dbe);
		test_loop_equal(playlist_has("Hidden", track), (bool)false, i);
		test_loop_equal(collection_ban(track), (bool)true,  i);
		test_loop_equal(collection_ban(track), (bool)false, i);
		test_loop_equal(playlist_has("Hidden", track), (bool)true, i);
		test_loop_equal(queue_size(q), track_db->db_size - (i + 1), i);
		i++;
	} test_loop_passed();
	test_equal(queue_size(q), 0);

	i = 0;
	db_for_each(dbe, next, track_db) {
		track = TRACK(dbe);
		test_loop_equal(playlist_has("Hidden", track), (bool)true, i);
		test_loop_equal(collection_unban(track), (bool)true,  i);
		test_loop_equal(collection_unban(track), (bool)false, i);
		test_loop_equal(playlist_has("Hidden", track), (bool)false, i);
		test_loop_equal(queue_size(q), i + 1, i);
		i++;
	} test_loop_passed();
	test_equal(queue_size(q), track_db->db_size);
}

static void test_enable()
{
	struct queue *q = collection_get_queue();
	struct library *lib = library_get(0);
	struct db_entry *dbe, *next;

	collection_set_enabled(NULL, true);
	test_equal(queue_size(q), 48);

	collection_set_enabled(lib, false);
	test_equal(queue_size(q), 0);

	collection_set_enabled(lib, false);
	test_equal(queue_size(q), 0);

	/* Banned tracks should not be re-added to the queue. */
	db_for_each(dbe, next, track_db_get()) {
		collection_ban(TRACK(dbe));
		next = db_next(track_db_get(), next);
	}

	collection_set_enabled(lib, true);
	test_equal(queue_size(q), 24);

	collection_set_enabled(lib, true);
	test_equal(queue_size(q), 24);

	db_for_each(dbe, next, track_db_get()) {
		collection_unban(TRACK(dbe));
		next = db_next(track_db_get(), next);
	}
	test_equal(queue_size(q), 48);
}

static void test_save_load()
{
	struct queue *q = collection_get_queue();
	struct db_entry *dbe, *next;
	GSList *list;

	collection_save(NULL, Q_ENABLED);
	test_equal(test_data_file_exists("library.q"), (bool)false);

	queue_sort(q, COMPARE_TRACK, (bool)true);
	queue_sort(q, COMPARE_TRACK, (bool)false);
	queue_sort(q, COMPARE_GENRE, (bool)false);

	collection_save(q, Q_ENABLED);
	test_equal(test_data_file_exists("library.q"), (bool)true);

	collection_deinit();
	test_equal(queue_size(q), 0);
	test_equal(g_slist_length(q->q_sort), 0);

	db_for_each(dbe, next, track_db_get()) {
		collection_ban(TRACK(dbe));
		next = db_next(track_db_get(), next);
	}

	collection_init(NULL);
	while (idle_run_task()) {};
	test_equal(queue_size(q), track_db_get()->db_size / 2);
	test_equal(g_slist_length(q->q_sort), 2);

	db_for_each(dbe, next, track_db_get()) {
		collection_unban(TRACK(dbe));
		next = db_next(track_db_get(), next);
	}
	test_equal(queue_size(q), track_db_get()->db_size);

	list = q->q_sort;
	test_equal(GPOINTER_TO_INT(list->data), -COMPARE_TRACK);
	list = g_slist_next(list);
	test_equal(GPOINTER_TO_INT(list->data), COMPARE_GENRE);
}

static void test_eio()
{
	struct queue *q = collection_get_queue();
	struct library *lib = library_get(0);

	test_equal(queue_size(q), 48);
	test_equal(collection_check_library(lib), 0);
	test_equal(lib->li_enabled, (bool)true);
	test_equal(queue_size(q), 48);

	test_collection_error = true;
	test_equal(collection_check_library(lib), -1);
	test_equal(lib->li_enabled, (bool)false);
	test_equal(queue_size(q), 0);

	collection_set_enabled(lib, true);
	test_equal(lib->li_enabled, (bool)false);
	test_equal(queue_size(q), 0);

	test_collection_error = false;
	collection_set_enabled(lib, true);
	test_equal(lib->li_enabled, (bool)true);
	test_equal(queue_size(q), 48);

	test_collection_error = true;
	collection_update_all();
	test_equal(idle_run_task(), (bool)true);
	test_equal(lib->li_enabled, (bool)false);
	test_equal(queue_size(q), 0);

	test_collection_error = false;
	collection_set_enabled(lib, true);
	test_equal(lib->li_enabled, (bool)true);
	test_equal(queue_size(q), 48);
}

static void test_remove()
{
	struct queue *q = collection_get_queue();

	collection_remove(NULL);
	test_equal(track_db_get()->db_size, 48);

	collection_remove(library_get(0));
	test_equal(track_db_get()->db_size, 0);
	test_equal((void *)library_get(0),  NULL);
	test_equal(queue_size(q), 0);

	collection_deinit();
	playlist_deinit();
	tags_deinit();
	filter_deinit();
}

DECLARE_UNIT_TESTS(
	UNIT_TEST("Collection Initialization", test_init),
	UNIT_TEST("Collection Add Path", test_add),
	UNIT_TEST("Collection Update Path", test_update),
	UNIT_TEST("Collection Ban and Unban", test_ban),
	UNIT_TEST("Collection Enable and Disable", test_enable),
	UNIT_TEST("Collection Save and Load", test_save_load),
	UNIT_TEST("Colleciton -EIO Handling", test_eio),
	UNIT_TEST("Collection Remove Path", test_remove),
);