#include "ble_port_a2dp_service.h"
#include "audio_manager_c_wrapper.h"
#include "ble_api.h"
#include "bt_audio.h"
#include "bt_audio_hal_interface.h"
#include "bts_a2dp_sink.h"
#include "bts_a2dp_source.h"
#include "bts_avrcp_controller.h"
#include "bts_avrcp_target.h"
#include "osal_addr.h"
#include "osal_timer.h"
#include "soc_errno.h"
#include "sys_config.h"

#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 AVRCP_CT_AUTO_REG_TYPE 1
#define AVRCP_CT_AUTO_REG_NON 0
#define BTS_ATTR_ID_LEN 4
#define BTS_ATTR_LIST_LEN 12
#define BTS_UID_LEN 8
#define MAX_SAMPLE_AVRCP_CT_REG_CNT 5 // 支持一次shell命令最多能注册5个事件
#define AVRCP_SHIFT_BITS_32 32
#define LONG_MIN (-LONG_MAX - 1)
#define LONG_MAX 2147483647L
#define A2DP_STREAM_ACCEPT_TIMER_PERIOD 500

#define BLUETOOTH_MAX_NUM 20
#define MEDIA_A2DP_SNK_INTERFACE 1
#define MEMORY_MINI 1

enum
{
    AVRCP_SRV_PRESS_VALUE,
    AVRCP_SRV_RELEASED_VALUE,
    AVRCP_SRV_INIT_VALUE
};

enum
{
    SAMPLE_A2DP_STREAM_UNKNOWN, /* no a2dp */
    SAMPLE_A2DP_STREAM_CREATE,
    SAMPLE_A2DP_STREAM_OPENED,
    SAMPLE_A2DP_STREAM_START,
    SAMPLE_A2DP_STREAM_SUSPENDED,
    SAMPLE_A2DP_STREAM_CLOSED
};

// typedef void *td_pvoid;

typedef struct
{
    td_pvoid stream_hdl;
    uint8_t loc_volume;
    uint8_t play_stat;
    uint8_t dir_forward;
    uint8_t avrcp_button_flag;
    bd_addr_t bd_addr;
    uint8_t reg_cap_auto;
    uint8_t resrv;
    profile_connect_state_t avrcp_srv_conn_stat;
} sample_avrcp_tg_sample_inf;
sample_avrcp_tg_sample_inf g_tjd_avrcp_srv_inf;

static src_connect_state_callback_t g_src_connect_state_callback = NULL;
static snk_connect_state_callback_t g_snk_connect_state_callback = NULL;
static playing_state_callback_t g_playing_state_callback = NULL;
// static uint32_t g_tjd_hid_service_handle = 0;
static sync_lrc_callback_t g_sync_lrc_callback = NULL;

osal_timer g_tjd_a2dp_stream_accept_timer = {0};
static bool isFirst = false;

extern AudioFormatConfig g_audio_format_config;

#pragma region a2dp src
/****************************
 * A2DP SRC
 */
// static void A2dpSrcConnectstateChanged(bd_addr_t *bdAddr, int connState)
// {
//     static_print_debug("a2dp_src_connectStateChangedCallback addr: %02x%02x%02x%02x%02x%02x connState: %x",
//         bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* 5 4 3 idx */
//         bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0], connState); /* 2 1 0 idx */
//     if ((gap_get_device_class(bdAddr) & 0x200) != 0) {
//         static_print_debug("a2dp_src_connectstateChangedCb: Mobile Phone Device");
//         return;
//     }
//     if (connState == PROFILE_STATE_CONNECTED) {
//         avrcp_ct_connect(bdAddr);
//     }
//     else if (connState == PROFILE_STATE_DISCONNECTED) {
//         static_print_debug("a2dp_src_connectstateChangedCb: Disconnected");
//     }
// }

// static void A2dpSrcConfigureChanged(bd_addr_t *bdAddr, a2dp_codec_info_t *info)
// {
//     static_print_debug("A2dpSrcConfigurationChangedCallback addr: %02x%02x%02x%02x%02x%02x ",
//         bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* 5 4 3 idx */
//         bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0]); /* 2 1 0 idx */
//     static_print_debug("codec_priority: %04x codec_type: %04x sample_rate: %02x bits_per_sample: %02x channel_mode:
//     %02x ",
//         info->codec_priority, info->codec_type, info->sample_rate, info->bits_per_sample, info->channel_mode);
//     static_print_debug("codec_specific1: %04x codec_specific2: %04x codec_specific3: %04x codec_specific4: %04x",
//         info->codec_specific1, info->codec_specific2, info->codec_specific3, info->codec_specific4);
// }

// static void A2dpSrcPlayingStateChanged(bd_addr_t *bdAddr, int playState)
// {
//     static_print_debug("A2dpSrcPlayingStateChangedCallback addr: %02x%02x%02x%02x%02x%02x playState: %x",
//         bdAddr->addr[5], bdAddr->addr[4], bdAddr->addr[3], /* 5 4 3 idx */
//         bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0], playState); /* 2 1 0 idx */
// }

