#include <errno.h>
#include <fcntl.h>
#include <glib.h>
#include <unistd.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/signalfd.h>
#include <readline/readline.h>
#include <readline/history.h>

#include "gdbus/gdbus.h"
#include "avrcpctrl.h"
#include "a2dp_source/a2dp_masterctrl.h"
#include "DeviceIo.h"
//#include "Rk_shell.h"
#include "slog.h"

#define COLOR_OFF	"\x1B[0m"
#define COLOR_RED	"\x1B[0;91m"
#define COLOR_GREEN	"\x1B[0;92m"
#define COLOR_YELLOW	"\x1B[0;93m"
#define COLOR_BLUE	"\x1B[0;94m"
#define COLOR_BOLDGRAY	"\x1B[1;30m"
#define COLOR_BOLDWHITE	"\x1B[1;37m"

/* String display constants */
#define COLORED_NEW	COLOR_GREEN "NEW" COLOR_OFF
#define COLORED_CHG	COLOR_YELLOW "CHG" COLOR_OFF
#define COLORED_DEL	COLOR_RED "DEL" COLOR_OFF

#define PROMPT_ON	COLOR_BLUE "[bluetooth]" COLOR_OFF "# "
#define PROMPT_OFF	"[bluetooth]# "

static GList *proxy_list;

static const char *last_device_path = NULL;
static char last_obj_path[] = "/org/bluez/hci0/dev_xx_xx_xx_xx_xx_xx";
static GDBusProxy *last_connected_device_proxy = NULL;
static GDBusProxy *last_temp_connected_device_proxy = NULL;
static GList *device_list;
static guint reconnect_timer;
#define STORAGE_PATH "/data/cfg/lib/bluetooth"
static void device_connected_post(GDBusProxy *proxy);

#define BLUEZ_MEDIA_PLAYER_INTERFACE "org.bluez.MediaPlayer1"
#define BLUEZ_MEDIA_FOLDER_INTERFACE "org.bluez.MediaFolder1"
#define BLUEZ_MEDIA_ITEM_INTERFACE "org.bluez.MediaItem1"
#define BLUEZ_MEDIA_TRANSPORT_INTERFACE "org.bluez.MediaTransport1"

extern DBusConnection *dbus_conn;
static GDBusProxy *default_player;
static GSList *players = NULL;
static GSList *folders = NULL;
static GSList *items = NULL;

static int first_ctrl = 1;
extern GDBusClient *btsrc_client;

static int g_btsrc_connect_status = RK_BT_SINK_STATE_IDLE;

extern void print_iter(const char *label, const char *name, DBusMessageIter *iter);

typedef struct {
	RK_BT_SINK_CALLBACK avrcp_sink_cb;
	RK_BT_AVRCP_TRACK_CHANGE_CB avrcp_track_cb;
	RK_BT_AVRCP_PLAY_POSITION_CB avrcp_position_cb;
	RK_BT_SINK_VOLUME_CALLBACK avrcp_volume_cb;
} avrcp_callback_t;

static avrcp_callback_t g_avrcp_cb = {
	NULL, NULL, NULL, NULL,
};

static char track_key[256];
static int current_song_len = 0;

void bt_sink_state_send(RK_BT_SINK_STATE state)
{
	if (g_avrcp_cb.avrcp_sink_cb)
		(g_avrcp_cb.avrcp_sink_cb)(state);
}

void report_avrcp_event(enum BtEvent event, void *data, int len) {

	pr_info("[AVRCP DEBUG]: event: %d \n", event);

	switch(event) {
		case BT_SINK_ENV_CONNECT:
			g_btsrc_connect_status = RK_BT_SINK_STATE_CONNECT;
			bt_sink_state_send(RK_BT_SINK_STATE_CONNECT);
			break;
		case BT_SINK_ENV_DISCONNECT:
			g_btsrc_connect_status = RK_BT_SINK_STATE_DISCONNECT;
			bt_sink_state_send(RK_BT_SINK_STATE_DISCONNECT);
			break;
		case BT_EVENT_START_PLAY:
			bt_sink_state_send(RK_BT_SINK_STATE_PLAY);
			break;
		case BT_EVENT_PAUSE_PLAY:
			bt_sink_state_send(RK_BT_SINK_STATE_PAUSE);
			break;
		case BT_EVENT_STOP_PLAY:
			bt_sink_state_send(RK_BT_SINK_STATE_STOP);
			break;
		default:
			break;
	}
}

bool system_command(const char* cmd)
{
	pid_t status = 0;
	bool ret_value = false;

	status = system(cmd);

	if (-1 == status) {
	} else {
		if (WIFEXITED(status)) {
			if (0 == WEXITSTATUS(status)) {
				ret_value = true;
			} else {
			}
		} else {
		}
	}

	return ret_value;
}

void rkbt_inquiry_scan(bool scan)
{
	if (scan)
		system_command("hciconfig hci0 piscan");
	else
		system_command("hciconfig hci0 noscan");
}

