/*
 * Copyright (c) 2018 Rockchip, Inc. All Rights Reserved.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
#include <net/if.h>
#include <signal.h>
#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 <sys/signalfd.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <time.h>
#include <pthread.h>

#include "bluez_ctrl.h"
#include <RkBle.h>
#include "utility.h"

#define BT_IS_BLE_SINK_COEXIST 1

volatile bt_control_t bt_control = {
	0,
	0,
	0,
	0,
	0,
	0,
	0,
};

static int bt_close_a2dp_server();

int bt_gethostname(char *hostname_buf, const size_t size)
{
	char hostname[HOSTNAME_MAX_LEN + 1];
	size_t buf_len = sizeof(hostname) - 1;

	memset(hostname_buf, 0, size);
	memset(hostname, 0, sizeof(hostname));

	if (gethostname(hostname, buf_len) != 0) {
		pr_err("bt_gethostname gethostname error !!!!!!!!\n");
		return -1;
	}

	/* Deny sending of these local hostnames */
	if (hostname[0] == '\0' || hostname[0] == '.' || strcmp(hostname, "(none)") == 0) {
		pr_err("bt_gethostname gethostname format error !!!\n");
		return -2;
	}

	strncpy(hostname_buf, hostname, strlen(hostname) > (size - 1) ? (size - 1) : strlen(hostname));
	return 0;
}

static int _bt_close_server(void)
{
	pr_info("=== _bt_close_server ===\n");

	if (kill_task("obexctl") < 0)
		return -1;

	if (kill_task("obexd") < 0)
		return -1;

	if (kill_task("bluealsa") < 0)
		return -1;

	if (kill_task("bluealsa-aplay") < 0)
		return -1;

	if (kill_task("bluetoothctl") < 0)
		return -1;

	if (kill_task("bluetoothd") < 0)
		return -1;

	if (get_ps_pid("rtk_hciattach")) {
		exec_command_system("hciconfig hci0 down");
		if (kill_task("rtk_hciattach") < 0)
			return -1;
		sleep(1);
	}

	if (get_ps_pid("brcm_patchram_plus1")) {
		exec_command_system("hciconfig hci0 down");
		if (kill_task("brcm_patchram_plus1") < 0)
			return -1;
		sleep(1);
	}


	return 0;
}

