#include "include.h"
#include "communication.h"
#include "artist.h"
 
#define GET_INFO_METHOD_NAME "artist.getInfo"
 
static const lfmmethod artist_method_declarations[] =
{
	//method name           type         parameter                                     optional parameter 
	{"artist.addTags",      POST_METHOD, {{"artist"}, {"tags", utf8_array2csl}      }, {                                          } },
    {"artist.getEvents",    GET_METHOD,  {{"artist"}                                }, {                                          } },
    {GET_INFO_METHOD_NAME,  GET_METHOD,  {{"artist"}                                }, {                                          } },
    {"artist.getSimilar",   GET_METHOD,  {{"artist"}                                }, {{"limit", uint2utf8}                      } },
    {"artist.getTopAlbums", GET_METHOD,  {{"artist"}                                }, {                                          } }, 
    {"artist.getTopFans",   GET_METHOD,  {{"artist"}                                }, {                                          } },
    {"artist.getTopTags",   GET_METHOD,  {{"artist"}                                }, {                                          } },
    {"artist.getTopTracks", GET_METHOD,  {{"artist"}                                }, {                                          } },
    {"artist.removeTag",    POST_METHOD, {{"artist"}, {"tag"}                       }, {                                          } },
    {"artist.search",       GET_METHOD,  {{"artist"}                                }, {{"limit", uint2utf8}, {"page", uint2utf8} } },
    {"artist.share",        POST_METHOD, {{"artist"}, {"recipient", utf8_array2csl} }, {{"message"}                               } }
};
 
//enum has to be index of declarations
//changing this will break other code!
enum artist_methods
{
	add_tags,
	get_events,
	get_info,
	get_similar_artists,
	get_top_albums,
	get_top_fans,
	get_top_tags,
	get_top_tracks,
	remove_tag,
	search,
	share
};
 
static lfmmethod mbid_method =
{
	GET_INFO_METHOD_NAME,
	GET_METHOD,
	{{"mbid"}},
	{}
};
 
#undef GET_INFO_METHOD_NAME
 
static const lfmget primary_methods[] = 
{
	//method                                path to data        data type 
	{&mbid_method,                          {"artist", "name"}, DATA_UTF8},
	{&artist_method_declarations[get_info], {"artist", "mbid"}, DATA_UTF8},
	{&artist_method_declarations[get_info], {"artist", "url"}, DATA_URL},
	{&artist_method_declarations[get_info], {"artist", "image[size=small]"}, DATA_URL},
	{&artist_method_declarations[get_info], {"artist", "image[size=medium]"}, DATA_URL},
	{&artist_method_declarations[get_info], {"artist", "image[size=large]"}, DATA_URL},
	{&artist_method_declarations[get_info], {"artist", "streamable"}, DATA_BOOLEAN},
	{&artist_method_declarations[get_info], {"artist", "stats", "listeners"}, DATA_UINT},
	{&artist_method_declarations[get_info], {"artist", "stats", "plays"}, DATA_UINT},
	{&artist_method_declarations[get_info], {"artist", "bio", "published"}, DATA_DATE_TIME},
	{&artist_method_declarations[get_info], {"artist", "bio", "summary"}, DATA_UTF8},
	{&artist_method_declarations[get_info], {"artist", "bio", "content"}, DATA_UTF8}	
};
 
enum primary_info
{
	ARTIST_NAME,
	ARTIST_MUSICBRAINZ_ID,
	ARTIST_URL,
	ARTIST_IMAGE_SMALL,
	ARTIST_IMAGE_MEDIUM,
	ARTIST_IMAGE_LARGE,
	ARTIST_STREAMABLE,
	ARTIST_LISTENER_COUNT,
	ARTIST_PLAY_COUNT,
	ARTIST_TEXT_PUBLISHED,
	ARTIST_SUMMARY,
	ARTIST_DESCRIPTION
};
 
lfmget related_methods[] =
{
	{&artist_method_declarations[get_events],          {"events", "event", "id"}, DATA_EVENTS},
	{&artist_method_declarations[get_similar_artists], {"similarartists", "artist", "name"}, DATA_ARTISTS},
	{&artist_method_declarations[get_info],            {"artist", "similar", "artist", "name"}, DATA_ARTISTS},
	{&artist_method_declarations[get_info],            {"artist", "tags", "tag", "name"}, DATA_TAGS},
	{&artist_method_declarations[get_top_albums],      {"topalbums", "album"}, DATA_ALBUMS},
	{&artist_method_declarations[get_top_fans],        {"topfans", "user", "name"}, DATA_USERS},
	{&artist_method_declarations[get_top_tags],        {"toptags", "tag", "name"}, DATA_TAGS},
	{&artist_method_declarations[get_top_tracks],      {"toptracks", "track", "name"}, DATA_TRACKS},
	{&artist_method_declarations[add_tags],            {}, DATA_VOID},
	{&artist_method_declarations[remove_tag],          {}, DATA_VOID}
};
 
enum related_info
{
	ARTIST_EVENTS,
	ARTIST_SIMILAR_1,
	ARTIST_SIMILAR_2,
	ARTIST_TAGS,
	ARTIST_TOP_ALBUMS,
	ARTIST_TOP_FANS,
	ARTIST_TOP_TAGS,
	ARTIST_TOP_TRACKS,
	ARTIST_ADD_TAGS,
	ARTIST_REMOVE_TAG
};
 
#define artist_call_method_with_parameters(artist, call, callback, user_data, ...) \
	call_method_with_parameters(call, callback, user_data, artist, __VA_ARGS__);
 