struct adapter {
	GDBusProxy *proxy;
	GDBusProxy *ad_proxy;
	GList *devices;
};

extern struct adapter *default_ctrl;
extern GList *ctrl_list;

static gboolean device_is_child(GDBusProxy *device, GDBusProxy *master)
{
	DBusMessageIter iter;
	const char *adapter, *path;

	if (!master)
		return FALSE;

	if (g_dbus_proxy_get_property(device, "Adapter", &iter) == FALSE)
		return FALSE;

	dbus_message_iter_get_basic(&iter, &adapter);
	path = g_dbus_proxy_get_path(master);

	if (!strcmp(path, adapter))
		return TRUE;

	return FALSE;
}

static struct adapter *find_parent(GDBusProxy *device)
{
	GList *list;

	for (list = g_list_first(ctrl_list); list; list = g_list_next(list)) {
		struct adapter *parent_adapter = (struct adapter*)(list->data);

		if (device_is_child(device, parent_adapter->proxy) == TRUE)
			return parent_adapter;
	}

	return NULL;
}

void connect_handler(DBusConnection *connection, void *user_data)
{
	pr_info("%s \n", __func__);
}

void disconnect_handler(DBusConnection *connection, void *user_data)
{
	pr_info("%s \n", __func__);
}

void print_folder(GDBusProxy *proxy, const char *description)
{
	const char *path;

	path = g_dbus_proxy_get_path(proxy);
}

void folder_removed(GDBusProxy *proxy)
{
	folders = g_slist_remove(folders, proxy);

	print_folder(proxy, COLORED_DEL);
}

char *proxy_description(GDBusProxy *proxy, const char *title,
						const char *description)
{
	const char *path;

	path = g_dbus_proxy_get_path(proxy);

	return g_strdup_printf("%s%s%s%s %s ",
					description ? "[" : "",
					description ? : "",
					description ? "] " : "",
					title, path);
}

void print_player(GDBusProxy *proxy, const char *description)
{
	char *str;
	char strplay[256];
	str = proxy_description(proxy, "Player", description);

	memset(strplay, 0x00, 256);
	sprintf(strplay,"%s%s\n", str, (default_player == proxy ? "[default]" : ""));
	pr_info(strplay);

	g_free(str);
}

void player_added(GDBusProxy *proxy)
{
	pr_info("player_added \n");

	if (g_slist_length(players) == 0) {
		pr_info("=== add set last_connected_device_proxy 0x%p \n", proxy);
		last_connected_device_proxy = last_temp_connected_device_proxy;
		device_connected_post(last_connected_device_proxy);
		report_avrcp_event(BT_SINK_ENV_CONNECT, NULL, 0);
		pr_info("[D: %s]: BT_SNK_DEVICE CONNECTED\n", __func__);
		system("hciconfig hci0 noscan");
		system("hciconfig hci0 noscan");
	}

	players = g_slist_append(players, proxy);

	if (default_player == NULL) {
		pr_info("set default player: %s\n", g_dbus_proxy_get_path(proxy));
		default_player = proxy;
	}

	print_player(proxy, COLORED_NEW);
}
void print_item(GDBusProxy *proxy, const char *description)
{
	const char *path, *name;
	DBusMessageIter iter;

	path = g_dbus_proxy_get_path(proxy);

	if (g_dbus_proxy_get_property(proxy, "Name", &iter))
	 dbus_message_iter_get_basic(&iter, &name);
	else
	 name = "<unknown>";
}

void item_added(GDBusProxy *proxy)
{
	items = g_slist_append(items, proxy);

	print_item(proxy, COLORED_NEW);
}

void folder_added(GDBusProxy *proxy)
{
	folders = g_slist_append(folders, proxy);

	print_folder(proxy, COLORED_NEW);
}

static GDBusProxy *proxy_lookup(GList *list, int *index, const char *path,
						const char *interface)
{
	GList *l;

	if (!interface)
		return NULL;

	for (l = g_list_nth(list, index ? *index : 0); l; l = g_list_next(l)) {
		GDBusProxy *proxy = (GDBusProxy *)(l->data);
		const char *proxy_iface = g_dbus_proxy_get_interface(proxy);
		const char *proxy_path = g_dbus_proxy_get_path(proxy);

		if (index)
			(*index)++;

		/* Proxy info mybe error. */
		if (!proxy_iface || !proxy_path) {
			pr_info("ERROR: %s proxy info error! proxy_iface:%s, proxy_path:%s\n",
				__func__, proxy_iface, proxy_path);
			return NULL;
		}

		if (g_str_equal(proxy_iface, interface) == TRUE &&
			g_str_equal(proxy_path, path) == TRUE)
			return proxy;
		}

	return NULL;
}

