/*
 * Copyright 2016 (c) Anna Schumaker.
 */
#include <core/audio.h>
#include <core/idle.h>
#include <core/core.h>
#include <core/playlist.h>
#include <gui/builder.h>
#include <gui/model.h>
#include <tests/test.h>
#include <string.h>

unsigned int count_insert = 0;
unsigned int count_delete = 0;
unsigned int count_update = 0;

void on_row_inserted(GtkTreeModel *model, GtkTreePath *path,
		     GtkTreeIter *iter,   gpointer data)
	{ count_insert++; }
void on_row_deleted(GtkTreeModel *model, GtkTreePath *path, gpointer data)
	{ count_delete++; }
void on_row_changed(GtkTreeModel *model, GtkTreePath *path,
		    GtkTreeIter *iter,   gpointer data)
	{ count_update++; }

void *test_queue_init(struct queue *queue, void *data)
	{ return NULL; }
void test_queue_deinit(struct queue *queue)
	{ }
void test_queue_save(struct queue *queue, enum queue_flags flag) {}
void test_on_load(struct track *track) {}
void test_on_state_change(GstState state) {}
void test_on_config_pause(int count) {}

struct queue_ops test_ops = {
	.qop_init    = test_queue_init,
	.qop_deinit  = test_queue_deinit,
	.qop_added   = gui_queue_model_add,
	.qop_removed = gui_queue_model_remove,
	.qop_cleared = gui_queue_model_clear,
	.qop_save    = test_queue_save,
	.qop_updated = gui_queue_model_update,
};

struct audio_ops test_audio_ops = {
	.on_load = test_on_load,
	.on_state_change = test_on_state_change,
	.on_config_pause = test_on_config_pause,
};

struct core_init_data init_data = {
	.playlist_ops = &test_ops,
	.audio_ops      = &test_audio_ops,
};

static void test_init()
{
	GtkTreeModel  *treemodel;
	GuiQueueModel *model;
	GType type;

	gui_queue_model_init();
	model = gui_queue_model_get();
	g_assert_null(gui_queue_model_get_queue());
	gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection"));
	g_assert_nonnull(model);
	g_assert_true(GTK_IS_TREE_MODEL(model));
	g_assert(gui_queue_model_get_queue() == playlist_get_queue(PL_SYSTEM, "Collection"));

	treemodel = GTK_TREE_MODEL(model);
	g_assert_cmpuint(gtk_tree_model_get_flags(treemodel), ==, GTK_TREE_MODEL_LIST_ONLY);
	g_assert_cmpuint(gtk_tree_model_get_n_columns(treemodel), ==, 11);

	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_TRACK_NR);
	g_assert_cmpuint(type, ==, G_TYPE_UINT);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_TITLE);
	g_assert_cmpuint(type, ==, G_TYPE_STRING);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_LENGTH);
	g_assert_cmpuint(type, ==, G_TYPE_STRING);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_ARTIST);
	g_assert_cmpuint(type, ==, G_TYPE_STRING);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_ALBUM);
	g_assert_cmpuint(type, ==, G_TYPE_STRING);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_YEAR);
	g_assert_cmpuint(type, ==, G_TYPE_UINT);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_GENRE);
	g_assert_cmpuint(type, ==, G_TYPE_STRING);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_COUNT);
	g_assert_cmpuint(type, ==, G_TYPE_UINT);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_LAST_PLAY);
	g_assert_cmpuint(type, ==, G_TYPE_STRING);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_FILE_PATH);
	g_assert_cmpuint(type, ==, G_TYPE_STRING);
	type = gtk_tree_model_get_column_type(treemodel, Q_MODEL_FONT);
	g_assert_cmpuint(type, ==, G_TYPE_STRING);

	gui_queue_model_deinit();
	g_assert_false(G_IS_OBJECT(model));
}

