/*
 *
 *  BlueZ - Bluetooth protocol stack for Linux
 *
 *  Copyright (C) 2014  Instituto Nokia de Tecnologia - INdT
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <arpa/inet.h>
#include <sys/signalfd.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <time.h>
#include <pthread.h>

#include <glib.h>
#include <dbus/dbus.h>
#include <RkBtBase.h>

#include "error.h"
#include "gdbus/gdbus.h"
#include "gatt_config.h"
#include "slog.h"

#define GATT_MGR_IFACE				"org.bluez.GattManager1"
#define GATT_SERVICE_IFACE			"org.bluez.GattService1"
#define GATT_CHR_IFACE				"org.bluez.GattCharacteristic1"
#define GATT_DESCRIPTOR_IFACE		"org.bluez.GattDescriptor1"

static char reconnect_path[66];
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
static volatile bool g_dis_adv_close_ble = false;
#define min(x, y) ((x) < (y) ? (x) : (y))

#define AD_FLAGS						0x1
#define AD_COMPLETE_128_SERVICE_UUID	0x7
#define AD_COMPLETE_LOCAL_NAME			0x9

typedef struct {
	uint8_t data[16];
} uuid128_t;

typedef struct {
	uint8_t data[6];
} mac_t;

struct AdvDataContent {
	uint8_t adv_length;
	uint8_t flag_length;
	uint8_t flag;
	uint8_t flag_value;
	uint8_t service_uuid_length;
	uint8_t service_uuid_flag;
	uuid128_t service_uuid_value;
};

struct AdvRespDataContent {
	uint8_t adv_resp_length;
	uint8_t local_name_length;
	uint8_t local_name_flag;
	uint8_t local_name_value[29];
};

#define GATT_MAX_CHR 10
#define MAX_UUID_LEN 38
typedef struct BLE_CONTENT_T
{
	uint8_t advData[MXA_ADV_DATA_LEN];
	uint8_t advDataLen;
	uint8_t respData[MXA_ADV_DATA_LEN];
	uint8_t respDataLen;
	uint8_t server_uuid[MAX_UUID_LEN];
	uint8_t char_uuid[GATT_MAX_CHR][MAX_UUID_LEN];
	uint8_t char_cnt;
	void (*cb_ble_recv_fun)(const char *uuid, char *data, int len);
	void (*cb_ble_request_data)(const char *uuid);
} ble_content_t;

ble_content_t *ble_content_internal = NULL;
ble_content_t ble_content_internal_bak;
static int gid = 0;
static int gdesc_id = 0;
static int characteristic_id = 1;
static int service_id = 1;
static bool gatt_is_stopping = false;

static char g_cmd_ra[256];
static char g_cmd_para[256];

#define CMD_RA           "hcitool -i hci0 cmd 0x08 0x0005"

//first A0 00(0xA0): min interval, 0xA0 * 0.625ms, second A0 00(0xA0): max interval, 0xA0 * 0.625ms
#define CMD_PARA         "hcitool -i hci0 cmd 0x08 0x0006 A0 00 A0 00 00 01 00 00 00 00 00 00 00 07 00"
//#define CMD_PARA         "hcitool -i hci0 cmd 0x08 0x0006 A0 00 A0 00 00 02 00 00 00 00 00 00 00 07 00"

#define SERVICES_UUID    "23 20 56 7c 05 cf 6e b4 c3 41 77 28 51 82 7e 1b"
#define CMD_EN           "hcitool -i hci0 cmd 0x08 0x000a 1"
#define CMD_DISEN        "hcitool -i hci0 cmd 0x08 0x000a 0"

static GDBusProxy *ble_proxy = NULL;

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

extern GDBusProxy *ble_dev;
extern struct adapter *default_ctrl;
extern DBusConnection *dbus_conn;

struct characteristic {
	char *service;
	char *uuid;
	char *path;
	uint8_t *value;
	int vlen;
	const char **props;
};

struct characteristic *gchr[GATT_MAX_CHR];
struct descriptor *gdesc[GATT_MAX_CHR];
char *gservice_path = NULL;

struct descriptor {
	struct characteristic *chr;
	char *uuid;
	char *path;
	uint8_t *value;
	int vlen;
	const char **props;
};

int gatt_set_on_adv(void);

/*
 * Supported properties are defined at doc/gatt-api.txt. See "Flags"
 * property of the GattCharacteristic1.
 */
static const char *ias_alert_level_props[] = { "read", "write", NULL };
static const char *chr_props[] = { "read", "write", "notify", "indicate", "write-without-response", NULL };
static const char *desc_props[] = { "read", "write", NULL };

static void chr_write(struct characteristic *chr, const uint8_t *value, int len);
static void chr_iface_destroy(gpointer user_data);

static gboolean desc_get_uuid(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *user_data)
{
	struct descriptor *desc = user_data;

	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &desc->uuid);

	return TRUE;
}

