#define DEBUG_PRINT_ENABLE 0
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include <math.h>
#include "xmath/xmath.h"
#include "eq.h"
#include "eq_flash_storage.h"
#include "lfs_io.h"
#include "lfs.h"
#include "eq_coefficient_calculator.h"
#include "debug_print.h"

#if 0 // DEBUG_PRINT_ENABLE
#define DPRINTF(...) printf(__VA_ARGS__)
#else
#define DPRINTF(...)
#endif
// 外部函数声明
extern uint32_t get_reference_time(void);
extern lfs_t lfs;
void delay_milliseconds(unsigned int);
#define FILE_PATH_MAX_LENGTH 30

// EQ Flash存储目录和文件名全局变量定义（默认值）
// 改动原因：统一管理所有EQ相关文件的存储路径，便于支持不同产品的参数存储
#if UAC2 == 1
char *g_eq_flash_base_dir = "uac2";           // 基础目录名
#elif FPS == 1
char *g_eq_flash_base_dir = "fps";           // 基础目录名
#elif SPATIAL_MODE == 1
char *g_eq_flash_base_dir = "spa";           // 基础目录名
#else
char *g_eq_flash_base_dir = "default";           // 基础目录名
#endif
char *g_eq_flash_gains_file = "gains";         // 增益文件名
char *g_eq_flash_mode_file = "cur_mode"; // 当前模式文件名
char *g_eq_flash_enable_file = "eq_enable"; // EQ使能开关文件名（独立存储）
char *g_eq_flash_name_prefix = "name_";            // 模式名称文件前缀

// 外部EQ数组声明
// 改动原因：进一步优化EQ参数存储策略，所有采样率共用44100Hz数组
extern eq_mode_data_t sEQ_data_44100HZ[NUM_EQ_MODES][NUM_EQ_CHANS];
extern void debug_print_eq_mode(eq_mode_data_t *eq_data);
extern unsigned int g_eq_sample_rate;

// 支持的采样率数组
static const uint32_t supported_sample_rates[EQ_FLASH_MAX_SAMPLE_RATES] = EQ_SAMPLE_RATES;

// 存储状态
static eq_storage_status_t storage_status = {0};

// 脏标志数组，用于跟踪哪些模式需要同步到Flash (简化版本，不按采样率分组)
static int dirty_flags[EQ_FLASH_MAX_MODES] = {0};

// 增益和模式名称脏标志（分别独立）
static int gain_dirty = 0;
static int name_dirty = 0;

// 单参数存储数据库
static eq_single_param_database_t single_param_database = {0};

// 内部函数声明
static int get_sample_rate_index(uint32_t sample_rate);
static int create_eq_directory_structure(void);
// 元数据相关函数已移除，简化存储系统
static int verify_file_header(const eq_file_header_t *header, uint8_t mode, uint8_t channel);
static eq_mode_data_t (*get_eq_array_ptr(uint32_t sample_rate))[NUM_EQ_MODES][NUM_EQ_CHANS];

/**
 * @brief 获取采样率在数组中的索引
 * @param sample_rate 采样率
 * @return 索引，-1表示不支持
 */
static int get_sample_rate_index(uint32_t sample_rate) {
    for (int i = 0; i < EQ_FLASH_MAX_SAMPLE_RATES; i++) {
        if (supported_sample_rates[i] == sample_rate) {
            return i;
        }
    }
    return -1;
}

/**
 * @brief 获取对应采样率的EQ数组指针
 * @param sample_rate 采样率
 * @return EQ数组指针，NULL表示不支持的采样率
 */
static eq_mode_data_t (*get_eq_array_ptr(uint32_t sample_rate))[NUM_EQ_MODES][NUM_EQ_CHANS] {
    // 改动原因：所有采样率共用44100Hz数组
    return &sEQ_data_44100HZ;
}

/**
 * @brief 验证文件头 (简化版本，去除采样率字段)
 * @param header 文件头指针
 * @param mode 期望的模式
 * @param channel 期望的通道
 * @return 1: 有效, 0: 无效
 */
static int verify_file_header(const eq_file_header_t *header, uint8_t mode, uint8_t channel) {
    if (!header) return 0;

    return (header->magic == EQ_FLASH_MAGIC &&
            header->version == EQ_FLASH_VERSION &&
            header->mode == mode &&
            header->channel == channel &&
            header->data_size == sizeof(eq_mode_data_t));
}

/**
 * @brief 创建EQ目录结构（按需创建）
 * @return 0: 成功, -1: 失败
 */
static int create_eq_directory_structure(void) {
    char dir_path[64];

    DPRINTF("Creating EQ directory structure (on-demand)\n");

    // 检查主目录是否存在，不存在才创建
    // 改动原因：使用全局变量代替硬编码目录名，支持不同产品
    if (!lfs_file_exists(g_eq_flash_base_dir)) {
        lfs_mkdir(&lfs, g_eq_flash_base_dir);
        DPRINTF("Created %s directory\n", g_eq_flash_base_dir);
    } else {
        DPRINTF("%s directory already exists\n", g_eq_flash_base_dir);
    }

    // 不再为每个采样率创建子目录，因为同一模式的参数是相同的
    DPRINTF("EQ parameters will be stored without sample rate grouping\n");

    DPRINTF("EQ directory structure creation completed\n");
    return 0;
}

// 元数据保存函数已移除，简化存储系统

// 元数据加载函数已移除，简化存储系统

// 元数据迁移函数已移除，简化存储系统

/**
 * @brief 初始化EQ Flash存储系统
 * @return 0: 成功, -1: 失败
 */
int eq_flash_init(void) {
    DPRINTF("Initializing EQ Flash storage system\n");

    // 初始化存储状态
    memset(&storage_status, 0, sizeof(storage_status));
    memset(dirty_flags, 0, sizeof(dirty_flags));

    // 延迟一段时间，确保QSPI Flash已经初始化完成
    delay_milliseconds(100);

    // 尝试初始化LFS，最多重试3次
    int retry_count = 0;
    int lfs_init_result = -1;

    while (retry_count < 3 && lfs_init_result != 0) {
        lfs_init_result = lfs_init();
        if (lfs_init_result != 0) {
            lfs_deinit();  // 释放session锁，避免下次循环自死锁
            retry_count++;
            DPRINTF("Failed to initialize LFS, retry %d/3\n", retry_count);
            if (retry_count < 3) {
                delay_milliseconds(200 * retry_count); // 递增延迟
            }
        }
    }

    if (lfs_init_result != 0) {
        DPRINTF("Failed to initialize LFS after %d retries, continuing without Flash storage\n", retry_count);
        // 即使LFS初始化失败，也标记为已初始化，系统继续运行
        storage_status.is_initialized = 1;
        storage_status.has_flash_data = 0;
        return 0;
    }

    DPRINTF("LFS initialized successfully\n");

    // 创建目录结构（按需创建）
    create_eq_directory_structure();

    // 检查是否有现有数据（通过检查目录是否存在）
    // 改动原因：使用全局变量代替硬编码目录名
    storage_status.has_flash_data = lfs_file_exists(g_eq_flash_base_dir) ? 1 : 0;
    storage_status.is_initialized = 1;

    DPRINTF("EQ Flash storage initialized, has_data: %d\n", storage_status.has_flash_data);

    lfs_deinit();
    return 0;
}

/**
 * @brief 反初始化EQ Flash存储系统
 */
void eq_flash_deinit(void) {
    DPRINTF("Deinitializing EQ Flash storage system\n");
    storage_status.is_initialized = 0;
    storage_status.has_flash_data = 0;
    memset(dirty_flags, 0, sizeof(dirty_flags));
}

// 注意：eq_flash_load_all 函数已移除，现在使用动态单参数存储系统

// 注意：eq_flash_save_all 函数已移除，现在使用动态单参数存储系统

/**
 * @brief 从Flash加载指定模式的EQ参数
 * @param mode EQ模式
 * @return 0: 成功, -1: 失败
 */
/**
 * @brief Initialize eq_mode_data_t with default bypass values
 * @param eq_data Target data to initialize
 * @param sample_rate Sample rate to set
 */
static void init_eq_data_defaults(eq_mode_data_t *eq_data, uint32_t sample_rate) {
    memset(eq_data, 0, sizeof(eq_mode_data_t));
    eq_data->sample_rate = sample_rate;
    eq_data->total_bshift = 0;
    eq_data->post_gain_db = 0;
    for (int i = 0; i < MAX_EQ_BANDS; i++) {
        eq_data->bands[i].index = i;
        eq_data->bands[i].type = FILTER_TYPE_BYPASS;
        eq_data->bands[i].fc = 1000.0f;
        eq_data->bands[i].q = 0.707f;
        eq_data->bands[i].bw = 1.0f;
        eq_data->bands[i].gain = 0.0f;
    }
    for (int i = 0; i < 8; i++) {
        eq_data->filter.coef[0][i] = 1 << 30;
        eq_data->filter.coef[1][i] = 0;
        eq_data->filter.coef[2][i] = 0;
        eq_data->filter.coef[3][i] = 0;
        eq_data->filter.coef[4][i] = 0;
    }
}

