#ifndef AUDIO_MODEL_ESP32_H
#define AUDIO_MODEL_ESP32_H

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>
#include <stdbool.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

// 添加Arduino相关头文件
#ifdef ARDUINO
#include <Arduino.h>
#else
#include <stdint.h>
#include <stdbool.h>
#endif
#include "audio_model_data.h"

// ==================== 模型配置参数 ====================
#define SAMPLE_RATE 16000           // 音频采样率 (Hz)
#define AUDIO_DURATION_MS 2000      // 音频片段时长 (毫秒)
#define N_MELS 32                   // Mel频谱图频率bins数量
#define N_FFT 1024                  // FFT窗口大小
#define HOP_LENGTH 512              // 跳跃长度
#define NUM_CLASSES 4               // 分类数量

// 计算得出的参数
#define AUDIO_BUFFER_SIZE (SAMPLE_RATE * AUDIO_DURATION_MS / 1000)  // 32000 samples
#define MEL_FRAMES ((AUDIO_BUFFER_SIZE - N_FFT) / HOP_LENGTH + 1)   // 约63帧
#define INPUT_SIZE (MEL_FRAMES * N_MELS)                            // 输入特征大小

// 预处理参数
#define MEL_FMIN 0.0f               // Mel滤波器最低频率
#define MEL_FMAX 8000.0f            // Mel滤波器最高频率
#define WINDOW_TYPE_HANN 1          // 海宁窗
#define ENERGY_THRESHOLD 0.01f      // 音频活动检测阈值
#define CONFIDENCE_THRESHOLD 0.6f   // 预测置信度阈值

// ==================== 数据结构定义 ====================

// 音频分类枚举
typedef enum {
    AUDIO_CLASS_PERSON_PRESENT = 0,  // 室内有人
    AUDIO_CLASS_DOOR_CLOSING = 1,    // 关门
    AUDIO_CLASS_KEY_JINGLING = 2,    // 钥匙弹子声
    AUDIO_CLASS_PERSON_ABSENT = 3    // 室内无人
} AudioClassType;

// 预测结果结构体
typedef struct {
    AudioClassType predicted_class;     // 预测的类别
    float confidence;                   // 最高置信度 (0.0 - 1.0)
    float class_probabilities[NUM_CLASSES]; // 各类别概率
    bool is_valid;                      // 预测结果是否有效
    uint32_t inference_time_us;         // 推理耗时(微秒)
} AudioPredictionResult;

// 音频预处理状态
typedef struct {
    float* mel_buffer;                  // Mel特征缓冲区
    float* fft_buffer;                  // FFT计算缓冲区
    float* window_buffer;               // 窗函数缓冲区
    bool is_initialized;                // 是否已初始化
} AudioPreprocessor;

// ==================== 全局变量定义 ====================
static AudioPreprocessor g_preprocessor = {0};
static float g_confidence_threshold = CONFIDENCE_THRESHOLD;
static bool g_debug_mode = false;
static char g_last_error[256] = {0};
static uint32_t g_last_inference_time = 0;
static uint32_t g_total_predictions = 0;
static uint32_t g_successful_predictions = 0;
static float g_total_confidence = 0.0f;

// ==================== 常量定义 ====================
static const char* CLASS_NAMES_EN[NUM_CLASSES] = {
    "person_present",   // 室内有人
    "door_closing",     // 关门
    "key_jingling",     // 钥匙弹子声
    "person_absent"     // 室内无人
};

static const char* CLASS_NAMES_CN[NUM_CLASSES] = {
    "室内有人",
    "关门声",
    "钥匙声",
    "室内无人"
};

// ==================== 函数声明 ====================
int preprocess_audio_to_mel(const int16_t* audio_data, int audio_length, float* mel_features);
int preprocess_audio_to_mel_simple(const int16_t* audio_data, int audio_length, float* mel_features, int feature_count);
float calculate_rms_energy(const int16_t* audio_data, int length);
void audio_model_cleanup(void);
const unsigned char* get_audio_model_data(void);
size_t get_audio_model_size(void);
const char* get_class_name_en(AudioClassType class_id);
const char* get_class_name_cn(AudioClassType class_id);