static void __test_empty_subprocess()
{
	GtkTreeModel *model;
	GtkTreeIter iter;
	GValue value;
	GType type;

	gui_queue_model_init();
	model = GTK_TREE_MODEL(gui_queue_model_get());
	gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection"));
	memset(&value, 0, sizeof(GValue));

	g_assert_false(gtk_tree_model_get_iter_first(model, &iter));
	g_assert_null(gtk_tree_model_get_path(model, &iter));
	g_assert_null(gui_queue_model_iter_get_track(&iter));

	/* These will all trigger assertion failures ... sorry */
	gtk_tree_model_get_value(model, &iter, Q_MODEL_TRACK_NR, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_TITLE, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_LENGTH, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_ARTIST, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_ALBUM, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_YEAR, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_GENRE, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_COUNT, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_LAST_PLAY, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_FILE_PATH, &value);
	g_assert_false(G_IS_VALUE(&value));
	gtk_tree_model_get_value(model, &iter, Q_MODEL_FONT, &value);
	g_assert_false(G_IS_VALUE(&value));

	type = gtk_tree_model_get_column_type(model, Q_MODEL_N_COLUMNS);
	g_assert_cmpuint(type, ==, G_TYPE_INVALID);

	g_assert_false(gtk_tree_model_iter_next(model, &iter));
	g_assert_false(gtk_tree_model_iter_children(model, &iter, NULL));
	g_assert_false(gtk_tree_model_iter_has_child(model, &iter));
	g_assert_cmpuint(gtk_tree_model_iter_n_children(model, &iter), ==, 0);
	g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL),  ==, 0);
	g_assert_false(gtk_tree_model_iter_nth_child(model, &iter, NULL, 3));
	g_assert_false(gtk_tree_model_iter_parent(model, &iter, &iter));

	gui_queue_model_deinit();
}

static void test_empty()
{
	if (g_test_subprocess()) {
		__test_empty_subprocess();
		return;
	}

	g_test_trap_subprocess(NULL, 0, 0);
	g_test_trap_assert_failed();
}