int eq_flash_load_mode(uint8_t mode) {
    //DPRINTF("Loading EQ mode %d from Flash\n", mode);

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: EQ Flash storage not initialized\n");
        return -1;
    }

    if (mode >= NUM_EQ_MODES) {
        DPRINTF("  Error: Invalid mode %d (max: %d)\n", mode, NUM_EQ_MODES - 1);
        return -1;
    }

    if (lfs_init() != 0) {
        lfs_deinit();
        return -1;
    }

    // 获取当前采样率的EQ数组指针
    eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr(g_eq_sample_rate);
    if (!eq_array) {
        DPRINTF("  Error: Failed to get EQ array for current sample rate %lu\n", (unsigned long)g_eq_sample_rate);
        lfs_deinit();
        return -1;
    }

    // 加载左右两个声道的数据
    for (int ch = 0; ch < NUM_EQ_CHANS; ch++) {
    // 构建文件路径
    // 改动原因：使用全局变量代替硬编码目录名，统一文件路径管理
    char file_path[FILE_PATH_MAX_LENGTH];
        snprintf(file_path, sizeof(file_path), "%s/mode%d_ch%d.bin", g_eq_flash_base_dir, mode, ch);
        DPRINTF("  File path (channel %d): %s\n", ch, file_path);

    // 检查文件是否存在
    if (!lfs_file_exists(file_path)) {
            DPRINTF(" ****************** file is not exist (ch %d), initializing with default values\n", ch);
            init_eq_data_defaults(&(*eq_array)[mode][ch], g_eq_sample_rate);
            DPRINTF("  Initialized with default values for mode %d, channel %d\n", mode, ch);
            continue;  // 继续处理下一个通道
    }

    // 准备读取缓冲区
    eq_file_header_t header;
        eq_flash_data_t flash_data;
    uint8_t file_data[sizeof(header) + sizeof(flash_data)];

    // 使用lfs_read_config读取文件
    DPRINTF("  Read file data, size: %zu bytes\n", sizeof(file_data));
    lfs_read_config(file_path, file_data, sizeof(file_data));

    // 解析文件数据
    memcpy(&header, file_data, sizeof(header));
    memcpy(&flash_data, file_data + sizeof(header), sizeof(flash_data));

    // 检查文件头基本信息
    DPRINTF("  File header: magic=0x%08X, version=%u, mode=%u\n",
                 header.magic, header.version, header.mode);

    // 验证文件头
    DPRINTF("  Verifying file header:\n");
        DPRINTF("    Expected: magic=0x%08X, version=%u, mode=%u, channel=%d, data_size=%zu\n",
                     EQ_FLASH_MAGIC, EQ_FLASH_VERSION, mode, ch, sizeof(eq_flash_data_t));
    DPRINTF("    Actual:   magic=0x%08X, version=%u, mode=%u, channel=%u, data_size=%u\n",
                 header.magic, header.version, header.mode, header.channel, header.data_size);

        if (!verify_file_header(&header, mode, ch)) {
            DPRINTF("  Invalid file header for mode %d, channel %d\n", mode, ch);
            init_eq_data_defaults(&(*eq_array)[mode][ch], g_eq_sample_rate);
            DPRINTF("  Initialized with default values for mode %d, channel %d\n", mode, ch);
            continue;  // 继续处理下一个通道
    }

    // 验证CRC32
    uint32_t calculated_crc = eq_flash_calculate_crc32((uint8_t*)&flash_data, sizeof(flash_data));
    if (calculated_crc != header.crc32) {
            DPRINTF("  CRC32 mismatch for mode %d, sample rate %lu, channel %d\n", mode, (unsigned long)g_eq_sample_rate, ch);
            init_eq_data_defaults(&(*eq_array)[mode][ch], g_eq_sample_rate);
            DPRINTF("  Initialized with default values due to CRC32 mismatch for channel %d\n", ch);
            continue;  // 继续处理下一个通道
    }

    // 将Flash数据加载到EQ数组
        eq_mode_data_t *eq_data = &(*eq_array)[mode][ch];

    // 检查Flash数据的完整性
        DPRINTF("  Flash data before restore (ch %d): active_bands_count=%d\n",
                     ch, flash_data.active_bands_count);

        DPRINTF("  EQ array after copy (ch %d): sample_rate=%u, post_gain_db=%ld\n",
                     ch, eq_data->sample_rate, (long)eq_data->post_gain_db);
        DPRINTF("  EQ array total_bshift=%ld\n",
                 (long)eq_data->total_bshift);


    // 检查内存地址是否有效
    if (eq_data == NULL) {
        DPRINTF("  ERROR: eq_data is NULL\n");
            continue;  // 继续处理下一个通道
    }

    DPRINTF("  eq_data address: %p\n", (void*)eq_data);
    DPRINTF("  eq_data size: %zu bytes\n", sizeof(eq_mode_data_t));

    // 检查bands数组地址是否有效
    DPRINTF("  bands array address: %p\n", (void*)&eq_data->bands);
    DPRINTF("  bands array size: %zu bytes\n", sizeof(eq_data->bands));

    // 检查bands数组偏移量
    DPRINTF("  bands offset in struct: %zu bytes\n", (size_t)&eq_data->bands - (size_t)eq_data);

    // 检查第一个band的地址
    DPRINTF("  bands[0] address: %p\n", (void*)&eq_data->bands[0]);
    DPRINTF("  bands[0] size: %zu bytes\n", sizeof(eq_data->bands[0]));

    // 检查内存对齐
    DPRINTF("  eq_data alignment: %zu\n", (size_t)eq_data % 4);
    DPRINTF("  bands alignment: %zu\n", (size_t)&eq_data->bands % 4);

    // 尝试安全地访问第一个band
    DPRINTF("  Attempting to access bands[0]...\n");

    // 先检查bands[0]的地址是否在合理范围内
    if ((size_t)&eq_data->bands[0] < (size_t)eq_data ||
        (size_t)&eq_data->bands[0] > (size_t)eq_data + sizeof(eq_mode_data_t)) {
        DPRINTF("  ERROR: bands[0] address out of range\n");
            continue;  // 继续处理下一个通道
    }

    // 暂时注释掉有问题的调试代码
     DPRINTF("  Accessing bands[0].index...\n");
     DPRINTF("  bands[0].index = %d\n", eq_data->bands[0].index);

     DPRINTF("  Accessing bands[0].type...\n");
     DPRINTF("  bands[0].type = %d\n", eq_data->bands[0].type);

     DPRINTF("  Accessing bands[0].fc...\n");
        DPRINTF("  bands[0].fc = %d.%02d Hz\n", (int)eq_data->bands[0].fc, (int)((eq_data->bands[0].fc - (int)eq_data->bands[0].fc) * 100));

     DPRINTF("  Accessing bands[0].q...\n");
        DPRINTF("  bands[0].q = %d.%04d\n", (int)eq_data->bands[0].q, (int)((eq_data->bands[0].q - (int)eq_data->bands[0].q) * 10000));

        DPRINTF("  Successfully loaded EQ parameters for mode %d, channel %d\n", mode, ch);
    }

    lfs_deinit();
    return 0;
}

/**
 * @brief 检查滤波器是否为默认值（bypass）
 * @param band 滤波器参数
 * @return 1: 是默认值, 0: 不是默认值
 */
int is_filter_bypass(const filter_params_t *band) {
    if (band == NULL) return 1;

    // 检查是否为bypass类型
    if (band->type != FILTER_TYPE_BYPASS) return 0;

    // 检查其他参数是否为默认值
    if (band->fc != 1000.0f) return 0;
    if (band->q != 0.707f) return 0;
    if (band->bw != 1.0f) return 0;
    if (band->gain != 0.0f) return 0;

    return 1;
}

/**
 * @brief 从EQ数据中提取非默认滤波器到Flash存储格式
 * @param eq_data 源EQ数据
 * @param flash_data 目标Flash存储数据
 * @return 0: 成功, -1: 失败
 */
int extract_active_filters(const eq_mode_data_t *eq_data, eq_flash_data_t *flash_data) {
    if (eq_data == NULL || flash_data == NULL) return -1;

    flash_data->active_bands_count = 0;

    // 遍历所有滤波器，只保存非bypass的
    for (int i = 0; i < MAX_EQ_BANDS; i++) {
        if (!is_filter_bypass(&eq_data->bands[i])) {
            if (flash_data->active_bands_count >= MAX_EQ_BANDS) {
                DPRINTF("  Warning: Too many active filters, truncating\n");
                break;
            }

            // 复制非默认滤波器
            flash_data->active_bands[flash_data->active_bands_count] = eq_data->bands[i];
            flash_data->active_bands[flash_data->active_bands_count].index = flash_data->active_bands_count;
            flash_data->active_bands_count++;
        }
    }

    DPRINTF("  Extracted %d active filters from %d total filters\n",
           flash_data->active_bands_count, MAX_EQ_BANDS);

    return 0;
}

/**
 * @brief 从Flash存储格式恢复EQ数据
 * @param flash_data 源Flash存储数据
 * @param eq_data 目标EQ数据
 * @return 0: 成功, -1: 失败
 */
int restore_eq_from_flash(const eq_flash_data_t *flash_data, eq_mode_data_t *eq_data) {
    if (flash_data == NULL || eq_data == NULL) return -1;

    // 初始化所有滤波器为bypass
    for (int i = 0; i < MAX_EQ_BANDS; i++) {
        eq_data->bands[i].index = i;
        eq_data->bands[i].type = FILTER_TYPE_BYPASS;
        eq_data->bands[i].fc = 1000.0f;
        eq_data->bands[i].q = 0.707f;
        eq_data->bands[i].bw = 1.0f;
        eq_data->bands[i].gain = 0.0f;
    }

    // 恢复非默认滤波器
    for (int i = 0; i < flash_data->active_bands_count && i < MAX_EQ_BANDS; i++) {
        int target_index = flash_data->active_bands[i].index;
        if (target_index >= 0 && target_index < MAX_EQ_BANDS) {
            eq_data->bands[target_index] = flash_data->active_bands[i];
        }
    }

    DPRINTF("  Restored %d active filters to EQ data\n", flash_data->active_bands_count);

    return 0;
}