static GDBusProxy *proxy_lookup_client(GDBusClient *client, int *index,
					   const char* path,
					   const char *interface)
{
	return proxy_lookup(proxy_list, index, path, interface);
}

static const char *load_connected_device(const char *str)
{
	int fd;
	int result;
	char path[64];

	sprintf(path, "%s/%s/reconnect", STORAGE_PATH, str);

	pr_info("Load path %s", path);

	result = access(path, F_OK);
	if (result == -1) {
		pr_info("%s doesnot exist", path);
		return NULL;
	}

	fd = open(path, O_RDONLY);
	if (fd == -1) {
		pr_info("Open %s error: %s", path,
			  strerror(errno));
		return NULL;
	}

	result = read(fd, last_obj_path, sizeof(last_obj_path) - 1);
	close(fd);

	if (result > 0) {
		pr_info("Previous device path: %s", last_obj_path);
		return last_obj_path;
	} else {
		pr_info("Read %s error: %s", path,
			  strerror(errno));
		return NULL;
	}
}

static void store_connected_device(GDBusProxy *proxy)
{
	int fd;
	int result;
	const char *object_path;
	struct adapter *adapter = find_parent(proxy);
	char path[64];
	DBusMessageIter iter;
	const char *str;

	if (!adapter)
		return;

	if (g_dbus_proxy_get_property(adapter->proxy,
					  "Address", &iter) == FALSE) {
		pr_err("Get adapter address error");
		return;
	}

	dbus_message_iter_get_basic(&iter, &str);

	sprintf(path, "%s/%s/reconnect", STORAGE_PATH, str);
	pr_info("Store path: %s", path);

	object_path = g_dbus_proxy_get_path(proxy);

	pr_info("Connected device object path: %s", object_path);

	fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0644);
	if (fd == -1) {
		pr_info("Open %s error: %s", path,
			  strerror(errno));
		return;
	}

	result = write(fd, object_path, strlen(object_path) + 1);
	close(fd);

	if (result > 0)
		memcpy(last_obj_path, object_path, sizeof(last_obj_path) - 1);
	else
		pr_info("Write %s error: %s", path, strerror(errno));
}

static void device_connected_post(GDBusProxy *proxy)
{
	int device_num = g_list_length(device_list);

	pr_info("Connected device number %d", device_num);

	if (!device_num)
		return;

	store_connected_device(proxy);
}

static void disconn_device_reply(DBusMessage * message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);
	if (dbus_set_error_from_message(&error, message) == TRUE) {

		if (strstr(error.name, "Failed"))
			pr_info("disconn_device_reply failed\n");
		dbus_error_free(&error);
	}
}

#define RECONN_INTERVAL	2
static void reconn_last_device_reply(DBusMessage * message, void *user_data)
{

	DBusError error;
	static int count = 1;

	dbus_error_init(&error);
	if (dbus_set_error_from_message(&error, message) == TRUE) {

		if (strstr(error.name, "Failed") && (count > 0)) {
			pr_info("Retry to reconn_last connect, count %d", count);
			count--;
			reconnect_timer = g_timeout_add_seconds(RECONN_INTERVAL,
					reconn_last, NULL);
			dbus_error_free(&error);
			return;
		}

		report_avrcp_event(BT_SINK_ENV_CONNECT_FAIL, NULL, 0);
		dbus_error_free(&error);
	}
	count = 1;
}

bool disconn_device(void)
{
	GDBusProxy *proxy = last_connected_device_proxy;
	DBusMessageIter iter, addr_iter;
	dbus_bool_t connected;

	if (!proxy) {
		pr_info("Invalid proxy, stop disconnecting\n");
		return FALSE;
	}

	pr_info("disconnect g_dbus_proxy_get_path [0x%p]: %s\n", proxy, g_dbus_proxy_get_path(proxy));

	if (g_dbus_proxy_get_property(proxy, "Address",
				 &addr_iter) == TRUE) {
		const char *address;

		dbus_message_iter_get_basic(&addr_iter,
					 &address);
		pr_info("disconn_device addrs %s ", address);
	}

	if (g_dbus_proxy_get_property(proxy, "Connected", &iter)) {
		dbus_message_iter_get_basic(&iter, &connected);
		if (!connected)
			return FALSE;
	}

	if (g_list_length(device_list) <= 0) {
		pr_info("Device already disconnected");
		return FALSE;
	}

	pr_info("disconnect target device: %s", g_dbus_proxy_get_path(proxy));

	if (g_dbus_proxy_method_call(proxy,
					 "Disconnect",
					 NULL,
					 disconn_device_reply,
					 last_connected_device_proxy, NULL) == FALSE) {
		pr_info("Failed to call org.bluez.Device1.Disonnect");
	}

	return TRUE;
}