static gboolean desc_get_characteristic(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *user_data)
{
	struct descriptor *desc = user_data;

	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
						&desc->chr->path);

	return TRUE;
}

static bool desc_read(struct descriptor *desc, DBusMessageIter *iter)
{
	DBusMessageIter array;

	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
					DBUS_TYPE_BYTE_AS_STRING, &array);

	if (desc->vlen && desc->value)
		dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
						&desc->value, desc->vlen);

	dbus_message_iter_close_container(iter, &array);

	return true;
}

static gboolean desc_get_value(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *user_data)
{
	struct descriptor *desc = user_data;

	pr_info("Descriptor(%s): Get(\"Value\")\n", desc->uuid);

	return desc_read(desc, iter);
}

static void desc_write(struct descriptor *desc, const uint8_t *value, int len)
{
	g_free(desc->value);
	desc->value = g_memdup(value, len);
	desc->vlen = len;

	g_dbus_emit_property_changed(dbus_conn, desc->path,
					GATT_DESCRIPTOR_IFACE, "Value");
}

static int parse_value(DBusMessageIter *iter, const uint8_t **value, int *len)
{
	DBusMessageIter array;

	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
		return -EINVAL;

	dbus_message_iter_recurse(iter, &array);
	dbus_message_iter_get_fixed_array(&array, value, len);

	return 0;
}

static void desc_set_value(const GDBusPropertyTable *property,
				DBusMessageIter *iter,
				GDBusPendingPropertySet id, void *user_data)
{
	struct descriptor *desc = user_data;
	const uint8_t *value;
	int len;

	pr_info("Descriptor(%s): Set(\"Value\", ...)\n", desc->uuid);

	if (parse_value(iter, &value, &len)) {
		pr_info("Invalid value for Set('Value'...)\n");
		g_dbus_pending_property_error(id,
					ERROR_INTERFACE ".InvalidArguments",
					"Invalid arguments in method call");
		return;
	}

	desc_write(desc, value, len);

	g_dbus_pending_property_success(id);
}

static gboolean desc_get_props(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *data)
{
	struct descriptor *desc = data;
	DBusMessageIter array;
	int i;

	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
					DBUS_TYPE_STRING_AS_STRING, &array);

	for (i = 0; desc->props[i]; i++)
		dbus_message_iter_append_basic(&array,
					DBUS_TYPE_STRING, &desc->props[i]);

	dbus_message_iter_close_container(iter, &array);

	return TRUE;
}

static const GDBusPropertyTable desc_properties[] = {
	{ "UUID",		"s", desc_get_uuid },
	{ "Characteristic",	"o", desc_get_characteristic },
	{ "Value",		"ay", desc_get_value, desc_set_value, NULL },
	{ "Flags",		"as", desc_get_props, NULL, NULL },
	{ }
};

static gboolean chr_get_uuid(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *user_data)
{
	struct characteristic *chr = user_data;

	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &chr->uuid);

	return TRUE;
}

static gboolean chr_get_service(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *user_data)
{
	struct characteristic *chr = user_data;

	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
							&chr->service);

	return TRUE;
}

static bool chr_read(struct characteristic *chr, DBusMessageIter *iter)
{
	DBusMessageIter array;

	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
					DBUS_TYPE_BYTE_AS_STRING, &array);

	dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
						&chr->value, chr->vlen);

	dbus_message_iter_close_container(iter, &array);

	return true;
}

static gboolean chr_get_value(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *user_data)
{
	struct characteristic *chr = user_data;

	pr_info("Characteristic(%s): Get(\"Value\")\n", chr->uuid);

	return chr_read(chr, iter);
}

static gboolean chr_get_props(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *data)
{
	struct characteristic *chr = data;
	DBusMessageIter array;
	int i;

	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
					DBUS_TYPE_STRING_AS_STRING, &array);

	for (i = 0; chr->props[i]; i++)
		dbus_message_iter_append_basic(&array,
					DBUS_TYPE_STRING, &chr->props[i]);

	dbus_message_iter_close_container(iter, &array);

	return TRUE;
}

static void chr_write(struct characteristic *chr, const uint8_t *value, int len)
{
	g_free(chr->value);
	chr->value = g_memdup(value, len);
	chr->vlen = len;

	g_dbus_emit_property_changed(dbus_conn, chr->path, GATT_CHR_IFACE,
								"Value");
}

static void chr_set_value(const GDBusPropertyTable *property,
				DBusMessageIter *iter,
				GDBusPendingPropertySet id, void *user_data)
{
	struct characteristic *chr = user_data;
	const uint8_t *value;
	int len;

	pr_info("Characteristic(%s): Set('Value', ...)\n", chr->uuid);

	if (!parse_value(iter, &value, &len)) {
		pr_info("Invalid value for Set('Value'...)\n");
		g_dbus_pending_property_error(id,
					ERROR_INTERFACE ".InvalidArguments",
					"Invalid arguments in method call");
		return;
	}

	chr_write(chr, value, len);

	g_dbus_pending_property_success(id);
}

