/*
 * Copyright 2016 (c) Anna Schumaker.
 */
#include <core/idle.h>
#include <core/playlists/artist.h>
#include <core/string.h>

static struct file artist_file = FILE_INIT("playlist.artist", 0);

static struct playlist_ops pl_artist_ops = {
	.pl_can_select = playlist_generic_can_select,
	.pl_set_random = playlist_generic_set_random,
	.pl_sort       = playlist_generic_sort,
};


static struct playlist *__artist_pl_alloc(struct artist *artist)
{
	return playlist_generic_alloc(artist->ar_name, PL_ARTIST,
				      artist_index(artist), &pl_artist_ops);
}

static bool __artist_pl_add(void *data)
{
	struct playlist *playlist = (struct playlist *)data;
	struct artist   *artist   = artist_lookup(playlist->pl_name);
	struct db_entry *dbe, *next;

	db_for_each(dbe, next, track_db_get()) {
		if (TRACK(dbe)->tr_album->al_artist == artist)
			playlist_generic_add_front(playlist, TRACK(dbe));
	}

	playlist_generic_resort(playlist);
	return true;
}

static struct playlist *__artist_pl_lookup(const gchar *name)
{
	struct artist *artist = artist_lookup(name);
	return artist ? artist->ar_playlist : NULL;
}

static bool __artist_pl_load(void *data)
{
	struct playlist *playlist;
	unsigned int i, n;
	gchar *name;

	if (!file_open(&artist_file, OPEN_READ))
		return true;

	file_readf(&artist_file, "%u\n", &n);
	for (i = 0; i < n; i++) {
		name     = file_readl(&artist_file);
		playlist = __artist_pl_lookup(name);
		if (playlist)
			playlist_generic_load(playlist, &artist_file,
							 PL_SAVE_METADATA);
		g_free(name);
	}

	file_close(&artist_file);
	return true;
}


static void pl_artist_save(void)
{
	struct db_entry *dbe, *next;
	struct playlist *playlist;

	if (!file_open(&artist_file, OPEN_WRITE))
		return;

	file_writef(&artist_file, "%u\n", artist_db_get()->db_size);
	db_for_each(dbe, next, artist_db_get()) {
		playlist = ARTIST(dbe)->ar_playlist;
		file_writef(&artist_file, "%s\n", playlist->pl_name);
		playlist_generic_save(playlist, &artist_file, PL_SAVE_METADATA);
	}

	file_close(&artist_file);
}

static struct playlist *pl_artist_lookup(const gchar *name)
{
	return __artist_pl_lookup(name);
}

static struct playlist *pl_artist_get(unsigned int id)
{
	struct artist *artist = artist_get(id);
	return artist ? artist->ar_playlist : NULL;
}

static void pl_artist_played(struct track *track)
{
	struct artist *artist = track->tr_album->al_artist;
	playlist_generic_update(artist->ar_playlist, track);
}


struct playlist_type pl_artist = {
	.pl_save     = pl_artist_save,
	.pl_lookup   = pl_artist_lookup,
	.pl_get      = pl_artist_get,
	.pl_played   = pl_artist_played,
	.pl_selected = pl_artist_played,
};


void pl_artist_init(void)
{
	struct db_entry *dbe, *next;
	struct playlist *playlist;

	db_for_each(dbe, next, artist_db_get()) {
		playlist = __artist_pl_alloc(ARTIST(dbe));
		ARTIST(dbe)->ar_playlist = playlist;

		idle_schedule(IDLE_SYNC, __artist_pl_add, playlist);
	}

	idle_schedule(IDLE_SYNC, __artist_pl_load, NULL);
}

void pl_artist_deinit()
{
	struct db_entry *dbe, *next;

	db_for_each(dbe, next, artist_db_get()) {
		playlist_generic_free(ARTIST(dbe)->ar_playlist);
		ARTIST(dbe)->ar_playlist = NULL;
	}
}

void pl_artist_new_track(struct track *track)
{
	struct artist   *artist   = track->tr_album->al_artist;
	struct playlist *playlist = (struct playlist *)artist->ar_playlist;

	if (!playlist) {
		playlist = __artist_pl_alloc(artist);
		artist->ar_playlist = playlist;
	}

	playlist_generic_add(playlist, track);
}

void pl_artist_delete_track(struct track *track)
{
	struct artist *artist = track->tr_album->al_artist;
	playlist_generic_remove(artist->ar_playlist, track);
}