bool reconn_last(void)
{
	GDBusProxy *proxy = last_connected_device_proxy;
	DBusMessageIter addr_iter, addrType_iter;
	int fd, ret, reconnect = 1;
	char buff[100] = {0};

	fd = open("/userdata/cfg/bt_reconnect", O_RDONLY);
	if (fd > 0) {
		ret = read(fd, buff, sizeof(buff));
		if (ret > 0) {
			if (strstr(buff, "bluez-reconnect:disable"))
				reconnect = 0;
		}
		close(fd);
	}

	if (reconnect == 0) {
		pr_info("%s: automatic reconnection is disabled!", __func__);
		return 0;
	}

	if (bt_is_connected()) {
		pr_info("%s: The device is connected and does not need to be reconnected!", __func__);
		return 0;
	}

	if (reconnect_timer) {
		g_source_remove(reconnect_timer);
		reconnect_timer = 0;
	}

	pr_info("%s: lcdp: 0x%p, last_device_path: %s.\n",
		__func__, last_connected_device_proxy, last_device_path);

	if ((!last_connected_device_proxy) && last_device_path) {
		/* Check if the device exists */
		last_connected_device_proxy = proxy_lookup_client(
							btsrc_client, NULL,
							last_device_path,
							"org.bluez.Device1");
		proxy = last_connected_device_proxy;
	}

	if (!proxy) {
		pr_info("Invalid proxy, stop reconnecting\n");
		return FALSE;
	}

	if (g_list_length(device_list) > 0) {
		pr_info("Device device_list: %d.\n", g_list_length(device_list));
		//return FALSE;

	}

	pr_info("reconn_last target device: %s", g_dbus_proxy_get_path(proxy));
	if (g_dbus_proxy_get_property(proxy, "Address",
				 &addr_iter) == TRUE) {
		const char *address;

		dbus_message_iter_get_basic(&addr_iter,
					 &address);
		pr_info("disconn_device addrs %s ", address);
	}

	if (g_dbus_proxy_get_property(proxy, "AddressType",
			  &addrType_iter) == TRUE) {
		const char *addrType;

		dbus_message_iter_get_basic(&addrType_iter,
				  &addrType);
		pr_info("addrType %s ", addrType);
		if (strcmp(addrType, "random") == 0)
			return 0;
	}

	if (g_dbus_proxy_method_call(proxy,
					 "Connect",
					 NULL,
					 reconn_last_device_reply,
					 last_connected_device_proxy, NULL) == FALSE) {
		pr_info("Failed to call org.bluez.Device1.Connect");
	}

	return FALSE;
}

static int adapter_is_powered(GDBusProxy *proxy)
{
	DBusMessageIter iter;
	dbus_bool_t powered;

	if (g_dbus_proxy_get_property(proxy, "Powered", &iter)) {
		dbus_message_iter_get_basic(&iter, &powered);
		if (powered)
			return 1;
	}

	return 0;
}

void a2dp_sink_device_added(GDBusProxy *proxy)
{
	const char *path = g_dbus_proxy_get_path(proxy);
	dbus_bool_t connected = 0;
	static int first = 1;
	DBusMessageIter iter;

	proxy_list = g_list_append(proxy_list, proxy);

	if (g_dbus_proxy_get_property(proxy, "Connected", &iter)) {
		dbus_message_iter_get_basic(&iter, &connected);

		if (connected) {
			device_list = g_list_append(device_list, proxy);
			pr_info("=== BT SINK set last_temp_connected_device_proxy %p \n", proxy);
			last_temp_connected_device_proxy = proxy;
			return;
		}
	}
}

void a2dp_sink_proxy_added(GDBusProxy *proxy, void *user_data)
{
	pr_info("BT SINK proxy_added\n");
	const char *interface;
	interface = g_dbus_proxy_get_interface(proxy);

	pr_info("BT SINK proxy_added interface:%s \n", interface);

	if (!strcmp(interface, BLUEZ_MEDIA_PLAYER_INTERFACE))
		player_added(proxy);
	else if (!strcmp(interface, BLUEZ_MEDIA_FOLDER_INTERFACE))
		folder_added(proxy);
	else if (!strcmp(interface, BLUEZ_MEDIA_ITEM_INTERFACE))
		item_added(proxy);

	if (!strcmp(interface, "org.bluez.Device1")) {
		//a2dp_sink_device_added(proxy);
	} else if (!strcmp(interface, "org.bluez.Adapter1")) {
		DBusMessageIter iter;
		const char *str;

		if (!g_dbus_proxy_get_property(proxy, "Address", &iter)) {
				pr_err("Failed to get adapter address");
				return;
		}

		dbus_message_iter_get_basic(&iter, &str);

		if (!first_ctrl)
			return;

		first_ctrl = 0;
		/* Load previous connected device */
		last_device_path = load_connected_device(str);
	}
}

 void player_removed(GDBusProxy *proxy)
{
	print_player(proxy, COLORED_DEL);

	if (default_player == proxy) {
		default_player = NULL;
	}

	players = g_slist_remove(players, proxy);
	if (g_slist_length(players) == 0) {
		pr_info("[D: %s]: BT_SNK_DEVICE DISCONNECTED\n", __func__);
		report_avrcp_event(BT_SINK_ENV_DISCONNECT, NULL, 0);
		system("hciconfig hci0 piscan");
		system("hciconfig hci0 piscan");
	}
}