// ==================== 单参数动态存储系统实现 ====================

/**
 * @brief 初始化单参数存储数据库
 * @return 0: 成功, -1: 失败
 */
int eq_single_param_database_init(void) {
    DPRINTF("Initializing single parameter storage database\n");

    memset(&single_param_database, 0, sizeof(single_param_database));
    single_param_database.max_params = MAX_EQ_BANDS * 8 * 2; // 最多8个模式×2通道的所有参数
    single_param_database.param_count = 0;
    single_param_database.last_save_time = 0;

    DPRINTF("  Single parameter database initialized: max_params=%d\n", single_param_database.max_params);
    return 0;
}

/**
 * @brief 处理0x8c/0x8d命令的单参数变化
 * @param data 接收到的数据
 * @param len 数据长度
 * @return 0: 成功, -1: 失败
 */
int eq_process_single_param_change(uint32_t sample_rate, uint8_t mode, uint8_t channel, uint8_t band_index, filter_params_t *band) {
    // 添加到单参数数据库
    if (eq_add_single_param(sample_rate, mode, channel, band_index, band) == 0) {
        // 标记为脏数据
        dirty_flags[mode] = 1;

        return 0;
    } else {
        return -1;
    }
}

/**
 * @brief 比较单个参数是否不同
 * @param old_params 旧参数
 * @param new_params 新参数
 * @return 1: 不同, 0: 相同
 */
int eq_single_params_different(const filter_params_t *old_params, const filter_params_t *new_params) {
    if (old_params == NULL || new_params == NULL) return 1;

    // 比较各个字段
    if (old_params->type != new_params->type) return 1;
    if (fabsf(old_params->fc - new_params->fc) > 0.01f) return 1;
    if (fabsf(old_params->q - new_params->q) > 0.0001f) return 1;
    if (fabsf(old_params->bw - new_params->bw) > 0.01f) return 1;
    if (fabsf(old_params->gain - new_params->gain) > 0.01f) return 1;

    return 0;
}

/**
 * @brief 添加单个参数变化到数据库
 * @param sample_rate 采样率
 * @param mode 模式
 * @param channel 通道
 * @param band_index 滤波器索引
 * @param new_params 新参数
 * @return 0: 成功, -1: 失败
 */
int eq_add_single_param(uint32_t sample_rate, uint8_t mode, uint8_t channel,
                       uint8_t band_index, const filter_params_t *new_params) {
    if (new_params == NULL) return -1;

    // 检查是否已存在相同的参数记录
    for (int i = 0; i < single_param_database.param_count; i++) {
        eq_single_param_t *param = &single_param_database.params[i];
        if (param->sample_rate == sample_rate &&
            param->mode == mode &&
            param->channel == channel &&
            param->band_index == band_index) {
            // 更新现有记录
            param->params = *new_params;
            param->timestamp = get_reference_time();
            param->is_dirty = 1;
            DPRINTF("  Updated existing single parameter: rate=%u, mode=%d, ch=%d, band=%d\n",
                   sample_rate, mode, channel, band_index);
            return 0;
        }
    }

    // 检查数据库是否已满
    if (single_param_database.param_count >= single_param_database.max_params) {
        DPRINTF("  Warning: Single parameter database full, overwriting oldest entry\n");
        // 移动所有条目向前一位，覆盖最旧的
        memmove(&single_param_database.params[0], &single_param_database.params[1],
                (single_param_database.max_params - 1) * sizeof(eq_single_param_t));
        single_param_database.param_count--;
    }

    // 添加新参数
    eq_single_param_t *param = &single_param_database.params[single_param_database.param_count];
    param->sample_rate = sample_rate;
    param->mode = mode;
    param->channel = channel;
    param->band_index = band_index;
    param->params = *new_params;
    param->timestamp = get_reference_time();
    param->is_dirty = 1;

    single_param_database.param_count++;

    DPRINTF("  Added single parameter: rate=%u, mode=%d, ch=%d, band=%d, count=%d\n",
           sample_rate, mode, channel, band_index, single_param_database.param_count);

    return 0;
}

/**
 * @brief 保存单个参数到Flash
 * @param sample_rate 采样率
 * @param mode 模式
 * @param channel 通道
 * @param band_index 滤波器索引
 * @return 0: 成功, -1: 失败
 */
int eq_save_single_param(uint32_t sample_rate, uint8_t mode, uint8_t channel, uint8_t band_index) {
    if (mode < EQ_USER_MODE_MIN || mode > EQ_USER_MODE_MAX ) {
        return -1;
    }
    DPRINTF("Saving single parameter to Flash: mode=%d, ch=%d, band=%d (applying to all sample rates)\n",
           mode, channel, band_index);

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 构建单个参数文件路径 - 简化格式：只存储mode和band信息
    // 改动原因：使用全局变量代替硬编码目录名，统一文件路径管理
    char file_path[FILE_PATH_MAX_LENGTH];
    snprintf(file_path, sizeof(file_path), "%s/mode%d_band%d.bin",
             g_eq_flash_base_dir, mode, band_index);

    // 改动原因：优化EQ参数存储策略，统一参数源为44100Hz
    // 保存参数时，总是从44100Hz读取参数，确保参数一致性
    eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr(44100);
    if (!eq_array) {
        DPRINTF("  Error: Failed to get EQ array for sample rate 44100 (unified source)\n");
        return -1;
    }

    // 从44100Hz统一参数源读取参数
    filter_params_t *param = &(*eq_array)[mode][channel].bands[band_index];

    // 创建文件头
    eq_file_header_t header;
    header.magic = EQ_FLASH_MAGIC;
    header.version = EQ_FLASH_VERSION;
    header.mode = mode;
    header.channel = 0; // 固定为channel 0，因为只存储channel 0的参数
    header.reserved = band_index; // 使用reserved字段存储band_index
    header.data_size = sizeof(filter_params_t);
    header.crc32 = eq_flash_calculate_crc32((uint8_t*)param, sizeof(filter_params_t));

    // 创建文件数据
    uint8_t file_data[sizeof(header) + sizeof(filter_params_t)];
    memcpy(file_data, &header, sizeof(header));
    memcpy(file_data + sizeof(header), param, sizeof(filter_params_t));

    // 写入文件
    lfs_write_config(file_path, file_data, sizeof(file_data));

    DPRINTF("  Successfully saved single parameter to %s\n", file_path);

    // 改动原因：优化EQ参数存储策略，参数保存后需要同步到44100Hz并更新所有采样率
    // 确保44100Hz作为统一参数源，然后通过copy_params_from_44100函数同步到其他采样率
    // 注意：这里只保存参数，系数会在切换采样率时动态计算
    // 参数已经保存到Flash，加载时会自动应用到所有采样率

    return 0;
}

/**
 * @brief 从Flash加载单个参数
 * @param sample_rate 采样率
 * @param mode 模式
 * @param channel 通道
 * @param band_index 滤波器索引
 * @return 0: 成功, -1: 失败
 */
int eq_load_single_param(uint32_t sample_rate, uint8_t mode, uint8_t channel, uint8_t band_index) {
    if (mode < EQ_USER_MODE_MIN || mode > EQ_USER_MODE_MAX ) {
        return -1;
    }
    DPRINTF("Loading single parameter from Flash: mode=%d, ch=%d, band=%d (applying to all sample rates)\n",
           mode, channel, band_index);

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 构建单个参数文件路径 - 简化格式：只存储mode和band信息
    // 改动原因：使用全局变量代替硬编码目录名，统一文件路径管理
    char file_path[FILE_PATH_MAX_LENGTH];
    snprintf(file_path, sizeof(file_path), "%s/mode%d_band%d.bin",
             g_eq_flash_base_dir, mode, band_index);

    // 检查文件是否存在
    if (!lfs_file_exists(file_path)) {
        DPRINTF("  Single parameter file does not exist: %s\n", file_path);
        return -1;
    }

    // 准备读取缓冲区
    eq_file_header_t header;
    filter_params_t param;
    uint8_t file_data[sizeof(header) + sizeof(filter_params_t)];

    // 读取文件
    lfs_read_config(file_path, file_data, sizeof(file_data));

    // 解析文件数据
    memcpy(&header, file_data, sizeof(header));
    memcpy(&param, file_data + sizeof(header), sizeof(filter_params_t));

    // 验证文件头
    if (header.magic != EQ_FLASH_MAGIC ||
        header.version != EQ_FLASH_VERSION ||
        header.mode != mode ||
        header.channel != 0 ||  // 固定验证channel为0
        header.reserved != band_index) {
        DPRINTF("  Error: Invalid single parameter file header\n");
        return -1;
    }

    // 验证CRC32
    uint32_t calculated_crc = eq_flash_calculate_crc32((uint8_t*)&param, sizeof(filter_params_t));
    if (calculated_crc != header.crc32) {
        DPRINTF("  Error: CRC32 mismatch for single parameter\n");
        return -1;
    }

    // 为所有采样率应用参数到两个通道并计算系数
    for (int i = 0; i < EQ_FLASH_MAX_SAMPLE_RATES; i++) {
        uint32_t fs = supported_sample_rates[i];
        eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr(fs);
        if (eq_array) {
            // 应用到两个通道
            (*eq_array)[mode][0].bands[band_index] = param;
            (*eq_array)[mode][1].bands[band_index] = param;
        }
    }

    return 0;
}

/**
 * @brief 保存所有脏参数到Flash
 * @return 0: 成功, -1: 失败
 */
