/*
 * Copyright 2014 (c) Anna Schumaker.
 * Test a DatabaseEntry
 */

#include <core/tags.h>
#include <tests/test.h>

static Library *LIB_NULL = NULL;
static Track *TRACK_NULL = NULL;

struct TagArgs {
	struct Library *library;
	std::string full_path;

	std::string artist;
	std::string artist_lower;

	std::string album;
	std::string album_lower;
	unsigned int year;

	std::string genre;
	std::string genre_lower;

	unsigned int track;
	unsigned int length;
	unsigned int play_count;
	unsigned int last_year;
	unsigned int last_month;
	unsigned int last_day;
	std::string title;
	std::string title_lower;
	std::string filepath;
	std::string length_str;
};

static void test_library()
{
	Library *lib = tagdb :: add_library("tests/Music/");

	test_not_equal(lib, LIB_NULL);
	test_equal(lib->root_path, (std::string)"tests/Music/");
	test_equal(lib->count, (unsigned)0);
	test_equal(lib->enabled, true);

	test_equal(tagdb :: add_library("tests/Music/"), LIB_NULL);
	test_equal(lib, tagdb :: lookup_library(0));

	tagdb :: remove_library(0);
	test_equal(tagdb :: get_library_db().size(), (unsigned)0);
}

static void test_track(struct TagArgs *args)
{
	Track *track = tagdb :: add_track(args->full_path, args->library);

	test_not_equal(track, TRACK_NULL);
	test_equal(track->path(), args->full_path);

	/*
	 * Check tags
	 */
	test_equal(track->artist->name,		args->artist);
	test_equal(track->artist->lower,	args->artist_lower);
	test_equal(track->album->name,		args->album);
	test_equal(track->album->lower,		args->album_lower);
	test_equal(track->album->year,		args->year);
	test_equal(track->genre->name,		args->genre);
	test_equal(track->genre->lower,		args->genre_lower);
	test_equal(track->track,		args->track);
	test_equal(track->length,		args->length);
	test_equal(track->play_count,		args->play_count);
	test_equal(track->last_year,		args->last_year);
	test_equal(track->last_month,		args->last_month);
	test_equal(track->last_day,		args->last_day);
	test_equal(track->title,		args->title);
	test_equal(track->title_lower,		args->title_lower);
	test_equal(track->filepath,		args->filepath);
	test_equal(track->length_str,		args->length_str);

	test_equal(tagdb :: lookup(args->track - 1), track);
	test_equal(args->library->count, (unsigned)1);
	tagdb :: remove_track(args->track - 1);
	test_equal(tagdb :: lookup(args->track - 1), TRACK_NULL);
	test_equal(tagdb :: get_track_db().size(), (unsigned)0);
	test_equal(args->library->count, (unsigned)0);

	/*
	 * Mark track played, double check new values
	 */
	track->played();
	test_equal(track->play_count,		args->play_count + 1);
	test_not_equal(track->last_year,	args->last_year);
	test_not_equal(track->last_month,	args->last_month);
	test_not_equal(track->last_day,		args->last_day);
}