// ==================== 核心API函数 ====================

/**
 * @brief 初始化音频模型
 * @return 0: 成功, -1: 失败
 * @note 必须在使用其他函数前调用
 */
int audio_model_init(void) {
    if (g_preprocessor.is_initialized) {
        return 0;  // 已经初始化
    }
    
    // 分配内存缓冲区
    g_preprocessor.mel_buffer = (float*)malloc(INPUT_SIZE * sizeof(float));
    g_preprocessor.fft_buffer = (float*)malloc(N_FFT * sizeof(float));
    g_preprocessor.window_buffer = (float*)malloc(N_FFT * sizeof(float));
    
    if (!g_preprocessor.mel_buffer || !g_preprocessor.fft_buffer || !g_preprocessor.window_buffer) {
        strcpy(g_last_error, "内存分配失败");
        audio_model_cleanup();
        return -1;
    }
    
    // 预计算海宁窗
    for (int i = 0; i < N_FFT; i++) {
        g_preprocessor.window_buffer[i] = 0.5f * (1.0f - cosf(2.0f * M_PI * i / (N_FFT - 1)));
    }
    
    g_preprocessor.is_initialized = true;
    strcpy(g_last_error, "");
    return 0;
}

/**
 * @brief 清理音频模型资源
 * @note 程序结束时调用，释放内存
 */
void audio_model_cleanup(void) {
    if (g_preprocessor.mel_buffer) {
        free(g_preprocessor.mel_buffer);
        g_preprocessor.mel_buffer = NULL;
    }
    if (g_preprocessor.fft_buffer) {
        free(g_preprocessor.fft_buffer);
        g_preprocessor.fft_buffer = NULL;
    }
    if (g_preprocessor.window_buffer) {
        free(g_preprocessor.window_buffer);
        g_preprocessor.window_buffer = NULL;
    }
    g_preprocessor.is_initialized = false;
}

/**
 * @brief 音频预测函数（完整版）
 * @param audio_data 输入音频数据指针
 * @param audio_length 音频数据长度（样本数）
 * @param result 预测结果输出指针
 * @return 0: 成功, -1: 失败
 * 
 * 音频数据格式要求：
 * - 数据类型: int16_t (16位有符号整数)
 * - 采样率: 16000 Hz
 * - 声道数: 单声道
 * - 数据长度: 32000 samples (2秒)
 * - 数值范围: -32768 到 32767
 * - 字节序: 小端序(Little Endian)
 * 
 * 示例调用：
 * int16_t audio_buffer[AUDIO_BUFFER_SIZE];
 * AudioPredictionResult result;
 * // ... 填充audio_buffer ...
 * int ret = audio_model_predict(audio_buffer, AUDIO_BUFFER_SIZE, &result);
 */