static void sample_a2dp_src_connect_state_changed_callback(const bd_addr_t *bd_addr, int conn_state)
{
    static_print_debug("addr: ****%02x%02x%02x%02x conn_state: %x", bd_addr->addr[3], bd_addr->addr[2],
                       bd_addr->addr[1], bd_addr->addr[0], conn_state); /* 3 2 1 0 idx */

    if (g_src_connect_state_callback != NULL) {
        static_print_debug("g_src_connect_state_callback");
        g_src_connect_state_callback(conn_state);
    }
    if (conn_state == PROFILE_STATE_CONNECTED) {
        avrcp_ct_connect(bd_addr);
        audio_manager_set_device_connection_state(OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_CONNECTED);
    } else if (conn_state == PROFILE_STATE_DISCONNECTING) {

    } else if (conn_state == PROFILE_STATE_DISCONNECTED) {
        audio_manager_set_device_connection_state(OUT_BLUETOOTH_A2DP, AUDIO_DEVICE_DISCONNECTED);
    }
    // static_print_debug("addr: ****%02x%02x%02x%02x conn_state: %x",
    //     bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1], bd_addr->addr[0], conn_state); /* 3 2 1 0 idx */

    // if (conn_state == PROFILE_STATE_CONNECTED) {
    //     /* A2DP 连接建立成功后，主动建立AVRCP连接 */
    //     int conn_ret = avrcp_ct_connect(bd_addr);
    //     if (conn_ret != ERRCODE_BT_SUCCESS) {
    //         static_print_debug("avrcp_ct_connect failed, ret: %d", conn_ret);
    //     }
    // }
    // else if (conn_state == PROFILE_STATE_DISCONNECTED) {
    //     /* A2DP 连接断开后，主动断开AVRCP连接 */
    //     int disconn_ret = avrcp_ct_disconnect(bd_addr);
    //     if (disconn_ret != ERRCODE_BT_SUCCESS) {
    //         static_print_debug("avrcp_ct_disconnect failed, ret: %d", disconn_ret);
    //     }
    // }
}

static void sample_a2dp_src_configuration_changed_callback(const bd_addr_t *bd_addr, const a2dp_codec_info_t *info)
{
    static_print_debug("addr: ****%02x%02x%02x%02x ", bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1],
                       bd_addr->addr[0]); /* 3 2 1 0 idx */
    static_print_debug(
        "codec_priority: %04x codec_type: %04x sample_rate: %02x bits_per_sample: %02x channel_mode: %02x",
        info->codec_priority, info->codec_type, info->sample_rate, info->bits_per_sample, info->channel_mode);
    static_print_debug("codec_specific1: %04x codec_specific2: %04x codec_specific3: %04x codec_specific4: %04x",
                       (unsigned int)info->codec_specific1, (unsigned int)info->codec_specific2,
                       (unsigned int)info->codec_specific3, (unsigned int)info->codec_specific4);
}

static void sample_a2dp_src_playing_state_changed_callback(const bd_addr_t *bd_addr, int playing_state)
{
    static_print_debug("addr: ****%02x%02x%02x%02x playing_state: %x", bd_addr->addr[3], bd_addr->addr[2],
                       bd_addr->addr[1], bd_addr->addr[0], playing_state); /* 3 2 1 0 idx */
    /* 播放状态变化通知CT */
    avrcp_tg_notify_playback_status_changed((unsigned char)playing_state);
}

void register_a2dpsrc_servers_callbacks(void)
{
    static a2dp_src_callbacks_t g_sample_a2dp_src_callbacks = {
        .connectstate_changed_cb = sample_a2dp_src_connect_state_changed_callback,
        .configuration_changed_cb = sample_a2dp_src_configuration_changed_callback,
        .playing_state_changed_cb = sample_a2dp_src_playing_state_changed_callback};

    int ret = a2dp_src_register_callbacks(&g_sample_a2dp_src_callbacks);
    if (ret != ERRCODE_BT_SUCCESS) {
        static_print_debug("a2dp_src_register_callbacks failed, ret: %d", ret);
    }
    audio_manager_init(AUDIO_STREAM_MUSIC);
}
#pragma endregion

#pragma region a2dp snk
/************************************************************************
 *   A2DP SINK Server
 */

static void sample_a2dp_snk_connect_state_changed_callback(const bd_addr_t *bd_addr, int conn_state)
{
    // static_print_debug("sample_a2dp_snk_connect_state_changed_callback ba_addr: %p ",bd_addr);
    if (bd_addr == NULL) {
        static_print_debug("sample_a2dp_snk_connect_state_changed_callback: bd_addr is NULL");
        return;
    }
    static_print_debug("a2dp_snk_connect_state_changed_callback addr: ****%02x%02x%02x%02x conn_state: %x",
                       bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1], bd_addr->addr[0],
                       conn_state); /* 3 2 1 0 idx */

    if (g_snk_connect_state_callback != NULL) {
        static_print_debug("g_snk_connect_state_callback");
        g_snk_connect_state_callback(conn_state);
    }

    if (conn_state == PROFILE_STATE_CONNECTED) {
        /* A2DP 连接建立成功后，主动建立AVRCP连接 */
        int conn_ret = avrcp_tg_connect(bd_addr);
        if (conn_ret != ERRCODE_BT_SUCCESS) {
            static_print_debug("avrcp_tg_connect failed, ret: %x", conn_ret);
        }
        static_print_debug("test mode auto reg");
        g_tjd_avrcp_srv_inf.avrcp_button_flag = AVRCP_SRV_RELEASED_VALUE;
        g_tjd_avrcp_srv_inf.reg_cap_auto = AVRCP_CT_AUTO_REG_TYPE;
        conn_ret = avrcp_ct_connect(bd_addr);
        if (conn_ret != ERRCODE_BT_SUCCESS) {
            static_print_debug("avrcp_ct_connect failed, ret: %x", conn_ret);
        }
    }

    if (conn_state == PROFILE_STATE_DISCONNECTED) {
        /* A2DP 连接断开后，主动断开AVRCP连接 */
        int disconn_ret = avrcp_tg_disconnect(bd_addr);
        if (disconn_ret != ERRCODE_BT_SUCCESS) {
            static_print_debug("avrcp_tg_disconnect failed, ret: %x", disconn_ret);
        }
    }
}