static const GDBusPropertyTable chr_properties[] = {
	{ "UUID",	"s", chr_get_uuid },
	{ "Service",	"o", chr_get_service },
	{ "Value",	"ay", chr_get_value, chr_set_value, NULL },
	{ "Flags",	"as", chr_get_props, NULL, NULL },
	{ }
};

static gboolean service_get_primary(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *user_data)
{
	dbus_bool_t primary = TRUE;

	pr_info("Get Primary: %s\n", primary ? "True" : "False");

	dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &primary);

	return TRUE;
}

static gboolean service_get_uuid(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *user_data)
{
	const char *uuid = user_data;

	pr_info("Get UUID: %s\n", uuid);

	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid);

	return TRUE;
}

static const GDBusPropertyTable service_properties[] = {
	{ "Primary", "b", service_get_primary },
	{ "UUID", "s", service_get_uuid },
	{ }
};

static void chr_iface_destroy(gpointer user_data)
{
	struct characteristic *chr = user_data;

	pr_info("== %s ==\n", __func__);
	g_free(chr->uuid);
	g_free(chr->service);
	g_free(chr->value);
	g_free(chr->path);
	g_free(chr);
}

static void desc_iface_destroy(gpointer user_data)
{
	struct descriptor *desc = user_data;

	pr_info("== %s ==\n", __func__);
	g_free(desc->uuid);
	g_free(desc->value);
	g_free(desc->path);
	g_free(desc);
}

static int parse_options(DBusMessageIter *iter, const char **device)
{
	DBusMessageIter dict;

	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
		return -EINVAL;

	dbus_message_iter_recurse(iter, &dict);

	while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
		const char *key;
		DBusMessageIter value, entry;
		int var;

		dbus_message_iter_recurse(&dict, &entry);
		dbus_message_iter_get_basic(&entry, &key);

		dbus_message_iter_next(&entry);
		dbus_message_iter_recurse(&entry, &value);

		var = dbus_message_iter_get_arg_type(&value);
		if (strcasecmp(key, "device") == 0) {
			if (var != DBUS_TYPE_OBJECT_PATH)
				return -EINVAL;
			dbus_message_iter_get_basic(&value, device);
			pr_info("Device: %s\n", *device);
		}

		dbus_message_iter_next(&dict);
	}

	return 0;
}

static void execute(const char cmdline[], char recv_buff[], int len)
{
	//pr_info("[GATT_CONFIG] execute: %s\n", cmdline);

	FILE *stream = NULL;
	char *tmp_buff = recv_buff;

	memset(recv_buff, 0, len);

	if ((stream = popen(cmdline, "r")) != NULL) {
		while (fgets(tmp_buff, len, stream)) {
			//pr_info("tmp_buf[%d]: %s\n", strlen(tmp_buff), tmp_buff);
			tmp_buff += strlen(tmp_buff);
			len -= strlen(tmp_buff);
			if (len <= 1)
				break;
		}
		//pr_info("[GATT_CONFIG] execute_r: %s \n", recv_buff);
		pclose(stream);
	}
}

static DBusMessage *chr_read_value(DBusConnection *conn, DBusMessage *msg,
							void *user_data)
{
	struct characteristic *chr = user_data;
	DBusMessage *reply;
	DBusMessageIter iter;
	const char *device;
	pr_info("=== chr_read_value enter ===\n");

	if (!dbus_message_iter_init(msg, &iter))
		return g_dbus_create_error(msg, DBUS_ERROR_INVALID_ARGS,
							"Invalid arguments");

	if (parse_options(&iter, &device))
		return g_dbus_create_error(msg, DBUS_ERROR_INVALID_ARGS,
							"Invalid arguments");

	reply = dbus_message_new_method_return(msg);
	if (!reply)
		return g_dbus_create_error(msg, DBUS_ERROR_NO_MEMORY,
							"No Memory");

	dbus_message_iter_init_append(reply, &iter);

	//an empty response
	chr->vlen = 0;
	chr_read(chr, &iter);

	if(ble_content_internal->cb_ble_request_data)
		ble_content_internal->cb_ble_request_data(chr->uuid);

	pr_info("=== chr_read_value exit ===\n");
	return reply;
}

static DBusMessage *chr_write_value(DBusConnection *conn, DBusMessage *msg,
							void *user_data)
{
	pr_info("=== chr_write_value enter ===\n");
	struct characteristic *chr = user_data;
	DBusMessageIter iter;
	const uint8_t *value;
	int len;
	const char *device;

	dbus_message_iter_init(msg, &iter);

	if (parse_value(&iter, &value, &len))
		return g_dbus_create_error(msg, DBUS_ERROR_INVALID_ARGS,
							"Invalid arguments");

	if (parse_options(&iter, &device))
		return g_dbus_create_error(msg, DBUS_ERROR_INVALID_ARGS,
							"Invalid arguments");

	chr_write(chr, value, len);
	if(len == 0 || chr->value == NULL) {
		pr_info("chr_write_value is null\n");
		return dbus_message_new_method_return(msg);
	}

	if (ble_content_internal->cb_ble_recv_fun) {
		ble_content_internal->cb_ble_recv_fun(chr->uuid, (char *)chr->value, len);
	} else {
		pr_info("cb_ble_recv_fun is null !!! \n");
	}

	pr_info("=== chr_write_value exit ===\n");
	return dbus_message_new_method_return(msg);
}