static void test_all_tracks()
{
	struct TagArgs expected;

	expected.library = tagdb :: add_library("tests/Music");
	expected.full_path	= "tests/Music/1.ogg";
	expected.artist		= "Artist";
	expected.artist_lower	= "artist";
	expected.album		= "Album";
	expected.album_lower	= "album";
	expected.year		= 2014;
	expected.genre		= "Silence";
	expected.genre_lower	= "silence";
	expected.track		= 1;
	expected.length		= 1;
	expected.play_count	= 0;
	expected.last_year	= 0;
	expected.last_month	= 0;
	expected.last_day	= 0;
	expected.title		= "One";
	expected.title_lower	= "one";
	expected.filepath	= "1.ogg";
	expected.length_str	= "0:01";
	run_test("Tags Track Test (1.ogg)", test_track, &expected);

	expected.full_path	= "tests/Music/10.ogg";
	expected.track		= 2;
	expected.length		= 10;
	expected.title		= "Ten";
	expected.title_lower	= "ten";
	expected.filepath	= "10.ogg";
	expected.length_str	= "0:10";
	run_test("Tags Track Test (10.ogg)", test_track, &expected);

	expected.full_path	= "tests/Music/15.ogg";
	expected.track		= 3;
	expected.length		= 15;
	expected.title		= "Fifteen";
	expected.title_lower	= "fifteen";
	expected.filepath	= "15.ogg";
	expected.length_str	= "0:15";
	run_test("Tags Track Test (15.ogg)", test_track, &expected);

	expected.full_path	= "tests/Music/60.ogg";
	expected.track		= 4;
	expected.length		= 60;
	expected.title		= "Sixty";
	expected.title_lower	= "sixty";
	expected.filepath	= "60.ogg";
	expected.length_str	= "1:00";
	run_test("Tags Track Test (60.ogg)", test_track, &expected);

	expected.full_path	= "tests/Music/90.ogg";
	expected.album		= "Album Two";
	expected.album_lower	= "album two";
	expected.track		= 5;
	expected.length		= 90;
	expected.title		= "Ninety";
	expected.title_lower	= "ninety";
	expected.filepath	= "90.ogg";
	expected.length_str	= "1:30";
	run_test("Tags Track Test (90.ogg)", test_track, &expected);

	expected.full_path	= "tests/Music/600.ogg";
	expected.track		= 6;
	expected.length		= 600;
	expected.title		= "Six Hundred";
	expected.title_lower	= "six hundred";
	expected.filepath	= "600.ogg";
	expected.length_str	= "10:00";
	run_test("Tags Track Test (600.ogg)", test_track, &expected);

	expected.full_path	= "tests/Music/666.ogg";
	expected.track		= 7;
	expected.length		= 666;
	expected.title		= "Six-Six-Six";
	expected.title_lower	= "six six six";
	expected.filepath	= "666.ogg";
	expected.length_str	= "11:06";
	run_test("Tags Track Test (666.ogg)", test_track, &expected);
}