static int _bt_open_server()
{
	char ret_buff[1024];
	char bt_buff[1024];

	pr_err("[BT_OPEN] _bt_open_server\n");

	exec_command_system("echo 0 > /sys/class/rfkill/rfkill0/state && usleep 10000");
	exec_command_system("echo 1 > /sys/class/rfkill/rfkill0/state && usleep 10000");

	/* check bt vendor (exteran/rkwifibt) */
	if (access("/usr/bin/bt_init.sh", F_OK)) {
		pr_err("[BT_OPEN]  bt_init.sh not exist !!!\n");
		if (access("/userdata/bt_pcba_test", F_OK)) {
			pr_err("[BT_OPEN] userdata bt_pcba_test not exist !!!\n");
			return -1;
		}
	}

	/* realtek init */
	exec_command("cat /usr/bin/bt_init.sh | grep rtk_hciattach", bt_buff, 1024);
	if (bt_buff[0]) {
		exec_command_system("insmod /usr/lib/modules/hci_uart.ko && usleep 50000");
		exec_command("lsmod", ret_buff, 1024);
		if (!strstr(ret_buff, "hci_uart")) {
			pr_err("open bt server: insmod hci_uart.ko failed!\n");
			return -1;
		}

		pr_err("bt_buff: %s \n", bt_buff);
		exec_command_system(bt_buff);

		sleep(1);
		if (!get_ps_pid("rtk_hciattach")) {
			pr_err("open bt server error: rtk_hciattach failed!\n");
			return -1;
		}
	}

	/* broadcom or cypress init */
	exec_command("cat /usr/bin/bt_init.sh | grep brcm_patchram_plus1 | grep -v killall", bt_buff, 1024);
	if (bt_buff[0]) {
		pr_err("bt_buff: %s \n", bt_buff);
		exec_command_system(bt_buff);
		sleep(1);
		exec_command("pidof brcm_patchram_plus1", ret_buff, 1024);
		if (!ret_buff[0]) {
			pr_err("open bt server failed! error: brcm_patchram_plus1 failed!\n");
			return -1;
		}
		sleep(1);
	}

#if 0
	exec_command_system("hcidump -i hci0 -w /data/btsnoop.log &");
	sleep(1);
	if (access("/data/btsnoop.log", F_OK)) {
		printf("save btsnoop error, retry\n");
		exec_command_system("hcidump -i hci0 -w /data/btsnoop.log &");
		sleep(1);
		if (access("/data/btsnoop.log", F_OK)) {
			printf("second save btsnoop error\n");
		} else {
			printf("save btsnoop successfully\n\n\n");
		}
	} else {
		printf("save btsnoop successfully\n\n\n");
	}

	msleep(50);
#endif

	/* run bluetoothd */
	if (run_task("bluetoothd", "/usr/libexec/bluetooth/bluetoothd -C -n -d -E &")) {
		pr_err("open bt server failed! error: bluetoothd failed!\n");
		return -1;
	}

	//set Bluetooth NoInputNoOutput mode
	//exec_command_system("bluetoothctl -a NoInputNoOutput &");
	msleep(10);

	//set vendor params for scan/conn x realtek
	exec_command("cat /usr/bin/bt_init.sh | grep rtk_hciattach", bt_buff, 1024);
	if (bt_buff[0]) {
		exec_command_system("hciconfig hci0 pageparms 18:1024");
		msleep(10);
		exec_command_system("hciconfig hci0 inqparms 18:2048");
		msleep(10);
		exec_command_system("hcitool cmd 0x03 0x47 0x01");
		msleep(10);
		exec_command_system("hcitool cmd 0x03 0x43 0x01");
		msleep(10);
	}

	pr_err("_bt_open_server end\n");
	return 0;
}

static int bt_start_a2dp_source()
{
	char ret_buff[1024];
	int count = 10;

	kill_task("bluealsa");
	kill_task("bluealsa-aplay");

	exec_command_system("bluealsa --profile=a2dp-source &");
	exec_command("pidof bluealsa", ret_buff, 1024);
	if (!ret_buff[0]) {
		pr_err("start a2dp source profile failed!\n");
		return -1;
	}

	while(count--) {
		msleep(10);
		if (access("/var/run/bluealsa/hci0", F_OK))
			pr_info("%s: wait for /var/run/bluealsa/hci0 to set up\n", __func__);
		else
			break;

		msleep(50);
	}

	exec_command_system("hciconfig hci0 class 0x480400");
	msleep(10);
	exec_command_system("hciconfig hci0 class 0x480400");
	msleep(10);

	return 0;
}

static int bt_start_a2dp_sink(int sink_only)
{
	char ret_buff[1024];
	int count = 10;

	kill_task("bluealsa");
	kill_task("bluealsa-aplay");
	msleep(500);

	if (sink_only)
		exec_command_system("bluealsa --profile=a2dp-sink --a2dp-volume &");
	else
		exec_command_system("bluealsa --a2dp-volume &");
	exec_command("pidof bluealsa", ret_buff, 1024);
	if (!ret_buff[0]) {
		pr_err("start a2dp sink profile failed!\n");
		return -1;
	}

	while(count--) {
		msleep(10);
		if (access("/var/run/bluealsa/hci0", F_OK))
			pr_info("%s: wait for /var/run/bluealsa/hci0 to set up\n", __func__);
		else
			break;

		msleep(50);
	}

	exec_command_system("bluealsa-aplay --profile-a2dp 00:00:00:00:00:00 &");
	exec_command("pidof bluealsa-aplay", ret_buff, 1024);
	if (!ret_buff[0]) {
		pr_err("start a2dp sink play server failed!\n");
		return -1;
	}

	exec_command_system("hciconfig hci0 class 0x240404");
	msleep(100);
	exec_command_system("hciconfig hci0 class 0x240404");
	msleep(100);
	pr_err("bt_start_a2dp_sink exit\n");

	return 0;
}

