// Beep Remote
//
// Douglas Thrift
//
// $Id$

#include <audacious/beepctrl.h>

#include "Audacious.hpp"

void Audacious::Playlist(char **list, int size, bool enqueue)
{
	::xmms_remote_playlist(session, list, size, enqueue);
}

int Audacious::GetVersion() const
{
	return ::xmms_remote_get_version(session);
}

void Audacious::PlaylistAdd(::GList *list)
{
	::xmms_remote_playlist_add(session, list);
}

void Audacious::PlaylistDelete(int position)
{
	::xmms_remote_playlist_delete(session, position);
}

void Audacious::Play()
{
	::xmms_remote_play(session);
}

void Audacious::Pause()
{
	::xmms_remote_pause(session);
}

void Audacious::Stop()
{
	::xmms_remote_stop(session);
}

bool Audacious::IsPlaying() const
{
	return ::xmms_remote_is_playing(session);
}

bool Audacious::IsPaused() const
{
	return ::xmms_remote_is_paused(session);
}

int Audacious::GetPlaylistPosition() const
{
	return ::xmms_remote_get_playlist_pos(session);
}

void Audacious::SetPlaylistPosition(int position)
{
	::xmms_remote_set_playlist_pos(session, position);
}

int Audacious::GetPlaylistLength() const
{
	return ::xmms_remote_get_playlist_length(session);
}

void Audacious::PlaylistClear()
{
	return ::xmms_remote_playlist_clear(session);
}

int Audacious::GetOutputTime() const
{
	return ::xmms_remote_get_output_time(session);
}

void Audacious::JumpToTime(int position)
{
	::xmms_remote_jump_to_time(session, position);
}

void Audacious::GetVolume(int& left, int& right) const
{
	::xmms_remote_get_volume(session, &left, &right);
}

int Audacious::GetMainVolume() const
{
	return ::xmms_remote_get_main_volume(session);
}

int Audacious::GetBalance() const
{
	return ::xmms_remote_get_balance(session);
}

void Audacious::SetVolume(int left, int right)
{
	::xmms_remote_set_volume(session, left, right);
}

void Audacious::SetMainVolume(int volume)
{
	::xmms_remote_set_main_volume(session, volume);
}

void Audacious::SetBalance(int balance)
{
	::xmms_remote_set_balance(session, balance);
}

std::string Audacious::GetSkin() const
{
	return ::xmms_remote_get_skin(session);
}

void Audacious::SetSkin(const std::string &skin)
{
	::xmms_remote_set_skin(session, const_cast<char*>(skin.c_str()));
}

std::string Audacious::GetPlaylistFile(int position) const
{
	return ::xmms_remote_get_playlist_file(session, position);
}

std::string Audacious::GetPlaylistTitle(int position) const
{
	return ::xmms_remote_get_playlist_title(session, position);
}

int Audacious::GetPlaylistTime(int position) const
{
	return ::xmms_remote_get_playlist_time(session, position);
}

void Audacious::GetInfo(int &rate, int &frequency, int &channels) const
{
	::xmms_remote_get_info(session, &rate, &frequency, &channels);
}

void Audacious::MainWindowToggle(bool show)
{
	::xmms_remote_main_win_toggle(session, show);
}

void Audacious::PlaylistWindowToggle(bool show)
{
	::xmms_remote_pl_win_toggle(session, show);
}

void Audacious::EqualizerWindowToggle(bool show)
{
	::xmms_remote_eq_win_toggle(session, show);
}

bool Audacious::IsMainWindow() const
{
	return ::xmms_remote_is_main_win(session);
}

bool Audacious::IsPlaylistWindow() const
{
	return ::xmms_remote_is_pl_win(session);
}

bool Audacious::IsEqualizerWindow() const
{
	return ::xmms_remote_is_eq_win(session);
}

void Audacious::ShowPreferencesBox()
{
	::xmms_remote_show_prefs_box(session);
}

void Audacious::ToggleAlwaysOnTop(bool always)
{
	::xmms_remote_toggle_aot(session, always);
}

void Audacious::Eject()
{
	::xmms_remote_eject(session);
}

void Audacious::PlaylistPrevious()
{
	::xmms_remote_playlist_prev(session);
}