int audio_model_predict(const int16_t* audio_data, int audio_length, AudioPredictionResult* result) {
    if (!g_preprocessor.is_initialized) {
        strcpy(g_last_error, "模型未初始化");
        return -1;
    }
    
    if (!audio_data || !result || audio_length != AUDIO_BUFFER_SIZE) {
        strcpy(g_last_error, "无效参数");
        return -1;
    }

    uint32_t start_time = micros();
    
    // 添加看门狗喂狗
    #ifdef ARDUINO
    yield();
    #endif
    
    // TODO: 集成TensorFlow Lite模型进行真实的音频识别
    // 当前使用audio_model_data.h中的TensorFlow Lite模型数据
    // 需要实现以下步骤：
    // 1. 初始化TensorFlow Lite解释器
    // 2. 加载模型数据 (audio_model_data)
    // 3. 预处理音频数据为模型输入格式
    // 4. 执行推理
    // 5. 解析输出结果
    
    // 临时实现：基于音频能量的简单分类，提供更合理的结果
    #ifdef ARDUINO
    Serial.println("警告：当前使用临时实现，等待TensorFlow Lite模型集成");
    #endif
    
    // 计算音频能量来做简单的分类判断
    float rms_energy = calculate_rms_energy(audio_data, audio_length);
    
    // 添加调试信息：检查音频数据的实际值
    #ifdef ARDUINO
    int non_zero_count = 0;
    int16_t min_val = 32767, max_val = -32768;
    long long sum_abs = 0;
    
    for (int i = 0; i < min(100, audio_length); i++) {  // 检查前100个样本
        if (audio_data[i] != 0) non_zero_count++;
        if (audio_data[i] < min_val) min_val = audio_data[i];
        if (audio_data[i] > max_val) max_val = audio_data[i];
        sum_abs += abs(audio_data[i]);
    }
    
    Serial.printf("音频数据调试: 非零样本=%d/100, 最小值=%d, 最大值=%d, 平均绝对值=%lld\n", 
                  non_zero_count, min_val, max_val, sum_abs/100);
    #endif
    
    // 基于能量水平进行简单分类
    AudioClassType predicted_class;
    float confidence;
    
    if (rms_energy > 0.1f) {
        // 高能量：可能是关门声或钥匙声
        if (rms_energy > 0.3f) {
            predicted_class = AUDIO_CLASS_DOOR_CLOSING;
            confidence = 0.75f;
        } else {
            predicted_class = AUDIO_CLASS_KEY_JINGLING;
            confidence = 0.65f;
        }
    } else if (rms_energy > 0.02f) {
        // 中等能量：室内有人
        predicted_class = AUDIO_CLASS_PERSON_PRESENT;
        confidence = 0.70f;
    } else {
        // 低能量：室内无人
        predicted_class = AUDIO_CLASS_PERSON_ABSENT;
        confidence = 0.80f;
    }
    
    // 设置结果
    result->predicted_class = predicted_class;
    result->confidence = confidence;
    
    // 设置概率分布
    for (int i = 0; i < NUM_CLASSES; i++) {
        if (i == (int)predicted_class) {
            result->class_probabilities[i] = confidence;
        } else {
            result->class_probabilities[i] = (1.0f - confidence) / (NUM_CLASSES - 1);
        }
    }
    
    result->is_valid = result->confidence >= g_confidence_threshold;
    result->inference_time_us = micros() - start_time;
    g_last_inference_time = result->inference_time_us;
    
    // 更新统计信息
    g_total_predictions++;
    if (result->is_valid) {
        g_successful_predictions++;
        g_total_confidence += result->confidence;
    }
    
    #ifdef ARDUINO
    Serial.printf("音频能量: %.4f, 预测类别: %s, 置信度: %.2f\n", 
                  rms_energy, get_class_name_cn(predicted_class), confidence);
    #endif
    
    return 0;
}

/**
 * @brief 音频预测函数（简化版）
 * @param audio_data 输入音频数据指针
 * @param audio_length 音频数据长度
 * @param predicted_class 预测类别输出
 * @param confidence 置信度输出
 * @return 0: 成功, -1: 失败
 */
int audio_model_predict_simple(const int16_t* audio_data, int audio_length, 
                              AudioClassType* predicted_class, float* confidence) {
    AudioPredictionResult result;
    int ret = audio_model_predict(audio_data, audio_length, &result);
    if (ret == 0 && result.is_valid) {
        *predicted_class = result.predicted_class;
        *confidence = result.confidence;
    }
    return ret;
}

// ==================== 数据预处理函数 ====================

/**
 * @brief 音频数据预处理（完整流程）
 * @param audio_data 原始音频数据 (int16_t格式)
 * @param audio_length 音频长度
 * @param mel_features 输出的Mel特征 (大小为INPUT_SIZE)
 * @return 0: 成功, -1: 失败
 * 
 * 预处理步骤：
 * 1. 数据类型转换 (int16_t -> float)
 * 2. 归一化处理 ([-1.0, 1.0])
 * 3. 预加重滤波
 * 4. 加窗处理 (汉宁窗)
 * 5. FFT变换
 * 6. 功率谱计算
 * 7. Mel滤波器组
 * 8. 对数变换
 * 9. 特征归一化
 */
/**
 * @brief 将音频数据预处理为Mel频谱图特征（优化版本）
 * @param audio_data 输入音频数据指针
 * @param audio_length 音频数据长度
 * @param mel_features 输出Mel特征数组
 * @return 0: 成功, -1: 失败
 */