static int bt_start_hfp()
{
	char ret_buff[1024];
	int count = 10;

	kill_task("bluealsa");
	kill_task("bluealsa-aplay");

	exec_command_system("bluealsa --profile=hfp-hf &");
	exec_command("pidof bluealsa", ret_buff, 1024);
	if (!ret_buff[0]) {
		pr_err("start hfp-hf profile failed!\n");
		return -1;
	}

	while(count--) {
		msleep(10);
		if (access("/var/run/bluealsa/hci0", F_OK))
			pr_info("%s: wait for /var/run/bluealsa/hci0 to set up\n", __func__);
		else
			break;

		msleep(50);
	}

	exec_command_system("hciconfig hci0 class 0x240404");
	msleep(10);
	exec_command_system("hciconfig hci0 class 0x240404");
	msleep(10);
	pr_err("%s exit\n", __func__);

	return 0;
}

bool bt_is_open()
{
	if (bt_control.is_bt_open) {
		if (get_ps_pid("bluetoothd")) {
			return true;
		} else {
			pr_err("bt has been opened but bluetoothd server exit.\n");
		}
	}

	return false;
}

bool bt_sink_is_open(void)
{
	if (bt_control.is_a2dp_sink_open) {
		if (get_ps_pid("bluetoothd")) {
			if(!get_ps_pid("bluealsa")) {
				pr_err("bt sink has been opened, but bluealsa exit\n");
				//return false;
			}

			if(!get_ps_pid("bluealsa-aplay")) {
				pr_err("bt sink has been opened, but bluealsa-aplay exit\n");
				//return false;
			}

			return true;
		} else {
			pr_err("bt sink has been opened, but bluetoothd server exit\n");
		}
	}

	return false;
}

bool bt_hfp_is_open(void)
{
	if (bt_control.is_hfp_open) {
		if (get_ps_pid("bluetoothd")) {
			if(!get_ps_pid("bluealsa")) {
				pr_err("bt hfp has been opened, but bluealsa exit\n");
				//return false;
			}

			return true;
		} else {
			pr_err("bt hfp has been opened, but bluetoothd server exit\n");
		}
	}

	return false;
}

bool bt_source_is_open(void)
{
	if (bt_control.is_a2dp_source_open) {
		if (get_ps_pid("bluetoothd")) {
			if(!get_ps_pid("bluealsa")) {
				pr_err("bt source has been opened, but bluealsa exit\n");
				//return false;
			}

			return true;
		} else {
			pr_err("bt source has been opened, but bluetoothd server exit\n");
		}
	}

	return false;
}

bool ble_is_open()
{
	if (bt_control.is_ble_open) {
		if (get_ps_pid("bluetoothd")) {
			return true;
		} else {
			pr_err("ble has been opened, but bluetoothd server exit\n");
		}
	}

	return false;
}

bool ble_client_is_open()
{
	if (bt_control.is_ble_client_open) {
		if (get_ps_pid("bluetoothd")) {
			return true;
		} else {
			pr_err("ble client has been opened, but bluetoothd server exit\n");
		}
	}

	return false;
}

int bt_control_cmd_send(enum BtControl bt_ctrl_cmd)
{
	char cmd[10];
	memset(cmd, 0, 10);
	sprintf(cmd, "%d", bt_ctrl_cmd);

	if (!bt_sink_is_open()) {
		pr_err("Not bluetooth play mode, don`t send bluetooth control commands\n");
		return -1;
	}

	pr_err("bt_control_cmd_send, cmd: %s, len: %d\n", cmd, strlen(cmd));
	switch (bt_ctrl_cmd) {
	case (BT_PLAY):
	case (BT_RESUME_PLAY):
		play_avrcp();
		break;
	case (BT_PAUSE_PLAY):
		pause_avrcp();
		break;
	case (BT_AVRCP_STOP):
		stop_avrcp();
		break;
	case (BT_AVRCP_BWD):
		previous_avrcp();
		break;
	case (BT_AVRCP_FWD):
		next_avrcp();
		break;
	default:
		break;
	}

	return 0;
}