void item_removed(GDBusProxy *proxy)
{
	items = g_slist_remove(items, proxy);

	print_item(proxy, COLORED_DEL);
}

 void a2dp_sink_proxy_removed(GDBusProxy *proxy, void *user_data)
{
	const char *interface;

	pr_info("BT SINK proxy_removed\n");
	interface = g_dbus_proxy_get_interface(proxy);

	if (!strcmp(interface, BLUEZ_MEDIA_PLAYER_INTERFACE))
		player_removed(proxy);
	if (!strcmp(interface, BLUEZ_MEDIA_FOLDER_INTERFACE))
		folder_removed(proxy);
	if (!strcmp(interface, BLUEZ_MEDIA_ITEM_INTERFACE))
		item_removed(proxy);
}

static void save_track_info(BtTrackInfo *track, const char *valstr, unsigned int valu32)
{
	if(!strcmp(track_key, "Title") && valstr != NULL)
		memcpy(track->title, valstr, strlen(valstr));
	else if(!strcmp(track_key, "Album") && valstr != NULL)
		memcpy(track->album, valstr, strlen(valstr));
	else if(!strcmp(track_key, "Artist") && valstr != NULL)
		memcpy(track->artist, valstr, strlen(valstr));
	else if(!strcmp(track_key, "Genre") && valstr != NULL)
		memcpy(track->genre, valstr, strlen(valstr));
	else if(!strcmp(track_key, "TrackNumber"))
		sprintf(track->track_num, "%d", valu32);
	else if(!strcmp(track_key, "NumberOfTracks"))
		sprintf(track->num_tracks, "%d", valu32);
	else if(!strcmp(track_key, "Duration")) {
		sprintf(track->playing_time, "%d", valu32);
		current_song_len = valu32;
	}

	memset(track_key, 0, 256);
}

static void avrcp_get_track_info(BtTrackInfo *track, const char *name,
					 DBusMessageIter *iter)
{
	dbus_uint32_t valu32;
	const char *valstr;
	DBusMessageIter subiter;
	char *entry;

	switch (dbus_message_iter_get_arg_type(iter)) {
	case DBUS_TYPE_STRING:
		dbus_message_iter_get_basic(iter, &valstr);
		if(!strncmp(name, "Track Key", 9))
			memcpy(track_key, valstr, strlen(valstr));
		else if(!strncmp(name, "Track Value", 11))
			save_track_info(track, valstr, 0);
		break;
	case DBUS_TYPE_UINT32:
		dbus_message_iter_get_basic(iter, &valu32);
		if(!strncmp(name, "Track Value", 11))
			save_track_info(track, NULL, (unsigned int)valu32);
		break;
	case DBUS_TYPE_VARIANT:
		dbus_message_iter_recurse(iter, &subiter);
		avrcp_get_track_info(track, name, &subiter);
		break;
	case DBUS_TYPE_ARRAY:
		dbus_message_iter_recurse(iter, &subiter);
		while (dbus_message_iter_get_arg_type(&subiter) !=
							DBUS_TYPE_INVALID) {
			avrcp_get_track_info(track, name, &subiter);
			dbus_message_iter_next(&subiter);
		}
		break;
	case DBUS_TYPE_DICT_ENTRY:
		dbus_message_iter_recurse(iter, &subiter);
		entry = g_strconcat(name, " Key", NULL);
		avrcp_get_track_info(track, entry, &subiter);
		g_free(entry);

		entry = g_strconcat(name, " Value", NULL);
		dbus_message_iter_next(&subiter);
		avrcp_get_track_info(track, entry, &subiter);
		g_free(entry);
		break;
	}
}

static void avrcp_track_info_send(const char *name, DBusMessageIter *iter)
{
	char addr[18];
	DBusMessageIter addr_iter;
	BtTrackInfo track;

	if(strncmp(name, "Track", 5))
		return;

	memset(addr, 0, 18);
	bt_get_default_dev_addr(addr, 18);

	memset(track_key, 0, 256);
	memset(&track, 0, sizeof(BtTrackInfo));
	avrcp_get_track_info(&track, name, iter);

	if(g_avrcp_cb.avrcp_track_cb) {
		g_avrcp_cb.avrcp_track_cb(addr, track);
	}
}

static void avrcp_position_send(const char *name, DBusMessageIter *iter)
{
	dbus_uint32_t valu32;
	char addr[18];

	if(strncmp(name, "Position", 8))
		return;

	memset(addr, 0, 18);
	bt_get_default_dev_addr(addr, 18);

	dbus_message_iter_get_basic(iter, &valu32);

	if(g_avrcp_cb.avrcp_position_cb)
		g_avrcp_cb.avrcp_position_cb(addr, current_song_len, valu32);
}