/**
 * @brief 简化的音频预处理函数，减少内存使用
 * @param audio_data 输入音频数据
 * @param audio_length 音频数据长度
 * @param mel_features 输出特征数组
 * @param feature_count 特征数量
 * @return 0: 成功, -1: 失败
 */
int preprocess_audio_to_mel_simple(const int16_t* audio_data, int audio_length, float* mel_features, int feature_count) {
    if (!audio_data || !mel_features || audio_length != AUDIO_BUFFER_SIZE || feature_count <= 0) {
        return -1;
    }
    
    // 使用更简化的特征提取，减少计算量和内存使用
    const int SIMPLE_FRAMES = feature_count / 4;  // 每帧4个特征
    const int FRAME_SIZE = AUDIO_BUFFER_SIZE / SIMPLE_FRAMES;
    
    for (int frame = 0; frame < SIMPLE_FRAMES; frame++) {
        int start_idx = frame * FRAME_SIZE;
        int end_idx = (frame + 1) * FRAME_SIZE;
        if (end_idx > audio_length) end_idx = audio_length;
        
        // 计算每帧的基本统计特征
        float energy = 0.0f;
        float zero_crossings = 0.0f;
        int16_t prev_sample = 0;
        
        for (int i = start_idx; i < end_idx; i++) {
            float sample = (float)audio_data[i] / 32768.0f;
            energy += sample * sample;
            
            // 零交叉率计算
            if (i > start_idx && 
                ((audio_data[i] >= 0 && prev_sample < 0) || 
                 (audio_data[i] < 0 && prev_sample >= 0))) {
                zero_crossings += 1.0f;
            }
            prev_sample = audio_data[i];
            
            // 添加看门狗喂狗，防止长时间计算
            #ifdef ARDUINO
            if (i % 1000 == 0) {
                yield(); // ESP32看门狗喂狗
            }
            #endif
        }
        
        // 归一化特征
        energy = sqrtf(energy / (end_idx - start_idx));
        zero_crossings = zero_crossings / (end_idx - start_idx);
        
        // 为每帧生成4个特征值
        for (int mel = 0; mel < 4; mel++) {
            int feature_idx = frame * 4 + mel;
            if (feature_idx < feature_count) {
                switch (mel) {
                    case 0: mel_features[feature_idx] = logf(energy + 1e-10f); break;
                    case 1: mel_features[feature_idx] = logf(zero_crossings + 1e-10f); break;
                    case 2: mel_features[feature_idx] = energy * zero_crossings; break;
                    case 3: mel_features[feature_idx] = energy - zero_crossings; break;
                }
            }
        }
    }
    
    // 填充剩余特征（如果需要）
    int filled_features = SIMPLE_FRAMES * 4;
    for (int i = filled_features; i < feature_count; i++) {
        mel_features[i] = -10.0f; // 静音值
    }
    
    return 0;
}