static void sample_a2dp_snk_accept_timer_stop(void)
{
    static_print_debug("stop timer");
    if (g_tjd_a2dp_stream_accept_timer.timer != NULL) {
        (void)osal_timer_stop(&g_tjd_a2dp_stream_accept_timer);
        (void)osal_timer_destroy(&g_tjd_a2dp_stream_accept_timer);
        g_tjd_a2dp_stream_accept_timer.timer = NULL;
    }
    static_print_debug("stop timer success!");
}

bool g_isA2dpSnkConnected = false;
static void sample_a2dp_snk_start_accept_handler(unsigned long data)
{
    static_print_debug("sample_a2dp_snk_start_accept_handler");
    // bts_unused(data);
    // if (g_isA2dpSnkConnected) {
    bd_addr_t active_bd_addr = a2dp_snk_get_active_device();
    a2dp_snk_start_accept(&active_bd_addr);
    sample_a2dp_snk_accept_timer_stop();
    // }
}

static int32_t sample_a2dp_snk_start_accept_timer(void)
{
    static_print_debug("start timer");
    if (g_tjd_a2dp_stream_accept_timer.timer != NULL) {
        static_print_debug("timer is running");
        return EXT_ERR_SUCCESS;
    }

    g_tjd_a2dp_stream_accept_timer.handler = sample_a2dp_snk_start_accept_handler;
    g_tjd_a2dp_stream_accept_timer.interval = A2DP_STREAM_ACCEPT_TIMER_PERIOD;

    int32_t timer_ret = osal_timer_init(&g_tjd_a2dp_stream_accept_timer);
    if (timer_ret != EOK) {
        static_print_debug("create timer error! ret: %x", timer_ret);
        sample_a2dp_snk_accept_timer_stop();
        return EXT_ERR_FAILURE;
    }
    timer_ret = osal_timer_start(&g_tjd_a2dp_stream_accept_timer);
    if (timer_ret != EOK) {
        static_print_debug("start timer error! ret: %x", timer_ret);
        sample_a2dp_snk_accept_timer_stop();
        return EXT_ERR_FAILURE;
    }
    return EXT_ERR_SUCCESS;
}

static int32_t sample_a2dp_snk_audio_create(void)
{
#if MEDIA_A2DP_SNK_INTERFACE
    static_print_debug("audioFormat %d channelCount %d sampleRate %u ", g_audio_format_config.audioFormat,
                       g_audio_format_config.channelCount, g_audio_format_config.sampleRate);
    // g_audio_format_config.audioFormat =
    int32_t ret = AudioManagerA2dpSinkSetParam(g_audio_format_config);
    static_print_debug("AudioManagerA2dpSinkSetParam ret %x", ret);
    ret = AudioManagerA2dpSinkCreate();
    static_print_debug("AudioManagerA2dpSinkCreate ret %x", ret);
#endif
    /* 起定时器接受音乐开始请求 */
    sample_a2dp_snk_start_accept_timer();
    return 0;
}

static void sample_a2dp_snk_start_stream_request_callback(const bd_addr_t *bd_addr)
{
    // static_print_debug("sample_a2dp_snk_start_stream_request_callback ba_addr: %p ",bd_addr);
    if (bd_addr == NULL) {
        static_print_debug("sample_a2dp_snk_start_stream_request_callback: bd_addr is NULL");
        return;
    }
    static_print_debug("a2dp_snk_start_stream_request_callback addr: ****%02x%02x%02x%02x ", bd_addr->addr[3],
                       bd_addr->addr[2], bd_addr->addr[1], bd_addr->addr[0]); /* 3 2 1 0 idx */
    sample_a2dp_snk_audio_create();
}

static int32_t sample_a2dp_snk_audio_destroy(void)
{
#if MEDIA_A2DP_SNK_INTERFACE
    int32_t ret = AudioManagerA2dpSinkDestroy();
    static_print_debug("AudioManagerA2dpSinkDestroy ret %x", ret);
#endif
    return 0;
}

