#include "parameter.h"
#include "flash_drv.h"
#include "modbus_rtu_slave.h"
#include <string.h>
#include "i2c_mcu.h"
#include <math.h>
#include "freertos/FreeRTOS.h"
#include "freertos/timers.h"
#include "system_control.h"
#include "esp_timer.h"

// 当前参数值
system_work_parameter_struct current_param;

// 默认值
const system_work_parameter_struct init_param = {
    .RS485_address = 1,
    .Baud_rate = 2,
    .Temp_calibration = 0,
    .Set_upper_temperature_limit = 35,
    .Set_lower_temperature_limit = 5,
    .Power_off_memory = 0,
    .Fan_delay_off = 30,
    .Fan_state_with_heat_valve = 1,
    .Fan_state_with_cool_valve = 0,
    .Valve_start_delay = 0,
    .Pipe_option = 0,
    .System_mode = 1,
    .External_Input = 0,
    .ECO_Heat = 18,
    .ECO_Cool = 28,
    .Program_option = 2,
    .temperature_unit = 0,
    .Proportional_band = 3,
    .Min_Valve_Open = 2,
    .Valve_Interval = 0,
    .Max_Fan_Voltage = 10,
    .Min_Fan_Voltage = 3,
    .High_Fan_Voltage = 9,
    .Med_Fan_Voltage = 5,
    .Low_Fan_Voltage = 3,
    .Hour1224 = 1,
    .ScreenOffTime = 60,
    .SetPoint = 20,
    .Fan_speed = 1,
    .Work_mode = 1,
    .BL_level = 50,
    .OnOffState = 1,
    .Key_Lock = 0,
    .NetConnection = 0,
    .Sleep_mode = 0,
    .flash_save_flag =  0x5a5a,
};

// --- 批量防抖保存机制 ---
// 只用一个定时器，3秒内多次参数变化只保存一次，保护Flash寿命
static TimerHandle_t g_save_param_timer = NULL;
static bool g_param_save_pending = false;

// 定时器回调：3秒内无新参数变化时，批量保存到Flash
static void SaveParamTimerCallback(TimerHandle_t xTimer) {
    if (g_param_save_pending) {
        // 实际保存到Flash
        //FlashSystemWorkParameterWrite(&current_param);
        system_control_send_event(SYS_EVENT_FLASH_WRITE, 1, 0, 0);
        g_param_save_pending = false;
    }
}

// 启动/刷新3秒批量保存定时器
void SaveParam(void) {
    g_param_save_pending = true;
    if (g_save_param_timer == NULL) {
        g_save_param_timer = xTimerCreate("ParamSaveTmr", pdMS_TO_TICKS(3000), pdFALSE, NULL, SaveParamTimerCallback);
    }
    if (xTimerIsTimerActive(g_save_param_timer)) {
        xTimerStop(g_save_param_timer, 0);
    }
    xTimerStart(g_save_param_timer, 0);
}