int preprocess_audio_to_mel(const int16_t* audio_data, int audio_length, float* mel_features) {
    if (!audio_data || !mel_features || audio_length != AUDIO_BUFFER_SIZE) {
        return -1;
    }
    
    // 使用简化的特征提取，避免复杂的Mel频谱图计算
    // 将音频分成更少的帧来减少计算量
    const int SIMPLE_FRAMES = 8;  // 减少帧数
    const int FRAME_SIZE = AUDIO_BUFFER_SIZE / SIMPLE_FRAMES;
    
    for (int frame = 0; frame < SIMPLE_FRAMES; frame++) {
        int start_idx = frame * FRAME_SIZE;
        int end_idx = (frame + 1) * FRAME_SIZE;
        if (end_idx > audio_length) end_idx = audio_length;
        
        // 计算每帧的基本统计特征
        float energy = 0.0f;
        float zero_crossings = 0.0f;
        int16_t prev_sample = 0;
        
        for (int i = start_idx; i < end_idx; i++) {
            float sample = (float)audio_data[i] / 32768.0f;
            energy += sample * sample;
            
            // 零交叉率计算
        if (i > start_idx && 
            ((audio_data[i] >= 0 && prev_sample < 0) || 
             (audio_data[i] < 0 && prev_sample >= 0))) {
            zero_crossings += 1.0f;
        }
        prev_sample = audio_data[i];
            
            // 添加看门狗喂狗，防止长时间计算
            #ifdef ARDUINO
            if (i % 1000 == 0) {
                yield(); // ESP32看门狗喂狗
            }
            #endif
        }
        
        // 归一化特征
        energy = sqrtf(energy / (end_idx - start_idx));
        zero_crossings = zero_crossings / (end_idx - start_idx);
        
        // 为每帧生成4个特征值（模拟32个Mel频带的简化版本）
        for (int mel = 0; mel < 4; mel++) {
            int feature_idx = frame * 4 + mel;
            if (feature_idx < INPUT_SIZE) {
                switch (mel) {
                    case 0: mel_features[feature_idx] = logf(energy + 1e-10f); break;
                    case 1: mel_features[feature_idx] = logf(zero_crossings + 1e-10f); break;
                    case 2: mel_features[feature_idx] = energy * zero_crossings; break;
                    case 3: mel_features[feature_idx] = energy - zero_crossings; break;
                }
            }
        }
    }
    
    // 填充剩余特征（如果需要）
    int filled_features = SIMPLE_FRAMES * 4;
    for (int i = filled_features; i < INPUT_SIZE; i++) {
        mel_features[i] = -10.0f; // 静音值
    }
    
    return 0;
}

/**
 * @brief 音频数据归一化
 * @param audio_data 输入音频数据
 * @param length 数据长度
 * @param normalized_data 归一化后的数据输出
 * @return 0: 成功, -1: 失败
 */
int normalize_audio_data(const int16_t* audio_data, int length, float* normalized_data);

/**
 * @brief 计算Mel频谱图
 * @param audio_float 浮点音频数据
 * @param length 数据长度
 * @param mel_spectrogram 输出的Mel频谱图
 * @return 0: 成功, -1: 失败
 */
int compute_mel_spectrogram(const float* audio_float, int length, float* mel_spectrogram);

/**
 * @brief 应用汉宁窗
 * @param data 输入数据
 * @param length 数据长度
 * @param windowed_data 加窗后的数据
 * @return 0: 成功, -1: 失败
 */
int apply_hann_window(const float* data, int length, float* windowed_data);

// ==================== 辅助函数 ====================

/**
 * @brief 简单的FFT实现（仅用于演示）
 * @param real 实部数组
 * @param imag 虚部数组
 * @param n 数据长度（必须是2的幂）
 */
void simple_fft(float* real, float* imag, int n) {
    // 位反转
    int j = 0;
    for (int i = 1; i < n; i++) {
        int bit = n >> 1;
        while (j & bit) {
            j ^= bit;
            bit >>= 1;
        }
        j ^= bit;
        if (i < j) {
            float temp = real[i];
            real[i] = real[j];
            real[j] = temp;
            temp = imag[i];
            imag[i] = imag[j];
            imag[j] = temp;
        }
    }
    
    // FFT计算
    for (int len = 2; len <= n; len <<= 1) {
        float angle = -2.0f * M_PI / len;
        float wlen_real = cosf(angle);
        float wlen_imag = sinf(angle);
        
        for (int i = 0; i < n; i += len) {
            float w_real = 1.0f;
            float w_imag = 0.0f;
            
            for (int j = 0; j < len / 2; j++) {
                int u = i + j;
                int v = i + j + len / 2;
                
                float u_real = real[u];
                float u_imag = imag[u];
                float v_real = real[v] * w_real - imag[v] * w_imag;
                float v_imag = real[v] * w_imag + imag[v] * w_real;
                
                real[u] = u_real + v_real;
                imag[u] = u_imag + v_imag;
                real[v] = u_real - v_real;
                imag[v] = u_imag - v_imag;
                
                float temp_real = w_real * wlen_real - w_imag * wlen_imag;
                w_imag = w_real * wlen_imag + w_imag * wlen_real;
                w_real = temp_real;
            }
        }
    }
}