int eq_save_dirty_params(void) {
    //DPRINTF("Saving dirty single parameters to Flash\n");

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    int has_dirty = 0;
    for (int i = 0; i < single_param_database.param_count; i++) {
        if (single_param_database.params[i].is_dirty) {
            has_dirty = 1;
            break;
        }
    }

    if (!has_dirty) {
        return 0;
    }

    if (lfs_init() != 0) {
        lfs_deinit();
        return -1;
    }

    //DPRINTF("  Single param database count: %d\n", single_param_database.param_count);

    int saved_count = 0;

    // 遍历所有脏参数，但只保存一次（不按采样率分组）
    bool saved_params[EQ_FLASH_MAX_MODES][NUM_EQ_CHANS][MAX_EQ_BANDS] = {0}; // 记录已保存的参数

    for (int i = 0; i < single_param_database.param_count; i++) {
        eq_single_param_t *param = &single_param_database.params[i];

        DPRINTF("  Checking param %d: mode=%d, ch=%d, band=%d, dirty=%d\n",
               i, param->mode, param->channel, param->band_index, param->is_dirty);

        if (param->is_dirty && !saved_params[param->mode][param->channel][param->band_index]) {
            DPRINTF("  Saving dirty single parameter: mode=%d, ch=%d, band=%d (applying to all sample rates)\n",
                   param->mode, param->channel, param->band_index);
            if (param->mode < EQ_USER_MODE_MIN || param->mode > EQ_USER_MODE_MAX ) {
                DPRINTF("  Invalid mode %d, only user modes (%d-%d) can be saved\n", param->mode, EQ_USER_MODE_MIN, EQ_USER_MODE_MAX);
                continue;
            }
            if (eq_save_single_param(param->sample_rate, param->mode, param->channel, param->band_index) == 0) {
                // 标记所有相同模式的参数为已保存
                for (int j = 0; j < single_param_database.param_count; j++) {
                    eq_single_param_t *p = &single_param_database.params[j];
                    if (p->mode == param->mode && p->channel == param->channel && p->band_index == param->band_index) {
                        p->is_dirty = 0;
                    }
                }
                saved_params[param->mode][param->channel][param->band_index] = true;
                saved_count++;
                DPRINTF("  Successfully saved single parameter\n");
            } else {
                DPRINTF("  Error: Failed to save single parameter\n");
            }
        }
    }

    if (saved_count > 0) {
        DPRINTF("  Saved %d dirty single parameters\n", saved_count);
    }
    lfs_deinit();
    return 0;
}
/**
 * @brief 保存脏的增益到Flash
 * @return 0: 成功, -1: 失败
 */
int eq_save_dirty_gain(void) {
    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 检查是否有脏的增益
    if (!gain_dirty) {
        DPRINTF("  No dirty gain to save\n");
        return 0;
    }

    if (lfs_init() != 0) {
        lfs_deinit();
        return -1;
    }

    DPRINTF("  Saving dirty gain\n");
    // 使用新的独立保存函数
    if (eq_save_gain() == 0) {
        gain_dirty = 0;  // 只清除增益脏标志
        DPRINTF("  Successfully saved gain\n");
        lfs_deinit();
        return 0;
    } else {
        DPRINTF("  Error: Failed to save gain\n");
        lfs_deinit();
        return -1;
    }
}
/**
 * @brief 保存脏的模式名称到Flash
 * @return 0: 成功, -1: 失败
 */
int eq_save_dirty_names(void) {
    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 检查是否有脏的模式名称
    if (!name_dirty) {
        DPRINTF("  No dirty mode names to save\n");
        return 0;
    }

    if (lfs_init() != 0) {
        lfs_deinit();
        return -1;
    }

    DPRINTF("  Saving dirty mode names\n");
    // 使用新的独立保存函数，逐个保存每个用户模式的name
    int saved_count = 0;
    int skipped_count = 0;

    for (int i = EQ_USER_MODE_MIN; i <= EQ_USER_MODE_MAX; i++) {
        int result = eq_save_name(i);
        if (result == 0) {
            saved_count++;
        } else if (result == 1) {
            skipped_count++;  // 跳过（与初始值相同或为空）
        }
        // result == -1 表示错误，但继续处理其他模式
    }

    name_dirty = 0;  // 清除名称脏标志（无论是否保存成功）

    if (saved_count > 0) {
        DPRINTF("  Successfully saved %d mode name(s), skipped %d\n", saved_count, skipped_count);
        lfs_deinit();
        return 0;
    } else if (skipped_count > 0) {
        DPRINTF("  All mode names skipped (same as default or empty), %d skipped\n", skipped_count);
        lfs_deinit();
        return 0;  // 跳过是正常的，不算错误
    } else {
        DPRINTF("  Error: Failed to save mode names\n");
        lfs_deinit();
        return -1;
    }
}

/**
 * @brief 保存用户模式的增益到Flash（只保存用户模式6-8）
 * @return 0: 成功, -1: 失败
 */
int eq_save_gain(void) {
    DPRINTF("Saving user mode gains to Flash\n");

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 构建文件路径
    // 改动原因：使用全局变量代替硬编码文件名，统一文件路径管理，将文件存储到基础目录下
    char file_path[FILE_PATH_MAX_LENGTH];
    snprintf(file_path, sizeof(file_path), "%s/%s", g_eq_flash_base_dir, g_eq_flash_gains_file);

    // 准备数据（只存储用户模式6-8的gain）
    eq_gain_data_t data = {0};

    // 从全局模式信息中获取数据
    extern eq_mode_info_t g_mode_info;

    // 只复制用户模式(6-8)的增益数据
    for (int i = EQ_USER_MODE_MIN; i <= EQ_USER_MODE_MAX; i++) {
        int idx = i - EQ_USER_MODE_MIN;  // 转换为数组索引 0, 1, 2
        data.mode_gains[idx] = g_mode_info.mode_gains[i];
        debug_printf("  Saving user mode %d: gain=%d\n", i, data.mode_gains[idx]);
    }

    // 创建文件头
    eq_gain_header_t header;
    header.magic = 0x4551474E; // "EQGN"
    header.version = EQ_FLASH_VERSION;
    header.data_size = sizeof(eq_gain_data_t);
    header.crc32 = eq_flash_calculate_crc32((uint8_t*)&data, sizeof(eq_gain_data_t));

    // 创建文件数据
    uint8_t file_data[sizeof(header) + sizeof(eq_gain_data_t)];
    memcpy(file_data, &header, sizeof(header));
    memcpy(file_data + sizeof(header), &data, sizeof(eq_gain_data_t));

    // 写入文件
    lfs_write_config(file_path, file_data, sizeof(file_data));

    DPRINTF("  Successfully saved gains to %s\n", file_path);
    return 0;
}

/**
 * @brief 保存单个用户模式的名称到Flash（只有与初始值不同且非空才保存）
 * @param mode 模式号（必须是用户模式6-8）
 * @return 0: 成功, -1: 失败, 1: 跳过（与初始值相同或为空）
 */
int eq_save_name(uint8_t mode) {
    if (mode < EQ_USER_MODE_MIN || mode > EQ_USER_MODE_MAX) {
        DPRINTF("  Error: Invalid mode %d, only user modes (%d-%d) can be saved\n",
                mode, EQ_USER_MODE_MIN, EQ_USER_MODE_MAX);
        return -1;
    }

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 从全局模式信息中获取当前名称
    extern eq_mode_info_t g_mode_info;
    const char* current_name = g_mode_info.mode_names[mode];

    // 获取初始默认名称
    const char* default_names[] = {"user 1", "user 2", "user 3"};
    int idx = mode - EQ_USER_MODE_MIN;  // 转换为数组索引 0, 1, 2
    const char* default_name = default_names[idx];

    // 检查是否与初始值相同
    if (strncmp(current_name, default_name, 15) == 0) {
        DPRINTF("  Mode %d name '%s' is same as default, skip saving\n", mode, current_name);
        return 1;  // 跳过保存
    }

    // 检查是否为空（全0或全空格）
    bool name_is_empty = true;
    if (current_name[0] != '\0') {
        for (int i = 0; i < 16 && current_name[i] != '\0'; i++) {
            if (current_name[i] != ' ') {
                name_is_empty = false;
                break;
            }
        }
    }

    if (name_is_empty) {
        DPRINTF("  Mode %d name is empty, skip saving\n", mode);
        // 如果文件存在，删除它
        // 改动原因：使用全局变量代替硬编码文件名，统一文件路径管理，将文件存储到基础目录下
        char file_path[FILE_PATH_MAX_LENGTH];
        snprintf(file_path, sizeof(file_path), "%s/%s%d", g_eq_flash_base_dir, g_eq_flash_name_prefix, mode);
        if (lfs_file_exists(file_path)) {
            // 删除文件（通过写入空文件或使用删除函数）
            DPRINTF("  Deleting empty name file: %s\n", file_path);
            // 注意：LittleFS可能没有直接的删除函数，可以通过写入空文件或标记删除
        }
        return 1;  // 跳过保存
    }

    DPRINTF("Saving user mode %d name to Flash: '%s'\n", mode, current_name);

    // 构建文件路径
    // 改动原因：使用全局变量代替硬编码文件名，统一文件路径管理，将文件存储到基础目录下
    char file_path[FILE_PATH_MAX_LENGTH];
    snprintf(file_path, sizeof(file_path), "%s/%s%d", g_eq_flash_base_dir, g_eq_flash_name_prefix, mode);

    // 准备数据
    eq_name_data_t data = {0};
    strncpy(data.mode_name, current_name, 15);
    data.mode_name[15] = '\0'; // 确保字符串终止

    // 创建文件头
    eq_name_header_t header;
    header.magic = 0x45514E4D; // "EQNM"
    header.version = EQ_FLASH_VERSION;
    header.mode = mode;
    header.reserved[0] = 0;
    header.reserved[1] = 0;
    header.reserved[2] = 0;
    header.data_size = sizeof(eq_name_data_t);
    header.crc32 = eq_flash_calculate_crc32((uint8_t*)&data, sizeof(eq_name_data_t));

    // 创建文件数据
    uint8_t file_data[sizeof(header) + sizeof(eq_name_data_t)];
    memcpy(file_data, &header, sizeof(header));
    memcpy(file_data + sizeof(header), &data, sizeof(eq_name_data_t));

    // 写入文件
    lfs_write_config(file_path, file_data, sizeof(file_data));

    DPRINTF("  Successfully saved mode %d name to %s\n", mode, file_path);
    return 0;
}