void bt_close_ble(bool disconnect)
{
	pr_err("ble server close\n");

	gatt_set_stopping(true);
	if(disconnect) {
		if(!ble_disconnect())
			sleep(3);
	} else {
		if(!remove_ble_device())
			sleep(2);
	}

	ble_disable_adv();
	ble_deregister_state_callback();
	ble_deregister_mtu_callback();
	gatt_set_stopping(false);
	bt_control.is_ble_open = false;
}

int bt_close_sink(bool disconnect)
{
	int ret = 0;

	if (!bt_sink_is_open())
		return -1;

	pr_err("bt_close_sink\n");

	if (bt_hfp_is_open()) {
		release_avrcp_ctrl2();
		kill_task("bluealsa-aplay");
	} else {
		kill_task("bluealsa-aplay");

		if(disconnect) {
			if(!disconnect_current_devices())
				sleep(3);
		}

		release_avrcp_ctrl();
		kill_task("bluealsa");
	}

	bt_control.is_a2dp_sink_open = false;
	return ret;
}

int bt_close_source(bool disconnect)
{
	if (!bt_source_is_open())
		return -1;

	pr_info("%s\n", __func__);

	if(disconnect) {
		if (!disconnect_current_devices())
			sleep(3);
	}

	//source_stop_connecting();

	kill_task("bluealsa");
	return 0;
}

static int bt_a2dp_sink_open(void)
{
	pr_err("bt_a2dp_sink_server_open\n");
	if(bt_start_a2dp_sink(1) < 0)
		return -1;

	a2dp_sink_open();
	return 0;
}