static void test_comparison()
{
	Library *lib = tagdb :: lookup_library(1);
	Track *track1   = tagdb :: add_track("tests/Music/1.ogg",   lib);
	Track *track10  = tagdb :: add_track("tests/Music/10.ogg",  lib);
	Track *track15  = tagdb :: add_track("tests/Music/15.ogg",  lib);
	Track *track60  = tagdb :: add_track("tests/Music/60.ogg",  lib);
	Track *track90  = tagdb :: add_track("tests/Music/90.ogg",  lib);
	Track *track600 = tagdb :: add_track("tests/Music/600.ogg", lib);
	Track *track666 = tagdb :: add_track("tests/Music/666.ogg", lib);

	Artist art2("");
	track10->artist = &art2;
	test_equal(track1->less_than(track10, SORT_ARTIST), -1);
	test_equal(track10->less_than(track1, SORT_ARTIST), 1);

	Artist art3("Artist Three");
	track10->artist = &art3;
	test_equal(track1->less_than(track1,  SORT_ARTIST), 0);
	test_equal(track1->less_than(track10, SORT_ARTIST)  < 0, true);
	test_equal(track10->less_than(track1, SORT_ARTIST)  > 0, true);

	test_equal(track1->less_than(track1,  SORT_ALBUM), 0);
	test_equal(track1->less_than(track90, SORT_ALBUM) < 0, true);
	test_equal(track90->less_than(track1, SORT_ALBUM) > 0, true);

	track15->play_count++;
	test_equal(track1->less_than(track1,  SORT_COUNT), 0);
	test_equal(track1->less_than(track15, SORT_COUNT) < 0, true);
	test_equal(track15->less_than(track1, SORT_COUNT) > 0, true);

	Genre gen2("X-Treme Silence!!!");
	track60->genre = &gen2;
	test_equal(track1->less_than(track1,  SORT_GENRE), 0);
	test_equal(track1->less_than(track60, SORT_GENRE) < 0, true);
	test_equal(track60->less_than(track1, SORT_GENRE) > 0, true);

	test_equal(track1->less_than(track1,   SORT_LENGTH), 0);
	test_equal(track1->less_than(track600, SORT_LENGTH) < 0, true);
	test_equal(track600->less_than(track1, SORT_LENGTH) > 0, true);

	track15->last_year = 2014;
	test_equal(track1->less_than(track1,  SORT_PLAYED), 0);
	test_equal(track1->less_than(track15, SORT_PLAYED) < 0, true);
	test_equal(track15->less_than(track1, SORT_PLAYED) > 0, true);

	track1->last_year = 2014;
	track15->last_month = 5;
	test_equal(track1->less_than(track15, SORT_PLAYED) < 0, true);
	test_equal(track15->less_than(track1, SORT_PLAYED) > 0, true);

	track1->last_month = 5;
	track15->last_day = 6;
	test_equal(track1->less_than(track15, SORT_PLAYED) < 0, true);
	test_equal(track15->less_than(track1, SORT_PLAYED) > 0, true);

	test_equal(track1->less_than(track1,   SORT_TITLE), 0);
	test_equal(track1->less_than(track666, SORT_TITLE) < 0, true);
	test_equal(track666->less_than(track1, SORT_TITLE) > 0, true);

	test_equal(track1->less_than(track1,  SORT_TRACK), 0);
	test_equal(track1->less_than(track60, SORT_TRACK) < 0, true);
	test_equal(track60->less_than(track1, SORT_TRACK) > 0, true);

	track666->album->year = 2048;
	test_equal(track1->less_than(track1,   SORT_YEAR), 0);
	test_equal(track1->less_than(track666, SORT_YEAR) < 0, true);
	test_equal(track666->less_than(track1, SORT_YEAR) > 0, true);
}

static void test_lib_removal()
{
	test_equal(tagdb :: get_track_db().size(), (unsigned)7);
	test_equal(tagdb :: lookup_library(1)->count, (unsigned)7);
	tagdb :: remove_library(1);
	test_equal(tagdb :: get_track_db().size(), (unsigned)0);
}

static void test_save_load()
{
	Database<Artist> artist("artist.db", false);
	Database<Album> album("album.db", false);
	Database<Genre> genre("genre.db", false);

	artist.load();
	album.load();
	genre.load();

	test_equal(artist.size(), (unsigned)1);
	test_equal(album.size(), (unsigned)2);
	test_equal(genre.size(), (unsigned)1);


	Database<Library> library("library.db", false);
	library.load();
	test_equal(library.size(), (unsigned)0);

	Library *lib = tagdb :: add_library("tests/Music");
	library.load();
	test_equal(library.size(), (unsigned)1);

	Database<Library> library2("library.db", false);
	lib->enabled = false;
	tagdb :: commit_library();
	library2.load();
	test_equal(library2.at(2)->enabled, false);


	tagdb :: add_track("tests/Music/1.ogg", lib);
	tagdb :: add_track("tests/Music/15.ogg", lib);
	tagdb :: add_track("tests/Music/60.ogg", lib);

	Database<Track> track("track.db", false);
	track.load();
	test_equal(track.size(), (unsigned)0);

	tagdb :: commit();
	track.load();
	test_equal(track.size(), (unsigned)3);
}

int main(int argc, char **argv)
{
	run_test("Tags Library Test", test_library);
	test_all_tracks();
	run_test("Tags Comparison Test", test_comparison);
	run_test("Tags Library Removal Test", test_lib_removal);
	run_test("Tags Save and Load Test", test_save_load);
	return 0;
}