// Copyright (2025) Beijing Volcano Engine Technology Ltd.
// SPDX-License-Identifier: Apache-2.0

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <inttypes.h>
#include <stdbool.h>

#include <cJSON.h>
#include <esp_heap_caps.h>

// 确保在包含volc_rtc.h之前定义ENABLE_RTC_MODE
#ifndef ENABLE_RTC_MODE
#define ENABLE_RTC_MODE
#endif

#include "VolcEngineRTCLite.h"
#include "volc_rtc.h"
#include "volc_platform.h"
#include "util/volc_list.h"
#include "util/volc_log.h"
#include "util/volc_json.h"
#include "base/volc_base.h"
#include "base/volc_device_manager.h"

// 移除多余的ENABLE_RTC_MODE条件编译块，因为它已经在头文件中处理

#define MAGIC_CONTROL "ctrl"
#define MAGIC_CONV    "conv"
#define MAGIC_LENGTH 4
#define MAGIC_OFFSET 8
const char* interrupt_str = "{\"Command\":\"interrupt\"}";

typedef struct {
    bool b_pipeline_started;
    bool b_user_joined;
    bool b_channel_joined;
    bool b_first_keyframe_received;
    bool b_fini;
    bool b_audio_publish;
    bool b_video_publish;
    bool b_audio_subscribe;
    bool b_video_subscribe;
    char* p_appid;
    char* p_channel_name;
    char* p_user_id;
    char* p_remote_user_id;
    char* p_token;
    void* context;
    int audio_codec;
    volc_room_info_t info;
    volc_msg_cb message_callback;
    volc_data_cb data_callback;
    byte_rtc_engine_t rtc;
    byte_rtc_event_handler_t event_handler;
} rtc_impl_t;

static bool __is_first_keyframe_not_received(rtc_impl_t* rtc, int is_key_frame)
{
    return (!rtc->b_first_keyframe_received && !is_key_frame);
}

static int _build_binary_message(const char* magic, const char* message, 
                        uint8_t** out_buf, size_t* out_len) {
    size_t magic_len = strlen(magic);
    size_t msg_len = strlen(message);
    
    // 分配内存：魔术字 + 4字节长度 + 消息内容
    *out_len = magic_len + 4 + msg_len;
    *out_buf = (uint8_t*)hal_malloc(*out_len);
    if (!*out_buf) {
        LOGE("hal_malloc failed");
        return -1;
    }
    
    // 填充魔术字
    memcpy(*out_buf, magic, magic_len);
    
    // 以大端序填充长度
    uint8_t* len_ptr = *out_buf + magic_len;
    len_ptr[0] = (uint8_t)((msg_len >> 24) & 0xFF); // 最高位字节
    len_ptr[1] = (uint8_t)((msg_len >> 16) & 0xFF);
    len_ptr[2] = (uint8_t)((msg_len >> 8)  & 0xFF);
    len_ptr[3] = (uint8_t)(msg_len & 0xFF);         // 最低位字节
    
    // 填充消息内容
    memcpy(*out_buf + magic_len + 4, message, msg_len);
    
    return 0;
}

