#include "ble_cmd_process.h"
#include "ate_at_process.h"
#include "ate_cmd_manager.h"
// #include "aw88166_port.h"
#include "common_def.h"
#include "securec.h"
#include "soc_osal.h"
#include <rtc.h>
#include <soc_errno.h>
#include "ble_api.h"
#include "ble_protocol_ota_service.h"

#define TD_U4_BITS 4
#define TD_U8_MAX           0xFF

#define ENABLE_PRINT_INFO 1
#if ENABLE_PRINT_INFO
#define static_print_debug(...) sys_bt_log_d(__VA_ARGS__)  // 一般信息打印宏控制
#define static_print_warn(...) sys_bt_log_w(__VA_ARGS__)  // 警告信息打印一般常开
#define static_print_error(...) sys_bt_log_e(__VA_ARGS__) // 错误信息打印一般常开
#else
#define static_print_debug(...)
#define static_print_warn(...)
#define static_print_error(...)
#endif

#define ARRAY_COUNT(array) (sizeof(array) / sizeof(array[0]))

void ble_cmd_process_init(void)
{
    return;
}

#define TEN 10

static uint8_t char_2_num(int8_t c)
{
    if (c >= '0' && c <= '9') {
        return (uint8_t)(c - '0');
    } else if (c >= 'A' && c <= 'F') {
        return (uint8_t)(c - 'A' + TEN);
    } else if (c >= 'a' && c <= 'f') {
        return (uint8_t)(c - 'a' + TEN);
    } else {
        return TD_U8_MAX;
    }
}

/* 从字符串中解析十六进制数字，例： "7d05" -> [0x7d, 0x05] */
static uint32_t decode_hex_from_str(const char *str,  uint8_t *nums)
{
    uint32_t len = strlen(str);
    static_print_debug("str_len: %u str: %s  num:", len, str);
    uint32_t cnt = 0;
    for (uint32_t i = 0; i < len - 1; i += 2) { /* 2: 每个字节包含2个字符 */
        nums[cnt] = (char_2_num(str[i]) << TD_U4_BITS) + char_2_num(str[i + 1]);
        static_print_debug("%02x", nums[cnt]);
        cnt++;
    }
    static_print_debug("\n");
    return EXT_ERR_SUCCESS;
}

#define BD_ADDR_STR_LEN 12
#define TD_U8_MAX           0xFF

/* 从字符串中解析设备地址，示例： "c0a012345678" -> [0x78, 0x56, 0x34, 0x12, 0xa0, 0xc0] */
static uint32_t decode_bd_addr(const int8_t *str,  uint8_t *device_addr, int32_t len)
{
    int32_t str_len = (int32_t)strnlen((const char *)str, BD_ADDR_STR_LEN + 1);
    if (str_len != BD_ADDR_STR_LEN || len != BD_ADDR_LEN) {
        static_print_debug("len err! str_len = %d  len = %d\n", str_len, len);
        return EXT_ERR_FAILURE;
    }

    static_print_debug("str: %s  bd_addr:", str);
    int32_t cnt = 0;
    for (int32_t i = BD_ADDR_STR_LEN - 1; i >= 0; i -= 2) { /* 2: 每个字节包含2个字符 */
        uint8_t num1 = char_2_num(str[i - 1]);
        uint8_t num2 = char_2_num(str[i]);
        if (num1 == TD_U8_MAX || num2 == TD_U8_MAX) {
            static_print_debug("invalid input %c%c\n", str[i - 1], str[i]);
            return EXT_ERR_FAILURE;
        }
        device_addr[cnt] = ((num1 << TD_U4_BITS) | num2);
        static_print_debug("%02x", device_addr[cnt]);
        cnt++;
    }
    static_print_debug("\n");

    return EXT_ERR_SUCCESS;
}

result_t ble_enable_start(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    ble_api_cmd_enable();
    return result;
}

result_t ble_disable_start(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    ble_api_cmd_disable();
    return result;
}

result_t ble_set_local_name_start(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (argc != 2) {
        static_print_debug("params_cnt error! need: name len\n");
        return result;
    }
    ble_api_cmd_set_local_name(argv[0],atoi((const char *)argv[1]));
    return result;
}

/* 获取本地设备名称 params: sample_mode length */
result_t ble_get_local_name_start(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    ble_api_cmd_get_local_name();
    return result;
}

result_t ble_set_local_addr_start(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    bd_addr_t bd_addr;
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (decode_bd_addr((int8_t *)argv[0], bd_addr.addr, BD_ADDR_LEN) != EXT_ERR_SUCCESS) {
        static_print_debug("decode addr error!\n");
        return result;
    }
    ble_api_cmd_set_local_addr(&bd_addr);
    return result;
}

result_t ble_get_local_addr_start(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    ble_api_cmd_get_local_addr();
    return result;
}

result_t ble_get_bt_local_addr(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    ble_api_cmd_get_bt_local_addr();
    return result;
}

