/*
 * Copyright 2016 (c) Anna Schumaker.
 */
#include <core/filter.h>
#include <core/idle.h>
#include <core/playlists/system.h>
#include <core/tags/tags.h>
#include <tests/test.h>

#define __test_playlist_state(queue, ex_size, ex_track0, ex_track1)		\
	test_equal(queue_size(queue), ex_size);					\
	test_equal(queue_has(queue, track_get(0)), (bool)ex_track0);		\
	test_equal(queue_has(queue, track_get(1)), (bool)ex_track1)

#define __test_playlist_add(name, queue)					\
	__test_playlist_state(queue, 0, false, false);				\
	test_equal(pl_system.pl_add_track(name, track_get(0)), (bool)true);	\
	test_equal(pl_system.pl_add_track(name, track_get(0)), (bool)false);	\
	test_equal(pl_system.pl_add_track(name, track_get(1)), (bool)true);	\
	test_equal(pl_system.pl_add_track(name, track_get(1)), (bool)false);	\
	__test_playlist_state(queue, 2, true, true)

#define __test_playlist_remove(name, queue)					\
	test_equal(pl_system.pl_remove_track(name, track_get(0)), (bool)true);	\
	test_equal(pl_system.pl_remove_track(name, track_get(0)), (bool)false);	\
	test_equal(pl_system.pl_remove_track(name, track_get(1)), (bool)true);	\
	test_equal(pl_system.pl_remove_track(name, track_get(1)), (bool)false);	\
	__test_playlist_state(queue, 0, false, false)

#define __test_playlist_update(name, queue, ex_size, ex_track0, ex_track1)	\
	pl_system.pl_update(name);						\
	while (idle_run_task()) {};						\
	__test_playlist_state(queue, ex_size, ex_track0, ex_track1)

#define __test_playlist_hide_track(name, queue, ex_size, ex_track0, ex_track1)	\
	test_equal(pl_system.pl_add_track("Hidden", track_get(0)), (bool)true);	\
	__test_playlist_state(queue, ex_size, ex_track0, ex_track1);		\
	test_equal(pl_system.pl_add_track(name, track_get(0)), (bool)false)

#define __test_playlist_unhide_track(name, queue, ex_size, ex_track0, ex_track1)	\
	test_equal(pl_system.pl_remove_track("Hidden", track_get(0)), (bool)true);	\
	__test_playlist_state(queue, ex_size, ex_track0, ex_track1)

#define __test_playlist_reinit(queue, ex_size, ex_track0, ex_track1)		\
	pl_system_deinit();							\
	pl_system_init(NULL);							\
	__test_playlist_state(queue, 0, false, false);				\
	while (idle_run_task()) {};						\
	__test_playlist_state(queue, ex_size, ex_track0, ex_track1)


static void test_init()
{
	struct library *library;

	idle_init_sync();
	filter_init();
	tags_init();
	pl_system_init(NULL);
	while (idle_run_task()) {};

	/* Add tracks to the collection. */
	library = library_find("tests/Music");
	track_add(library, "tests/Music/Hyrule Symphony/01 - Title Theme.ogg");
	track_add(library, "tests/Music/Hyrule Symphony/02 - Kokiri Forest.ogg");
}

static void test_invalid()
{
	test_init();

	test_equal((void *)pl_system.pl_get_queue(NULL), NULL);
	test_equal((void *)pl_system.pl_get_queue("Invalid"), NULL);

	test_equal(pl_system.pl_add_track(NULL, track_get(0)),    (bool)false);
	test_equal(pl_system.pl_remove_track(NULL, track_get(0)), (bool)false);
}

static void test_favorites()
{
	struct queue *queue = pl_system.pl_get_queue("Favorites");

	test_not_equal((void *)queue, NULL);
	test_equal(queue_has_flag(queue, Q_ADD_FRONT), (bool)false);

	__test_playlist_add("Favorites", queue);
	__test_playlist_reinit(queue, 2, true, true);
	__test_playlist_update("Favorites", queue, 2, true, true);
	__test_playlist_remove("Favorites", queue);
}

static void test_hidden()
{
	struct queue *queue = pl_system.pl_get_queue("Hidden");

	test_not_equal((void *)queue, NULL);
	test_equal((void *)pl_system.pl_get_queue("Banned"), (void *)queue);
	test_equal(queue_has_flag(queue, Q_ADD_FRONT), (bool)false);

	__test_playlist_add("Hidden", queue);
	__test_playlist_reinit(queue, 2, true, true);
	__test_playlist_update("Hidden", queue, 2, true, true);
	__test_playlist_remove("Hidden", queue);
}