static void sample_a2dp_snk_playing_state_changed_callback(const bd_addr_t *bd_addr, int playing_state)
{
    // static_print_debug("sample_a2dp_snk_playing_state_changed_callback ba_addr: %p ",bd_addr);
    if (bd_addr == NULL) {
        static_print_debug("sample_a2dp_snk_playing_state_changed_callback: bd_addr is NULL");
        return;
    }
    static_print_debug("a2dp_snk_playing_state_changed_callback addr: ****%02x%02x%02x%02x playing_state: %x",
                       bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1], bd_addr->addr[0],
                       playing_state); /* 3 2 1 0 idx */

    if (playing_state == A2DP_NOT_PLAYING) {
        sample_a2dp_snk_audio_destroy();
    }

    // }else if (playing_state == A2DP_IS_PLAYING){
    //     static_print_debug("a2dp is playing...");
    //     // avrcp_ct_get_element_attr_para_t element_attr_param;
    //     // element_attr_param.attr_num = AVRCP_CT_ELEMENT_ATTR_TRACK_PLAYING_TIME;
    //     // element_attr_param.attr_id_list =
    //     //     (unsigned int *)(void *)osal_kmalloc(sizeof(unsigned int) *
    //     element_attr_param.attr_num,OSAL_GFP_KERNEL);
    //     // for (int i = 0; i < element_attr_param.attr_num; i++) {
    //     //     element_attr_param.attr_id_list[i] = (unsigned int)i + 1;
    //     // }
    //     // avrcp_ct_get_element_attributes(bd_addr,&element_attr_param);
    //     // if (element_attr_param.attr_id_list != NULL) {
    //     // osal_kfree(element_attr_param.attr_id_list);
    //     // element_attr_param.attr_id_list = NULL;
    //     // }
    // }
}

static void sample_a2dp_snk_configuration_changed_callback(const bd_addr_t *bd_addr, const a2dp_snk_codec_info_t *info)
{
    // static_print_debug("sample_a2dp_snk_configuration_changed_callback ba_addr: %p  info: %p",bd_addr,info);
    if (bd_addr == NULL || info == NULL) {
        static_print_debug("sample_a2dp_snk_configuration_changed_callback: bd_addr or infois NULL");
        return;
    }
    static_print_debug("a2dp_snk_configuration_changed_callback addr: ****%02x%02x%02x%02x ", bd_addr->addr[3],
                       bd_addr->addr[2], bd_addr->addr[1], bd_addr->addr[0]); /* 3 2 1 0 idx */
    static_print_debug(
        "codec_priority: %04x codec_type: %04x sample_rate: %02x bits_per_sample: %02x channel_mode: %02x",
        info->codec_priority, info->codec_type, info->sample_rate, info->bits_per_sample, info->channel_mode);
    static_print_debug("codec_specific1: %04x codec_specific2: %04x codec_specific3: %04x codec_specific4: %04x",
                       (unsigned int)info->codec_specific1, (unsigned int)info->codec_specific2,
                       (unsigned int)info->codec_specific3, (unsigned int)info->codec_specific4);
#if MEDIA_A2DP_SNK_INTERFACE
    if (info->codec_type == A2DP_SNK_CODEC_TYPE_AAC) {
        g_audio_format_config.audioFormat = AAC_LC;
    } else {
        g_audio_format_config.audioFormat = SBC;
    }
    /* channel count 1 or 2 */
    g_audio_format_config.channelCount = (info->channel_mode == A2DP_SNK_CODEC_CHANNEL_MODE_NONE ? 1 : 2);

    switch (info->sample_rate) {
    case A2DP_SNK_CODEC_SAMPLE_RATE_48000:
        g_audio_format_config.sampleRate = BT_AUDIO_A2DP_SMAPLE_RATE48000;
        break;
    case A2DP_SNK_CODEC_SAMPLE_RATE_88200:
        g_audio_format_config.sampleRate = BT_AUDIO_A2DP_SMAPLE_RATE88200;
        break;
    case A2DP_SNK_CODEC_SAMPLE_RATE_96000:
        g_audio_format_config.sampleRate = BT_AUDIO_A2DP_SMAPLE_RATE96000;
        break;
    default:
        g_audio_format_config.sampleRate = BT_AUDIO_A2DP_SMAPLE_RATE44100;
        break;
    }
    static_print_debug("audioFormat %d channelCount %d sampleRate %u ", g_audio_format_config.audioFormat,
                       g_audio_format_config.channelCount, g_audio_format_config.sampleRate);
#endif
}

void register_a2dpsnk_servers_callback(void)
{
    static a2dp_snk_callbacks_t g_sample_a2dp_snk_callbacks = {
        .connectstate_changed_cb = sample_a2dp_snk_connect_state_changed_callback,
        .start_stream_request_cb = sample_a2dp_snk_start_stream_request_callback,
        .playing_state_changed_cb = sample_a2dp_snk_playing_state_changed_callback,
        .configuration_changed_cb = sample_a2dp_snk_configuration_changed_callback};

    int ret = a2dp_snk_register_callbacks(&g_sample_a2dp_snk_callbacks);
    if (ret != ERRCODE_BT_SUCCESS) {
        static_print_debug("a2dp_snk_register_callbacks ret(int): %x", ret);
    }
}
#pragma endregion

#pragma region avrcp ct server
/*************************************************************
 * AVRCP CT SERVER
 */
static bd_addr_t *sample_avrcp_srv_get_active_addr(void) { return &g_tjd_avrcp_srv_inf.bd_addr; }