static int __rtc_start(rtc_impl_t* rtc, volc_rtc_option_t* option)
{
    byte_rtc_room_options_t room_opt = {0};
    if (!rtc || !option) {
        LOGE("rtc or option is NULL");
        return -1;
    }
    if (!option->p_channel_name || !option->p_uid || !option->p_token) {
        LOGE("invalid rtc option: channel(%p) uid(%p) token(%p)", option->p_channel_name, option->p_uid, option->p_token);
        return -1;
    }
    if (strlen(option->p_channel_name) == 0 || strlen(option->p_uid) == 0 || strlen(option->p_token) == 0) {
        LOGE("invalid rtc option: empty field");
        return -1;
    }

    room_opt.auto_publish_audio = rtc->b_audio_publish;
    room_opt.auto_publish_video = rtc->b_video_publish;
    room_opt.auto_subscribe_audio = rtc->b_audio_subscribe;
    room_opt.auto_subscribe_video = rtc->b_video_subscribe;
    
    // 记录内存使用情况
    size_t heap_free_before = heap_caps_get_free_size(MALLOC_CAP_DEFAULT);
    size_t spiram_free_before = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
    
    LOGI("Joining channel: %s, uid: %s, token: %s, vpub: %d, vsub: %d, apub: %d, asub: %d", 
         option->p_channel_name, option->p_uid, option->p_token, 
         (int)room_opt.auto_publish_video, (int)room_opt.auto_subscribe_video, 
         (int)room_opt.auto_publish_audio, (int)room_opt.auto_subscribe_audio);
    LOGI("Memory before byte_rtc_join_room - Heap: %u bytes, SPIRAM: %u bytes", 
         (unsigned)heap_free_before, (unsigned)spiram_free_before);
    
    int ret = byte_rtc_join_room(rtc->rtc, option->p_channel_name, option->p_uid, option->p_token, &room_opt);
    
    // 记录内存使用情况
    size_t heap_free_after = heap_caps_get_free_size(MALLOC_CAP_DEFAULT);
    size_t spiram_free_after = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
    
    LOGI("Memory after byte_rtc_join_room - Heap: %u bytes (change: %d), SPIRAM: %u bytes (change: %d)", 
         (unsigned)heap_free_after, (int)(heap_free_after - heap_free_before), 
         (unsigned)spiram_free_after, (int)(spiram_free_after - spiram_free_before));
    
    if (ret != 0) {
        LOGE("Failed to join room: %d", ret);
        return ret;
    }
    rtc->b_pipeline_started = true;
    
    rtc->p_channel_name = strdup(option->p_channel_name);
    if (!rtc->p_channel_name) {
        LOGE("Failed to allocate memory for channel name");
        return -1;
    }
    rtc->p_user_id = strdup(option->p_uid);
    if (!rtc->p_user_id) {
        LOGE("Failed to allocate memory for user ID");
        HAL_SAFE_FREE(rtc->p_channel_name);
        return -1;
    }

    return 0;
}

static void __rtc_stop(rtc_impl_t* rtc)
{
    if (!rtc) {
        LOGE("rtc instance is NULL");
        return;
    }
    if (!rtc->b_pipeline_started) {
        LOGI("pipeline not started");
        return;
    }

    int ret = byte_rtc_leave_room(rtc->rtc, rtc->p_channel_name);
    if (ret != 0) {
        LOGE("Failed to leave room: %d", ret);
        return;
    }
    rtc->b_pipeline_started = false;
    HAL_SAFE_FREE(rtc->p_channel_name);

    return;
}

// static void __send_message_2_user(rtc_impl_t* rtc, volc_msg_t* msg)
// {
//     if (rtc->message_callback) {
//         rtc->message_callback(rtc->context, msg);
//     }
// }

static void __send_data_2_user(rtc_impl_t* rtc, const void* data, int data_len, volc_data_info_t* info) {
    // 添加详细的参数验证，确保回调函数的安全调用
    if (!rtc) {
        LOGE("__send_data_2_user: rtc is NULL");
        return;
    }
    
    if (!rtc->data_callback) {
        // 没有注册回调函数，这是正常情况，不记录错误
        return;
    }
    
    if (!data) {
        LOGE("__send_data_2_user: data is NULL");
        return;
    }
    
    if (data_len <= 0) {
        LOGE("__send_data_2_user: data_len is <= 0");
        return;
    }
    
    if (!info) {
        LOGE("__send_data_2_user: info is NULL");
        return;
    }
    
    // 调用数据回调函数
    rtc->data_callback(rtc->context, data, data_len, info);
}

// static void _register_message_router(rtc_impl_t* rtc, volc_msg_cb callback)
// {
//     rtc->message_callback = callback;
// }

static void _send_message_2_user(rtc_impl_t* rtc, volc_msg_t* msg)
{
    if (rtc->message_callback) {
        rtc->message_callback(rtc->context, msg);
    }
}

static bool _is_target_message(const uint8_t* message, int size, const char* target) {
    if (message == NULL || target == NULL || size < MAGIC_LENGTH) {
        return false;
    }
    return memcmp(message, target, MAGIC_LENGTH) == 0;
}

static int _on_conversion_status_message_parsed(const char* json, int len) {
    int c = -1;
    char* buf = (char*)hal_malloc(len + 1);
    if (!buf) return c;
    memcpy(buf, json, len);
    buf[len] = '\0';
    cJSON *root = cJSON_Parse(buf);
    if (root != NULL) {
        volc_json_read_int(root, "Stage.Code", &c);
        cJSON_Delete(root);
    }
    hal_free(buf);
    return c;
}