static void test_unplayed()
{
	struct queue *queue = pl_system.pl_get_queue("Unplayed");

	pl_system_deinit();
	pl_system_init(NULL);

	test_not_equal((void *)queue, NULL);
	test_equal(queue_has_flag(queue, Q_ADD_FRONT), (bool)true);

	__test_playlist_reinit(queue, 2, true, true);
	__test_playlist_remove("Unplayed", queue);

	track_get(1)->tr_count = 1;
	test_equal(pl_system.pl_add_track("Unplayed", track_get(0)), (bool)true);
	test_equal(pl_system.pl_add_track("Unplayed", track_get(0)), (bool)false);
	test_equal(queue_size(queue), 1);

	track_get(0)->tr_count = 1;
	track_get(1)->tr_count = 0;
	__test_playlist_update("Unplayed", queue, 1, false, true);

	track_get(0)->tr_count = 0;
	__test_playlist_update("Unplayed", queue, 2, true, true);

	__test_playlist_hide_track("Unplayed", queue, 1, false, true);
	__test_playlist_reinit(queue, 1, false, true);
	__test_playlist_update("Unplayed", queue, 1, false, true);
	__test_playlist_unhide_track("Unplayed", queue, 2, true, true);
}

static void test_most_played()
{
	struct queue *most  = pl_system.pl_get_queue("Most Played");

	/* Set average =  (4 / 2) = 2 */
	track_played(track_get(0));
	track_played(track_get(1));
	track_played(track_get(1));
	track_played(track_get(1));

	pl_system_deinit();
	pl_system_init(NULL);

	test_not_equal((void *)most,  NULL);
	test_equal(queue_has_flag(most,  Q_ADD_FRONT), (bool)true);

	__test_playlist_reinit(most, 1, false, true);

	test_equal(pl_system.pl_remove_track("Most Played", track_get(0)), (bool)false);
	test_equal(pl_system.pl_remove_track("Most Played", track_get(1)), (bool)true);
	test_equal(pl_system.pl_remove_track("Most Played", track_get(1)), (bool)false);
	__test_playlist_state(most, 0, false, false);

	test_equal(pl_system.pl_add_track("Most Played", track_get(0)), (bool)false);
	test_equal(pl_system.pl_add_track("Most Played", track_get(1)), (bool)true);
	test_equal(pl_system.pl_add_track("Most Played", track_get(1)), (bool)false);
	__test_playlist_state(most, 1, false, true);

	track_get(0)->tr_count = 3;
	track_get(1)->tr_count = 1;
	__test_playlist_update("Most Played", most, 1, true, false);

	__test_playlist_hide_track("Most Played", most, 0, false, false);
	__test_playlist_reinit(most, 0, false, false);
	__test_playlist_update("Most Played", most, 0, false, false);
	__test_playlist_unhide_track("Most Played", most, 1, true, false);
}

static void test_least_played()
{
	struct queue *least = pl_system.pl_get_queue("Least Played");

	/* Reset playcounts so track 1 is "least played" */
	track_get(0)->tr_count = 3;
	track_get(1)->tr_count = 1;

	pl_system_deinit();
	pl_system_init(NULL);

	test_not_equal((void *)least, NULL);
	test_equal(queue_has_flag(least, Q_ADD_FRONT), (bool)true);

	__test_playlist_reinit(least, 1, false, true);

	test_equal(pl_system.pl_remove_track("Least Played", track_get(0)), (bool)false);
	test_equal(pl_system.pl_remove_track("Least Played", track_get(1)), (bool)true);
	test_equal(pl_system.pl_remove_track("Least Played", track_get(1)), (bool)false);
	__test_playlist_state(least, 0, false, false);

	test_equal(pl_system.pl_add_track("Least Played", track_get(0)), (bool)false);
	test_equal(pl_system.pl_add_track("Least Played", track_get(1)), (bool)true);
	test_equal(pl_system.pl_add_track("Least Played", track_get(1)), (bool)false);
	__test_playlist_state(least, 1, false, true);

	track_get(0)->tr_count = 1;
	track_get(1)->tr_count = 3;
	__test_playlist_update("Least Played", least, 1, true, false);

	__test_playlist_hide_track("Least Played", least, 0, false, false);
	__test_playlist_reinit(least, 0, false, false);
	__test_playlist_update("Least Played", least, 0, false, false);
	__test_playlist_unhide_track("Least Played", least, 1, true, false);

	pl_system_deinit();
}

DECLARE_UNIT_TESTS(
	UNIT_TEST("Invalid Playlist", test_invalid),
	UNIT_TEST("Favorites Playlist", test_favorites),
	UNIT_TEST("Hidden Playlist", test_hidden),
	UNIT_TEST("Unplayed Tracks Playlist", test_unplayed),
	UNIT_TEST("Most Played Tracks Playlist", test_most_played),
	UNIT_TEST("Least Played Tracks Playlist", test_least_played),
);