/*
 * Copyright 2014 (c) Anna Schumaker.
 */
#include <core/idle.h>
#include <core/string.h>
#include <core/tags/tags.h>
#include <core/tags/track.h>
#include <tests/test.h>
#include <locale.h>


static struct track *test_alloc(const gchar *key)
{
	const struct db_ops *track_ops = test_track_ops();
	return TRACK(track_ops->dbe_alloc(key));
}

static void test_verify_tags(struct track *track)
{
	test_equal(track->tr_album->al_name,   "Hyrule Symphony");
	test_equal(track->tr_album->al_year,   1998);
	test_equal(track->tr_artist->ar_name,  "Koji Kondo");
	test_equal(track->tr_genre->ge_name,   "Game");
	test_equal(track->tr_library->li_path, "tests/Music");
}

static void test_verify_track(struct track *track)
{
	const struct db_ops *track_ops = test_track_ops();
	test_verify_tags(track);

	test_equal(track->tr_title, "Title Theme");
	test_equal(track->tr_tokens[0], "title");
	test_equal(track->tr_tokens[1], "theme");
	test_equal((void *)track->tr_tokens[2], NULL);
	test_equal((void *)track->tr_alts[0], NULL);
	test_equal(track_ops->dbe_key(&track->tr_dbe),
			"0/Hyrule Symphony/01 - Title Theme.ogg");
	test_str_equal(track_path(track),
			"tests/Music/Hyrule Symphony/01 - Title Theme.ogg");
	test_str_equal(track_last_play(track), "Never");

	test_equal(track->tr_track,  1);
	test_equal(track->tr_length, 243);
	test_equal(track->tr_count,  0);
}

static void test_verify_notrack(struct track *track)
{
	const struct db_ops *track_ops = test_track_ops();
	test_verify_tags(track);

	test_equal(track->tr_title, "");
	test_equal((void *)track->tr_tokens[0], NULL);
	test_equal((void *)track->tr_alts[0], NULL);
	test_equal(track_ops->dbe_key(&track->tr_dbe),
			"0/Hyrule Symphony/00 - No Track.ogg");
	test_str_equal(track_path(track),
			"tests/Music/Hyrule Symphony/00 - No Track.ogg");
	test_str_equal(track_last_play(track), "Never");

	test_equal(track->tr_track,  0);
	test_equal(track->tr_length, 0);
	test_equal(track->tr_count,  0);
}

static void test_track()
{
	const struct db_ops *track_ops = test_track_ops();
	time_t rawtime = time(NULL);
	struct tm *now = localtime(&rawtime);
	struct library *library;
	struct track   *track;
	struct file f;
	gchar *date;

	setlocale(LC_TIME, "C");
	idle_init_sync();
	tags_init();
	file_init(&f, "track_tag", 0, 0);
	while (idle_run_task()) {}

	date    = string_tm2str(now);
	library = library_find("tests/Music");

	track = test_alloc("0/Hyrule Symphony/01 - Title Theme.ogg");
	track->tr_dbe.dbe_index = 0;
	track_ops->dbe_setup(&track->tr_dbe);
	test_verify_track(track);
	test_equal(library->li_size, 1);

	test_equal(track_match_token(track, "title"),  (bool)true);
	test_equal(track_match_token(track, "theme"),  (bool)true);
	test_equal(track_match_token(track, "hyrule"), (bool)false);

	file_open(&f, OPEN_WRITE);
	file_writef(&f, "0 0 0 0 0 0 0 0 0 0 \n");
	file_writef(&f, "Hyrule Symphony/00 - No Track.ogg\n");
	track_ops->dbe_write(&f, &track->tr_dbe);
	file_close(&f);

	g_free(track->tr_path);
	track_ops->dbe_free(&track->tr_dbe);
	test_equal(library->li_size, 0);

	file_open(&f, OPEN_READ);
	track = TRACK(track_ops->dbe_read(&f));
	track->tr_dbe.dbe_index = 0;
	track_ops->dbe_setup(&track->tr_dbe);
	test_verify_notrack(track);
	test_equal(library->li_size, 1);

	g_free(track->tr_path);
	track_ops->dbe_free(&track->tr_dbe);

	track = TRACK(track_ops->dbe_read(&f));
	track->tr_dbe.dbe_index = 0;
	track_ops->dbe_setup(&track->tr_dbe);
	test_verify_track(track);
	test_equal(library->li_size, 1);
	file_close(&f);

	track_played(track);
	test_equal(track->tr_count, 1);
	test_str_equal(track_last_play(track), date);

	g_free(track->tr_path);
	track_ops->dbe_free(&track->tr_dbe);
	g_free(date);
}

