// Copyright (c) 2012 Bryan Schumaker.
#include <deck.h>
#include <track.h>
#include <library.h>

#include <vector>
using namespace std;

static AutoPauseType pause_type;
static unsigned short pause_count = 0;

static vector<libsaria::Playlist *> playlist_deck;
static libsaria::Playlist recent_playlist(PL_STATIC | PL_NO_DRAIN | PL_UNIQUE);

static libsaria::Playlist *get_active_playlist()
{
	for (unsigned int i = 0; i < playlist_deck.size(); i++) {
		if (!playlist_deck[i]->check_flag(PL_DISABLED))
			return playlist_deck[i];
	}
	return libsaria::library::get_playlist();
}

static bool check_play()
{
	switch(pause_type) {
	case PS_AFTER_N:
		if (pause_count == 0) {
			libsaria::deck::set_pause_type(PS_NONE, 0);
			return false;
		} else {
			pause_count--;
			libsaria::notify(PAUSE_COUNT, &pause_count);
		}
	default:
		break;
	}
	return true;
}

static void remove_playlist(libsaria::Playlist *plist)
{
	for (unsigned int i = 0; i < playlist_deck.size(); i++) {
		if (playlist_deck[i] == plist) {
			playlist_deck.erase(playlist_deck.begin() + i);
			break;
		}
	}
}

static void renumber_playlists()
{
	for (unsigned int i = 0; i < playlist_deck.size(); i++)
		playlist_deck[i]->renumber(i);
}

static void read_playlist(ifstream &stream)
{
	libsaria::Playlist *plist = new libsaria::Playlist(0);
	playlist_deck.push_back(plist);
	notify(PLAYLIST_NEW, plist);
	plist->load(stream);
	plist->renumber(playlist_deck.size() - 1);
}

namespace libsaria
{

	void deck::garbage_collect()
	{
		for (unsigned int i = 0; i < playlist_deck.size(); i++) {
			Playlist *plist = playlist_deck[i];
			if (plist->get_size() == 0) {
				plist->prepare_for_removal();
				notify(PLAYLIST_DELETE, plist);
				delete plist;
				playlist_deck.erase(playlist_deck.begin() + i);
			}
		}
		renumber_playlists();
	}

	void deck::next()
	{
		Playlist *plist = get_active_playlist();
		Track *track = plist->next();
		if (track)
			track->load(check_play());
		garbage_collect();
	}

	void deck::prev()
	{
		Track *track = recent_playlist.next();
		if (track)
			track->load_unlisted(true);
	}

	Playlist *deck::new_playlist(list<Track *> &tracks, unsigned int flags, bool front)
	{
		Playlist *plist;

		if (playlist_deck.size() == MAX_PLAYLISTS)
			return NULL;
		plist = new Playlist(flags);

		if (front)
			playlist_deck.insert(playlist_deck.begin(), plist);
		else
			playlist_deck.push_back(plist);
		notify(PLAYLIST_NEW, plist);

		renumber_playlists();
		plist->push_back(tracks);
		return plist;
	}

	void deck::delete_playlist(Playlist *plist)
	{
		plist->prepare_for_removal();
		notify(PLAYLIST_DELETE, plist);
		remove_playlist(plist);
		garbage_collect();
	}

	unsigned int deck::move_playlist(Playlist *plist, unsigned int index)
	{
		if (index >= playlist_deck.size())
			index = playlist_deck.size() - 1;

		remove_playlist(plist);
		playlist_deck.insert(playlist_deck.begin() + index, plist);
		renumber_playlists();
		return index;
	}

	void deck::track_removed(Track *track)
	{
		for (unsigned int i = 0; i < playlist_deck.size(); i++)
			playlist_deck[i]->remove_track(track);
	}

	Playlist *deck::get_recent_plist()
	{
		return &recent_playlist;
	}

	void deck::list_recent(Track *track)
	{
		recent_playlist.push_front(track);
		recent_playlist.reset_iterator();
	}

	Playlist *deck::get_playlist(unsigned int n)
	{
		if (n >= playlist_deck.size())
			return NULL;
		return playlist_deck[n];
	}

	unsigned int deck::get_playlist_index(Playlist *plist)
	{
		for (unsigned int i = 0; i < playlist_deck.size(); i++) {
			if (playlist_deck[i] == plist)
				return i;
		}
		return -1;
	}

	unsigned int deck::size()
	{
		return playlist_deck.size();
	}

	void deck::init()
	{
		app::mkdir("playlist");
		app::read_numdir("playlist", read_playlist);
	}

	void deck::set_pause_type(AutoPauseType type, unsigned int count)
	{
		pause_type = type;
		pause_count = count;
		notify(PAUSE_TYPE, &pause_type);
		notify(PAUSE_COUNT, &count);
	}

	AutoPauseType deck::get_pause_type()
	{
		return pause_type;
	}

	unsigned short deck::get_pause_count()
	{
		return pause_count;
	}

}; /* Namespace: Libsaria */