static void sample_avrcp_ct_connect_state_changed_callback(const bd_addr_t *bd_addr, profile_connect_state_t state)
{
    if (bd_addr == NULL) {
        static_print_debug("null pointer");
        return;
    }
    static_print_debug("avrcp ct update conn stat:%u", state);
    (void)memcpy_s(g_tjd_avrcp_srv_inf.bd_addr.addr, BD_ADDR_LEN, bd_addr->addr, BD_ADDR_LEN);
    static_print_debug("addr: ****%02x%02x%02x%02x ", bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1],
                       bd_addr->addr[0]); /* 3 2 1 0 idx */
    g_tjd_avrcp_srv_inf.avrcp_srv_conn_stat = state;
    avrcp_ct_get_supported_events(g_tjd_avrcp_srv_inf.bd_addr.addr);
}

static void sample_avrcp_ct_press_button_rsp_cbk(const bd_addr_t *bd_addr, int32_t key_operation)
{
    if (bd_addr == NULL) {
        static_print_debug("null pointer");
        return;
    }
    static_print_debug("avrcp ct press button rsp_cbk key:%d", key_operation);
    if (g_tjd_avrcp_srv_inf.avrcp_button_flag == AVRCP_SRV_RELEASED_VALUE) {
        static_print_debug("avrcp ct press button button_flag change:%u->%u", g_tjd_avrcp_srv_inf.avrcp_button_flag,
                           AVRCP_SRV_PRESS_VALUE);
        g_tjd_avrcp_srv_inf.avrcp_button_flag = AVRCP_SRV_PRESS_VALUE;
    }
    static_print_debug("avrcp ct press button cbk key:%d button_flag:%u", key_operation,
                       g_tjd_avrcp_srv_inf.avrcp_button_flag);
}

static void sample_avrcp_press_release_button_log(uint32_t key_operation)
{
    switch (key_operation) {
    case AVRCP_KEY_VOLUME_UP:
        static_print_debug("AVRCP_KEY_VOLUME_UP");
        break;
    case AVRCP_KEY_VOLUME_DOWN:
        static_print_debug("AVRCP_KEY_VOLUME_DOWN");
        break;
    case AVRCP_KEY_MUTE:
        static_print_debug("AVRCP_KEY_VOLUME_MUTE");
        break;
    case AVRCP_KEY_PLAY:
        static_print_debug("AVRCP_KEY_PLAY");
        break;
    case AVRCP_KEY_STOP:
        static_print_debug("AVRCP_KEY_STOP");
        break;
    case AVRCP_KEY_PAUSE:
        static_print_debug("AVRCP_KEY_PAUSE");
        break;
    case AVRCP_KEY_FORWARD:
        static_print_debug("AVRCP_KEY_FORWARD");
        break;
    case AVRCP_KEY_BACKWARD:
        static_print_debug("AVRCP_KEY_BACKWARD");
        break;
    case AVRCP_NOTIFY_EVENT_VOLUME_CHANGED:
        static_print_debug("AVRCP_EVENT_VOLUME_CHANGED");
        break;
    default:
        static_print_debug("invalid");
        break;
    }
}

static void sample_avrcp_ct_release_button_rsp_cbk(const bd_addr_t *bd_addr, int32_t key_operation)
{
    if (bd_addr == NULL) {
        static_print_debug("null pointer");
        return;
    }
    static_print_debug("avrcp ct release button cbk key:%d", key_operation);
    if (g_tjd_avrcp_srv_inf.avrcp_button_flag == AVRCP_SRV_PRESS_VALUE) {
        static_print_debug("avrcp ct released button button_flag change:%u->%u", g_tjd_avrcp_srv_inf.avrcp_button_flag,
                           AVRCP_SRV_RELEASED_VALUE);
        g_tjd_avrcp_srv_inf.avrcp_button_flag = AVRCP_SRV_RELEASED_VALUE;
    }
    sample_avrcp_press_release_button_log((uint32_t)key_operation);
}

static void sample_avrcp_ct_support_company_callback(const bd_addr_t *bd_addr,
                                                     const avrcp_ct_support_company_para_t *company)
{
    if (bd_addr == NULL || company == NULL || company->company_id == NULL) {
        static_print_debug("null pointer");
        return;
    }
    static_print_debug("sample_avrcp_ct_get_support_company company list:");
    for (uint8_t i = 0; i < company->company_num; i++) {
        static_print_debug(" 0x%x ", *company->company_id);
    }
}