static DBusMessage *chr_start_notify(DBusConnection *conn, DBusMessage *msg,
							void *user_data)
{
	return g_dbus_create_error(msg, DBUS_ERROR_NOT_SUPPORTED,
							"Not Supported");
}

static DBusMessage *chr_stop_notify(DBusConnection *conn, DBusMessage *msg,
							void *user_data)
{
	return g_dbus_create_error(msg, DBUS_ERROR_NOT_SUPPORTED,
							"Not Supported");
}

static const GDBusMethodTable chr_methods[] = {
	{ GDBUS_ASYNC_METHOD("ReadValue", GDBUS_ARGS({ "options", "a{sv}" }),
					GDBUS_ARGS({ "value", "ay" }),
					chr_read_value) },
	{ GDBUS_ASYNC_METHOD("WriteValue", GDBUS_ARGS({ "value", "ay" },
						{ "options", "a{sv}" }),
					NULL, chr_write_value) },
	{ GDBUS_ASYNC_METHOD("StartNotify", NULL, NULL, chr_start_notify) },
	{ GDBUS_METHOD("StopNotify", NULL, NULL, chr_stop_notify) },
	{ }
};

static DBusMessage *desc_read_value(DBusConnection *conn, DBusMessage *msg,
							void *user_data)
{
	struct descriptor *desc = user_data;
	DBusMessage *reply;
	DBusMessageIter iter;
	const char *device;

	if (!dbus_message_iter_init(msg, &iter))
		return g_dbus_create_error(msg, DBUS_ERROR_INVALID_ARGS,
							"Invalid arguments");

	if (parse_options(&iter, &device))
		return g_dbus_create_error(msg, DBUS_ERROR_INVALID_ARGS,
							"Invalid arguments");

	reply = dbus_message_new_method_return(msg);
	if (!reply)
		return g_dbus_create_error(msg, DBUS_ERROR_NO_MEMORY,
							"No Memory");

	dbus_message_iter_init_append(reply, &iter);

	desc_read(desc, &iter);

	return reply;
}

static DBusMessage *desc_write_value(DBusConnection *conn, DBusMessage *msg,
							void *user_data)
{
	struct descriptor *desc = user_data;
	DBusMessageIter iter;
	const char *device;
	const uint8_t *value;
	int len;

	if (!dbus_message_iter_init(msg, &iter))
		return g_dbus_create_error(msg, DBUS_ERROR_INVALID_ARGS,
							"Invalid arguments");

	if (parse_value(&iter, &value, &len))
		return g_dbus_create_error(msg, DBUS_ERROR_INVALID_ARGS,
							"Invalid arguments");

	if (parse_options(&iter, &device))
		return g_dbus_create_error(msg, DBUS_ERROR_INVALID_ARGS,
							"Invalid arguments");

	desc_write(desc, value, len);

	return dbus_message_new_method_return(msg);
}

static const GDBusMethodTable desc_methods[] = {
	{ GDBUS_ASYNC_METHOD("ReadValue", GDBUS_ARGS({ "options", "a{sv}" }),
					GDBUS_ARGS({ "value", "ay" }),
					desc_read_value) },
	{ GDBUS_ASYNC_METHOD("WriteValue", GDBUS_ARGS({ "value", "ay" },
						{ "options", "a{sv}" }),
					NULL, desc_write_value) },
	{ }
};

static gboolean unregister_ble(void)
{
	int i;

	for (i = 0; i < gdesc_id; i++) {
		pr_info("%s: desc_uuid[%d]: %s, gdesc[%d]->path: %s\n", __func__, i, gdesc[i]->uuid, i, gdesc[i]->path);
		g_dbus_unregister_interface(dbus_conn, gdesc[i]->path, GATT_DESCRIPTOR_IFACE);
	}

	for (i = 0; i < gid; i++) {
		pr_info("%s: char_uuid[%d]: %s, gchr[%d]->path: %s\n", __func__, i, ble_content_internal->char_uuid[i], i, gchr[i]->path);
		g_dbus_unregister_interface(dbus_conn, gchr[i]->path, GATT_CHR_IFACE);
	}

	pr_info("%s: gservice_path: %s\n", __func__, gservice_path);
	g_dbus_unregister_interface(dbus_conn, gservice_path, GATT_SERVICE_IFACE);

	return TRUE;
}