static void avrcp_volume_send(const char *name, DBusMessageIter *iter)
{
	dbus_uint16_t valu16;

	if(strncmp(name, "Volume", 6))
		return;

	dbus_message_iter_get_basic(iter, &valu16);
	pr_info("Volume: 0x%2x\n", valu16);

	if(g_avrcp_cb.avrcp_volume_cb)
		g_avrcp_cb.avrcp_volume_cb(valu16);
}

void player_property_changed(GDBusProxy *proxy, const char *name,
					 DBusMessageIter *iter)
{
	char *str;

	str = proxy_description(proxy, "Player", COLORED_CHG);
	pr_info("player_property_changed: str: %s, name: %s\n", str, name);

	avrcp_track_info_send(name, iter);
	avrcp_position_send(name, iter);

	print_iter(str, name, iter);
	g_free(str);
}

void folder_property_changed(GDBusProxy *proxy, const char *name,
					 DBusMessageIter *iter)
{
	char *str;

	str = proxy_description(proxy, "Folder", COLORED_CHG);
	print_iter(str, name, iter);
	g_free(str);
}

void item_property_changed(GDBusProxy *proxy, const char *name,
					DBusMessageIter *iter)
{
	char *str;

	str = proxy_description(proxy, "Item", COLORED_CHG);
	print_iter(str, name, iter);
	g_free(str);
}

void transport_property_changed(GDBusProxy *proxy, const char *name,
					DBusMessageIter *iter)
{
	char *str;
	const char *valstr;

	str = proxy_description(proxy, "MediaTransport1", COLORED_CHG);

	if (!strncmp(name, "State", 5)) {
		dbus_message_iter_get_basic(iter, &valstr);
		if (strstr(valstr, "active"))
			bt_sink_state_send(RK_BT_A2DP_SINK_STARTED);
		else if (strstr(valstr, "idle"))
			bt_sink_state_send(RK_BT_A2DP_SINK_SUSPENDED);
	}

	avrcp_volume_send(name, iter);

	print_iter(str, name, iter);
	g_free(str);
}

void device_changed(GDBusProxy *proxy, DBusMessageIter *iter,
			   void *user_data)
{
	dbus_bool_t val;
	const char *object_path = g_dbus_proxy_get_path(proxy);

	dbus_message_iter_get_basic(iter, &val);

	pr_info("%s connect status changed to %s", object_path,
		val ? "TRUE" : "FALSE");
	if (val) {
		device_list = g_list_append(device_list, proxy);
		last_temp_connected_device_proxy = proxy;
	} else {
		/* Device has been stored when being connected */
		device_list = g_list_remove(device_list, proxy);
	}
}

void adapter_changed(GDBusProxy *proxy, DBusMessageIter *iter,
			   void *user_data)
{
	dbus_bool_t val;

	dbus_message_iter_get_basic(iter, &val);

	pr_info("Adapter powered changed to %s", val ? "TRUE" : "FALSE");
}

void a2dp_sink_property_changed(GDBusProxy *proxy, const char *name,
					 DBusMessageIter *iter, void *user_data)
{
	const char *interface;

	interface = g_dbus_proxy_get_interface(proxy);
	pr_info("BT SINK: property_changed %s\n", interface);

	if (!strcmp(interface, BLUEZ_MEDIA_PLAYER_INTERFACE))
		player_property_changed(proxy, name, iter);
	else if (!strcmp(interface, BLUEZ_MEDIA_FOLDER_INTERFACE))
		folder_property_changed(proxy, name, iter);
	else if (!strcmp(interface, BLUEZ_MEDIA_ITEM_INTERFACE))
		item_property_changed(proxy, name, iter);
	else if (!strcmp(interface, BLUEZ_MEDIA_TRANSPORT_INTERFACE))
		transport_property_changed(proxy, name, iter);
}

bool check_default_player(void)
{
	if (!default_player) {
		if (NULL != players) {
			GSList *l;
			l = players;
			GDBusProxy *proxy = (GDBusProxy *)l->data;
			default_player = proxy;
			pr_info("set default player\n");
			return TRUE;
		}
		pr_info("No default player available\n");
		return FALSE;
	}
	pr_info(" player ok\n");

	return TRUE;
}

gboolean option_version = FALSE;

GOptionEntry options[] = {
	{ "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
			 "Show version information and exit" },
	{ NULL },
};

int init_avrcp_ctrl(void)
{
	proxy_list = NULL;
	last_device_path = NULL;
	last_connected_device_proxy = NULL;
	device_list = NULL;
	reconnect_timer = 0;

	return 1;
}

void a2dp_sink_open(void)
{
	pr_info("call avrcp_thread init_avrcp\n");

	g_btsrc_connect_status = RK_BT_SINK_STATE_IDLE;

	system("hciconfig hci0 piscan");
	system("hciconfig hci0 piscan");
}