static void _on_join_channel_success(byte_rtc_engine_t engine, const char* channel, int elapsed_ms, bool rejoin)
{
    volc_msg_t msg = {0};
    LOGI("join channel success %s elapsed %d ms\n", channel, elapsed_ms);
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);

    rtc->b_first_keyframe_received = false;
    rtc->b_channel_joined = true;

    msg.code = VOLC_MSG_CONNECTED;
    _send_message_2_user(rtc, &msg);
};

static void _on_user_joined(byte_rtc_engine_t engine, const char* channel, const char* user_name, int elapsed_ms)
{
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    volc_msg_t msg = {0};
    LOGI("remote user joined %s:%s elapsed %d ms\n", channel, user_name, elapsed_ms);

    rtc->b_user_joined = true;
    
    // 先释放旧的内存
    HAL_SAFE_FREE(rtc->p_remote_user_id);
    
    // 分配新内存并检查结果
    char* temp = strdup(user_name);
    if (temp) {
        rtc->p_remote_user_id = temp;
    } else {
        LOGE("Failed to allocate memory for remote user ID");
    }

    msg.code = VOLC_MSG_USER_JOINED;
    _send_message_2_user(rtc, &msg);
};

static void _on_user_offline(byte_rtc_engine_t engine, const char* channel, const char* user_name, int reason)
{
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    volc_msg_t msg = {0};
    LOGI("remote user offline %s:%s reason %d\n", channel, user_name, reason);
    rtc->b_user_joined = false;
    
    // 清理远程用户ID，避免内存泄漏
    HAL_SAFE_FREE(rtc->p_remote_user_id);

    msg.code = VOLC_MSG_USER_OFFLINE;
    _send_message_2_user(rtc, &msg);
};

static void _on_user_mute_audio(byte_rtc_engine_t engine, const char* channel, const char* user_name, int muted)
{
    LOGD("remote user mute audio  %s:%s %d\n", channel, user_name, muted);
};

static void _on_user_mute_video(byte_rtc_engine_t engine, const char* channel, const char* user_name, int muted)
{
    LOGD("remote user mute video  %s:%s %d\n", channel, user_name, muted);
};

static void _on_audio_data(byte_rtc_engine_t engine, const char* channel, const char* user_name, uint16_t sent_ts, audio_data_type_e data_type,
                            const void* data_ptr, size_t data_len, const uint8_t* extra_info, size_t extra_info_size)
{
    // 添加详细的参数验证，防止空指针和无效数据导致崩溃
    if (!engine) {
        LOGE("_on_audio_data: engine is NULL");
        return;
    }
    
    if (!channel) {
        LOGE("_on_audio_data: channel is NULL");
        return;
    }
    
    if (!user_name) {
        LOGE("_on_audio_data: user_name is NULL");
        return;
    }
    
    if (!data_ptr) {
        LOGE("_on_audio_data: data_ptr is NULL");
        return;
    }
    
    if (data_len == 0) {
        LOGE("_on_audio_data: data_len is 0");
        return;
    }
    
    volc_data_info_t info = {0};
    rtc_impl_t* rtc = (rtc_impl_t*)byte_rtc_get_user_data(engine);

    if (NULL == rtc) {
        LOGE("_on_audio_data: rtc instance is NULL");
        return;
    }
    
    if (!rtc->b_pipeline_started) {
        LOGE("_on_audio_data: pipeline not started");
        return;
    }
    
    if (!rtc->b_channel_joined) {
        LOGE("_on_audio_data: channel not joined");
        return;
    }
    
    if (!rtc->b_user_joined) {
        LOGE("_on_audio_data: user not joined");
        return;
    }
    
    info.type = VOLC_DATA_TYPE_AUDIO;
    info.info.audio.data_type = (volc_audio_data_type_e) data_type;
    // info.info.audio.sent_ts = sent_ts;
    
    // 限制数据大小，防止内存溢出
    if (data_len > 16384) { // 16KB的合理限制
        LOGW("_on_audio_data: data_len too large (%zu), truncating to 16KB", data_len);
        data_len = 16384;
    }
    
    __send_data_2_user(rtc, data_ptr, data_len, &info);
};