static gboolean register_characteristic(const char *chr_uuid,
						const uint8_t *value, int vlen,
						const char **props,
						const char *desc_uuid,
						const char **desc_props,
						const char *service_path)
{
	struct characteristic *chr;
	struct descriptor *desc;

	chr = g_new0(struct characteristic, 1);
	chr->uuid = g_strdup(chr_uuid);
	chr->value = g_memdup(value, vlen);
	chr->vlen = vlen;
	chr->props = props;
	chr->service = g_strdup(service_path);
	chr->path = g_strdup_printf("%s/characteristic%d", service_path, characteristic_id++);
	pr_info("register_characteristic chr->uuid: %s, chr->path: %s\n", chr->uuid, chr->path);
	if (!g_dbus_register_interface(dbus_conn, chr->path, GATT_CHR_IFACE,
					chr_methods, NULL, chr_properties,
					chr, chr_iface_destroy)) {
		pr_info("Couldn't register characteristic interface\n");
		chr_iface_destroy(chr);
		return FALSE;
	}

	gchr[gid++] = chr;

	if (!desc_uuid)
		return TRUE;

	desc = g_new0(struct descriptor, 1);
	desc->uuid = g_strdup(desc_uuid);
	desc->chr = chr;
	desc->props = desc_props;
	desc->path = g_strdup_printf("%s/descriptor%d", chr->path, characteristic_id++);

	if (!g_dbus_register_interface(dbus_conn, desc->path,
					GATT_DESCRIPTOR_IFACE,
					desc_methods, NULL, desc_properties,
					desc, desc_iface_destroy)) {
		pr_info("Couldn't register descriptor interface\n");
		g_dbus_unregister_interface(dbus_conn, chr->path,
							GATT_CHR_IFACE);

		desc_iface_destroy(desc);
		return FALSE;
	}

	gdesc[gdesc_id++] = desc;
	return TRUE;
}

static char *register_service(const char *uuid)
{
	static int id = 1;
	char *path;

	path = g_strdup_printf("/service%d", service_id++);
	if (!g_dbus_register_interface(dbus_conn, path, GATT_SERVICE_IFACE,
				NULL, NULL, service_properties,
				g_strdup(uuid), g_free)) {
		pr_info("Couldn't register service interface\n");
		g_free(path);
		return NULL;
	}

	return path;
}

static void gatt_create_services(void)
{
	char *service_path;
	uint8_t level = ' ';
	int i;

	pr_info("server_uuid: %s\n", ble_content_internal->server_uuid);
	service_path = register_service(ble_content_internal->server_uuid);
	if (!service_path)
		return;

	gservice_path = service_path;

	for (i = 0; i < ble_content_internal->char_cnt; i++) {
		pr_info("char_uuid[%d]: %s\n", i, ble_content_internal->char_uuid[i]);
		gboolean mcharacteristic = register_characteristic(ble_content_internal->char_uuid[i],
							&level, sizeof(level),
							chr_props,
							NULL,
							desc_props,
							service_path);
		/* Add Alert Level Characteristic to Immediate Alert Service */
		if (!mcharacteristic) {
			pr_info("Couldn't register characteristic.\n");
			g_dbus_unregister_interface(dbus_conn, service_path,
								GATT_SERVICE_IFACE);
			g_free(service_path);
			return;
		}
	}

	pr_info("Registered service: %s\n", service_path);
}

int gatt_write_data(char *uuid, void *data, int len)
{
	int i;
	struct characteristic *chr;

	if (!ble_dev) {
		pr_info("gatt_write_data: ble not connect!\n");
		return 0;
	}

	pr_info("gatt_write uuid: %s, len: [%d], data[%p]: %s\n", uuid, len, data, (char *)data);

	if (!gchr[0])
		while(1);

	for (i = 0; i < gid; i++) {
		pr_info("gatt_write[%d] uuid: %s\n", i, gchr[i]->uuid);
		if (strcmp(gchr[i]->uuid, uuid) == 0) {
			chr = gchr[i];
			break;
		}
	}

	if (chr == NULL) {
		pr_info("gatt_write invaild uuid: %s.\n", uuid);
		return -1;
	}

	chr_write(chr, data, len);
	return 0;
}

int ble_enable_adv(void)
{
	char ret_buff[1024];

	if(gatt_set_on_adv() < 0) {
		pr_err("%s: gatt_set_on_adv failed\n", __func__);
		return -1;
	}

	execute(CMD_EN, ret_buff, 1024);
	return 0;
}

void ble_disable_adv(void)
{
	char ret_buff[1024];

	pr_info("=== ble_disable_adv ===\n");
	//g_dis_adv_close_ble = true;
	execute(CMD_DISEN, ret_buff, 1024);
	execute(CMD_DISEN, ret_buff, 1024);
}