/**
 * @brief 保存增益和模式名称到Flash（兼容旧接口，内部调用新函数）
 * @return 0: 成功, -1: 失败
 */
int eq_save_gain_and_names(void) {
    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    int ret = 0;

    // 保存gain
    if (eq_save_gain() != 0) {
        ret = -1;
    }

    // 保存每个用户模式的name（如果与初始值不同且非空）
    for (int i = EQ_USER_MODE_MIN; i <= EQ_USER_MODE_MAX; i++) {
        int result = eq_save_name(i);
        if (result == -1) {
            ret = -1;  // 错误
        }
        // result == 1 表示跳过，这是正常的
    }

    lfs_deinit();
    return ret;
}

/**
 * @brief 标记增益为脏（需要保存）
 */
void eq_mark_gain_dirty(void) {
    gain_dirty = 1;
    DPRINTF("Marked gain as dirty for Flash sync\n");
}

/**
 * @brief 标记模式名称为脏（需要保存）
 */
void eq_mark_name_dirty(void) {
    name_dirty = 1;
    DPRINTF("Marked mode names as dirty for Flash sync\n");
}

/**
 * @brief 从Flash加载用户模式的增益
 * @return 0: 成功, -1: 失败
 */
int eq_load_gain(void) {
    DPRINTF("Loading user mode gains from Flash\n");

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 构建文件路径
    // 改动原因：使用全局变量代替硬编码文件名，统一文件路径管理，将文件存储到基础目录下
    char file_path[FILE_PATH_MAX_LENGTH];
    snprintf(file_path, sizeof(file_path), "%s/%s", g_eq_flash_base_dir, g_eq_flash_gains_file);

    // 检查文件是否存在
    if (!lfs_file_exists(file_path)) {
        debug_printf("  Gains file does not exist: %s, using defaults\n", file_path);
        return -1;  // 文件不存在，使用默认值
    }

    // 准备读取缓冲区
    eq_gain_header_t header;
    eq_gain_data_t data;
    uint8_t file_data[sizeof(header) + sizeof(eq_gain_data_t)];

    // 读取文件
    lfs_read_config(file_path, file_data, sizeof(file_data));

    // 解析文件数据
    memcpy(&header, file_data, sizeof(header));
    memcpy(&data, file_data + sizeof(header), sizeof(eq_gain_data_t));

    // 验证文件头
    if (header.magic != 0x4551474E) { // "EQGN"
        DPRINTF("  Error: Invalid gains file magic\n");
        return -1;
    }

    if (header.version != EQ_FLASH_VERSION) {
        DPRINTF("  Error: Unsupported gains file version\n");
        return -1;
    }

    // 验证CRC32
    uint32_t calculated_crc = eq_flash_calculate_crc32((uint8_t*)&data, sizeof(eq_gain_data_t));
    if (calculated_crc != header.crc32) {
        DPRINTF("  Error: CRC32 mismatch for gains data\n");
        return -1;
    }

    // 更新全局模式信息（只加载用户模式）
    extern eq_mode_info_t g_mode_info;

    // 只加载用户模式(6-8)的增益
    for (int i = EQ_USER_MODE_MIN; i <= EQ_USER_MODE_MAX; i++) {
        int idx = i - EQ_USER_MODE_MIN;  // 转换为数组索引 0, 1, 2
        g_mode_info.mode_gains[i] = data.mode_gains[idx];
        debug_printf("  Loaded user mode %d: gain=%d\n", i, g_mode_info.mode_gains[i]);
    }

    DPRINTF("  Successfully loaded gains\n");
    return 0;
}

/**
 * @brief 从Flash加载单个用户模式的名称
 * @param mode 模式号（必须是用户模式6-8）
 * @return 0: 成功, -1: 失败（文件不存在或错误）
 */
int eq_load_name(uint8_t mode) {
    if (mode < EQ_USER_MODE_MIN || mode > EQ_USER_MODE_MAX) {
        DPRINTF("  Error: Invalid mode %d, only user modes (%d-%d) can be loaded\n",
                mode, EQ_USER_MODE_MIN, EQ_USER_MODE_MAX);
        return -1;
    }

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 构建文件路径
    // 改动原因：使用全局变量代替硬编码文件名，统一文件路径管理，将文件存储到基础目录下
    char file_path[FILE_PATH_MAX_LENGTH];
    snprintf(file_path, sizeof(file_path), "%s/%s%d", g_eq_flash_base_dir, g_eq_flash_name_prefix, mode);

    // 检查文件是否存在
    if (!lfs_file_exists(file_path)) {
        DPRINTF("  Mode %d name file does not exist: %s, using default\n", mode, file_path);
        return -1;  // 文件不存在，使用默认值
    }

    // 准备读取缓冲区
    eq_name_header_t header;
    eq_name_data_t data;
    uint8_t file_data[sizeof(header) + sizeof(eq_name_data_t)];

    // 读取文件
    lfs_read_config(file_path, file_data, sizeof(file_data));

    // 解析文件数据
    memcpy(&header, file_data, sizeof(header));
    memcpy(&data, file_data + sizeof(header), sizeof(eq_name_data_t));

    // 验证文件头
    if (header.magic != 0x45514E4D) { // "EQNM"
        DPRINTF("  Error: Invalid name file magic for mode %d\n", mode);
        return -1;
    }

    if (header.mode != mode) {
        DPRINTF("  Error: Mode mismatch in name file (expected %d, got %d)\n", mode, header.mode);
        return -1;
    }

    if (header.version != EQ_FLASH_VERSION) {
        DPRINTF("  Error: Unsupported name file version for mode %d\n", mode);
        return -1;
    }

    // 验证CRC32
    uint32_t calculated_crc = eq_flash_calculate_crc32((uint8_t*)&data, sizeof(eq_name_data_t));
    if (calculated_crc != header.crc32) {
        DPRINTF("  Error: CRC32 mismatch for mode %d name data\n", mode);
        return -1;
    }

    // 更新全局模式信息
    extern eq_mode_info_t g_mode_info;
    strncpy(g_mode_info.mode_names[mode], data.mode_name, 15);
    g_mode_info.mode_names[mode][15] = '\0'; // 确保字符串终止

    DPRINTF("  Loaded user mode %d name: '%s'\n", mode, g_mode_info.mode_names[mode]);
    return 0;
}

/**
 * @brief 从Flash加载增益和模式名称（兼容旧接口，内部调用新函数）
 * @return 0: 成功, -1: 失败
 */
int eq_load_gain_and_names(void) {
    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    int ret = 0;

    // 加载gain
    if (eq_load_gain() != 0) {
        ret = -1;  // 文件不存在是正常的，使用默认值
    }

    // 加载每个用户模式的name
    for (int i = EQ_USER_MODE_MIN; i <= EQ_USER_MODE_MAX; i++) {
        if (eq_load_name(i) != 0) {
            // 文件不存在是正常的，使用默认值
        }
    }

    DPRINTF("Successfully loaded gain and mode names\n");
    lfs_deinit();
    return ret;
}

/**
 * @brief 系统开机时加载所有参数并计算系数
 * @param sample_rate 采样率
 * @param mode 模式
 * @return 0: 成功, -1: 失败
 */
int eq_load_all_params_and_calculate_coefficients(uint32_t sample_rate, uint8_t mode) {
    //DPRINTF("Loading all parameters and calculating coefficients for rate=%u, mode=%d\n",
    //       sample_rate, mode);

    if (mode < EQ_USER_MODE_MIN || mode > EQ_USER_MODE_MAX ) {
        return -1;
    }
    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    // 获取EQ数组指针
    eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr(sample_rate);
    if (!eq_array) {
        DPRINTF("  Error: Failed to get EQ array for sample rate %u\n", sample_rate);
        lfs_deinit();
        return -1;
    }

    int loaded_count = 0;

    // 简化加载逻辑：只从44100Hz channel 0加载参数，然后应用到所有采样率和通道
    for (int band = 0; band < MAX_EQ_BANDS; band++) {
        if (eq_load_single_param(44100, mode, 0, band) == 0) {
            loaded_count++;
            DPRINTF("    Loaded parameter for band %d from 44100Hz channel 0\n", band);
        }
    }

    //DPRINTF("  Loaded %d single parameters and calculated coefficients for mode %d\n",
    //       loaded_count, mode);

    lfs_deinit();
    return 0;
}

/**
 * @brief 获取单参数存储统计
 * @param stats 输出统计信息
 * @return 0: 成功, -1: 失败
 */
int eq_get_single_param_stats(eq_single_param_database_t *stats) {
    if (stats == NULL) return -1;

    *stats = single_param_database;
    return 0;
}

/**
 * @brief 清空单参数存储数据库
 * @return 0: 成功, -1: 失败
 */