int release_avrcp_ctrl(void)
{
	pr_info("=== release_avrcp_ctrl ===\n");
	g_btsrc_connect_status = RK_BT_SINK_STATE_IDLE;
	system("hciconfig hci0 noscan");
	system("hciconfig hci0 noscan");
	return 0;
}

int release_avrcp_ctrl2(void)
{
	pr_info("=== release_avrcp_ctrl2 ===\n");
	g_btsrc_connect_status = RK_BT_SINK_STATE_IDLE;
	return 0;
}

void play_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
	  pr_info("Failed to play\n");
	  dbus_error_free(&error);
	  return;
	}

	pr_info("Play successful\n");
}

int play_avrcp(void)
{
	if (!check_default_player())
		return -1;
	if (g_dbus_proxy_method_call(default_player, "Play", NULL, play_reply,
				  NULL, NULL) == FALSE) {
		pr_info("Failed to play\n");
		return -1;
	}
	pr_info("Attempting to play\n");
	return 0;
}

void pause_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
		pr_info("Failed to pause: %s\n", __func__);
		dbus_error_free(&error);
		return;
	}

	pr_info("Pause successful\n");
}

int pause_avrcp(void)
{
	if (!check_default_player())
		return -1;
	if (g_dbus_proxy_method_call(default_player, "Pause", NULL,
					pause_reply, NULL, NULL) == FALSE) {
		pr_info("Failed to pause\n");
		return -1;
	}
	pr_info("Attempting to pause\n");
	return 0;
}

void volumedown_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
		pr_info("Failed to volume down\n");
		dbus_error_free(&error);
		return;
	}

	pr_info("volumedown successful\n");
}

void volumedown_avrcp(void)
{
	if (!check_default_player())
				return;
	if (g_dbus_proxy_method_call(default_player, "VolumeDown", NULL, volumedown_reply,
							NULL, NULL) == FALSE) {
		pr_info("Failed to volumeup\n");
		return;
	}
	pr_info("Attempting to volumeup\n");
}

void volumeup_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
		pr_info("Failed to volumeup\n");
		dbus_error_free(&error);
		return;
	}

	pr_info("volumeup successful\n");
}


void volumeup_avrcp()
{
	if (!check_default_player())
				return;
	if (g_dbus_proxy_method_call(default_player, "VolumeUp", NULL, volumeup_reply,
							NULL, NULL) == FALSE) {
		pr_info("Failed to volumeup\n");
		return;
	}
	pr_info("Attempting to volumeup\n");
}

void stop_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
		//rl_printf("Failed to stop: %s\n", error.name);
		dbus_error_free(&error);
		return;
	}

	pr_info("Stop successful\n");
}

int stop_avrcp()
{
	if (!check_default_player())
			return -1;
	if (g_dbus_proxy_method_call(default_player, "Stop", NULL, stop_reply,
							NULL, NULL) == FALSE) {
		pr_info("Failed to stop\n");
		return -1;
	}
	pr_info("Attempting to stop\n");

	return 0;
}

void next_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
		pr_info("Failed to jump to next\n");
		dbus_error_free(&error);
		return;
	}

	pr_info("Next successful\n");
}

int next_avrcp(void)
{
	{
		if (!check_default_player())
			return -1;
		if (g_dbus_proxy_method_call(default_player, "Next", NULL, next_reply,
								NULL, NULL) == FALSE) {
			pr_info("Failed to jump to next\n");
			return -1;
		}
		pr_info("Attempting to jump to next\n");
	}

	return 0;
}

void previous_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
		pr_info("Failed to jump to previous\n");
		dbus_error_free(&error);
		return;
	}

	pr_info("Previous successful\n");
}

int previous_avrcp(void)
{

	if (!check_default_player())
		return -1;
	if (g_dbus_proxy_method_call(default_player, "Previous", NULL,
					previous_reply, NULL, NULL) == FALSE) {
		pr_info("Failed to jump to previous\n");
		return -1;
	}
	pr_info("Attempting to jump to previous\n");

	return 0;
}

void fast_forward_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
		pr_info("Failed to fast forward\n");
		dbus_error_free(&error);
		return;
	}

	pr_info("FastForward successful\n");
}

void fast_forward_avrcp() {
	{
		if (!check_default_player())
				return;
		if (g_dbus_proxy_method_call(default_player, "FastForward", NULL,
					fast_forward_reply, NULL, NULL) == FALSE) {
			pr_info("Failed to jump to previous\n");
			return;
		}
		pr_info("Fast forward playback\n");
	}
}

void rewind_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
		pr_info("Failed to rewind\n");
		dbus_error_free(&error);
		return;
	}

	pr_info("Rewind successful\n");
}