static void sample_avrcp_ct_support_event_callback(const bd_addr_t *bd_addr, avrcp_ct_support_event_para_t *event)
{
    if (bd_addr == NULL || event == NULL || event->event_id == NULL) {
        static_print_debug("null pointer");
        return;
    }
    static_print_debug("sample_avrcp_ct_support_event_callback event list:");
    for (uint8_t i = 0; i < event->event_num; i++) {
        static_print_debug(" 0x%x ", event->event_id[i]);
    }
    if (g_tjd_avrcp_srv_inf.reg_cap_auto != AVRCP_CT_AUTO_REG_TYPE) {
        return;
    }
    uint8_t avrcp_ct_cap[] = {
        AVRCP_NOTIFY_EVENT_RESERVED,                // 0
        AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED, // 1
        AVRCP_NOTIFY_EVENT_TRACK_CHANGED,
        AVRCP_NOTIFY_EVENT_TRACK_REACHED_END,
        AVRCP_NOTIFY_EVENT_TRACK_REACHED_START,
        AVRCP_NOTIFY_EVENT_RESERVED, // 5
        AVRCP_NOTIFY_EVENT_RESERVED,
        AVRCP_NOTIFY_EVENT_RESERVED,
        AVRCP_NOTIFY_EVENT_RESERVED,
        AVRCP_NOTIFY_EVENT_NOW_PLAYING_CONTENT_CHANGED, // 9
        AVRCP_NOTIFY_EVENT_AVAILABLE_PLAYERS_CHANGED,   // A
        AVRCP_NOTIFY_EVENT_ADDRESSED_PLAYER_CHANGED,
        AVRCP_NOTIFY_EVENT_RESERVED,       // 0xC
        AVRCP_NOTIFY_EVENT_VOLUME_CHANGED, // 0xD
    };
    for (uint8_t i = 0; i < event->event_num; i++) {
        if (event->event_id[i] < AVRCP_NOTIFY_EVENT_RESERVED &&
            avrcp_ct_cap[event->event_id[i]] != AVRCP_NOTIFY_EVENT_RESERVED) {
            avrcp_ct_register_notification(bd_addr, event->event_id[i], 0);
            static_print_debug("avrcp_ct_register_notification auto reg event_id:0x%x", event->event_id[i]);
        }
    }
}

static void sample_avrcp_ct_get_element_attri_callback(const bd_addr_t *bd_addr,
                                                       avrcp_ct_element_attr_para_cb_t *attr_cb_para)
{
    if (bd_addr == NULL || attr_cb_para == NULL || attr_cb_para->attr_value == NULL) {
        static_print_debug("null pointer");
        return;
    }
    // static_print_debug("sample_avrcp_ct_get_element_attri_callback");
    for (uint8_t i = 0; i < attr_cb_para->attr_num; i++) {
        // static_print_debug("attrId-charaId-valLen: 0x%x-0x%x-%u ", attr_cb_para->attr_value[i].attr_id,
        //                    attr_cb_para->attr_value[i].character_set_id, attr_cb_para->attr_value[i].value_len);
        switch (attr_cb_para->attr_value[i].attr_id) {
        case AVRCP_CT_ELEMENT_ATTR_TITLE:
            // static_print_debug("Attr Title:");
            if (g_sync_lrc_callback != NULL) {
                // static_print_debug("g_sync_lrc_callback((const char *)value);");
                g_sync_lrc_callback((const char *)attr_cb_para->attr_value[i].value, isFirst);
            } else {
                // static_print_debug("g_sync_lrc_callback is NULL");
            }
            if (isFirst) {
                isFirst = false;
            }
            break;
        case AVRCP_CT_ELEMENT_ATTR_ARTIST_NAME:
            // static_print_debug("Attr Name:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_ALBUM_NAME:
            // static_print_debug("Attr Album:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_TRACK_NUMBER:
            // static_print_debug("Attr Track Number:");
            // uint8_t *value = (uint8_t *)(void *)osal_kmalloc(attr_cb_para->attr_value[i].value_len + 1,
            // OSAL_GFP_KERNEL); if (attr_cb_para->attr_value[i].value_len > 0 && attr_cb_para->attr_value[i].value !=
            // NULL) {
            //     if (memcpy_s(value, attr_cb_para->attr_value[i].value_len, attr_cb_para->attr_value[i].value,
            //                 attr_cb_para->attr_value[i].value_len) != EOK) {
            //         osal_kfree(value);
            //         static_print_debug("memcpy_s fail.");
            //         return;
            //     }
            // }
            // value[attr_cb_para->attr_value[i].value_len] = '\0';
            // static_print_debug(" %s ", value);
            // osal_kfree(value);
            break;
        case AVRCP_CT_ELEMENT_ATTR_TOTAL_NUMBER_OF_TRACKS:
            // static_print_debug("Attr Total Number Of Track:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_TRACK_GENRE:
            // static_print_debug("Attr Track GENRE:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_TRACK_PLAYING_TIME:
            // static_print_debug("Attr Track Playing Time_ms:");
            break;
        default:
            // static_print_debug("Other:");
            break;
        }
    }
}

static void sample_avrcp_ct_hdl_notify_volume_rsp_cbk(avrcp_ct_notification_value_cb_t *notification)
{
    static_print_debug("Set local volume:0x%x", notification->volume); /* 注册事件后通知的音量 */
}