/**
 * @brief 预处理音频数据为模型输入
 * @param audio_data 原始音频数据
 * @param length 数据长度
 * @param output 输出特征数组
 * @return 0: 成功, -1: 失败
 */
int preprocess_audio(const int16_t* audio_data, int length, float* output) {
    if (!g_preprocessor.is_initialized || !audio_data || !output) {
        return -1;
    }
    
    // 简化的预处理：直接归一化并截取/填充到所需长度
    int copy_length = (length < INPUT_SIZE) ? length : INPUT_SIZE;
    
    for (int i = 0; i < copy_length; i++) {
        output[i] = (float)audio_data[i] / 32768.0f;  // 归一化到[-1,1]
    }
    
    // 如果长度不足，用零填充
    for (int i = copy_length; i < INPUT_SIZE; i++) {
        output[i] = 0.0f;
    }
    
    return 0;
}

/**
 * @brief 检测音频活动
 * @param audio_data 音频数据
 * @param length 数据长度
 * @param threshold 能量阈值
 * @return true: 检测到音频活动, false: 静音
 */
bool detect_audio_activity(const int16_t* audio_data, int length, float threshold) {
    if (!audio_data || length <= 0) return false;
    
    float energy = calculate_rms_energy(audio_data, length);
    return energy > threshold;
}

/**
 * @brief 计算音频RMS能量
 * @param audio_data 音频数据
 * @param length 数据长度
 * @return RMS能量值
 */
float calculate_rms_energy(const int16_t* audio_data, int length) {
    if (!audio_data || length <= 0) return 0.0f;
    
    float sum = 0.0f;
    for (int i = 0; i < length; i++) {
        float sample = (float)audio_data[i] / 32768.0f;  // 归一化到[-1,1]
        sum += sample * sample;
    }
    return sqrtf(sum / length);
}

/**
 * @brief 获取类别名称（英文）
 * @param class_id 类别ID
 * @return 类别名称字符串
 */
const char* get_class_name_en(AudioClassType class_id) {
    if (class_id >= 0 && class_id < NUM_CLASSES) {
        return CLASS_NAMES_EN[class_id];
    }
    return "unknown";
}

/**
 * @brief 获取类别名称（中文）
 * @param class_id 类别ID
 * @return 类别名称字符串
 */
const char* get_class_name_cn(AudioClassType class_id) {
    if (class_id >= 0 && class_id < NUM_CLASSES) {
        return CLASS_NAMES_CN[class_id];
    }
    return "未知";
}

/**
 * @brief 验证音频数据格式
 * @param audio_data 音频数据指针
 * @param length 数据长度
 * @return true: 格式正确, false: 格式错误
 */
bool validate_audio_format(const int16_t* audio_data, int length) {
    if (!audio_data) return false;
    if (length != AUDIO_BUFFER_SIZE) return false;
    return true;
}

/**
 * @brief 打印预测结果
 * @param result 预测结果指针
 */
void print_prediction_result(const AudioPredictionResult* result) {
    if (!result) return;
    
    printf("预测结果:\n");
    printf("  类别: %s\n", get_class_name_cn(result->predicted_class));
    printf("  置信度: %.2f\n", result->confidence);
    printf("  有效性: %s\n", result->is_valid ? "是" : "否");
    printf("  推理时间: %u 微秒\n", result->inference_time_us);
    printf("  各类别概率:\n");
    for (int i = 0; i < NUM_CLASSES; i++) {
        printf("    %s: %.3f\n", get_class_name_cn((AudioClassType)i), result->class_probabilities[i]);
    }
}

// ==================== 性能监控函数 ====================

/**
 * @brief 获取上次推理耗时
 * @return 推理时间(微秒)
 */
uint32_t get_last_inference_time_us(void) {
    return g_last_inference_time;
}

/**
 * @brief 获取模型内存使用情况
 * @param model_memory 模型占用内存(字节)
 * @param buffer_memory 缓冲区占用内存(字节)
 * @return 0: 成功, -1: 失败
 */
