/*
 * Copyright 2013 (c) Anna Schumaker.
 */
#include <core/playlist.h>
#include <core/settings.h>

static const gchar *SETTINGS_CUR_TYPE = "core.playlist.cur.type";
static const gchar *SETTINGS_CUR_ID   = "core.playlist.cur.id";

struct playlist_type *playlist_types[] = {
	[PL_SYSTEM]  = &pl_system,
	[PL_ARTIST]  = &pl_artist,
	[PL_LIBRARY] = &pl_library,
};


void playlist_init(struct queue_ops *ops)
{
	pl_system_init(ops);
	pl_artist_init(ops);
	pl_library_init(ops);

	if (!settings_has(SETTINGS_CUR_TYPE) ||
	    !settings_has(SETTINGS_CUR_ID))
		playlist_select(PL_SYSTEM, "Collection");
}

void playlist_deinit()
{
	pl_system_deinit();
	pl_artist_deinit();
	pl_library_deinit();
}

bool playlist_select(enum playlist_type_t type, const gchar *name)
{
	if (!playlist_types[type]->pl_can_select(name))
		return false;

	settings_set(SETTINGS_CUR_TYPE, type);
	settings_set(SETTINGS_CUR_ID, playlist_get_id(type, name));
	return true;
}

bool playlist_new(enum playlist_type_t type, const gchar *name)
{
	return playlist_types[type]->pl_new(name);
}

bool playlist_delete(enum playlist_type_t type, const gchar *name)
{
	return playlist_types[type]->pl_delete(name);
}

bool playlist_add(enum playlist_type_t type, const gchar *name,
		  struct track *track)
{
	if (!track)
		return false;
	return playlist_types[type]->pl_add_track(name, track);
}

bool playlist_remove(enum playlist_type_t type, const gchar *name,
		     struct track *track)
{
	if (!track)
		return false;
	return playlist_types[type]->pl_remove_track(name, track);
}

void playlist_update(enum playlist_type_t type, const gchar *name)
{
	playlist_types[type]->pl_update(name);
}

bool playlist_has(enum playlist_type_t type, const gchar *name,
		  struct track *track)
{
	struct queue *queue = playlist_get_queue(type, name);
	if (!track || !queue)
		return false;
	return queue_has(queue, track);
}

unsigned int playlist_size(enum playlist_type_t type, const gchar *name)
{
	struct queue *queue = playlist_get_queue(type, name);
	return queue ? queue_size(queue) : 0;
}

void playlist_set_random(enum playlist_type_t type, const gchar *name,
			 bool enabled)
{
	playlist_types[type]->pl_set_flag(name, Q_RANDOM, enabled);
}

bool playlist_get_random(enum playlist_type_t type, const gchar *name)
{
	struct queue *queue = playlist_get_queue(type, name);
	return queue ? queue_has_flag(queue, Q_RANDOM) : false;
}

void playlist_sort(enum playlist_type_t type, const gchar *name,
		   enum compare_t sort, bool reset)
{
	playlist_types[type]->pl_sort(name, sort, reset);
}

struct track *playlist_next(void)
{
	if (playlist_size(PL_SYSTEM, "Queued Tracks") > 0)
		return playlist_types[PL_SYSTEM]->pl_next("Queued Tracks");
	return playlist_types[PL_SYSTEM]->pl_next("Collection");
}

struct track *playlist_prev(void)
{
	return playlist_types[PL_SYSTEM]->pl_next("History");
}

struct queue *playlist_get_queue(enum playlist_type_t type, const gchar *name)
{
	return playlist_types[type]->pl_get_queue(name);
}

unsigned int playlist_get_id(enum playlist_type_t type, const gchar *name)
{
	return playlist_types[type]->pl_get_id(name);
}

gchar *playlist_get_name(enum playlist_type_t type, unsigned int id)
{
	return playlist_types[type]->pl_get_name(id);
}