void rewind_avrcp(){
	{
		if (!check_default_player())
				return;
		if (g_dbus_proxy_method_call(default_player, "Rewind", NULL,
						rewind_reply, NULL, NULL) == FALSE) {
			pr_info("Failed to rewind\n");
			return;
		}
		pr_info("Rewind playback\n");
	}
}

int getstatus_avrcp(void)
{
	GDBusProxy *proxy;
	DBusMessageIter iter;
	const char *valstr;
	if (check_default_player() == FALSE)
		return AVRCP_PLAY_STATUS_ERROR; //default player no find
	proxy = default_player;
	if (g_dbus_proxy_get_property(proxy, "Status", &iter) == FALSE)
			return AVRCP_PLAY_STATUS_ERROR; //unkonw status
	dbus_message_iter_get_basic(&iter, &valstr);
	//pr_info("----getstatus_avrcp,rtl wifi,return %s--\n",valstr);
	if (!strcasecmp(valstr, "stopped"))
		return AVRCP_PLAY_STATUS_STOPPED;
	else if (!strcasecmp(valstr, "playing"))
		return AVRCP_PLAY_STATUS_PLAYING;
	else if (!strcasecmp(valstr, "paused"))
		return AVRCP_PLAY_STATUS_PAUSED;
	else if (!strcasecmp(valstr, "forward-seek"))
		return AVRCP_PLAY_STATUS_FWD_SEEK;
	else if (!strcasecmp(valstr, "reverse-seek"))
		return AVRCP_PLAY_STATUS_REV_SEEK;
	else if (!strcasecmp(valstr, "error"))
		return AVRCP_PLAY_STATUS_ERROR;

	return AVRCP_PLAY_STATUS_ERROR;
}

void get_play_status_reply(DBusMessage *message, void *user_data)
{
	DBusError error;

	dbus_error_init(&error);

	if (dbus_set_error_from_message(&error, message) == TRUE) {
		pr_info("Failed to GetPlayStatus\n");
		dbus_error_free(&error);
		return;
	}

	pr_info("GetPlayStatus successful\n");
}

int get_play_status_avrcp()
{
	if (!check_default_player())
		return -1;

	if (g_dbus_proxy_method_call(default_player, "GetPlayStatus", NULL,
					get_play_status_reply, NULL, NULL) == FALSE) {
		pr_info("Failed to GetPlayStatus\n");
		return -1;
	}

	pr_info("GetPlayStatus playback\n");
	return 0;
}

bool get_poschange_avrcp()
{
	DBusMessageIter iter;
	dbus_bool_t pos_change = FALSE;

	if (check_default_player() == FALSE)
		return FALSE;

	if (g_dbus_proxy_get_property(default_player, "PosChange", &iter) == FALSE) {
		pr_info("Failed to get PosChange\n");
		return FALSE;
	}

	dbus_message_iter_get_basic(&iter, &pos_change);
	return pos_change;
}

void a2dp_sink_register_cb(RK_BT_SINK_CALLBACK cb)
{
	g_avrcp_cb.avrcp_sink_cb = cb;
}

void a2dp_sink_register_track_cb(RK_BT_AVRCP_TRACK_CHANGE_CB cb)
{
	g_avrcp_cb.avrcp_track_cb = cb;
}

void a2dp_sink_register_position_cb(RK_BT_AVRCP_PLAY_POSITION_CB cb)
{
	g_avrcp_cb.avrcp_position_cb = cb;
}

void a2dp_sink_register_volume_cb(RK_BT_SINK_VOLUME_CALLBACK cb)
{
	g_avrcp_cb.avrcp_volume_cb = cb;
}

void a2dp_sink_clear_cb()
{
	g_avrcp_cb.avrcp_sink_cb = NULL;
	g_avrcp_cb.avrcp_track_cb = NULL;
	g_avrcp_cb.avrcp_position_cb = NULL;
	g_avrcp_cb.avrcp_volume_cb = NULL;
}

int a2dp_sink_status(RK_BT_SINK_STATE *pState)
{
	int avrcp_status;

	if (!pState)
		return -1;

	avrcp_status = getstatus_avrcp();
	switch (avrcp_status) {
		case AVRCP_PLAY_STATUS_STOPPED:
			*pState = RK_BT_SINK_STATE_STOP;
			break;
		case AVRCP_PLAY_STATUS_REV_SEEK:
		case AVRCP_PLAY_STATUS_FWD_SEEK:
		case AVRCP_PLAY_STATUS_PLAYING:
			*pState = RK_BT_SINK_STATE_PLAY;
			break;
		case AVRCP_PLAY_STATUS_PAUSED:
			*pState = RK_BT_SINK_STATE_PAUSE;
			break;
		default:
			if (g_btsrc_connect_status == RK_BT_SINK_STATE_CONNECT)
				*pState = RK_BT_SINK_STATE_CONNECT;
			else
				*pState = RK_BT_SINK_STATE_IDLE;
			break;
	}

	return 0;
}