int gatt_set_on_adv(void)
{
	char ret_buff[1024];
	char CMD_ADV_DATA[128] = "hcitool -i hci0 cmd 0x08 0x0008";
	char CMD_ADV_RESP_DATA[128] = "hcitool -i hci0 cmd 0x08 0x0009";
	char temp[32];
	int i;

	if(gatt_is_stopping) {
		pr_info("%s: ble is stopping\n", __func__);
		return -1;
	}

	if(!ble_content_internal) {
		pr_err("%s: ble_content_internal is NULL\n", __func__);
		return -1;
	}

	if (ble_content_internal->advDataLen <= 0) {
		pr_err("%s: invalid advDataLen = %d\n", __func__, ble_content_internal->advDataLen);
		return -1;
	}

	//LE Set Random Address Command
	execute(g_cmd_ra, ret_buff, 1024);
	pr_info("CMD_RA buff: %s", ret_buff);
	sleep(1);
	//LE SET PARAMETERS
	execute(g_cmd_para, ret_buff, 1024);
	pr_info("CMD_PARA buff: %s", ret_buff);

	// LE Set Advertising Data Command
	memset(temp, 0, 32);
	for(i = 0; i < ble_content_internal->advDataLen; i++) {
		sprintf(temp,"%02x", ble_content_internal->advData[i]);
		strcat(CMD_ADV_DATA, " ");
		strcat(CMD_ADV_DATA, temp);
	}
	pr_info("CMD_ADV_DATA: %s\n", CMD_ADV_DATA);
	execute(CMD_ADV_DATA, ret_buff, 1024);

	if(ble_content_internal->respDataLen > 0) {
		memset(temp, 0, 32);
		for (i = 0; i < ble_content_internal->respDataLen; i++) {
			sprintf(temp, "%02x", ble_content_internal->respData[i]);
			strcat(CMD_ADV_RESP_DATA, " ");
			strcat(CMD_ADV_RESP_DATA, temp);
		}
		usleep(500000);
		pr_info("CMD_ADV_RESP_DATA: %s\n", CMD_ADV_RESP_DATA);
		execute(CMD_ADV_RESP_DATA, ret_buff, 1024);
	}

	// LE Set Advertise Enable Command
	execute(CMD_EN, ret_buff, 1024);
	return 0;
}

static void register_app_reply(DBusMessage *reply, void *user_data)
{
	DBusError derr;

	dbus_error_init(&derr);
	dbus_set_error_from_message(&derr, reply);

	if (dbus_error_is_set(&derr))
		pr_info("RegisterApplication: %s\n", derr.message);
	else
		pr_info("RegisterApplication: OK\n");

	//send_advertise();
	//gatt_set_on_adv();

	dbus_error_free(&derr);
}

static void register_app_setup(DBusMessageIter *iter, void *user_data)
{
	const char *path = "/";
	DBusMessageIter dict;

	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);

	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, "{sv}", &dict);

	/* TODO: Add options dictionary */

	dbus_message_iter_close_container(iter, &dict);
}

void register_app(GDBusProxy *proxy)
{
	ble_proxy = proxy;

	if (!g_dbus_proxy_method_call(proxy, "RegisterApplication",
					register_app_setup, register_app_reply,
					NULL, NULL)) {
		pr_info("Unable to call RegisterApplication\n");
		return;
	}
}

static void unregister_app_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 unregister application: %s\n",
				error.name);
		dbus_error_free(&error);
		return;
	}

	pr_info("%s: Application unregistered\n", __func__);
}

static void unregister_app_setup(DBusMessageIter *iter, void *user_data)
{
	const char *path = "/";

	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
}

void unregister_app(GDBusProxy *proxy)
{
	if (g_dbus_proxy_method_call(proxy, "UnregisterApplication",
						unregister_app_setup,
						unregister_app_reply, NULL,
						NULL) == FALSE) {
		pr_info("Failed unregister profile\n");
		return;
	}
}

int gatt_setup(void)
{
	pr_info("gatt_setup\n");
	gatt_create_services();
	register_app(ble_proxy);

	return 1;
}

void gatt_cleanup(void)
{
	if(ble_content_internal) {
		unregister_ble();
		ble_content_internal = NULL;
	}

	if(gservice_path) {
		g_free(gservice_path);
		gservice_path = NULL;
	}
}

#define HOSTNAME_MAX_LEN	250	/* 255 - 3 (FQDN) - 2 (DNS enc) */
static void bt_gethostname(char *hostname_buf)
{
	char hostname[HOSTNAME_MAX_LEN + 1];
	size_t buf_len;

	buf_len = sizeof(hostname);
	if (gethostname(hostname, buf_len) != 0)
		pr_info("gethostname error !!!!!!!!\n");
	hostname[buf_len - 1] = '\0';

	/* Deny sending of these local hostnames */
	if (hostname[0] == '\0' || hostname[0] == '.' || strcmp(hostname, "(none)") == 0)
		pr_info("gethostname format error !!!\n");
	else
		pr_info("gethostname: %s, len: %d \n", hostname, strlen(hostname));

	strcpy(hostname_buf, hostname);
}