void Audacious::PlaylistNext()
{
	::xmms_remote_playlist_next(session);
}

void Audacious::PlaylistAddUrl(const std::string &url)
{
	::xmms_remote_playlist_add_url_string(session, const_cast<char*>(url.c_str()));
}

bool Audacious::IsRunning() const
{
	return ::xmms_remote_is_running(session);
}

void Audacious::ToggleRepeat()
{
	::xmms_remote_toggle_repeat(session);
}

void Audacious::ToggleShuffle()
{
	::xmms_remote_toggle_shuffle(session);
}

bool Audacious::IsRepeat() const
{
	return ::xmms_remote_is_repeat(session);
}

bool Audacious::IsShuffle() const
{
	return ::xmms_remote_is_shuffle(session);
}

void Audacious::GetEqualizer(float& preamp, float bands[10]) const
{
	float* bands_;

	::xmms_remote_get_eq(session, &preamp, &bands_);

	_forall (uint8_t, index, 0, 10)
		bands[index] = bands[index];

	::g_free(bands_);
}

float Audacious::GetEqualizerPreamp() const
{
	return ::xmms_remote_get_eq_preamp(session);
}

float Audacious::GetEqualizerBand(int band) const
{
	return ::xmms_remote_get_eq_band(session, band);
}

void Audacious::SetEqualizer(float preamp, float bands[10])
{
	::xmms_remote_set_eq(session, preamp, bands);
}

void Audacious::SetEqualizerPreamp(float preamp)
{
	::xmms_remote_set_eq_preamp(session, preamp);
}

void Audacious::SetEqualizerBand(int band, float value)
{
	::xmms_remote_set_eq_band(session, band, value);
}

// XMMS 1.2.1
void Audacious::Quit()
{
	::xmms_remote_quit(session);
}

// XMMS 1.2.6
void Audacious::PlayPause()
{
	::xmms_remote_play_pause(session);
}

void Audacious::PlaylistInsertUrl(const std::string &url, int position)
{
	::xmms_remote_playlist_ins_url_string(session, const_cast<char*>(url.c_str()), position);
}

// XMMS 1.2.11
void Audacious::PlayqueueAdd(int position)
{
	::xmms_remote_playqueue_add(session, position);
}

void Audacious::PlayqueueRemove(int position)
{
	::xmms_remote_playqueue_remove(session, position);
}

int Audacious::GetPlayqueueLength() const
{
	return ::xmms_remote_get_playqueue_length(session);
}

void Audacious::ToggleAdvance()
{
	::xmms_remote_toggle_advance(session);
}

bool Audacious::IsAdvance() const
{
	return ::xmms_remote_is_advance(session);
}

// BMP 0.9.7
void Audacious::Activate()
{
	::xmms_remote_activate(session);
}

// Audacious 1.1
void Audacious::ShowJumpToFileBox()
{
	::xmms_remote_show_jtf_box(session);
}

void Audacious::PlayqueueClear()
{
	::xmms_remote_playqueue_clear(session);
}

bool Audacious::PlayqueueIsQueued(int position) const
{
	return ::xmms_remote_playqueue_is_queued(session, position);
}

int Audacious::GetPlayqueuePosition(int position) const
{
	return ::xmms_remote_get_playqueue_position(session, position);
}

int Audacious::GetPlayqueueQueuePosition(int position) const
{
	return ::xmms_remote_get_playqueue_queue_position(session, position);
}

// Audacious 1.2
void Audacious::SetSessionUri(const std::string &uri)
{
	::audacious_set_session_uri(const_cast<char *>(uri.c_str()));
}

std::string Audacious::GetSessionUri() const
{
	return ::audacious_get_session_uri(session);
}

void Audacious::SetSessionType(Type type)
{
	::audacious_set_session_type(type);
}

// Audacious 1.3
void Audacious::PlaylistEnqueueToTemp(const std::string &string)
{
	::xmms_remote_playlist_enqueue_to_temp(session, const_cast<char *>(string.c_str()));
}

std::string Audacious::GetTupleFieldData(const std::string &field, int position)
{
	return ::audacious_get_tuple_field_data(session, const_cast<char *>(field.c_str()), position);
}