static void test_track_compare()
{
	const struct db_ops *track_ops = test_track_ops();
	struct track  *title = test_alloc("0/Hyrule Symphony/01 - Title Theme.ogg");
	struct track *kokiri = test_alloc("0/Hyrule Symphony/02 - Kokiri Forest.ogg");

	/* Compare artists. */
	title->tr_artist = artist_find("Hajime Wakai");
	test_equal(track_compare(title,  title,  COMPARE_ARTIST),  0);
	test_equal(track_compare(kokiri, title,  COMPARE_ARTIST),  1);
	test_equal(track_compare(title,  kokiri, COMPARE_ARTIST), -1);

	/* Compare albums. */
	kokiri->tr_album = album_find("Ocarina of Time", 1996);
	test_equal(track_compare(title,  title,  COMPARE_ALBUM),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_ALBUM), -1);
	test_equal(track_compare(kokiri, title,  COMPARE_ALBUM),  1);

	/* Compare play counts. */
	title->tr_count = 42;
	test_equal(track_compare(title,  title,  COMPARE_COUNT),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_COUNT),  42);
	test_equal(track_compare(kokiri, title,  COMPARE_COUNT), -42);
	title->tr_count = 0;

	/* Compare genres. */
	kokiri->tr_genre = genre_find("Video Game");
	test_equal(track_compare(title,  title,  COMPARE_GENRE),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_GENRE), -1);
	test_equal(track_compare(kokiri, title,  COMPARE_GENRE),  1);

	/* Compare lenghts (title = 243, kokiri = 130). */
	test_equal(track_compare(title,  title,  COMPARE_LENGTH),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_LENGTH),  113);
	test_equal(track_compare(kokiri, title,  COMPARE_LENGTH), -113);

	/* Compare last played dates. */
	date_set(&kokiri->tr_date, 0, 0, 17);
	test_equal(track_compare(title,  title,  COMPARE_PLAYED),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_PLAYED), -17);
	test_equal(track_compare(kokiri, title,  COMPARE_PLAYED),  17);

	date_set(&kokiri->tr_date, 0, 6, 17);
	test_equal(track_compare(title,  title,  COMPARE_PLAYED),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_PLAYED), -6);
	test_equal(track_compare(kokiri, title,  COMPARE_PLAYED),  6);

	date_set(&kokiri->tr_date, 1988, 6, 17);
	test_equal(track_compare(title,  title,  COMPARE_PLAYED),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_PLAYED), -1988);
	test_equal(track_compare(kokiri, title,  COMPARE_PLAYED),  1988);

	/* Compare titles. */
	test_equal(track_compare(title,  title,  COMPARE_TITLE),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_TITLE),  1);
	test_equal(track_compare(kokiri, title,  COMPARE_TITLE), -1);

	/* Compare track numbers. */
	test_equal(track_compare(title,  title,  COMPARE_TRACK),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_TRACK), -1);
	test_equal(track_compare(kokiri, title,  COMPARE_TRACK),  1);

	/* Compare years. */
	test_equal(track_compare(title,  title,  COMPARE_YEAR),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_YEAR),  2);
	test_equal(track_compare(kokiri, title,  COMPARE_YEAR), -2);

	kokiri->tr_album->al_year = title->tr_album->al_year;
	test_equal(track_compare(title,  title,  COMPARE_YEAR),  0);
	test_equal(track_compare(title,  kokiri, COMPARE_YEAR), -1);
	test_equal(track_compare(kokiri, title,  COMPARE_YEAR),  1);

	g_free(title->tr_path);
	g_free(kokiri->tr_path);
	track_ops->dbe_free(&title->tr_dbe);
	track_ops->dbe_free(&kokiri->tr_dbe);
}