static void sample_avrcp_ct_notification_callback(const bd_addr_t *bd_addr, avrcp_notify_event_t event_id,
                                                  avrcp_ct_notification_value_cb_t *notification)
{
    if (bd_addr == NULL || notification == NULL) {
        static_print_debug("null pointer");
        return;
    }
    static_print_debug("ct notification cbk event_id:0x%x playback_position %d", event_id,
                       notification->playback_position);
    bool notify_flag = true;
    switch (event_id) {
    case AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED:
        static_print_debug("tg notify ct playback status changed :%u", notification->play_status);
        if (g_playing_state_callback != NULL) {
            static_print_debug("g_playing_state_callback");
            g_playing_state_callback(notification->play_status);
        }
        break;
    case AVRCP_NOTIFY_EVENT_VOLUME_CHANGED:
        sample_avrcp_ct_hdl_notify_volume_rsp_cbk(notification);
        break;
    case AVRCP_NOTIFY_EVENT_NOW_PLAYING_CONTENT_CHANGED:
        static_print_debug("play conent changed event_id:0x%x", event_id);
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_CHANGED:
        static_print_debug("track changed event_id:0x%x", event_id);
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_END:
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_START:
    case AVRCP_NOTIFY_EVENT_PLAYBACK_POS_CHANGED:
    case AVRCP_NOTIFY_EVENT_BATT_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_SYSTEM_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_PLAYER_APPLICATION_SETTING_CHANGED:
    case AVRCP_NOTIFY_EVENT_AVAILABLE_PLAYERS_CHANGED:
    case AVRCP_NOTIFY_EVENT_ADDRESSED_PLAYER_CHANGED:
    case AVRCP_NOTIFY_EVENT_UIDS_CHANGED:
    case AVRCP_NOTIFY_EVENT_RESERVED:
    default:
        notify_flag = true;
        break;
    }
    if (notify_flag) {
        static_print_debug("notify reg event_id:%u", event_id);
        avrcp_ct_register_notification(bd_addr, event_id, 0); /* TG通知变化后CT重新注册事件 */
        avrcp_ct_get_element_attr_para_t element_attr_param;
        element_attr_param.attr_num = AVRCP_CT_ELEMENT_ATTR_TRACK_PLAYING_TIME;
        element_attr_param.attr_id_list =
            (unsigned int *)(void *)malloc(sizeof(unsigned int) * element_attr_param.attr_num);
        for (int i = 0; i < element_attr_param.attr_num; i++) {
            element_attr_param.attr_id_list[i] = (unsigned int)i + 1;
        }
        avrcp_ct_get_element_attributes(bd_addr, &element_attr_param);
        if (element_attr_param.attr_id_list != NULL) {
            free(element_attr_param.attr_id_list);
            element_attr_param.attr_id_list = NULL;
        }
    }
}

static void sample_avrcp_ct_get_play_status_callback(const bd_addr_t *bd_addr, const avrcp_ct_play_status_cb_t *status)
{
    if (bd_addr == NULL || status == NULL) {
        static_print_debug("null pointer");
        return;
    }
    static_print_debug("test get play status songlen:%u, songpos:%u, playstatus:%u:", status->song_length,
                       status->song_position, status->play_status);
    // if() {
    //         isFirst = true;
    //     }
}

void register_avrcp_ct_servers_callbacks(void)
{
    static avrcp_ct_callbacks_t g_sample_avrcp_ct_bts_cbk = {
        sample_avrcp_ct_connect_state_changed_callback, sample_avrcp_ct_press_button_rsp_cbk,
        sample_avrcp_ct_release_button_rsp_cbk,         sample_avrcp_ct_support_company_callback,
        sample_avrcp_ct_support_event_callback,         sample_avrcp_ct_get_element_attri_callback,
        sample_avrcp_ct_get_play_status_callback,       sample_avrcp_ct_notification_callback,
    };
    int ret = avrcp_ct_register_callbacks(&g_sample_avrcp_ct_bts_cbk);
    if (ret != ERRCODE_SUCC) {
        static_print_debug("avrcp_ct_register_callbacks fail:%d", ret);
    }
}
#pragma endregion

#pragma region AVRCP TG SERVERS
/***************************************************************
 *   AVRCP TG SERVERS
 */
static void sample_avrcp_tg_connect_state_changed_callback(const bd_addr_t *bd_addr, profile_connect_state_t state)
{
    if (bd_addr == NULL) {
        static_print_debug("null pointer");
        return;
    }
    static_print_debug("avrcp tg update conn stat:%u", state);
    if (memcpy_s(&g_tjd_avrcp_srv_inf.bd_addr, BD_ADDR_LEN, bd_addr->addr, BD_ADDR_LEN) != EOK) {
        static_print_debug("memcpy_s fail.");
        return;
    }
    g_tjd_avrcp_srv_inf.avrcp_srv_conn_stat = state;
    static_print_debug("addr: ****%02x%02x%02x%02x ", bd_addr->addr[3], bd_addr->addr[2], bd_addr->addr[1],
                       bd_addr->addr[0]); /* 3 2 1 0 idx */
}

void register_avrcp_tg_servers_callbacks(void)
{
    static avrcp_tg_callbacks_t g_sample_avrcp_tg_bts_cbk = {
        sample_avrcp_tg_connect_state_changed_callback,
    };
    int ret = avrcp_tg_register_callbacks(&g_sample_avrcp_tg_bts_cbk);
    if (ret != ERRCODE_SUCC) {
        static_print_debug("avrcp_tg_register_callbacks fail:%d", ret);
    }
}

static void sample_avrcp_set_notify(bt_avrcp_tg_evt_status_param *notify_event_status_param,
                                    avrcp_notify_event_t event_id, uint8_t event_status)
{
    notify_event_status_param->event_id = event_id;
    notify_event_status_param->event_status[0] = event_status;
}