int get_memory_usage(size_t* model_memory, size_t* buffer_memory) {
    if (!model_memory || !buffer_memory) return -1;
    
    *model_memory = get_audio_model_size();
    *buffer_memory = (INPUT_SIZE + N_FFT + N_FFT) * sizeof(float);
    return 0;
}

/**
 * @brief 获取预测统计信息
 * @param total_predictions 总预测次数
 * @param successful_predictions 成功预测次数
 * @param average_confidence 平均置信度
 * @return 0: 成功, -1: 失败
 */
int get_prediction_statistics(uint32_t* total_predictions, uint32_t* successful_predictions, 
                             float* average_confidence) {
    if (!total_predictions || !successful_predictions || !average_confidence) return -1;
    
    *total_predictions = g_total_predictions;
    *successful_predictions = g_successful_predictions;
    *average_confidence = (g_successful_predictions > 0) ? 
                         (g_total_confidence / g_successful_predictions) : 0.0f;
    return 0;
}

// ==================== 配置函数 ====================

/**
 * @brief 设置置信度阈值
 * @param threshold 新的阈值 (0.0 - 1.0)
 * @return 0: 成功, -1: 失败
 */
int set_confidence_threshold(float threshold) {
    if (threshold < 0.0f || threshold > 1.0f) {
        strcpy(g_last_error, "置信度阈值必须在0.0-1.0之间");
        return -1;
    }
    g_confidence_threshold = threshold;
    return 0;
}

/**
 * @brief 获取当前置信度阈值
 * @return 当前阈值
 */
float get_confidence_threshold(void) {
    return g_confidence_threshold;
}

/**
 * @brief 启用/禁用调试模式
 * @param enable true: 启用, false: 禁用
 */
void set_debug_mode(bool enable) {
    g_debug_mode = enable;
}

/**
 * @brief 检查调试模式状态
 * @return true: 已启用, false: 已禁用
 */
bool is_debug_mode_enabled(void) {
    return g_debug_mode;
}

// ==================== 错误处理 ====================

/**
 * @brief 获取最后一次错误信息
 * @return 错误信息字符串
 */
const char* get_last_error_message(void) {
    return g_last_error;
}

/**
 * @brief 清除错误状态
 */
void clear_error_status(void) {
    strcpy(g_last_error, "");
}

// ==================== 模型数据访问函数 ====================

/**
 * @brief 获取模型数据指针
 * @return 模型数据指针
 */
const unsigned char* get_audio_model_data(void) {
    return audio_model_data;
}

/**
 * @brief 获取模型数据大小
 * @return 模型数据大小（字节）
 */
size_t get_audio_model_size(void) {
    return AUDIO_MODEL_SIZE;
}

// ==================== 使用示例 ====================
/*
使用示例代码：

#include "audio_model_esp32.h"

void example_usage() {
    // 1. 初始化模型
    if (audio_model_init() != 0) {
        printf("模型初始化失败\n");
        return;
    }
    
    // 2. 准备音频数据
    int16_t audio_buffer[AUDIO_BUFFER_SIZE];
    // ... 从麦克风或其他源获取音频数据 ...
    
    // 3. 验证音频格式
    if (!validate_audio_format(audio_buffer, AUDIO_BUFFER_SIZE)) {
        printf("音频格式不正确\n");
        return;
    }
    
    // 4. 进行预测
    AudioPredictionResult result;
    if (audio_model_predict(audio_buffer, AUDIO_BUFFER_SIZE, &result) == 0) {
        // 5. 处理预测结果
        if (result.is_valid && result.confidence > 0.6f) {
            printf("预测类别: %s (置信度: %.2f)\n", 
                   get_class_name_cn(result.predicted_class), 
                   result.confidence);
        }
    }
    
    // 6. 清理资源
    audio_model_cleanup();
}

音频数据获取示例（ESP32 I2S）：
*/
#include "driver/i2s.h"

void get_audio_data(int16_t* buffer, size_t buffer_size) {
    size_t bytes_read;
    i2s_read(I2S_NUM_0, buffer, buffer_size * sizeof(int16_t), &bytes_read, portMAX_DELAY);
}

#ifdef __cplusplus
}
#endif

#endif // AUDIO_MODEL_ESP32_H