static void test_model()
{
	struct db_entry *dbe, *next;
	struct track *track;
	GtkTreeModel *model;
	GtkTreePath *path;
	GtkTreeIter iter;
	GtkLabel *label;
	GValue value;
	int argc = 0;

	gtk_init(&argc, NULL);
	core_init(&argc, NULL, &init_data);
	gui_builder_init("share/ocarina/ocarina.ui");
	gui_queue_model_init();
	while (idle_run_task() == true) {}

	model = GTK_TREE_MODEL(gui_queue_model_get());
	label = GTK_LABEL(gui_builder_widget("o_runtime"));
	gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection"));
	g_assert_cmpstr(gtk_label_get_text(label), ==, "");
	memset(&value, 0, sizeof(GValue));

	g_signal_connect(model, "row-inserted", (GCallback)on_row_inserted, NULL);
	g_signal_connect(model, "row-deleted",  (GCallback)on_row_deleted,  NULL);
	g_signal_connect(model, "row-changed",  (GCallback)on_row_changed,  NULL);

	/* Okay, now scan a directory ... */
	playlist_get_queue(PL_SYSTEM, "Collection")->q_private = model;
	playlist_new(PL_LIBRARY, "tests/Music/Hyrule Symphony");
	while (idle_run_task() == true) {}
	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Collection"), ==, 13);
	g_assert_cmpuint(count_insert, ==, 13);
	queue_resort(playlist_get_queue(PL_SYSTEM, "Collection"));
	g_assert_cmpuint(count_update, ==, 13);
	playlist_add(PL_SYSTEM, "Favorites", track_get(0));
	playlist_add(PL_SYSTEM, "Favorites", track_get(1));
	playlist_add(PL_SYSTEM, "Favorites", track_get(2));
	g_assert_cmpuint(playlist_size(PL_SYSTEM, "Favorites"), ==, 3);
	g_assert_cmpstr(gtk_label_get_text(label), ==, "42 minutes, 45 seconds");

	/* ... and test again */
	g_assert_true(gtk_tree_model_get_iter_first(model, &iter));
	track = gui_queue_model_iter_get_track(&iter);
	g_assert_cmpuint(track->tr_track, ==, 1);
	audio_load(track);

	path = gtk_tree_model_get_path(model, &iter);
	g_assert_nonnull(path);
	g_assert_cmpuint(gtk_tree_path_get_indices(path)[0], ==, 0);
	g_assert(gui_queue_model_path_get_track(path) == track);
	gtk_tree_path_free(path);

	gtk_tree_model_get_value(model, &iter, Q_MODEL_TRACK_NR, &value);
	g_assert_cmpuint(g_value_get_uint(&value), ==, track->tr_track);
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_TITLE, &value);
	g_assert_cmpstr(g_value_get_string(&value), ==, "Title Theme");
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_LENGTH, &value);
	g_assert_cmpstr(g_value_get_string(&value), ==, "4:03");
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_ARTIST, &value);
	g_assert_cmpstr(g_value_get_string(&value), ==, "Koji Kondo");
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_ALBUM, &value);
	g_assert_cmpstr(g_value_get_string(&value), ==, "Hyrule Symphony");
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_YEAR, &value);
	g_assert_cmpuint(g_value_get_uint(&value), ==, 1998);
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_GENRE, &value);
	g_assert_cmpstr(g_value_get_string(&value), ==, "Game");
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_COUNT, &value);
	g_assert_cmpuint(g_value_get_uint(&value), ==, 0);
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_LAST_PLAY, &value);
	g_assert_cmpstr(g_value_get_string(&value), ==, "Never");
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_FILE_PATH, &value);
	g_assert_cmpstr(g_value_get_string(&value), ==,
		   "tests/Music/Hyrule Symphony/01 - Title Theme.ogg");
	g_value_unset(&value);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_FONT, &value);
	g_assert_cmpstr(g_value_get_string(&value), ==, "bold");
	g_value_unset(&value);

	g_assert_true(gtk_tree_model_iter_next(model, &iter));
	track = gui_queue_model_iter_get_track(&iter);
	g_assert_cmpuint(track->tr_track, ==, 2);
	gtk_tree_model_get_value(model, &iter, Q_MODEL_FONT, &value);
	g_assert_cmpstr(g_value_get_string(&value), ==, "");
	g_value_unset(&value);

	g_assert_true(gtk_tree_model_iter_children(model, &iter, NULL));
	track = gui_queue_model_iter_get_track(&iter);
	g_assert_cmpuint(track->tr_track, ==, 1);

	g_assert_false(gtk_tree_model_iter_has_child(model, &iter));
	g_assert_cmpuint(gtk_tree_model_iter_n_children(model, &iter), ==, 0);
	g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL),  ==, 13);

	gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Favorites"));
	g_assert_cmpuint(count_delete, ==, 13);
	g_assert_cmpuint(count_insert, ==, 14);
	g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 3);
	g_assert_cmpstr(gtk_label_get_text(label), ==, "10 minutes, 46 seconds");

	gui_queue_model_set_queue(NULL);
	g_assert_cmpuint(count_delete, ==, 16);
	g_assert_cmpuint(count_insert, ==, 14);
	g_assert_cmpuint(gtk_tree_model_iter_n_children(model, NULL), ==, 0);
	g_assert_cmpstr(gtk_label_get_text(label), ==, "");

	gui_queue_model_set_queue(playlist_get_queue(PL_SYSTEM, "Collection"));
	g_assert_cmpuint(count_delete, ==, 16);
	g_assert_cmpuint(count_insert, ==, 15);
	g_assert_cmpstr(gtk_label_get_text(label), ==, "42 minutes, 45 seconds");

	g_assert_true(gtk_tree_model_iter_nth_child(model, &iter, NULL, 3));
	track = gui_queue_model_iter_get_track(&iter);
	g_assert_cmpuint(track->tr_track, ==, 4);

	g_assert_false(gtk_tree_model_iter_parent(model, &iter, &iter));

	db_for_each(dbe, next, track_db_get())
		playlist_remove(PL_SYSTEM, "Collection", TRACK(dbe));
	g_assert_cmpuint(count_delete, ==, 29);

	core_deinit();
	gui_queue_model_deinit();
}

int main(int argc, char **argv)
{
	g_test_init(&argc, &argv, NULL);
	g_test_add_func("/Gui/Queue Model/Init", test_init);
	g_test_add_func("/Gui/Queue Model/Empty", test_empty);
	g_test_add_func("/Gui/Queue Model", test_model);
	return g_test_run();
}