result_t ble_set_adv_data_start(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (argc != 4) {
        static_print_debug("params_cnt error! need: sample_mode adv_id adv_data scan_rsp_data\n");
        return result;
    }
    uint32_t sample_mode = (uint32_t)atoi((const char *)argv[0]);
    uint8_t adv_id = argv[1];
    char *adv_data = (char *)argv[2];
    char *scan_rsp_data = (char *)argv[3];
    gap_ble_config_adv_data_t cfg_adv_data = {0};
    errcode_t ret;
    if ((sample_mode & 0x1) != 0) {
        ret = gap_ble_set_adv_data(adv_id, NULL);
    } else {
        cfg_adv_data.adv_length = (uint16_t)(strlen(adv_data)) / 2; /* 2个字符为1字节 */
        cfg_adv_data.scan_rsp_length = (uint16_t)(strlen(scan_rsp_data)) / 2; /* 2个字符为1字节 */
        cfg_adv_data.adv_data = (uint8_t *)(void *)malloc(cfg_adv_data.adv_length);
        if (cfg_adv_data.adv_data == NULL) {
            static_print_debug("malloc adv data error!\n");
            return result;
        }
        cfg_adv_data.scan_rsp_data = (uint8_t *)(void *)malloc(cfg_adv_data.scan_rsp_length);
        if (cfg_adv_data.scan_rsp_data == NULL) {
            free(cfg_adv_data.adv_data);
            static_print_debug("malloc scan data error!\n");
            return result;
        }
        if (decode_hex_from_str(adv_data, cfg_adv_data.adv_data) != EXT_ERR_SUCCESS ||
            decode_hex_from_str(scan_rsp_data, cfg_adv_data.scan_rsp_data) != EXT_ERR_SUCCESS) {
            static_print_debug("decode adv data error!\n");
            free(cfg_adv_data.adv_data);
            free(cfg_adv_data.scan_rsp_data);
            return result;
        }
        ret = ble_api_cmd_set_adv_data(adv_id,&cfg_adv_data);
        free(cfg_adv_data.adv_data);
        free(cfg_adv_data.scan_rsp_data);
    }
    
    return result;
}

result_t ble_start_adv(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (argc != 1) {
        static_print_debug("params_cnt error! need: adv_id\n");
        return result;
    }
    ble_api_cmd_start_adv(argv[0]);
    return result;
}

result_t ble_show_scan_list(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    ble_api_cmd_show_scan_list();
    return result;
}

result_t ble_start_scan(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    ble_api_cmd_start_discovery();
    return result;
}


result_t ble_open_start(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    tjd_ble_api_cmd_open();
    return result;
}

result_t ble_close_start(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    ble_api_cmd_close();
    return result;
}

result_t ble_send_message(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (argc != 2) {
        static_print_debug("params_cnt error! need: adv_id\n");
        return result;
    }
    svr_bt_gatts_notify(argv[0],argv[1]);
    return result;
}

result_t ble_spp_send_msg(uint8_t *para, uint32_t para_len)
{
    
    unused(para);
    unused(para_len);
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (argc != 2) {
        static_print_debug("params_cnt error! need: data data_len\n");
        return result;
    }
    ble_spp_send_data(argv[0],atoi((const char *)argv[1]));
    return result;
}

result_t ble_upload_file(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (argc != 2) {
        static_print_debug("params_cnt error! need: data data_len\n");
        return result;
    }
    uint8_t file_type = atoi((const char *)argv[1]);
    tjd_ble_upload_file((const char *)argv[0], file_type);
    free_argv(argv, argc);
    // tjd_ble_upload_file("/user/tjd_record/2000-8-4.mp3");
    return result;
}

result_t ble_request_gps(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    tjd_ble_request_gps();
    return result;
}

result_t br_get_scan_mode(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    int ret = gap_br_get_scan_mode();
    printf("scan mode: %d\n",ret);
    return result;
}

result_t ble_request_flover(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    tjd_ble_request_flover();
    return result;
}

result_t ble_open_bt_only(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    tjd_open_bluetooth_only();
    return result;
}

result_t ble_close_bt_only(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    tjd_close_bluetooth_only();
    return result;
}

result_t ble_test_dial_config_json(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    // tjd_test_dial_config_json_file();
    tjd_service_send_sport_record_data();
    return result;
}

result_t ble_test_send_sport_record_json(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    tjd_service_send_sport_record_data();
    return result;
}

result_t ble_delete_directory(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (argc != 1) {
        static_print_debug("params_cnt error! need: data data_len\n");
        return result;
    }
    if(delete_directory((const char *)argv[0]) != 0){
        static_print_debug("delete_directory failed!\n");
    }else{
        static_print_debug("delete_directory success!");
    }

    return result;
}

result_t ble_rename_file_name(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (argc != 2) {
        static_print_debug("params_cnt error! need: data data_len\n");
        return result;
    }
    if(rename((const char *)argv[0],(const char *)argv[1]) != 0){
        static_print_debug("rename file failed!\n");
    }else{
        static_print_debug("rename file success! old name : %s , new name : %s\n",argv[0],argv[1]);
    }
    return result;
}

result_t ble_ota_recovery_test(uint8_t *para, uint32_t para_len)
{
    unused(para);
    unused(para_len);
    result_t result = {0};
    int32_t argc;
    uint8_t *argv[AT_MAX_PARAM_CNT];
    convert_at_param(para, para_len, &argc, argv);
    if (argc != 1) {
        static_print_debug("params_cnt error! need: data data_len\n");
        return result;
    }
    printf("ota recovery test start!,%s\n", argv[0]);
    int file_size = atoi((const char *)argv[0]);
    static_print_debug("tjd_ota_recovery_upgrade_operation file_size : %d",file_size);
    tjd_ota_recovery_upgrade_operation(file_size);
    free_argv(argv, argc);
    // tjd_ble_upload_file("/user/tjd_record/2000-8-4.mp3");
    return result;
}