static void _on_video_data(byte_rtc_engine_t engine, const char* channel, const char* user_name, uint16_t sent_ts, video_data_type_e codec,
                           int is_key_frame, const void* data_ptr, size_t data_len)
{
    volc_data_info_t info = {0};
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);

    if (NULL == rtc || !rtc->b_pipeline_started || !rtc->b_channel_joined || !rtc->b_user_joined) {
        LOGD("pipeline not started or channel not joined or user not joined");
        return;
    }

    if (__is_first_keyframe_not_received(rtc, is_key_frame)) {
        LOGD("first keyframe not received, request key frame");
        byte_rtc_request_video_key_frame(rtc->rtc, channel, user_name);
        return;
    }

    rtc->b_first_keyframe_received = true;

    info.type = VOLC_DATA_TYPE_VIDEO;
    info.info.video.data_type = (volc_video_data_type_e) codec;
    __send_data_2_user(rtc, data_ptr, data_len, &info);
};

static void _on_channel_error(byte_rtc_engine_t engine, const char* channel, int code, const char* msg)
{
    volc_msg_t msg_data = {0};
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    LOGE("channel error %s:%d %s\n", channel, code, msg ? msg : "");
    LOGI("channel error heap_free=%u", (unsigned)heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
    msg_data.code = code;
    char* copied = NULL;
    if (msg) {
        size_t len = strnlen(msg, 1024);
        copied = (char*)hal_malloc(len + 1);
        if (copied) {
            memcpy(copied, msg, len);
            copied[len] = '\0';
            msg_data.data.msg = copied;
        }
    }
    _send_message_2_user(rtc, &msg_data);
    if (copied) {
        hal_free(copied);
    }
};

static void _on_global_error(byte_rtc_engine_t engine, int code, const char* message)
{
    volc_msg_t msg_data = {0};
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    rtc->b_channel_joined = false;

    rtc->b_first_keyframe_received = false;
    LOGI("global error %d %s\n", code, message);
    LOGI("global error heap_free=%u", (unsigned)heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
    msg_data.code = VOLC_MSG_DISCONNECTED;
    _send_message_2_user(rtc, &msg_data);
};

static void _on_key_frame_gen_req(byte_rtc_engine_t engine, const char* channel, const char* user_name)
{
    LOGI("remote req key frame %s:%s\n", channel, user_name);
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    volc_msg_t msg_data = {0};
    msg_data.code = VOLC_MSG_KEY_FRAME_REQ;
    _send_message_2_user(rtc, &msg_data);
};

static void _on_target_bitrate_changed(byte_rtc_engine_t engine, const char* channel, uint32_t target_bps)
{
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    volc_msg_t msg_data = {0};

    LOGD("target bitrate changed %s %d bps\n", channel, (int)target_bps);
    // TODO: do not send it to user
    msg_data.code = VOLC_MSG_TARGET_BITRATE_CHANGED;
    msg_data.data.target_bitrate = target_bps;
    _send_message_2_user(rtc, &msg_data);
};

static void _on_token_privilege_will_expire(byte_rtc_engine_t engine, const char* token)
{
    LOGI("\ntoken privilege will expire %s", token);
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    volc_msg_t msg_data = {0};
    msg_data.code = VOLC_MSG_TOKEN_EXPIRED;
    // TODO: token?
    _send_message_2_user(rtc, &msg_data);
};

static void _on_message_received(byte_rtc_engine_t engine, const char* channel_name, const char* src, const uint8_t* message, int size, bool binary)
{
    int ret = 0;
    volc_msg_t msg = { 0 };
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    volc_data_info_t info = {0};
    info.type = VOLC_DATA_TYPE_MESSAGE;
    info.info.message.is_binary = binary;
    LOGI("message received channel=%s src=%s size=%d binary=%d free_heap=%u", channel_name, src, size, binary, (unsigned)heap_caps_get_free_size(MALLOC_CAP_DEFAULT));

    if (NULL == rtc || !rtc->b_pipeline_started || !rtc->b_channel_joined || !rtc->b_user_joined) {
        LOGE("pipeline not started or channel not joined or user not joined");
        return;
    }

    if (_is_target_message(message, size, MAGIC_CONV)) {
        if (size < MAGIC_OFFSET) {
            LOGW("conv message too short: %d", size);
            return;
        }
        int json_len = (message[4] << 24) | (message[5] << 16) | (message[6] << 8) | (message[7]);
        if (json_len <= 0 || size < (MAGIC_OFFSET + json_len)) {
            LOGW("conv message invalid length: %d size: %d", json_len, size);
            return;
        }
        const char* json_ptr = (const char*)(message + MAGIC_OFFSET);
        ret = _on_conversion_status_message_parsed(json_ptr, json_len);
        msg.code = VOLC_MSG_CONV_STATUS;
        msg.data.conv_status = ret;
        _send_message_2_user(rtc, &msg);
        return;
    }
    __send_data_2_user(rtc, message, size, &info);
};

static void _on_message_send_result(byte_rtc_engine_t engine, const char* channel_name, int64_t msgid, int error, const char* extencontent)
{
    LOGD("----------------------->MessageSendResult msg id %" PRId64 ", error %d, extencontent %s \n", msgid, error, extencontent);
};

static void _on_license_will_expire(byte_rtc_engine_t engine, int daysleft)
{
    LOGI("----------------------->license will expire in %d days \n", daysleft);
    volc_msg_t msg_data = {0};
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    msg_data.code = VOLC_MSG_LICENSE_EXPIRED;
    _send_message_2_user(rtc, &msg_data);
};

static void _on_fini_notify(byte_rtc_engine_t engine)
{
    rtc_impl_t* rtc = (rtc_impl_t*) byte_rtc_get_user_data(engine);
    rtc->b_fini = true;
}

static int __rtc_init(rtc_impl_t* engine, cJSON* p_config)
{
    int ret = 0;
    int video_codec = 0;
    int log_level = 0;
    int params_cnt = 0;
    cJSON* p_params = NULL;
    // 初始化结构体中的event_handler字段，避免局部变量导致的悬挂指针问题
    // 初始化结构体中的event_handler字段，避免局部变量导致的悬挂指针问题
    memset(&engine->event_handler, 0, sizeof(byte_rtc_event_handler_t));
    engine->event_handler.on_global_error = _on_global_error;
    engine->event_handler.on_join_room_success = _on_join_channel_success;
    engine->event_handler.on_room_error = _on_channel_error;
    engine->event_handler.on_user_joined = _on_user_joined;
    engine->event_handler.on_user_offline = _on_user_offline;
    engine->event_handler.on_user_mute_audio = _on_user_mute_audio;
    engine->event_handler.on_user_mute_video = _on_user_mute_video;
    engine->event_handler.on_audio_data = _on_audio_data;
    engine->event_handler.on_video_data = _on_video_data;
    engine->event_handler.on_key_frame_gen_req = _on_key_frame_gen_req;
    engine->event_handler.on_target_bitrate_changed = _on_target_bitrate_changed;
    engine->event_handler.on_token_privilege_will_expire = _on_token_privilege_will_expire;
    engine->event_handler.on_message_received = _on_message_received;
    engine->event_handler.on_message_send_result = _on_message_send_result;
    engine->event_handler.on_license_expire_warning = _on_license_will_expire;
    engine->event_handler.on_fini_notify = _on_fini_notify;
    ret = volc_json_read_int(p_config, "audio.codec", &engine->audio_codec);
    if (ret != 0 || engine->audio_codec < 0 || engine->audio_codec > AUDIO_CODEC_TYPE_G711U) {
        LOGE("volc_rtc_create: read audio_codec failed");
        return -1;
    }
    ret = volc_json_read_int(p_config, "video.codec", &video_codec);
    if (ret != 0 || video_codec < 0 || video_codec > VIDEO_CODEC_TYPE_BYTEVC1) {
        LOGE("volc_rtc_create: read video_codec failed");
        return -1;
    }
    ret = volc_json_read_int(p_config, "log_level", &log_level);
    if (ret != 0) {
       log_level = BYTE_RTC_LOG_LEVEL_WARN; // default log level
    }
    ret = volc_json_read_bool(p_config, "audio.publish", &engine->b_audio_publish);
    if (ret != 0) {
        engine->b_audio_publish = true; // default to publish audio
    }
    ret = volc_json_read_bool(p_config, "video.publish", &engine->b_video_publish);
    if (ret != 0) {
        engine->b_video_publish = false; // default to no publish video
    }
    ret = volc_json_read_bool(p_config, "audio.subscribe", &engine->b_audio_subscribe);
    if (ret != 0) {
        engine->b_audio_subscribe = true; // default to subscribe audio
    }
    ret = volc_json_read_bool(p_config, "video.subscribe", &engine->b_video_subscribe);
    if (ret != 0) {
        engine->b_video_subscribe = false; // default to no subscribe video
    }

    engine->rtc = byte_rtc_create(engine->p_appid, &engine->event_handler);
    if (!engine->rtc) {
        LOGE("volc_rtc_create: byte_rtc_create failed");
        return -1;
    }
    byte_rtc_set_user_data(engine->rtc, (void*) engine);
    byte_rtc_set_log_level(engine->rtc, log_level);
    
    ret = volc_json_read_object(p_config, "params", &p_params);
    if (0 == ret) {
        params_cnt = cJSON_GetArraySize(p_params);
        if (params_cnt > 0) {
            for (int i = 0; i < params_cnt; i++) {
                cJSON* p_param = cJSON_GetArrayItem(p_params, i);
                if (p_param && cJSON_IsString(p_param)) {
                    const char* param_str = cJSON_GetStringValue(p_param);
                    if (param_str && strlen(param_str) > 0) {
                        byte_rtc_set_params(engine->rtc, param_str);
                        LOGI("volc_rtc_create: set param[%d]: %s", i, param_str);
                    }
                }
            }
        }
        cJSON_Delete(p_params);
    }
    
    int init_ret = byte_rtc_init(engine->rtc);
    if (init_ret != 0) {
        LOGE("volc_rtc_create: byte_rtc_init failed with ret=%d", init_ret);
        return -1;
    }
    
    byte_rtc_set_audio_codec(engine->rtc, engine->audio_codec);
    byte_rtc_set_video_codec(engine->rtc, video_codec - 1); // -1 for default codec
    return 0;
}

volc_rtc_t volc_rtc_create(const char* appid, void* context, cJSON* p_config, volc_msg_cb message_callback, volc_data_cb data_callback)
{
    rtc_impl_t* rtc = (rtc_impl_t*) hal_calloc(1, sizeof(rtc_impl_t));
    if (!rtc) {
        LOGE("volc_rtc_create: malloc rtc failed");
        return NULL;
    }
    rtc->message_callback = message_callback;
    rtc->data_callback = data_callback;
    rtc->context = context;
    
    // 检查appid是否为空，如果为空则使用默认值
    const char* actual_appid = appid;
    if (!appid || strlen(appid) == 0) {
        LOGW("appid is empty, using default value");
        actual_appid = "default_appid";
    }
    
    rtc->p_appid = strdup(actual_appid);
    if (NULL == rtc->p_appid) {
        LOGE("malloc appid memory failed");
        goto err_out_label;
    }

    if (__rtc_init(rtc, p_config) != 0) {
        LOGE("volc_rtc_create: rtc init failed");
        goto err_out_label;
    }

    LOGD("rtc create success");
    return (volc_rtc_t)rtc;
err_out_label:
    HAL_SAFE_FREE(rtc->p_appid);
    HAL_SAFE_FREE(rtc);
    return NULL;
}

void volc_rtc_destroy(volc_rtc_t handle)
{
    rtc_impl_t* rtc = (rtc_impl_t*)handle;
    if (!rtc) {
        LOGE("rtc instance is NULL");
        return;
    }
    __rtc_stop(rtc);

    byte_rtc_fini(rtc->rtc);
    while (!rtc->b_fini) {
        usleep(1000 * 10);
    }
    byte_rtc_destroy(rtc->rtc);
    HAL_SAFE_FREE(rtc->p_channel_name);
    HAL_SAFE_FREE(rtc->p_user_id);
    HAL_SAFE_FREE(rtc->p_remote_user_id);
    HAL_SAFE_FREE(rtc->p_token);
    HAL_SAFE_FREE(rtc);
    LOGD("rtc destroy success");
}

// 新增：extra_params 用于传递额外的AgentConfig配置参数
int volc_rtc_start(volc_rtc_t rtc, const char* bot_id, volc_iot_info_t* iot_info, const char* extra_params) {
    // int ret = 0;
    volc_rtc_option_t *opt = NULL;
    rtc_impl_t* rtc_impl = (rtc_impl_t*) rtc;
    if (!rtc_impl) {
        LOGE("rtc instance is NULL");
        return -1;
    }
    if (!iot_info) {
        LOGE("iot_info is NULL");
        return -1;
    }
    // 检查bot_id是否为空，如果为空则使用默认值
    const char* actual_bot_id = bot_id;
    if (!bot_id || strlen(bot_id) == 0) {
        LOGW("bot_id is empty, using default value");
        actual_bot_id = "default_bot";
    }
    char* task_id = "test";
    LOGI("volc_rtc_start: bot_id=%s audio_codec=%d heap_free=%u", actual_bot_id, rtc_impl->audio_codec, (unsigned)heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
    // 新增：extra_params 用于传递额外的AgentConfig配置参数
    if (volc_get_rtc_config(iot_info, rtc_impl->audio_codec, actual_bot_id, task_id, extra_params, &rtc_impl->info)) {
        LOGE("get rtc config failed");
        return -1;
    }
    LOGI("volc_get_rtc_config success heap_free=%u", (unsigned)heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
    opt = &rtc_impl->info.rtc_opt;
    return __rtc_start(rtc_impl, opt);
}

int volc_rtc_stop(volc_rtc_t handle) {
    rtc_impl_t* rtc = (rtc_impl_t *)handle;
    if (!rtc) {
        LOGE("rtc instance is NULL");
        return -1;
    }
    __rtc_stop(rtc);
    return 0;
}

int volc_rtc_send(volc_rtc_t handle, const void* data, int size, volc_data_info_t* data_info) {
    rtc_impl_t* rtc = (rtc_impl_t *)handle;
    audio_frame_info_t audio_info = {0};
    video_frame_info_t video_info = {0};
    if (NULL == rtc || NULL == data || NULL == data_info) {
        LOGE("input args is invalid, rtc(%p), data(%p), data_info(%p)", rtc, data, data_info);
        return -1;
    }
    if (rtc->p_channel_name == NULL || size <= 0) {
        LOGE("channel not ready or invalid size");
        return -1;
    }
    LOGD("volc_rtc_send type=%d size=%d heap_free=%u", data_info->type, size, (unsigned)heap_caps_get_free_size(MALLOC_CAP_DEFAULT));
    switch (data_info->type) {
        case VOLC_DATA_TYPE_AUDIO: {
            audio_info.data_type = (audio_data_type_e) data_info->info.audio.data_type;
            byte_rtc_send_audio_data(rtc->rtc, rtc->p_channel_name, data, size, &audio_info);
            break;
        }
        case VOLC_DATA_TYPE_VIDEO: {
            video_info.data_type = (video_data_type_e) data_info->info.video.data_type;
            video_info.stream_type = VIDEO_STREAM_HIGH;
            video_info.frame_type = VIDEO_FRAME_AUTO_DETECT;
            LOGD("Sending video to channel: %s, data length: %d, data type: %d", rtc->p_channel_name, size, video_info.data_type);
            byte_rtc_send_video_data(rtc->rtc, rtc->p_channel_name, data, size, &video_info);
            break;
        }
        case VOLC_DATA_TYPE_MESSAGE: {
            if (rtc->p_remote_user_id == NULL) {
                LOGW("skip message: remote user not joined");
                return -1;
            }
            LOGD("Sending message to channel: %s, remote user: %s, data length: %d, is_binary: %d",
                 rtc->p_channel_name, rtc->p_remote_user_id, size, data_info->info.message.is_binary);
            byte_rtc_rts_send_message(rtc->rtc, rtc->p_channel_name, rtc->p_remote_user_id, data, size, data_info->info.message.is_binary,
                                      RTS_MESSAGE_RELIABLE);
            break;
        }
        default:
            LOGW("unsupported data type: %d", data_info->type);
            return -1;
    }
    return 0;
}

int volc_rtc_interrupt(volc_rtc_t rtc) {
    int ret = 0;
    uint8_t* msg_ctrl = NULL;
    size_t msg_len = 0;
    rtc_impl_t* rtc_impl = (rtc_impl_t*) rtc;
    volc_data_info_t data_info = {0};
    if (!rtc_impl) {
        LOGE("rtc instance is NULL");
        return -1;
    }
    if (!rtc_impl->b_user_joined || rtc_impl->p_remote_user_id == NULL) {
        LOGW("interrupt skipped: remote user not joined");
        return -1;
    }
    if (_build_binary_message(MAGIC_CONTROL, interrupt_str, &msg_ctrl, &msg_len) != 0) {
        LOGE("build control message failed");
        return -1;
    }
    data_info.type = VOLC_DATA_TYPE_MESSAGE;
    data_info.info.message.is_binary = true;
    if ((ret = volc_rtc_send(rtc, msg_ctrl, msg_len, &data_info)) != 0) {
        LOGE("send interrupt message failed");
    }
    HAL_SAFE_FREE(msg_ctrl);
    return ret;
}

int volc_rtc_send_jpg(volc_rtc_t rtc, void* data, int size) {
    return 0;
}