int eq_clear_single_param_database(void) {
    DPRINTF("Clearing single parameter database\n");

    memset(&single_param_database, 0, sizeof(single_param_database));
    single_param_database.max_params = MAX_EQ_BANDS * 8 * 2;

    DPRINTF("  Single parameter database cleared\n");
    return 0;
}

/**
 * @brief 保存指定模式的EQ参数到Flash
 * @param mode EQ模式
 * @return 0: 成功, -1: 失败
 */
int eq_flash_save_mode(uint8_t mode) {
    DPRINTF("Saving EQ mode %d to Flash\n", mode);

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: EQ Flash storage not initialized\n");
        return -1;
    }

    if (mode >= NUM_EQ_MODES) {
        DPRINTF("  Error: Invalid mode %d (max: %d)\n", mode, NUM_EQ_MODES - 1);
        return -1;
    }

    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    // 获取当前采样率的EQ数组指针
    eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = get_eq_array_ptr(g_eq_sample_rate);
    if (!eq_array) {
        DPRINTF("  Error: Failed to get EQ array for current sample rate %lu\n", (unsigned long)g_eq_sample_rate);
        lfs_deinit();
        return -1;
    }

    // 保存左右两个声道的数据
    for (int ch = 0; ch < NUM_EQ_CHANS; ch++) {
    // 构建文件路径
    // 改动原因：使用全局变量代替硬编码目录名，统一文件路径管理
    char file_path[FILE_PATH_MAX_LENGTH];
        snprintf(file_path, sizeof(file_path), "%s/mode%d_ch%d.bin", g_eq_flash_base_dir, mode, ch);
        DPRINTF("  File path (channel %d): %s\n", ch, file_path);

    // 从EQ数组读取数据
        eq_mode_data_t *eq_data = &(*eq_array)[mode][ch];
        DPRINTF("  Reading EQ data from array (ch %d): sample_rate=%u, post_gain_db=%ld\n",
                     ch, eq_data->sample_rate, (long)eq_data->post_gain_db);

        // 提取非默认滤波器到优化存储格式
        eq_flash_data_t flash_data;
        if (extract_active_filters(eq_data, &flash_data) != 0) {
            DPRINTF("  Error: Failed to extract active filters\n");
            continue;
    }

    // 准备文件头
    eq_file_header_t header;
    header.magic = EQ_FLASH_MAGIC;
    header.version = EQ_FLASH_VERSION;
    header.mode = mode;
        header.channel = ch;  // 使用正确的通道号
    header.reserved = 0;
        header.data_size = sizeof(eq_flash_data_t);
        header.crc32 = eq_flash_calculate_crc32((uint8_t*)&flash_data, sizeof(eq_flash_data_t));

        // 创建完整的数据包（文件头 + 优化EQ数据）
        uint8_t file_data[sizeof(header) + sizeof(eq_flash_data_t)];
        uint8_t file_data2[sizeof(header) + sizeof(eq_flash_data_t)];
        memcpy(file_data, &header, sizeof(header));
        memcpy(file_data + sizeof(header), &flash_data, sizeof(eq_flash_data_t));

        DPRINTF(" +++++++++++++++ data before save (ch %d) ++++++++++++++ \n", ch);
       // debug_print_eq_mode(eq_data);
        DPRINTF(" +++++++++++++++ data before save (ch %d) ++++++++++++++ \n", ch);

    // 使用lfs_write_config写入文件
    lfs_write_config(file_path, file_data, sizeof(file_data));
#if 0
    lfs_read_config(file_path, file_data2, sizeof(file_data2));

    if( memcmp(file_data, file_data2, sizeof(file_data)) != 0)
    {
        DPRINTF(" *********** ** \n %s, file_data is not equal to file_data2\n", file_path);
        return -1;
        }
        #endif
        DPRINTF("  Successfully saved EQ parameters for mode %d, channel %d\n", mode, ch);
    }

    lfs_deinit();
    return 0;
}

/**
 * @brief 标记指定模式为脏（需要同步）
 * @param mode EQ模式
 */
void eq_flash_mark_dirty(uint8_t mode) {
    if ((mode >= EQ_USER_MODE_MIN) && (mode <= EQ_USER_MODE_MAX )) {
        dirty_flags[mode] = 1;
        DPRINTF("Marked mode %d as dirty\n", mode);
    }
}

/**
 * @brief 同步指定模式参数到Flash(延迟写入)
 * @param mode 模式号
 * @return 0: 成功, -1: 失败
 */
int eq_flash_sync_mode(uint8_t mode) {
    DPRINTF("Syncing EQ mode %d to Flash\n", mode);

    if (!storage_status.is_initialized) {
        DPRINTF("EQ Flash storage not initialized\n");
        return -1;
    }

    if (mode >= NUM_EQ_MODES) {
        DPRINTF("Invalid mode %d\n", mode);
        return -1;
    }

    // 保存指定模式到Flash
    if (eq_flash_save_mode(mode) != 0) {
        DPRINTF("Failed to save mode %d to Flash\n", mode);
        return -1;
    }

    // 清除脏标志
    dirty_flags[mode] = 0;
    DPRINTF("EQ mode %d synced to Flash\n", mode);
    return 0;
}

/**
 * @brief 同步所有脏数据到Flash
 * @return 0: 成功, -1: 失败
 */
int eq_flash_sync_all(void) {
    DPRINTF("Syncing dirty EQ parameters to Flash\n");

    if (!storage_status.is_initialized) {
        DPRINTF("EQ Flash storage not initialized\n");
        return -1;
    }

    // 简化实现
    memset(dirty_flags, 0, sizeof(dirty_flags));
    DPRINTF("EQ parameters synced to Flash (simplified)\n");
    return 0;
}

/**
 * @brief 检查Flash中是否有EQ数据
 * @return 1: 有数据, 0: 无数据
 */
int eq_flash_has_data(void) {
    return storage_status.has_flash_data;
}

/**
 * @brief 获取存储状态
 * @param status 输出存储状态结构
 * @return 0: 成功, -1: 失败
 */
int eq_flash_get_status(eq_storage_status_t *status) {
    if (!status) {
        return -1;
    }
    *status = storage_status;
    return 0;
}

/**
 * @brief 清除所有Flash数据
 * @return 0: 成功, -1: 失败
 */
int eq_flash_clear_all(void) {
    DPRINTF("Clearing all EQ Flash data\n");

    if (!storage_status.is_initialized) {
        DPRINTF("EQ Flash storage not initialized\n");
        return -1;
    }

    // 简化实现
    storage_status.has_flash_data = 0;
    memset(dirty_flags, 0, sizeof(dirty_flags));
    DPRINTF("All EQ Flash data cleared\n");
    return 0;
}

/**
 * @brief 验证指定模式的完整性
 * @param mode EQ模式
 * @return 1: 有效, 0: 无效
 */
int eq_flash_verify_mode(uint8_t mode) {
    DPRINTF("Verifying EQ mode %d\n", mode);

    if (!storage_status.is_initialized) {
        return 0;
    }

    // 简化实现
    return 1;
}

/**
 * @brief 获取文件路径
 * @param mode EQ模式
 * @param channel 通道
 * @param file_path 输出文件路径
 * @param max_len 最大长度
 * @return 0: 成功, -1: 失败
 */
int eq_flash_get_file_path(uint8_t mode, uint8_t channel, char *file_path, size_t max_len) {
    if (!file_path || max_len == 0) {
        return -1;
    }
    // 改动原因：使用全局变量代替硬编码目录名，统一文件路径管理
    snprintf(file_path, max_len, "%s/mode%d_ch%d.bin", g_eq_flash_base_dir, mode, channel);
    return 0;
}

/**
 * @brief 计算CRC32校验和
 * @param data 数据指针
 * @param length 数据长度
 * @return CRC32值
 */
uint32_t eq_flash_calculate_crc32(const uint8_t *data, size_t length) {
    // 简化的CRC32计算（实际应该使用标准CRC32算法）
    uint32_t crc = 0xFFFFFFFF;
    for (size_t i = 0; i < length; i++) {
        crc ^= data[i];
        for (int j = 0; j < 8; j++) {
            if (crc & 1) {
                crc = (crc >> 1) ^ 0xEDB88320;
            } else {
                crc >>= 1;
            }
        }
    }
    return ~crc;
}

/**
 * @brief 检查是否有需要同步的数据
 * @return 1: 需要同步, 0: 不需要同步
 */
int eq_flash_needs_sync(void) {
    for (int j = 0; j < NUM_EQ_MODES; j++) {
        if (dirty_flags[j]) {
            return 1;
        }
    }
    return 0;
}

/**
 * @brief 删除Flash中的EQ参数文件
 * @param mode 模式号 (0-9, 0xFF表示所有模式)
 * @return 0: 成功, -1: 失败
 */
int delete_flash_eq_params(uint8_t mode) {
    DPRINTF("Deleting Flash EQ params for mode %d\n", mode);

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    int deleted_count = 0;

    if (mode == 0xFF) {
        // 删除所有模式的参数文件
        DPRINTF("  Deleting all mode parameters\n");
        for (uint8_t m = 0; m < NUM_EQ_MODES; m++) {
            for (uint8_t band = 0; band < MAX_EQ_BANDS; band++) {
                // 改动原因：使用全局变量代替硬编码目录名，统一文件路径管理
                char file_path[FILE_PATH_MAX_LENGTH];
                snprintf(file_path, sizeof(file_path), "%s/mode%d_band%d.bin", g_eq_flash_base_dir, m, band);

                if (lfs_file_exists(file_path)) {
                    if (lfs_remove_file(file_path) == 0) {
                        deleted_count++;
                        DPRINTF("    Deleted: %s\n", file_path);
                    } else {
                        DPRINTF("    Failed to delete: %s\n", file_path);
                    }
                }
            }
        }
    } else {
        // 删除指定模式的参数文件
        DPRINTF("  Deleting mode %d parameters\n", mode);
        for (uint8_t band = 0; band < MAX_EQ_BANDS; band++) {
            // 改动原因：使用全局变量代替硬编码目录名，统一文件路径管理
            char file_path[FILE_PATH_MAX_LENGTH];
            snprintf(file_path, sizeof(file_path), "%s/mode%d_band%d.bin", g_eq_flash_base_dir, mode, band);

            if (lfs_file_exists(file_path)) {
                if (lfs_remove_file(file_path) == 0) {
                    deleted_count++;
                    DPRINTF("    Deleted: %s\n", file_path);
                } else {
                    DPRINTF("    Failed to delete: %s\n", file_path);
                }
            }
        }
    }

    DPRINTF("  Deleted %d parameter files\n", deleted_count);
    lfs_deinit();
    return 0;
}