static void avrcp_tg_notify_press_button_callback(uint32_t key_operation, uint32_t key_value)
{
    bt_avrcp_tg_evt_status_param param;
    static_print_debug("sample_avcrp_tg_notify:key_type:%u", key_operation);
    // sample_avrcp_press_release_button_log(key_operation);
    switch (key_operation) {
    case AVRCP_KEY_VOLUME_UP:
        // sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_VOLUME_CHANGED, g_avrcp_srv_sample_inf.loc_volume);
        break;
    case AVRCP_KEY_VOLUME_DOWN:
        // sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_VOLUME_CHANGED, g_avrcp_srv_sample_inf.loc_volume);
        break;
    case AVRCP_KEY_MUTE:
        // sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_VOLUME_CHANGED, 0x0);
        break;
    case AVRCP_KEY_PLAY:
        // sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED, AVRCP_PLAY_STATUS_PLAYING);
        break;
    case AVRCP_KEY_STOP:
        // sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED, AVRCP_PLAY_STATUS_STOPPED);
        break;
    case AVRCP_KEY_PAUSE:
        // sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED, AVRCP_PLAY_STATUS_PAUSED);
        break;
    case AVRCP_KEY_FORWARD:
        // sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED, AVRCP_PLAY_STATUS_FWD_SEEK);
        break;
    case AVRCP_KEY_BACKWARD:
        // sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED, AVRCP_PLAY_STATUS_REV_SEEK);
        break;
    case AVRCP_NOTIFY_EVENT_VOLUME_CHANGED:
        static_print_debug("set absolute volume:%u", key_value);

        // sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_VOLUME_CHANGED, (uint8_t)key_value);
        break;
    default:
        sample_avrcp_set_notify(&param, AVRCP_NOTIFY_EVENT_RESERVED, AVRCP_PLAY_STATUS_ERROR);
        break;
    }
}

static void avrcp_tg_get_loc_media_status_callback(bt_avrcp_tg_evt_status_param *event_status_param)
{
    if (event_status_param == NULL) {
        return;
    }
    event_status_param->event_status[0] = 0xff;
    uint8_t stream_stat;
    switch (event_status_param->event_id) {
    case AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED:
        stream_stat = a2dp_src_get_stream_status();
        if (stream_stat == SAMPLE_A2DP_STREAM_START) {
            event_status_param->event_status[0] = AVRCP_PLAY_STATUS_PLAYING;
        } else if (stream_stat == SAMPLE_A2DP_STREAM_SUSPENDED) {
            event_status_param->event_status[0] = AVRCP_PLAY_STATUS_PAUSED;
        } else {
            event_status_param->event_status[0] = AVRCP_PLAY_STATUS_STOPPED;
        }
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_CHANGED:
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_END:
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_START:
        break;
    case AVRCP_NOTIFY_EVENT_PLAYBACK_POS_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_BATT_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_SYSTEM_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_PLAYER_APPLICATION_SETTING_CHANGED:
    case AVRCP_NOTIFY_EVENT_NOW_PLAYING_CONTENT_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_AVAILABLE_PLAYERS_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_ADDRESSED_PLAYER_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_UIDS_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_VOLUME_CHANGED:
        static_print_debug("avrcp_tg_get_loc_media_status_callback: volume:%u", event_status_param->event_status[0]);
        // event_status_param->event_status[0] = avrcp_tg_get_loc_media_volume();
        break;
    case AVRCP_NOTIFY_EVENT_RESERVED:
    default:
        break;
    }
    static_print_debug("sample_avrcp_tg_get_loc_media_status_callback event_id:0x%x event_status:%u",
                       event_status_param->event_id, event_status_param->event_status[0]);
}

void register_bt_avrcp_tg_bts_callback(void)
{
    static bt_avrcp_tg_bts_cbk g_sample_avrcp_tg_callbacks = {
        avrcp_tg_notify_press_button_callback,
        avrcp_tg_get_loc_media_status_callback,
    };
    bt_avrcp_tg_register_audio_cbk(&g_sample_avrcp_tg_callbacks);
}
#pragma endregion

void register_playing_state_callback(playing_state_callback_t callback)
{
    static_print_debug("register_playing_state_callback");
    g_playing_state_callback = callback;
}

void unregister_playing_state_callback(void) { g_playing_state_callback = NULL; }

void register_snk_connect_state_callback(snk_connect_state_callback_t callback)
{
    static_print_debug("g_snk_connect_state_callback");
    g_snk_connect_state_callback = callback;
}

void unregister_snk_connect_state_callback(void) { g_snk_connect_state_callback = NULL; }

void register_src_connect_state_callback(src_connect_state_callback_t callback)
{
    g_src_connect_state_callback = callback;
}

void unregister_src_connect_state_callback(void) { g_src_connect_state_callback = NULL; }

void register_sync_lrc_callback(sync_lrc_callback_t callback)
{
    static_print_debug("g_sync_lrc_callback");
    g_sync_lrc_callback = callback;
}

void unregister_sync_lrc_callback(void) { g_sync_lrc_callback = NULL; }