static void test_track_db()
{
	const gchar *path = "tests/Music/Hyrule Symphony/01 - Title Theme.ogg";
	struct library *library = library_find("tests/Music");
	const struct db_ops *track_ops = test_track_ops();
	struct database track_db;
	struct track *track;

	test_equal(track_db_count_unplayed(), 0);
	test_equal(track_db_count_plays(), 0);
	test_equal(track_db_average_plays(), 0);
	track = track_add(library, path);
	test_verify_track(track);
	test_equal(track_db_count_unplayed(), 1);

	test_equal((void *)track_add(library, path), NULL);
	test_equal((void *)track_get(0), (void *)track);
	test_equal((void *)track_get(1), NULL);
	test_equal(track_db_get()->db_size, 1);
	test_equal(track_db_count_unplayed(), 1);

	db_init(&track_db, "track.db", false, track_ops);
	db_load(&track_db);
	test_equal(track_db.db_size, 0);

	track_db_commit();
	db_load(&track_db);
	test_equal(track_db.db_size, 1);
	test_verify_track(TRACK(db_first(&track_db)));
	/* Make sure our unplayed count isn't skewed */
	db_deinit(&track_db);

	track_remove(track);
	test_equal(track_db_get()->db_size, 0);
	test_equal(track_db_count_unplayed(), 0);

	track = track_add(library, path);
	test_not_equal((void *)track, NULL);

	track = track_add(library,
			  "tests/Music/Hyrule Symphony/02 - Kokiri Forest.ogg");
	test_not_equal((void *)track, NULL);
	test_equal(track_db_get()->db_size, 2);
	test_equal(track_db_count_unplayed(), 2);

	test_equal(track_db_count_plays(), 0);
	test_equal(track_db_average_plays(), 0);
	track_played(track);
	test_equal(track_db_count_unplayed(), 1);
	test_equal(track_db_count_plays(), 1);
	test_equal(track_db_average_plays(), 1);
	track_played(track);
	test_equal(track_db_count_unplayed(), 1);
	test_equal(track_db_count_plays(), 2);
	test_equal(track_db_average_plays(), 2);

	track = track_add(library, "tests/Music/invalid_track");
	test_equal((void *)track, NULL);
	test_equal(track_db_get()->db_size, 2);
	test_equal(track_db_count_unplayed(), 1);

	/* Reload the database */
	track_db_deinit();
	test_equal(track_db_count_unplayed(), 0);
	test_equal(track_db_count_plays(), 0);
	test_equal(track_db_get()->db_size, 0);
	track_db_init();
	while (idle_run_task()) {};
	test_equal(track_db_get()->db_size, 2);
	test_equal(track_db_count_unplayed(), 1);
	test_equal(track_db_count_plays(), 2);
	test_equal(track_db_average_plays(), 2);

	track_remove(track_get(2));
	test_equal(track_db_count_plays(), 0);
	test_equal(track_db_average_plays(), 0);

	track_remove_all(library);
	test_equal(track_db_get()->db_size, 0);

	tags_deinit();
	idle_deinit();
}

DECLARE_UNIT_TESTS(
	UNIT_TEST("Track Tag", test_track),
	UNIT_TEST("Track Comparison", test_track_compare),
	UNIT_TEST("Track Database", test_track_db),
);