/*
 * Copyright 2013 (c) Anna Schumaker.
 */
#include <callback.h>
#include <filter.h>
#include <idle.h>
#include <library.h>
#include <print.h>

#include <glib.h>
#include <sstream>
#include <time.h>


/*
 * Internal library functions
 */
struct scan_info {
	Library *library;
	std :: string path;
};
static void do_scan_path(struct scan_info &);

static void read_tags(const std::string &path, Library *library)
{
	Track *track = tagdb :: add_track(path, library);
	get_callbacks()->on_library_track_add(track->id);
}

static void process_path(Library *library, const std :: string &dir,
			 const std :: string &name)
{
	struct scan_info scan;
	std :: string path = dir + "/" + name;

	if (g_file_test(path.c_str(), G_FILE_TEST_IS_DIR) == true) {
		scan.library = library;
		scan.path = path;
		idle :: schedule (do_scan_path, scan);
	} else
		read_tags(path, library);
}

static void do_scan_path(struct scan_info &scan)
{
	GDir *dir;
	const char *name;

	dir = g_dir_open(scan.path.c_str(), 0, NULL);
	if (dir == NULL)
		return;

	name = g_dir_read_name(dir);
	while (name != NULL) {
		process_path(scan.library, scan.path, name);
		name = g_dir_read_name(dir);
	}

	tagdb :: commit();
	get_callbacks()->on_library_update(scan.library->id, scan.library);
}

static void do_validate_library(unsigned int &lib_id)
{
	std :: string path;
	Database<Track> *db = &tagdb :: get_track_db();
	Database<Track>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it)) {
		Track *track = *it;
		if (track->library->id != lib_id)
			continue;

		if (g_file_test(track->path().c_str(), G_FILE_TEST_EXISTS) == false) {
			dprint("Removing file: %s\n", track->path().c_str());
			tagdb :: remove_track(track->id);
		}
	}

	get_callbacks()->on_library_update(lib_id, tagdb :: lookup_library(lib_id));
}

static void do_update_library(unsigned int lib_id)
{
	Library *library = tagdb :: lookup_library(lib_id);
	struct scan_info scan = { library, library->root_path };
	idle :: schedule(do_validate_library, lib_id);
	idle :: schedule(do_scan_path, scan);
}

static void do_import_track(File &f, Library *library)
{
	struct ImportData data;
	unsigned int year, banned, tmp;

	std::string filepath = f.getline();
	std::string title    = f.getline();
	std::string artist   = f.getline();
	std::string album    = f.getline();
	std::string comment  = f.getline();
	std::string genre    = f.getline();
	std::string lenstr   = f.getline();

	f >> tmp /* id */ >> year >> tmp >> data.play_count;
	f >> data.last_day >> data.last_month >> data.last_year >> tmp;
	f >> tmp >> tmp >>tmp >> banned; /* bitrate, sample, channels, banned */
	f.getline(); /* get rest of line */

	Track *track = tagdb :: import_track(filepath, library, data);
	get_callbacks()->on_library_track_add(track->id);

	if (banned == true)
		get_callbacks()->on_library_import_ban(track->id);
}

static void do_import_library(std::string &s)
{
	unsigned int id, next_id, size;
	std::string path;
	bool enabled;
	File f(s, FILE_TYPE_LEGACY);

	print("Importing: %s\n", f.get_filepath());
	f.open(OPEN_READ);

	if (f.get_version() != 2) {
		print("Version mismatch: %u != 2\n", f.get_version());
		return;
	}

	path = f.getline();
	f >> id >> enabled >> next_id >> size;

	Library *library = tagdb :: add_library(path);
	if (library == NULL) {
		print("Library already contains path: %s, skipping\n", path.c_str());
		return;
	}
	print("Adding path: %s\n", path.c_str());
	get_callbacks()->on_library_add(library->id, library);

	f.getline(); /* Get rest of line */
	for (unsigned int i = 0; i < size; i++)
		do_import_track(f, library);
	tagdb :: commit();
	get_callbacks()->on_library_update(library->id, library);

	library :: update_path(id);
}



/*
 * API used by the GUI begins here
 */

void library :: init()
{
	tagdb :: init();

	Database<Track> *db = &tagdb :: get_track_db();
	Database<Track>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it)) {
		if ((*it)->library->enabled)
			get_callbacks()->on_library_track_add((*it)->id);
	}

	Database<Library> *ldb = &tagdb :: get_library_db();
	Database<Library>::iterator l_it;

	for (l_it = ldb->begin(); l_it != ldb->end(); l_it = ldb->next(l_it))
		get_callbacks()->on_library_add((*l_it)->id, *l_it);
}

void library :: add_path(const std::string &dir)
{
	if (g_file_test(dir.c_str(), G_FILE_TEST_IS_DIR) == false)
		throw -E_INVAL;

	Library *library = tagdb :: add_library(dir);
	if (!library)
		return;

	get_callbacks()->on_library_add(library->id, library);
	update_path(library->id);
}

void library :: del_path(unsigned int id)
{
	Database<Track> *db = &tagdb :: get_track_db();
	Database<Track>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it)) {
		if ((*it)->library->id == id)
			get_callbacks()->on_library_track_del((*it)->id);
	}

	tagdb :: remove_library(id);
	tagdb :: commit();
}

void library :: update_path(unsigned int id)
{
	Library *library = tagdb :: lookup_library(id);
	if (library)
		do_update_library(library->id);
}

void library :: update_all()
{
	Database<Library> *db = &tagdb :: get_library_db();
	Database<Library>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it))
		update_path((*it)->id);
}

void library :: set_enabled(unsigned int id, bool enabled)
{
	Library *library = tagdb :: lookup_library(id);

	library->enabled = enabled;
	tagdb :: commit_library();

	Database<Track> *db = &(tagdb :: get_track_db());
	Database<Track>::iterator it;

	for (it = db->begin(); it != db->end(); it = db->next(it)) {
		if ((*it)->library->id == id) {
			if (enabled)
				get_callbacks()->on_library_track_add((*it)->id);
			else
				get_callbacks()->on_library_track_del((*it)->id);
		}
	}
}

void library :: import()
{
	unsigned int i = 0;
	std::string name;

	do {
		std::stringstream ss;
		ss << i;

		name = ss.str();
		File f(name, FILE_TYPE_LEGACY);

		if (f.exists() == false)
			break;

		idle :: schedule(do_import_library, name);
		ss.clear();
		i++;
	} while (true);
}

void library :: track_played(unsigned int id)
{
	time_t the_time = time(NULL);
	struct tm *now = localtime(&the_time);
	Track *track = tagdb :: lookup(id);

	if (!track)
		return;

	track->play_count++;
	track->last_day = now->tm_mday;
	track->last_month = now->tm_mon + 1;
	track->last_year = now->tm_year + 1900;

	tagdb :: commit();
	get_callbacks()->on_library_track_updated(track->id);
}

#ifdef CONFIG_TEST
void library :: print_db(DB_Type type)
{
	switch (type) {
	case DB_ALBUM:
		break;
	case DB_ARTIST:
		break;
	case DB_GENRE:
		break;
	case DB_LIBRARY:
		break;
	case DB_TRACK:
		break;
	}
}

void library :: reset()
{
}
#endif /* CONFIG_TEST */