/**
 * @brief 删除Flash中的增益和模式名称文件
 * @param mode 模式号 (0-9, 0xFF表示所有模式)
 * @return 0: 成功, -1: 失败
 *
 * 改动原因：修改为按模式删除，只删除指定模式的增益和名称，而不是删除所有文件
 * - 如果mode == 0xFF，删除所有用户模式的增益和名称文件
 * - 如果mode是用户模式(6-8)，只删除该模式的名称文件，并将该模式的增益恢复为默认值(0)
 * - 如果mode是预设模式(0-5)，不需要删除（预设模式的增益和名称不存储在Flash中）
 */
int delete_flash_gain_and_names(uint8_t mode) {
    DPRINTF("Deleting Flash gain and names for mode %d\n", mode);

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    // 处理删除所有模式的情况
    if (mode == 0xFF) {
        DPRINTF("  Deleting all user mode gains and names\n");

        // 删除gains文件
        char file_path[FILE_PATH_MAX_LENGTH];
        snprintf(file_path, sizeof(file_path), "%s/%s", g_eq_flash_base_dir, g_eq_flash_gains_file);
        if (lfs_file_exists(file_path)) {
            if (lfs_remove_file(file_path) == 0) {
                DPRINTF("  Successfully deleted gains file: %s\n", file_path);
            } else {
                DPRINTF("  Failed to delete gains file: %s\n", file_path);
            }
        }

        // 删除所有用户模式的名称文件
        for (int i = EQ_USER_MODE_MIN; i <= EQ_USER_MODE_MAX; i++) {
            snprintf(file_path, sizeof(file_path), "%s/%s%d", g_eq_flash_base_dir, g_eq_flash_name_prefix, i);
            if (lfs_file_exists(file_path)) {
                if (lfs_remove_file(file_path) == 0) {
                    DPRINTF("  Successfully deleted name file for mode %d: %s\n", i, file_path);
                } else {
                    DPRINTF("  Failed to delete name file for mode %d: %s\n", i, file_path);
                }
            }
        }

        lfs_deinit();
        return 0;
    }

    // 检查模式有效性
    if (mode >= NUM_EQ_MODES) {
        DPRINTF("  Error: Invalid mode %d\n", mode);
        lfs_deinit();
        return -1;
    }

    // 预设模式(0-5)的增益和名称不存储在Flash中，不需要删除
    if (mode < EQ_USER_MODE_MIN) {
        DPRINTF("  Mode %d is a preset mode, no Flash data to delete\n", mode);
        lfs_deinit();
        return 0;
    }

    // 只处理用户模式(6-8)
    if (mode >= EQ_USER_MODE_MIN && mode <= EQ_USER_MODE_MAX) {
        // 删除该模式的名称文件
        char file_path[FILE_PATH_MAX_LENGTH];
        snprintf(file_path, sizeof(file_path), "%s/%s%d", g_eq_flash_base_dir, g_eq_flash_name_prefix, mode);
        if (lfs_file_exists(file_path)) {
            if (lfs_remove_file(file_path) == 0) {
                DPRINTF("  Successfully deleted name file for mode %d: %s\n", mode, file_path);
            } else {
                DPRINTF("  Failed to delete name file for mode %d: %s\n", mode, file_path);
            }
        } else {
            DPRINTF("  Name file for mode %d does not exist: %s\n", mode, file_path);
        }

        // 从gains文件中移除该模式的增益（恢复为默认值0）
        // 改动原因：gains文件存储了所有用户模式的增益，需要读取、修改、写回
        snprintf(file_path, sizeof(file_path), "%s/%s", g_eq_flash_base_dir, g_eq_flash_gains_file);
        if (lfs_file_exists(file_path)) {
            // 读取gains文件
            // 改动原因：lfs_read_config返回void，不能检查返回值，需要通过验证文件头来判断读取是否成功
            eq_gain_header_t header;
            eq_gain_data_t data;
            uint8_t file_data[sizeof(header) + sizeof(eq_gain_data_t)];

            // 直接调用lfs_read_config（返回void，不能检查返回值）
            lfs_read_config(file_path, file_data, sizeof(file_data));

            // 解析文件数据
            memcpy(&header, file_data, sizeof(header));
            memcpy(&data, file_data + sizeof(header), sizeof(eq_gain_data_t));

            // 验证文件头来判断读取是否成功
            if (header.magic == 0x4551474E && header.version == EQ_FLASH_VERSION) {
                // 将对应模式的增益恢复为默认值(0)
                int idx = mode - EQ_USER_MODE_MIN;  // 转换为数组索引 0, 1, 2
                data.mode_gains[idx] = 0;
                DPRINTF("  Reset gain for mode %d to default (0)\n", mode);

                // 重新计算CRC32
                header.crc32 = eq_flash_calculate_crc32((uint8_t*)&data, sizeof(eq_gain_data_t));

                // 写回文件
                memcpy(file_data, &header, sizeof(header));
                memcpy(file_data + sizeof(header), &data, sizeof(eq_gain_data_t));
                lfs_write_config(file_path, file_data, sizeof(file_data));

                DPRINTF("  Successfully updated gains file for mode %d\n", mode);
            } else {
                DPRINTF("  Error: Invalid gains file format or read failed\n");
            }
        } else {
            DPRINTF("  Gains file does not exist: %s\n", file_path);
        }

        lfs_deinit();
        return 0;
    }

    // 其他模式（如模式9）不需要处理
    DPRINTF("  Mode %d does not require Flash data deletion\n", mode);
    lfs_deinit();
    return 0;
}

/**
 * @brief 恢复指定模式在指定采样率下的默认参数
 * @param mode 模式号
 * @param sample_rate 采样率
 */
void restore_mode_default_params(uint8_t mode, uint32_t sample_rate) {
    if (mode >= NUM_EQ_MODES) return;

    // 改动原因：所有采样率共用44100Hz数组
    eq_mode_data_t (*eq_array)[NUM_EQ_MODES][NUM_EQ_CHANS] = &sEQ_data_44100HZ;

    if (eq_array == NULL) return;

    // 恢复左右通道的默认参数
    for (int ch = 0; ch < NUM_EQ_CHANS; ch++) {
        eq_mode_data_t *eq_data = &(*eq_array)[mode][ch];

        // 恢复基本参数
        eq_data->sample_rate = sample_rate;
        eq_data->total_bshift = 0;
        eq_data->post_gain_db = 0;

        // 恢复所有滤波器的默认参数
        for (int i = 0; i < MAX_EQ_BANDS; i++) {
            filter_params_t *band = &eq_data->bands[i];
            band->index = i;
            band->type = FILTER_TYPE_BYPASS;
            band->fc = 1000.0f;
            band->q = 0.707f;
            band->bw = 1.0f;
            band->gain = 0.0f;

            // 恢复默认系数 (bypass滤波器)
            eq_data->filter.coef[0][i] = 1 << 30;  // b0 = 1.0 in Q30
            eq_data->filter.coef[1][i] = 0;        // b1 = 0
            eq_data->filter.coef[2][i] = 0;        // b2 = 0
            eq_data->filter.coef[3][i] = 0;        // a1 = 0
            eq_data->filter.coef[4][i] = 0;        // a2 = 0
        }

        eq_data->filter.biquad_count = MAX_EQ_BANDS;
        memset(eq_data->filter.state, 0, sizeof(eq_data->filter.state));
    }

    DPRINTF("    Restored mode %d for sample rate %u Hz\n", mode, sample_rate);
}
/**
 * @brief 恢复默认EQ参数
 * @param mode 模式号 (0-9, 0xFF表示所有模式)
 * @return 0: 成功, -1: 失败
 */
int restore_default_eq_params(uint8_t mode) {
    DPRINTF("Restoring default EQ params for mode %d\n", mode);

    // 改动原因：所有采样率共用44100Hz数组，只需要恢复44100Hz数组
    if (mode == 0xFF) {
        // 恢复所有模式的默认参数
        DPRINTF("  Restoring all modes to default parameters\n");
        for (uint8_t m = 0; m < NUM_EQ_MODES; m++) {
            restore_mode_default_params(m, 44100);  // 恢复44100Hz数组
        }
    } else {
        // 恢复指定模式的默认参数
        DPRINTF("  Restoring mode %d to default parameters\n", mode);
        restore_mode_default_params(mode, 44100);  // 恢复44100Hz数组
    }

    DPRINTF("  Default parameters restored successfully\n");
    return 0;
}

/**
 * @brief 保存EQ使能状态到Flash（独立文件存储，与模式存储完全分离）
 * @param enable EQ使能状态 (0=禁用, 1=启用)
 * @return 0: 成功, -1: 失败
 *
 * 改动原因：将eq_enable存储独立为单独文件，与模式存储完全分离，互不影响
 */