static int bt_hfp_hf_open(void)
{
	pr_err("%s is called!\n", __func__);
	if (bt_start_hfp() < 0)
		return -1;

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

static int bt_hfp_with_sink_open(void)
{
	pr_err("%s is called!\n", __func__);
	if (bt_start_a2dp_sink(0) < 0)
		return -1;

	a2dp_sink_open();
	return 0;
}

/* Load the Bluetooth firmware and turn on the Bluetooth SRC service. */
static int bt_a2dp_src_server_open(void)
{
	pr_err("%s\n", __func__);

	if(bt_start_a2dp_source() < 0)
		return -1;

	return 0;
}

int bt_interface(enum BtControl type, void *data)
{
	if (type == BT_SINK_OPEN) {
		pr_err("Open a2dp sink.");
		if (bt_a2dp_sink_open() < 0)
			return -1;
	} else if (type == BT_SOURCE_OPEN) {
		pr_err("Open a2dp source.");
		if (bt_a2dp_src_server_open() < 0)
			return -1;
	} else if (type == BT_BLE_OPEN) {
		pr_err("Open ble.");
		ble_clean();
		if(ble_enable_adv() < 0)
			return -1;
	} else if (type == BT_HFP_OPEN) {
		pr_err("Open bt hfp.");
		if(bt_hfp_hf_open() < 0)
			return -1;
	} else if (type == BT_HFP_SINK_OPEN) {
		pr_err("Open bt hfp with sink.");
		if(bt_hfp_with_sink_open() < 0)
			return -1;
	}

	return 0;
}

static int get_bt_mac(char *bt_mac)
{
	char ret_buff[1024] = {0};
	bool ret;

	exec_command("hciconfig hci0 | grep Address | awk '{print $3}'", ret_buff, 1024);
	if (!ret_buff[0]) {
		pr_err("get bt address failed.\n");
		return false;
	}
	strncpy(bt_mac, ret_buff, 17);
	return 0;
}

int rk_bt_control(enum BtControl cmd, void *data, int len)
{
	int ret = 0;
	RkBleConfig *ble_cfg;
	bool scan;

	pr_err("controlBt, cmd: %d\n", cmd);

	switch (cmd) {
	case BT_OPEN:
		if (_bt_close_server() < 0) {
			pr_err("_bt_close_server failed\n");
			return -1;
		}

		if (_bt_open_server() < 0) {
			pr_err("_bt_open_server failed\n");
			return -1;
		}

		if (bt_open((RkBtContent *)data) < 0) {
			pr_err("bt_open failed\n");
			return -1;
		}

		bt_control.is_bt_open = true;
		break;

	case BT_SINK_OPEN:
		if (!bt_is_open())
			return -1;

		if (bt_sink_is_open())
			return 1;

		if(bt_source_is_open()) {
			pr_info("bt source has been opened, close bt source");
			rk_bt_source_close();
		}

		if (bt_interface(BT_SINK_OPEN, NULL) < 0){
			bt_control.is_a2dp_sink_open = false;
			ret = -1;
		}

		bt_control.is_a2dp_sink_open = true;
		break;

	case BT_BLE_OPEN:
		if (bt_interface(BT_BLE_OPEN, data) < 0) {
			bt_control.is_ble_open = false;
			return -1;
		}

		bt_control.is_ble_open = true;
		pr_err("=== BT_BLE_OPEN ok ===\n");
		break;

	case BT_SOURCE_OPEN:
		rk_bt_source_open();
		break;

	case BT_SOURCE_SCAN:
		ret = a2dp_master_scan(data, len, SCAN_TYPE_AUTO);
		break;

	case BT_SOURCE_CONNECT:
		ret = a2dp_master_connect((char *)data);
		break;

	case BT_SOURCE_DISCONNECT:
		ret = rk_bt_source_disconnect_by_addr((char *)data);
		break;

	case BT_SOURCE_STATUS:
		ret = a2dp_master_status(NULL, 0, NULL, 0);
		break;

	case BT_SOURCE_REMOVE:
		ret = remove_by_address((char *)data);
		break;

	case BT_SINK_CLOSE:
		rk_bt_sink_close();
		break;

	case BT_SOURCE_CLOSE:
		rk_bt_source_close();
		break;

	case BT_BLE_COLSE:
		ret = rk_ble_stop();
		break;

	case BT_SINK_IS_OPENED:
		ret = bt_sink_is_open();
		break;

	case BT_SOURCE_IS_OPENED:
		ret = bt_source_is_open();
		break;

	case BT_BLE_IS_OPENED:
		ret = ble_is_open();
		break;

	case GET_BT_MAC:
		if (get_bt_mac((char *)data) <= 0)
			ret = -1;

		break;

	case BT_VOLUME_UP:
		if (bt_control_cmd_send(BT_VOLUME_UP) < 0) {
			pr_err("Bt send volume up cmd failed\n");
			ret = -1;
		}

		break;

	case BT_VOLUME_DOWN:
		if (bt_control_cmd_send(BT_VOLUME_UP) < 0) {
			pr_err("Bt send volume down cmd failed\n");
			ret = -1;
		}

		break;

	case BT_PLAY:
	case BT_RESUME_PLAY:
		if (bt_control_cmd_send(BT_RESUME_PLAY) < 0) {
			pr_err("Bt send play cmd failed\n");
			ret = -1;
		}

		break;
	case BT_PAUSE_PLAY:
		if (bt_control_cmd_send(BT_PAUSE_PLAY) < 0) {
			pr_err("Bt send pause cmd failed\n");
			ret = -1;
		}

		break;

	case BT_AVRCP_FWD:
		if (bt_control_cmd_send(BT_AVRCP_FWD) < 0) {
			pr_err("Bt send previous track cmd failed\n");
			ret = -1;
		}

		break;

	case BT_AVRCP_BWD:
		if (bt_control_cmd_send(BT_AVRCP_BWD) < 0) {
			pr_err("Bt socket send next track cmd failed\n");
			ret = -1;
		}

		break;

	case BT_BLE_WRITE:
		ble_cfg = (RkBleConfig *)data;
		ret = gatt_write_data(ble_cfg->uuid, ble_cfg->data, ble_cfg->len);

		break;
	case BT_VISIBILITY:
		scan = (*(bool *)data);
		rkbt_inquiry_scan(scan);
		break;
	case BT_BLE_DISCONNECT:
		ret = ble_disconnect();
		break;
	default:
 		pr_err("%s, cmd <%d> is not implemented.\n", __func__, cmd);
		break;
	}

	return ret;
}