void artist_get_info(const gchar* artist, const lfmget* call, gpointer callback, gpointer user_data)
{
	artist_call_method_with_parameters(artist, call, callback, user_data, NULL);
}
 
//Primary information
 
void artist_get_name(const gchar* musicbrainz_id, utf8_callback callback, gpointer user_data)
{
	call_method_with_parameters(&primary_methods[ARTIST_NAME], callback, user_data, musicbrainz_id, NULL);
}
 
gchar* s_artist_get_name(const gchar* musicbrainz_id, GError** error)
{
	IMPLEMENT_SYNC_UTF8(artist_get_name, musicbrainz_id);
}
 
void artist_get_musicbrainz_id(const gchar* artist, utf8_callback callback, gpointer user_data)
{
	artist_get_info(artist, &primary_methods[ARTIST_MUSICBRAINZ_ID], callback, user_data);
}
 
gchar* s_artist_get_musicbrainz_id(const gchar* artist, GError** error)
{
	IMPLEMENT_SYNC_UTF8(artist_get_musicbrainz_id, artist);
}
 
void artist_get_url(const gchar* artist, url_callback callback, gpointer user_data)
{
	artist_get_info(artist, &primary_methods[ARTIST_URL], callback, user_data);
}
 
gchar* s_artist_get_url(const gchar* artist, GError** error)
{
	IMPLEMENT_SYNC_UTF8(artist_get_url, artist);
}
 
void artist_get_image_url(const gchar* artist, image_size size, url_callback callback, gpointer user_data)
{
	const lfmget* call;
 
	switch(size)
	{
		case IMAGE_LARGE:
			call = &primary_methods[ARTIST_IMAGE_LARGE];
			break;
		case IMAGE_MEDIUM:
			call = &primary_methods[ARTIST_IMAGE_MEDIUM];
			break;
		default:
			call = &primary_methods[ARTIST_IMAGE_SMALL];
			break;
	}
 
	artist_get_info(artist, call, callback, user_data);
}
 
gchar* s_artist_get_image_url(const gchar* artist, image_size size, GError** error)
{
	IMPLEMENT_SYNC_UTF8(artist_get_image_url, artist, size);
}
 
void artist_is_streamable(const gchar* artist, boolean_callback callback, gpointer user_data)
{
	artist_get_info(artist, &primary_methods[ARTIST_STREAMABLE], callback, user_data);
}
 
void artist_get_listener_count(const gchar* artist, uint_callback callback, gpointer user_data)
{
	artist_get_info(artist, &primary_methods[ARTIST_LISTENER_COUNT], callback, user_data);
}
 
void artist_get_play_count(const gchar* artist, uint_callback callback, gpointer user_data)
{
	artist_get_info(artist, &primary_methods[ARTIST_PLAY_COUNT], callback, user_data);
}
 
void artist_get_published_date_time(const gchar* artist, date_time_callback callback, gpointer user_data)
{	
	artist_get_info(artist, &primary_methods[ARTIST_TEXT_PUBLISHED], callback, user_data);
}
 
void artist_get_summary(const gchar* artist, utf8_callback callback, gpointer user_data)
{	
	artist_get_info(artist, &primary_methods[ARTIST_SUMMARY], callback, user_data);
}
 
void artist_get_description(const gchar* artist, utf8_callback callback, gpointer user_data)
{
	artist_get_info(artist, &primary_methods[ARTIST_DESCRIPTION], callback, user_data);	
}
 
//
//Related information
//
 
void artist_get_events(const gchar* artist, events_callback callback, gpointer user_data)
{
	artist_get_info(artist, &related_methods[ARTIST_EVENTS], callback, user_data);
}
 
//0 means no limit
void artist_get_similar_artists(const gchar* artist, guint limit, artists_callback callback, gpointer user_data)
{
	artist_call_method_with_parameters(artist, &related_methods[ARTIST_SIMILAR_2], callback, user_data, limit, NULL);
}
 
void artist_get_tags(const gchar* artist, tags_callback callback, gpointer user_data)
{
	artist_get_info(artist, &related_methods[ARTIST_TAGS], callback, user_data);
}
 
void artist_get_top_albums(const gchar* artist, albums_callback callback, gpointer user_data)
{
	artist_get_info(artist, &related_methods[ARTIST_TOP_ALBUMS], callback, user_data);
}
    
void artist_get_top_fans(const gchar* artist, users_callback callback, gpointer user_data)
{
	artist_get_info(artist, &related_methods[ARTIST_TOP_FANS], callback, user_data);
}
 
void artist_get_top_tags(const gchar* artist, tags_callback callback, gpointer user_data)
{
	artist_get_info(artist, &related_methods[ARTIST_TOP_TAGS], callback, user_data);	
}
 
void artist_get_top_tracks(const gchar* artist, tracks_callback callback, gpointer user_data)
{
	artist_get_info(artist, &related_methods[ARTIST_TOP_TRACKS], callback, user_data);
}
 
void artist_add_tags(const gchar* artist, const gchar** tags, void_callback callback, gpointer user_data)
{	
	artist_call_method_with_parameters(artist, &related_methods[ARTIST_ADD_TAGS], callback, user_data, tags, NULL); 
}
 
void artist_remove_tag(const gchar* artist, const gchar* tag, void_callback callback, gpointer user_data)
{
	artist_call_method_with_parameters(artist, &related_methods[ARTIST_REMOVE_TAG], callback, user_data, tag, NULL);
}
 
/*
    * artist.search
    * artist.share
*/