int eq_flash_save_eq_enable(uint8_t enable)
{
    DPRINTF("Saving EQ enable state %d to Flash (independent file)\n", enable);

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 验证使能值范围
    if (enable > 1) {
        DPRINTF("  Error: Invalid EQ enable value %d (valid range: 0-1)\n", enable);
        return -1;
    }

    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    // 构建独立文件路径
    // 改动原因：使用独立的文件名存储eq_enable，与模式存储完全分离
    char file_path[FILE_PATH_MAX_LENGTH];
    snprintf(file_path, sizeof(file_path), "%s", g_eq_flash_enable_file);

    // 创建文件头
    eq_file_header_t header = {0};
    header.magic = EQ_FLASH_MAGIC;
    header.version = EQ_FLASH_VERSION;
    header.mode = 0;  // 不使用模式字段
    header.channel = 0;  // 不使用通道字段
    header.data_size = 1;  // 数据大小：只有使能状态（1字节）

    // 准备数据（只有使能状态）
    uint8_t enable_data = enable;

    header.crc32 = eq_flash_calculate_crc32(&enable_data, 1);

    // 准备文件数据
    uint8_t file_data[sizeof(header) + 1];
    memcpy(file_data, &header, sizeof(header));
    file_data[sizeof(header)] = enable;

    // 写入文件
    lfs_write_config(file_path, file_data, sizeof(file_data));
    DPRINTF("  Successfully saved EQ enable %d to Flash (independent file: %s)\n", enable, file_path);
    lfs_deinit();
    return 0;
}

/**
 * @brief 保存当前EQ模式到Flash（独立文件存储，与使能状态存储完全分离）
 * @param mode 模式值 (0-9)
 * @return 0: 成功, -1: 失败
 *
 * 改动原因：将模式存储独立为单独文件，与eq_enable存储完全分离，互不影响
 */
int eq_flash_save_current_mode(uint8_t mode)
{
    DPRINTF("Saving current EQ mode %d to Flash (independent file)\n", mode);

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    // 验证模式值范围
    if (mode > 9) {
        DPRINTF("  Error: Invalid mode %d (valid range: 0-9)\n", mode);
        return -1;
    }

    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    // 构建独立文件路径
    // 改动原因：使用独立的文件名存储模式，与eq_enable存储完全分离
    char file_path[FILE_PATH_MAX_LENGTH];
    snprintf(file_path, sizeof(file_path), "%s", g_eq_flash_mode_file);

    // 创建文件头
    eq_file_header_t header = {0};
    header.magic = EQ_FLASH_MAGIC;
    header.version = EQ_FLASH_VERSION;
    header.mode = mode;  // 模式值
    header.channel = 0;  // 不使用通道字段
    header.data_size = 1;  // 数据大小：只有模式值（1字节）

    // 准备数据（只有模式值）
    uint8_t mode_data = mode;

    header.crc32 = eq_flash_calculate_crc32(&mode_data, 1);

    // 准备文件数据
    uint8_t file_data[sizeof(header) + 1];
    memcpy(file_data, &header, sizeof(header));
    file_data[sizeof(header)] = mode;

    // 写入文件
    lfs_write_config(file_path, file_data, sizeof(file_data));
    DPRINTF("  Successfully saved EQ mode %d to Flash (independent file: %s)\n", mode, file_path);
    lfs_deinit();
    return 0;
}

/**
 * @brief 从Flash加载当前EQ模式和使能状态（从两个独立文件分别加载）
 * @return 模式值: 成功, -1: 失败
 *
 * 改动原因：从两个独立文件分别加载模式和使能状态，完全独立，互不影响
 */
int eq_flash_load_current_mode(void)
{
    uint8_t mode = 0;
    uint8_t eq_enable = 0;
    DPRINTF("Loading current EQ mode and enable state from Flash (independent files)\n");

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    // 加载模式（从独立文件）
    char mode_file_path[FILE_PATH_MAX_LENGTH];
    snprintf(mode_file_path, sizeof(mode_file_path), "%s", g_eq_flash_mode_file);

    if (lfs_file_exists(mode_file_path)) {
        eq_file_header_t header;
        uint8_t file_header_data[sizeof(header) + 1];
        lfs_read_config(mode_file_path, file_header_data, sizeof(file_header_data));
        memcpy(&header, file_header_data, sizeof(header));

        if (header.magic == EQ_FLASH_MAGIC && header.version == EQ_FLASH_VERSION) {
            mode = file_header_data[sizeof(header)];

            // 验证模式值范围
            if (mode > 9) {
                DPRINTF("  Error: Invalid mode value %d in file\n", mode);
                mode = 0;  // 使用默认值
            } else {
                // 验证CRC32
                uint8_t mode_data = mode;
                uint32_t calculated_crc = eq_flash_calculate_crc32(&mode_data, 1);
                if (calculated_crc == header.crc32) {
                    DPRINTF("  Successfully loaded mode %d from Flash\n", mode);
                } else {
                    DPRINTF("  Error: CRC32 mismatch for mode file, using default mode 0\n");
                    mode = 0;
                }
            }
        } else {
            DPRINTF("  Error: Invalid mode file header, using default mode 0\n");
            mode = 0;
        }
    } else {
        DPRINTF("  Mode file does not exist, using default mode 0\n");
        mode = 0;
    }

    // 加载使能状态（从独立文件）
    char enable_file_path[FILE_PATH_MAX_LENGTH];
    snprintf(enable_file_path, sizeof(enable_file_path), "%s", g_eq_flash_enable_file);

    if (lfs_file_exists(enable_file_path)) {
        eq_file_header_t header;
        uint8_t file_header_data[sizeof(header) + 1];
        lfs_read_config(enable_file_path, file_header_data, sizeof(file_header_data));
        memcpy(&header, file_header_data, sizeof(header));

        if (header.magic == EQ_FLASH_MAGIC && header.version == EQ_FLASH_VERSION) {
            eq_enable = file_header_data[sizeof(header)];

            // 验证使能值范围
            if (eq_enable > 1) {
                DPRINTF("  Warning: Invalid EQ enable value %d in file, defaulting to 0\n", eq_enable);
                eq_enable = 0;
            } else {
                // 验证CRC32
                uint8_t enable_data = eq_enable;
                uint32_t calculated_crc = eq_flash_calculate_crc32(&enable_data, 1);
                if (calculated_crc == header.crc32) {
                    DPRINTF("  Successfully loaded EQ enable %d from Flash\n", eq_enable);
                } else {
                    DPRINTF("  Error: CRC32 mismatch for enable file, using default enable 0\n");
                    eq_enable = 0;
                }
            }
        } else {
            DPRINTF("  Error: Invalid enable file header, using default enable 0\n");
            eq_enable = 0;
        }
    } else {
        DPRINTF("  Enable file does not exist, using default enable 0\n");
        eq_enable = 0;
    }
    // 设置全局变量g_eq_enable
    extern unsigned int g_eq_enable;
    g_eq_enable = eq_enable;

    DPRINTF("  Successfully loaded mode %d and EQ enable %d from Flash (independent files)\n", mode, eq_enable);
    lfs_deinit();
    return mode;
}

/**
 * @brief 从Flash加载EQ使能状态（独立文件加载，与模式加载完全分离）
 * @return 使能状态值: 成功(0或1), -1: 失败
 *
 * 改动原因：从独立文件（eq_enable）加载eq_enable，与模式加载完全分离，互不影响
 */
int eq_flash_load_eq_enable(void)
{
    uint8_t eq_enable = 0;
    DPRINTF("Loading EQ enable state from Flash (independent file)\n");

    if (!storage_status.is_initialized) {
        DPRINTF("  Error: Flash storage not initialized\n");
        return -1;
    }

    if (lfs_init() != 0) { lfs_deinit(); return -1; }

    // 加载使能状态（从独立文件）
    char enable_file_path[FILE_PATH_MAX_LENGTH];
    snprintf(enable_file_path, sizeof(enable_file_path), "%s", g_eq_flash_enable_file);

    if (lfs_file_exists(enable_file_path)) {
        eq_file_header_t header;
        uint8_t file_header_data[sizeof(header) + 1];
        lfs_read_config(enable_file_path, file_header_data, sizeof(file_header_data));
        memcpy(&header, file_header_data, sizeof(header));

        if (header.magic == EQ_FLASH_MAGIC && header.version == EQ_FLASH_VERSION) {
            eq_enable = file_header_data[sizeof(header)];

            // 验证使能值范围
            if (eq_enable > 1) {
                DPRINTF("  Warning: Invalid EQ enable value %d in file, defaulting to 0\n", eq_enable);
                eq_enable = 0;
            } else {
                // 验证CRC32
                uint8_t enable_data = eq_enable;
                uint32_t calculated_crc = eq_flash_calculate_crc32(&enable_data, 1);
                if (calculated_crc == header.crc32) {
                    DPRINTF("  Successfully loaded EQ enable %d from Flash\n", eq_enable);
                } else {
                    DPRINTF("  Error: CRC32 mismatch for enable file, using default enable 0\n");
                    eq_enable = 0;
                }
            }
        } else {
            DPRINTF("  Error: Invalid enable file header, using default enable 0\n");
            eq_enable = 0;
        }
    } else {
        DPRINTF("  Enable file does not exist, using default enable 0\n");
        eq_enable = 0;
    }

    // 设置全局变量g_eq_enable
    extern unsigned int g_eq_enable;
    g_eq_enable = eq_enable;

    DPRINTF("  Successfully loaded EQ enable %d from Flash (independent file)\n", eq_enable);
    lfs_deinit();
    return eq_enable;
}