static int bt_string_to_uuid128(uuid128_t *uuid, const char *string, int rever)
{
	uint32_t data0, data4;
	uint16_t data1, data2, data3, data5;
	uuid128_t u128;
	uint8_t *val = (uint8_t *) &u128;
	uint8_t tmp[16];

	if (sscanf(string, "%08x-%04hx-%04hx-%04hx-%08x%04hx",
				&data0, &data1, &data2,
				&data3, &data4, &data5) != 6)
		return -EINVAL;

	data0 = htonl(data0);
	data1 = htons(data1);
	data2 = htons(data2);
	data3 = htons(data3);
	data4 = htonl(data4);
	data5 = htons(data5);

	memcpy(&val[0], &data0, 4);
	memcpy(&val[4], &data1, 2);
	memcpy(&val[6], &data2, 2);
	memcpy(&val[8], &data3, 2);
	memcpy(&val[10], &data4, 4);
	memcpy(&val[14], &data5, 2);

	if (rever) {
		memcpy(tmp, val, 16);
		pr_info("UUID: ");
		for (int i = 0; i < 16; i++) {
			val[15 - i] = tmp[i];
			pr_info("0x%x ", tmp[i]);
		}
		pr_info("\n");
	}

	memset(uuid, 0, sizeof(uuid128_t));
	memcpy(uuid, &u128, sizeof(uuid128_t));
	return 0;
}

static int ble_adv_set(RkBtContent *bt_content, ble_content_t *ble_content)
{
	char hostname[HOSTNAME_MAX_LEN + 1];
	int i, name_len, uuid_len;
	struct AdvDataContent advdata;
	struct AdvRespDataContent advdataresp;
	uuid128_t uuid;

	if (bt_content->ble_content.advDataType == BLE_ADVDATA_TYPE_USER) {
		if (bt_content->ble_content.advDataLen <= 0) {
			pr_info("ERROR:Under the premise that advDataType is BLE_ADVDATA_TYPE_USER,"
				"the user must set the correct advData");
			return -1;
		}

		memcpy(ble_content->advData, bt_content->ble_content.advData, MXA_ADV_DATA_LEN);
		ble_content->advDataLen = bt_content->ble_content.advDataLen;
		if (bt_content->ble_content.respDataLen > 0) {
			memcpy(ble_content->respData, bt_content->ble_content.respData, MXA_ADV_DATA_LEN);
			ble_content->respDataLen = bt_content->ble_content.respDataLen;
		}
	} else {
		advdata.adv_length = 0x15;
		advdata.flag_length = 2;
		advdata.flag = AD_FLAGS;
		advdata.flag_value = 0x1a;
		advdata.service_uuid_length = 0x10 + 1;
		advdata.service_uuid_flag = AD_COMPLETE_128_SERVICE_UUID;

		if(bt_string_to_uuid128(&(advdata.service_uuid_value), bt_content->ble_content.server_uuid.uuid, 1) < 0) {
			pr_err("%s: bt_string_to_uuid128 failed\n", __func__);
			return -1;
		}

		ble_content->advDataLen = sizeof(struct AdvDataContent);
		memcpy(ble_content->advData, (uint8_t *)(&advdata), sizeof(struct AdvDataContent));

		//============================================================================
		if (bt_content->ble_content.ble_name) {
			name_len = strlen(bt_content->ble_content.ble_name);
			if (name_len > sizeof(advdataresp.local_name_value))
				name_len = sizeof(advdataresp.local_name_value);
			memcpy(advdataresp.local_name_value, bt_content->ble_content.ble_name, name_len);
			advdataresp.local_name_length = name_len + 1;
		} else {
			bt_gethostname(hostname);
			name_len = strlen(hostname);
			if (name_len > sizeof(advdataresp.local_name_value))
				name_len = sizeof(advdataresp.local_name_value);
			memcpy(advdataresp.local_name_value, hostname, name_len);
			advdataresp.local_name_length = name_len + 1;
		}
		advdataresp.local_name_flag = AD_COMPLETE_LOCAL_NAME;
		advdataresp.adv_resp_length = advdataresp.local_name_length + 1;

		ble_content->respDataLen = advdataresp.adv_resp_length + 1;
		memcpy(ble_content->respData, (uint8_t *)(&advdataresp), ble_content->respDataLen);
	}

	uuid_len = MAX_UUID_LEN > strlen(bt_content->ble_content.server_uuid.uuid) ? strlen(bt_content->ble_content.server_uuid.uuid) : MAX_UUID_LEN;
	memcpy(ble_content->server_uuid, bt_content->ble_content.server_uuid.uuid, uuid_len);

	/* set chr uuid */
	for (i = 0; i < bt_content->ble_content.chr_cnt; i++) {
		uuid_len = MAX_UUID_LEN > strlen(bt_content->ble_content.chr_uuid[i].uuid) ? strlen(bt_content->ble_content.chr_uuid[i].uuid) : MAX_UUID_LEN;
		memcpy(ble_content->char_uuid[i], bt_content->ble_content.chr_uuid[i].uuid, uuid_len);
	}

	ble_content->char_cnt = bt_content->ble_content.chr_cnt;
	ble_content->cb_ble_recv_fun = bt_content->ble_content.cb_ble_recv_fun;
	ble_content->cb_ble_request_data = bt_content->ble_content.cb_ble_request_data;
	return 0;
}