// 参数读写接口
// 设置RS485_address，仅当新旧值不一致时触发批量保存
void SetRS485_address(uint16_t data) {
    if (data < 1 || data > 254) return; // 范围检查
    if (current_param.RS485_address != data) {
        current_param.RS485_address = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取RS485_address当前值
uint16_t GetRS485_address(void) {
    return current_param.RS485_address;
}

// 设置Baud_rate，仅当新旧值不一致时触发批量保存和Modbus重配置
void SetBaud_rate(uint16_t data) {
    if (data != 1 && data != 2 && data != 3 && data != 4) return; // 范围检查
    if (current_param.Baud_rate != data) {
        current_param.Baud_rate = data;
        SaveParam(); // 启动/刷新批量保存
        
        // 重新配置Modbus波特率
        modbus_rtu_slave_reconfigure_baud_rate();
    }
}

// 获取Baud_rate当前值
uint16_t GetBaud_rate(void) {
    return current_param.Baud_rate;
}

// 设置Temp_calibration，仅当新旧值不一致时触发批量保存
void SetTemp_calibration(float data) {
    // 数据格式验证：只允许整数或小数部分为0.5的数值
    float temp = data * 2.0f;
    if (temp != (int)temp) {
        return; // 不是整数或0.5的倍数，拒绝设置
    }
    
    // 根据温度单位进行范围检查
    uint16_t temperature_unit = Gettemperature_unit();
    if (temperature_unit == 0) {
        // 摄氏度模式：-5到5度
        if (data < -5 || data > 5) return;
    } else {
        // 华氏度模式：-10到10度
        if (data < -10 || data > 10) return;
    }
    
    if (current_param.Temp_calibration != data) {
        current_param.Temp_calibration = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Temp_calibration当前值
float GetTemp_calibration(void) {
    return current_param.Temp_calibration;
}

// 设置Set_upper_temperature_limit，仅当新旧值不一致时触发批量保存
void SetSet_upper_temperature_limit(uint16_t data) {
    // 数据格式验证：只允许整数
    if (data != (uint16_t)data) {
        return; // 不是整数，拒绝设置
    }
    
    // 根据温度单位进行范围检查
    uint16_t temperature_unit = Gettemperature_unit();
    if (temperature_unit == 0) {
        // 摄氏度模式：20-35度
        if (data < 20 || data > 35) return;
    } else {
        // 华氏度模式：68-95度
        if (data < 68 || data > 95) return;
    }
    
    if (current_param.Set_upper_temperature_limit != data) {
        current_param.Set_upper_temperature_limit = data;
        
        // 检查当前设定温度，如果设定的上限低于当前设定温度，则调整设定温度为上限值
        float current_setpoint = GetSetPoint();
        if (data < current_setpoint) {
            SetSetPoint((float)data);
        }
        
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Set_upper_temperature_limit当前值
uint16_t GetSet_upper_temperature_limit(void) {
    return current_param.Set_upper_temperature_limit;
}

// 设置Set_lower_temperature_limit，仅当新旧值不一致时触发批量保存
void SetSet_lower_temperature_limit(uint16_t data) {
    // 数据格式验证：只允许整数
    if (data != (uint16_t)data) {
        return; // 不是整数，拒绝设置
    }
    
    // 根据温度单位进行范围检查
    uint16_t temperature_unit = Gettemperature_unit();
    if (temperature_unit == 0) {
        // 摄氏度模式：5-20度
        if (data < 5 || data > 20) return;
    } else {
        // 华氏度模式：41-68度
        if (data < 41 || data > 68) return;
    }
    
    if (current_param.Set_lower_temperature_limit != data) {
        current_param.Set_lower_temperature_limit = data;
        
        // 检查当前设定温度，如果设定的下限高于当前设定温度，则调整设定温度为下限值
        float current_setpoint = GetSetPoint();
        if (data > current_setpoint) {
            SetSetPoint((float)data);
        }
        
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Set_lower_temperature_limit当前值
uint16_t GetSet_lower_temperature_limit(void) {
    return current_param.Set_lower_temperature_limit;
}

// 设置Power_off_memory，仅当新旧值不一致时触发批量保存
void SetPower_off_memory(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    if (current_param.Power_off_memory != data) {
        current_param.Power_off_memory = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Power_off_memory当前值
uint16_t GetPower_off_memory(void) {
    return current_param.Power_off_memory;
}

// 设置Fan_delay_off，仅当新旧值不一致时触发批量保存
void SetFan_delay_off(uint16_t data) {
    if (data != 0 && data != 30 && data != 60) return; // 范围检查
    if (current_param.Fan_delay_off != data) {
        current_param.Fan_delay_off = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Fan_delay_off当前值
uint16_t GetFan_delay_off(void) {
    return current_param.Fan_delay_off;
}

// 设置Fan_state_with_heat_valve，仅当新旧值不一致时触发批量保存
void SetFan_state_with_heat_valve(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    if (current_param.Fan_state_with_heat_valve != data) {
        current_param.Fan_state_with_heat_valve = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Fan_state_with_heat_valve当前值
uint16_t GetFan_state_with_heat_valve(void) {
    return current_param.Fan_state_with_heat_valve;
}

// 设置Fan_state_with_cool_valve，仅当新旧值不一致时触发批量保存
void SetFan_state_with_cool_valve(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    if (current_param.Fan_state_with_cool_valve != data) {
        current_param.Fan_state_with_cool_valve = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Fan_state_with_cool_valve当前值
uint16_t GetFan_state_with_cool_valve(void) {
    return current_param.Fan_state_with_cool_valve;
}

// 设置Valve_start_delay，仅当新旧值不一致时触发批量保存
void SetValve_start_delay(uint16_t data) {
    if (data != 0 && data != 3 && data != 5) return; // 范围检查
    if (current_param.Valve_start_delay != data) {
        current_param.Valve_start_delay = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Valve_start_delay当前值
uint16_t GetValve_start_delay(void) {
    return current_param.Valve_start_delay;
}

// 设置Pipe_option，仅当新旧值不一致时触发批量保存
void SetPipe_option(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    
    // 检查System_mode关联限制
    uint16_t system_mode = GetSystem_mode();
    if (system_mode == 0 && data != 0) {
        // System_mode=0时，pipe_option只能为0
        return;
    }
    
    if (current_param.Pipe_option != data) {
        current_param.Pipe_option = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Pipe_option当前值
uint16_t GetPipe_option(void) {
    return current_param.Pipe_option;
}

// 设置System_mode，仅当新旧值不一致时触发批量保存
void SetSystem_mode(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    if (current_param.System_mode != data) {
        uint16_t old_system_mode = current_param.System_mode;
        current_param.System_mode = data;
        
        // 当System_mode从1变为0时，检查Work_mode是否需要调整
        if (old_system_mode == 1 && data == 0) {
            uint16_t current_work_mode = GetWork_mode();
            if (current_work_mode == 0 || current_work_mode == 2) {
                // System_mode从1变为0，且work_mode为0或2，自动改为1（制冷模式）
                SetWork_mode(1);
            }
        }
        
        // 当mode=0时，option只能为0
        if (data == 0) {
            uint16_t current_option = GetPipe_option();
            if (current_option != 0) {
                SetPipe_option(0); // 强制设置为0
            }
        }
        // 当mode=1时，option可以为0或1，不需要额外操作
        
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取System_mode当前值
uint16_t GetSystem_mode(void) {
    return current_param.System_mode;
}

// 设置External_Input，仅当新旧值不一致时触发批量保存
void SetExternal_Input(uint16_t data) {
    if (data != 0 && data != 1 && data != 2) return; // 范围检查
    if (current_param.External_Input != data) {
        current_param.External_Input = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取External_Input当前值
uint16_t GetExternal_Input(void) {
    return current_param.External_Input;
}

// 设置ECO_Heat，仅当新旧值不一致时触发批量保存
void SetECO_Heat(uint16_t data) {
    // 数据格式验证：只允许整数
    if (data != (uint16_t)data) {
        return; // 不是整数，拒绝设置
    }
    
    // 根据温度单位进行范围检查
    uint16_t temperature_unit = Gettemperature_unit();
    if (temperature_unit == 0) {
        // 摄氏度模式：5-35度
        if (data < 5 || data > 35) return;
    } else {
        // 华氏度模式：41-95度
        if (data < 41 || data > 95) return;
    }
    
    if (current_param.ECO_Heat != data) {
        current_param.ECO_Heat = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取ECO_Heat当前值
uint16_t GetECO_Heat(void) {
    return current_param.ECO_Heat;
}

// 设置ECO_Cool，仅当新旧值不一致时触发批量保存
void SetECO_Cool(uint16_t data) {
    // 数据格式验证：只允许整数
    if (data != (uint16_t)data) {
        return; // 不是整数，拒绝设置
    }
    
    // 根据温度单位进行范围检查
    uint16_t temperature_unit = Gettemperature_unit();
    if (temperature_unit == 0) {
        // 摄氏度模式：5-35度
        if (data < 5 || data > 35) return;
    } else {
        // 华氏度模式：41-95度
        if (data < 41 || data > 95) return;
    }
    
    if (current_param.ECO_Cool != data) {
        current_param.ECO_Cool = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取ECO_Cool当前值
uint16_t GetECO_Cool(void) {
    return current_param.ECO_Cool;
}

// 设置Program_option，仅当新旧值不一致时触发批量保存
void SetProgram_option(uint16_t data) {
    if (data != 0 && data != 1 && data != 2) return; // 范围检查
    if (current_param.Program_option != data) {
        current_param.Program_option = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Program_option当前值
uint16_t GetProgram_option(void) {
    return current_param.Program_option;
}

// 设置temperature_unit，仅当新旧值不一致时触发批量保存
void Settemperature_unit(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    if (current_param.temperature_unit != data) {
        uint16_t old_unit = current_param.temperature_unit;
        current_param.temperature_unit = data;
        
        // 当温度单位发生变化时，转换所有温度相关参数
        if (old_unit != data) {
            // 获取当前所有温度相关参数值
            float current_setpoint = GetSetPoint();
            float current_temp_calibration = GetTemp_calibration();
            uint16_t current_upper_limit = GetSet_upper_temperature_limit();
            uint16_t current_lower_limit = GetSet_lower_temperature_limit();
            uint16_t current_eco_heat = GetECO_Heat();
            uint16_t current_eco_cool = GetECO_Cool();
            uint16_t current_proportional_band = GetProportional_band();
            
            if (old_unit == 0 && data == 1) {
                // 从摄氏度（0）转换到华氏度（1）
                // 绝对温度转换: F = C * 9 / 5 + 32，需要四舍五入
                float new_setpoint = roundf(current_setpoint * 9.0 / 5.0 + 32.0);
                uint16_t new_upper_limit = (uint16_t)roundf(current_upper_limit * 9.0 / 5.0 + 32.0);
                uint16_t new_lower_limit = (uint16_t)roundf(current_lower_limit * 9.0 / 5.0 + 32.0);
                uint16_t new_eco_heat = (uint16_t)roundf(current_eco_heat * 9.0 / 5.0 + 32.0);
                uint16_t new_eco_cool = (uint16_t)roundf(current_eco_cool * 9.0 / 5.0 + 32.0);
                
                // 比例带特殊转换（温度差值补偿）: 华氏度比例带 = 摄氏度比例带 * 2
                uint16_t new_proportional_band = current_proportional_band * 2;
                
                // 温度校准值特殊转换（温度差值补偿）: 华氏度补偿 = 摄氏度补偿 * 2
                float new_temp_calibration = current_temp_calibration * 2.0;
                
                // 直接设置参数值，跳过范围检查
                current_param.SetPoint = new_setpoint;
                current_param.Temp_calibration = new_temp_calibration;
                current_param.Set_upper_temperature_limit = new_upper_limit;
                current_param.Set_lower_temperature_limit = new_lower_limit;
                current_param.ECO_Heat = new_eco_heat;
                current_param.ECO_Cool = new_eco_cool;
                current_param.Proportional_band = new_proportional_band;
                
            } else if (old_unit == 1 && data == 0) {
                // 从华氏度（1）转换到摄氏度（0）
                // 绝对温度转换: C = (F - 32) * 5 / 9，需要四舍五入
                float new_setpoint = roundf((current_setpoint - 32.0) * 5.0 / 9.0);
                uint16_t new_upper_limit = (uint16_t)roundf((current_upper_limit - 32) * 5.0 / 9.0);
                uint16_t new_lower_limit = (uint16_t)roundf((current_lower_limit - 32) * 5.0 / 9.0);
                uint16_t new_eco_heat = (uint16_t)roundf((current_eco_heat - 32) * 5.0 / 9.0);
                uint16_t new_eco_cool = (uint16_t)roundf((current_eco_cool - 32) * 5.0 / 9.0);
                
                // 比例带特殊转换（温度差值补偿）: 摄氏度比例带 = 华氏度比例带 / 2
                uint16_t new_proportional_band = current_proportional_band / 2;
                
                // 温度校准值特殊转换（温度差值补偿）: 摄氏度补偿 = 华氏度补偿 / 2
                float new_temp_calibration = current_temp_calibration / 2.0;
                
                // 直接设置参数值，跳过范围检查
                current_param.SetPoint = new_setpoint;
                current_param.Temp_calibration = new_temp_calibration;
                current_param.Set_upper_temperature_limit = new_upper_limit;
                current_param.Set_lower_temperature_limit = new_lower_limit;
                current_param.ECO_Heat = new_eco_heat;
                current_param.ECO_Cool = new_eco_cool;
                current_param.Proportional_band = new_proportional_band;
            }
        }
        
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取temperature_unit当前值
uint16_t Gettemperature_unit(void) {
    return current_param.temperature_unit;
}

// 设置Proportional_band，仅当新旧值不一致时触发批量保存
void SetProportional_band(uint16_t data) {
    // 数据格式验证：只允许整数
    if (data != (uint16_t)data) {
        return; // 不是整数，拒绝设置
    }
    
    // 根据温度单位进行范围检查
    uint16_t temperature_unit = Gettemperature_unit();
    if (temperature_unit == 0) {
        // 摄氏度模式：1-5度
        if (data < 1 || data > 5) return;
    } else {
        // 华氏度模式：2-10度
        //if (data < 2 || data > 10) return;
        
        // 华氏度模式额外限制：超出范围或为奇数时拒绝
        if ((data < 2 || data > 10) || (data % 2 == 1)) {
            return; // 超出范围且为奇数，拒绝设置
        }
    }
    
    if (current_param.Proportional_band != data) {
        current_param.Proportional_band = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Proportional_band当前值
uint16_t GetProportional_band(void) {
    return current_param.Proportional_band;
}

// 设置Min_Valve_Open，仅当新旧值不一致时触发批量保存
void SetMin_Valve_Open(uint16_t data) {
    if (data < 1 || data > 5) return; // 范围检查
    if (current_param.Min_Valve_Open != data) {
        current_param.Min_Valve_Open = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Min_Valve_Open当前值
uint16_t GetMin_Valve_Open(void) {
    return current_param.Min_Valve_Open;
}

// 设置Valve_Interval，仅当新旧值不一致时触发批量保存
void SetValve_Interval(uint16_t data) {
    // 数据格式验证：只允许30的整数倍
    if (data % 30 != 0) {
        return; // 不是30的整数倍，拒绝设置
    }
    
    // 范围检查：30-300
    if (data < 30 || data > 300) return;
    
    if (current_param.Valve_Interval != data) {
        current_param.Valve_Interval = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Valve_Interval当前值
uint16_t GetValve_Interval(void) {
    return current_param.Valve_Interval;
}

// 设置Max_Fan_Voltage，仅当新旧值不一致时触发批量保存
void SetMax_Fan_Voltage(uint16_t data) {
    if (data < 1 || data > 10) return; // 范围检查
    
    // 检查风机最小电压约束：最大电压不能低于当前最小电压
    uint16_t current_min_voltage = GetMin_Fan_Voltage();
    if (data < current_min_voltage) {
        return; // 最大电压不能低于当前最小电压
    }
    
    if (current_param.Max_Fan_Voltage != data) {
        current_param.Max_Fan_Voltage = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Max_Fan_Voltage当前值
uint16_t GetMax_Fan_Voltage(void) {
    return current_param.Max_Fan_Voltage;
}

// 设置Min_Fan_Voltage，仅当新旧值不一致时触发批量保存
void SetMin_Fan_Voltage(uint16_t data) {
    if (data < 1 || data > 10) return; // 范围检查
    
    // 检查风机最大电压约束：最小电压不能高于当前最大电压
    uint16_t current_max_voltage = GetMax_Fan_Voltage();
    if (data > current_max_voltage) {
        return; // 最小电压不能高于当前最大电压
    }
    
    if (current_param.Min_Fan_Voltage != data) {
        current_param.Min_Fan_Voltage = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Min_Fan_Voltage当前值
uint16_t GetMin_Fan_Voltage(void) {
    return current_param.Min_Fan_Voltage;
}

// 设置High_Fan_Voltage，仅当新旧值不一致时触发批量保存
void SetHigh_Fan_Voltage(uint16_t data) {
    if (data < 1 || data > 10) return; // 范围检查
    if (current_param.High_Fan_Voltage != data) {
        current_param.High_Fan_Voltage = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取High_Fan_Voltage当前值
uint16_t GetHigh_Fan_Voltage(void) {
    return current_param.High_Fan_Voltage;
}

// 设置Med_Fan_Voltage，仅当新旧值不一致时触发批量保存
void SetMed_Fan_Voltage(uint16_t data) {
    if (data < 1 || data > 10) return; // 范围检查
    if (current_param.Med_Fan_Voltage != data) {
        current_param.Med_Fan_Voltage = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Med_Fan_Voltage当前值
uint16_t GetMed_Fan_Voltage(void) {
    return current_param.Med_Fan_Voltage;
}

// 设置Low_Fan_Voltage，仅当新旧值不一致时触发批量保存
void SetLow_Fan_Voltage(uint16_t data) {
    if (data < 1 || data > 10) return; // 范围检查
    if (current_param.Low_Fan_Voltage != data) {
        current_param.Low_Fan_Voltage = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Low_Fan_Voltage当前值
uint16_t GetLow_Fan_Voltage(void) {
    return current_param.Low_Fan_Voltage;
}

// 设置Hour1224，仅当新旧值不一致时触发批量保存
void SetHour1224(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    if (current_param.Hour1224 != data) {
        current_param.Hour1224 = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Hour1224当前值
uint16_t GetHour1224(void) {
    return current_param.Hour1224;
}

// 设置ScreenOffTime，仅当新旧值不一致时触发批量保存
void SetScreenOffTime(uint16_t data) {
    // 数据格式验证：只允许30的整数倍
    if (data % 30 != 0) {
        return; // 不是30的整数倍，拒绝设置
    }
    
    // 范围检查：60-180
    if (data < 60 || data > 180) return;
    
    if (current_param.ScreenOffTime != data) {
        current_param.ScreenOffTime = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取ScreenOffTime当前值
uint16_t GetScreenOffTime(void) {
    return current_param.ScreenOffTime;
}

// 设置SetPoint，仅当新旧值不一致时触发批量保存
void SetSetPoint(float data) {
    // 数据格式验证：只允许整数或小数部分为0.5的数值
    // 将数据乘以2，如果结果是整数，说明原数据是整数或0.5的倍数
    float temp = data * 2.0f;
    if (temp != (int)temp) {
        return; // 不是整数或0.5的倍数，拒绝设置
    }
    
    // 动态范围检查：使用温度上下限参数
    uint16_t lower_limit = GetSet_lower_temperature_limit();
    uint16_t upper_limit = GetSet_upper_temperature_limit();
    if (data < lower_limit || data > upper_limit) return; // 动态范围检查

    int fault_code = get_fault_code();
    if (fault_code != 0) {
        return; // 故障时拒绝设置
    }
    
    // 检查SetPoint是否需要调整, 只有新旧值不一致时才调整
    if (current_param.SetPoint != data) {        
        current_param.SetPoint = data; // 正常设置
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取SetPoint当前值
float GetSetPoint(void) {
    return current_param.SetPoint;
}

// 设置Fan_speed，仅当新旧值不一致时触发批量保存
void SetFan_speed(uint16_t data) {
    if (data != 0 && data != 1 && data != 2 && data != 3) return; // 范围检查
    
    // 检查Work_mode关联限制
    uint16_t work_mode = GetWork_mode();
    if (work_mode == 3) {
        // Work_mode=3时，fan_speed只能为1/2/3
        if (data < 1 || data > 3) {
            return; // 超出允许范围，拒绝设置
        }
    }
    
    if (current_param.Fan_speed != data) {
        current_param.Fan_speed = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Fan_speed当前值
uint16_t GetFan_speed(void) {
    return current_param.Fan_speed;
}

// 设置Work_mode，仅当新旧值不一致时触发批量保存
void SetWork_mode(uint16_t data) {
    if (data != 0 && data != 1 && data != 2 && data != 3) return; // 范围检查
    
    // 检查Pipe_option和System_mode关联限制
    uint16_t pipe_option = GetPipe_option();
    uint16_t system_mode = GetSystem_mode();
    if (pipe_option == 0 && system_mode == 0 && (data == 0 || data == 2)) {
        // 当System_mode=0且Pipe_option=0时，work_mode不能为0（自动模式）或2（制热模式）
        return;
    }
    if (pipe_option == 0 && data == 0) {
        // Pipe_option=0时，work_mode不能为0（自动模式）
        return;
    }
    
    if (current_param.Work_mode != data) {
        uint16_t old_work_mode = current_param.Work_mode;
        current_param.Work_mode = data;
        
        // 检查Fan_speed是否需要调整
        uint16_t current_fan_speed = GetFan_speed();
        
        if (old_work_mode != 3 && data != 3) {
            // 在非通风模式之间切换
            if (current_fan_speed == 0) {
                // 如果当前fan_speed为0，自动设置为1
                SetFan_speed(1);
            }
            // 如果fan_speed不为0，保持不变
        } else if (old_work_mode == 3 && data != 3) {
            // 从通风模式切换到其他模式
            if (current_fan_speed == 0) {
                // 如果当前fan_speed为0，自动设置为1
                SetFan_speed(1);
            }
            // 如果fan_speed不为0，保持不变
        } else if (old_work_mode != 3 && data == 3) {
            // 从其他模式切换到通风模式
            if (current_fan_speed == 0) {
                // 如果当前fan_speed为0，自动设置为1
                SetFan_speed(1);
            }
            // 如果fan_speed不为0，保持不变
        }
        // 其他情况（如从通风模式到通风模式）不需要调整
        
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Work_mode当前值
uint16_t GetWork_mode(void) {
    return current_param.Work_mode;
}

// 设置BL_level，仅当新旧值不一致时触发批量保存
void SetBL_level(uint16_t data) {
    if (data > 100) return; // 范围检查
    if (current_param.BL_level != data) {
        current_param.BL_level = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取BL_level当前值
uint16_t GetBL_level(void) {
    return current_param.BL_level;
}

// 设置OnOffState，仅当新旧值不一致时触发批量保存
void SetOnOffState(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    if (current_param.OnOffState != data) {
        uint16_t old_onoff_state = current_param.OnOffState;
        current_param.OnOffState = data;
        
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取OnOffState当前值
uint16_t GetOnOffState(void) {
    return current_param.OnOffState;
}

// 设置Key_Lock，仅当新旧值不一致时触发批量保存
void SetKey_Lock(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    if (current_param.Key_Lock != data) {
        current_param.Key_Lock = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Key_Lock当前值
uint16_t GetKey_Lock(void) {
    return current_param.Key_Lock;
}

// 设置NetConnection，仅当新旧值不一致时触发批量保存
void SetNetConnection(uint16_t data) {
    if (data != 0 && data != 1) return; // 范围检查
    if (current_param.NetConnection != data) {
        current_param.NetConnection = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取NetConnection当前值
uint16_t GetNetConnection(void) {
    return current_param.NetConnection;
}

// 设置Sleep_mode，仅当新旧值不一致时触发批量保存
void SetSleep_mode(uint16_t data) {   
    if (data != 0 && data != 1) return; // 范围检查
    // 检查开关机状态：关机时不允许启用睡眠模式
    uint16_t onoff_state = GetOnOffState();
    if (onoff_state == 0 && data == 1) {
        // 系统关机时，拒绝启用睡眠模式
        return;
    }    
    if (current_param.Sleep_mode != data) {
        current_param.Sleep_mode = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取Sleep_mode当前值
uint16_t GetSleep_mode(void) {
    return current_param.Sleep_mode;
}

// 设置flash_save_flag，仅当新旧值不一致时触发批量保存
void Setflash_save_flag(uint16_t data) {
    if (current_param.flash_save_flag != data) {
        current_param.flash_save_flag = data;
        SaveParam(); // 启动/刷新批量保存
    }
}

// 获取flash_save_flag当前值
uint16_t Getflash_save_flag(void) {
    return current_param.flash_save_flag;
}

// 参数初始化
void InitParam(void) {
    LoadParam();  // 从 Flash 加载参数
}


esp_timer_handle_t aip8563_init_timer = NULL;   
void aip8563_init_timer_args_callback(void *arg)
{
    system_control_send_event(SYS_EVENT_AIP8563_INIT, 1, 0, 0);
}
// 参数从 Flash 加载
void LoadParam(void) {
    if (!FlashSystemWorkParameterRead(&current_param)) {
        // 若加载失败，使用默认值
        /*重置时钟芯片时间*/
        /*事件队列在后面函数中初始化，目前未初始化，创建定时器5秒后执行*/
        const esp_timer_create_args_t aip8563_init_timer_args= 
        {
            .callback = aip8563_init_timer_args_callback,
            .name = "aip8563_init_timer_args",
        };
        esp_timer_create(&aip8563_init_timer_args, &aip8563_init_timer);
        esp_timer_start_once(aip8563_init_timer, 5000000);
        
        memcpy(&current_param, &init_param, sizeof(system_work_parameter_struct));
        SaveParam(); // 自动保存默认值到 Flash
    }
}


/*wifi产测RSSI值*/
uint8_t wifi_rssi_value = 0;
void set_wifi_rssi_value(uint8_t rssi)
{
    wifi_rssi_value = rssi;
}

uint8_t get_wifi_rssi_value(void)
{
    return wifi_rssi_value;
}

/*产测运行中标志，用于后端屏蔽产测时部分正常逻辑*/
uint8_t production_test_running_flag = 0;
void set_production_test_running_flag(uint8_t flag)
{
    production_test_running_flag = flag;
}
uint8_t get_production_test_running_flag(void)
{
    return production_test_running_flag;
}