int gatt_init(RkBtContent *bt_content)
{
	int i;
	bool is_random_addr = true;
	uint8_t *ble_addr;
	uint8_t le_random_addr[DEVICE_ADDR_LEN];

	characteristic_id = 1;
	service_id = 1;
	gid = 0;
	gdesc_id = 0;
	gatt_is_stopping = false;

	if(bt_content->ble_content.server_uuid.len <= 0) {
		pr_info("%s: invalid server_uuid len = %d\n", __func__,
			bt_content->ble_content.server_uuid.len);
		return -1;
	}

	for(i = 0; i < DEVICE_ADDR_LEN; i++) {
		if(bt_content->ble_content.ble_addr[i] != 0) {
			is_random_addr = false;
			break;
		}
	}

	if(is_random_addr) {
		//random addr
		srand(time(NULL) + getpid() + getpid() * 987654 + rand());
		for(i = 0; i < DEVICE_ADDR_LEN;i++)
			le_random_addr[i] = rand() & 0xFF;

		//Clear two most significant bits
		le_random_addr[5] &= 0x3f;

		//Set second most significant bit, Private resolvable
		//le_random_addr[5] |= 0xc0;
		le_random_addr[5] |= 0x40;

		//Save random addr
		memcpy(bt_content->ble_content.ble_addr, le_random_addr, DEVICE_ADDR_LEN);
		ble_addr = le_random_addr;
	} else {
		ble_addr = bt_content->ble_content.ble_addr;
	}

	memset(g_cmd_ra, 0, 256);
	if(sprintf(g_cmd_ra, "%s %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx", CMD_RA,
			ble_addr[0], ble_addr[1], ble_addr[2],
			ble_addr[3], ble_addr[4], ble_addr[5]) < 0) {
		pr_err("%s: set ble address failed\n", __func__);
		return -1;
	}
	pr_info("CMD_RA: %d, %s\n", strlen(g_cmd_ra), g_cmd_ra);

	memset(g_cmd_para, 0, 256);
	memcpy(g_cmd_para, CMD_PARA, strlen(CMD_PARA));
	pr_info("CMD_PARA: %d, %s\n", strlen(g_cmd_para), g_cmd_para);

	//adv data set
	memset(&ble_content_internal_bak, 0, sizeof(ble_content_t));
	if(ble_adv_set(bt_content, &ble_content_internal_bak) < 0) {
		printf("%s: ble_adv_set failed\n", __func__);
		return -1;
	}

	ble_content_internal = &ble_content_internal_bak;
	gatt_create_services();
	return 0;
}

void gatt_set_stopping(bool stopping)
{
	gatt_is_stopping = stopping;
}

int ble_set_address(char *address)
{
	char ret_buff[1024];

	if(!address)
		return -1;

	memset(g_cmd_ra, 0, 256);
	if(sprintf(g_cmd_ra, "%s %02hhx %02hhx %02hhx %02hhx %02hhx %02hhx", CMD_RA,
			address[0], address[1], address[2],
			address[3], address[4], address[5]) < 0) {
		pr_err("%s: set ble address failed\n", __func__);
		return -1;
	}
	pr_info("CMD_RA: %d, %s\n", strlen(g_cmd_ra), g_cmd_ra);

	execute(g_cmd_ra, ret_buff, 1024);
	pr_info("CMD_RA buff: %s", ret_buff);

	return 0;
}

int ble_set_adv_interval(unsigned short adv_int_min, unsigned short adv_int_max)
{
	char ret_buff[1024];
	char adv_min_low, adv_min_high;
	char adv_max_low, adv_max_high;

	if(adv_int_min < 32) {
		pr_err("%s: the minimum is 32(20ms), adv_int_min = %d", __func__, adv_int_min);
		adv_int_min = 32;
	}

	if(adv_int_max < adv_int_min)
		adv_int_max = adv_int_min;

	adv_min_low = adv_int_min & 0xFF;
	adv_min_high = (adv_int_min & 0xFF00) >> 8;
	adv_max_low = adv_int_max & 0xFF;
	adv_max_high = (adv_int_max & 0xFF00) >> 8;

	memset(g_cmd_para, 0, 256);
	if(sprintf(g_cmd_para, "%s %02hhx %02hhx %02hhx %02hhx %s",
			"hcitool -i hci0 cmd 0x08 0x0006",
			adv_min_low, adv_min_high, adv_max_low, adv_max_high,
			"00 01 00 00 00 00 00 00 00 07 00") < 0) {
		pr_err("%s: set ble adv interval failed\n", __func__);
		return -1;
	}
	pr_info("CMD_PARA: %d, %s\n", strlen(g_cmd_para), g_cmd_para);

	execute(g_cmd_para, ret_buff, 1024);
	pr_info("CMD_PARA buff: %s", ret_buff);
}