/**
 * @file system_control.c
 * @brief 系统控制模块，实现事件驱动的系统任务调度
 * @details 本模块负责整个系统的控制逻辑，包括蜂鸣器、背光、RTC、温度等功能的统一调度
 *          采用事件驱动架构，与LVGL兼容，避免阻塞主线程
 */

#include "system_control.h"
#include "i2c_mcu.h"
#include "rtc_aip8563.h"
#include "parameter.h"
#include "output_control.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include <string.h>
#include "flash_drv.h"

// 确保日志级别宏定义可用
#ifndef CONFIG_LOG_MAXIMUM_LEVEL
#define CONFIG_LOG_MAXIMUM_LEVEL ESP_LOG_INFO
#endif

static const char *TAG = "SYS_CTRL";

// RTC时间数据结构
typedef struct {
    uint16_t year;   // 年
    uint8_t month;   // 月
    uint8_t day;     // 日
    uint8_t hour;    // 时
    uint8_t min;     // 分
    uint8_t sec;     // 秒
    uint8_t week;    // 星期
} rtc_time_data_t;

// 任务和队列句柄
static TaskHandle_t system_control_task_handle = NULL;
static QueueHandle_t system_event_queue = NULL;
static esp_timer_handle_t rtc_sync_timer = NULL;
static esp_timer_handle_t temp_read_timer = NULL;
static esp_timer_handle_t temp_control_timer = NULL;

// 系统状态变量
static struct {
    uint32_t last_beep_time;        // 上次蜂鸣器触发时间
    uint16_t last_bl_level;         // 上次背光级别
    bool task_running;              // 任务运行状态
} system_state = {0};

// RTC时间缓存（全局静态变量）
static rtc_time_cache_t rtc_time_cache = {0};

// 温控状态监控变量
static temp_control_monitor_t temp_monitor = {0};

// 静态函数声明
static void system_control_task(void *pvParameters);
static void rtc_sync_timer_callback(void *arg);
static void temp_read_timer_callback(void *arg);
static void temp_control_timer_callback(void *arg);
static esp_err_t handle_beep_request(const system_event_t *event);
static esp_err_t handle_backlight_update(const system_event_t *event);
static esp_err_t handle_backlight_onoff(const system_event_t *event);
static esp_err_t handle_rtc_sync(const system_event_t *event);
static esp_err_t handle_set_rtc_time(const system_event_t *event);
static esp_err_t handle_temp_read(const system_event_t *event);
static esp_err_t handle_temp_control(const system_event_t *event);
static esp_err_t handle_roomcard_detect(const system_event_t *event);
/*puxin add 20250717*/
static esp_err_t handle_wifi_enable(const system_event_t *event);
static uint16_t set_backlight_safe(void);

// 温控管理相关静态函数声明
static void temp_control_timer_callback(void *arg);
static esp_err_t handle_temp_control(const system_event_t *event);
static esp_err_t check_temp_control_changes(void);
static esp_err_t init_temp_control_monitor(void);

/**
 * @brief 初始化系统控制模块
 */
esp_err_t system_control_init(void)
{
    // 创建事件队列
    system_event_queue = xQueueCreate(SYSTEM_CONTROL_QUEUE_SIZE, sizeof(system_event_t));
    if (!system_event_queue) {
        ESP_LOGE(TAG, "创建事件队列失败");
        return ESP_FAIL;
    }

    // 初始化系统状态
    system_state.last_beep_time = 0;
    system_state.task_running = false;      //初始化系统运行状态为false

    // 初始化温控监控
    esp_err_t ret = init_temp_control_monitor();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "温控监控初始化失败");
        return ret;
    }

    ESP_LOGI(TAG, "系统控制模块初始化成功");
    return ESP_OK;
}

esp_timer_handle_t backlight_synchronization_timer = NULL;   
void backlight_synchronization_timer_callback(void *arg)
{
    system_backlight_onoff(1);
}

/**
 * @brief 启动系统控制任务
 */
esp_err_t system_control_start(void)
{
    if (system_control_task_handle != NULL) {
        ESP_LOGW(TAG, "系统控制任务已在运行");
        return ESP_OK;
    }

    // 创建系统控制任务
    BaseType_t ret = xTaskCreate(
        system_control_task,
        "sys_ctrl_task",
        SYSTEM_CONTROL_STACK_SIZE,
        NULL,
        SYSTEM_CONTROL_TASK_PRIORITY,
        &system_control_task_handle
    );

    if (ret != pdPASS) {
        ESP_LOGE(TAG, "创建系统控制任务失败");
        return ESP_FAIL;
    }

    // 创建RTC同步定时器
    esp_timer_create_args_t rtc_timer_args = {
        .callback = rtc_sync_timer_callback,
        .name = "rtc_sync_timer",
        .arg = NULL
    };

    esp_err_t err = esp_timer_create(&rtc_timer_args, &rtc_sync_timer);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "创建RTC同步定时器失败: %s", esp_err_to_name(err));
        return err;
    }

    // 创建温度读取定时器
    esp_timer_create_args_t temp_timer_args = {
        .callback = temp_read_timer_callback,
        .name = "temp_read_timer",
        .arg = NULL
    };

    err = esp_timer_create(&temp_timer_args, &temp_read_timer);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "创建温度读取定时器失败: %s", esp_err_to_name(err));
        return err;
    }

    // 启动RTC同步定时器
    err = esp_timer_start_periodic(rtc_sync_timer, SYSTEM_RTC_SYNC_TIMER_MS * 1000);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "启动RTC同步定时器失败: %s", esp_err_to_name(err));
        return err;
    }

    // 启动温度读取定时器
    err = esp_timer_start_periodic(temp_read_timer, SYSTEM_TEMP_READ_TIMER_MS * 1000);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "启动温度读取定时器失败: %s", esp_err_to_name(err));
        return err;
    }

    // 创建温控处理定时器
    esp_timer_create_args_t temp_ctrl_timer_args = {
        .callback = temp_control_timer_callback,
        .name = "temp_ctrl_timer",
        .arg = NULL
    };

    err = esp_timer_create(&temp_ctrl_timer_args, &temp_control_timer);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "创建温控处理定时器失败: %s", esp_err_to_name(err));
        return err;
    }

    // 启动温控处理定时器
    err = esp_timer_start_periodic(temp_control_timer, SYSTEM_TEMP_CONTROL_TIMER_MS * 1000);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "启动温控处理定时器失败: %s", esp_err_to_name(err));
        return err;
    }
    

    
    // 解决上电背光不亮问题
    const esp_timer_create_args_t backlight_synchronization = 
    {
        .callback = backlight_synchronization_timer_callback,
        .name = "backlight_synchronization_timer",
    };
    esp_timer_create(&backlight_synchronization, &backlight_synchronization_timer);
    esp_timer_start_once(backlight_synchronization_timer, 1000000);      // 延时2000毫秒后执行背光同步

    system_state.task_running = true;
    ESP_LOGI(TAG, "系统控制任务启动成功");
    return ESP_OK;
}

/**
 * @brief 系统控制主任务
 */
static void system_control_task(void *pvParameters)
{
    system_event_t event;
    
    ESP_LOGI(TAG, "系统控制任务开始运行");
    
    while (/*system_state.task_running*/1) {
        // 阻塞等待事件（不占用CPU资源）
        if (xQueueReceive(system_event_queue, &event, portMAX_DELAY) == pdTRUE) {
            // 根据事件类型分发处理
            switch (event.event_id) {
                case SYS_EVENT_BEEP_REQUEST:
                    handle_beep_request(&event);
                    break;
                    
                case SYS_EVENT_BACKLIGHT_UPDATE:
                    handle_backlight_update(&event);
                    break;
                    
                case SYS_EVENT_BACKLIGHT_ONOFF:
                    handle_backlight_onoff(&event);
                    break;
                    
                case SYS_EVENT_RTC_SYNC:
                    handle_rtc_sync(&event);
                    break;
                    
                case SYS_EVENT_RTC_SET_TIME:
                    handle_set_rtc_time(&event);
                    break;
                    
                case SYS_EVENT_TEMP_READ:
                    handle_temp_read(&event);
                    break;
                    
                case SYS_EVENT_TEMP_CONTROL:
                    if(get_production_test_running_flag() == 0)
                    handle_temp_control(&event);
                    break;
                    
                case SYS_EVENT_ROOMCARD_DETECT:
                    handle_roomcard_detect(&event);
                    break;

                case SYS_EVENT_FLASH_WRITE:
                    FlashSystemWorkParameterWrite(&current_param);
                    break;
                /*puxin add 20250717*/
                case SYS_EVENT_WIFI_ENABLE:
                    handle_wifi_enable(&event);
                    break;

                case SYS_EVENT_AIP8563_INIT:
                    rtc_time_t rtc_time = {
                        .year = 25,
                        .month = 1,
                        .day = 1,
                        .hour = 8,
                        .minute = 0,
                        .second = 0,
                        .weekday = 3
                    };
                    rtc_aip8563_set_time(&rtc_time);
                    break;
                    
                default:
                    ESP_LOGW(TAG, "未知事件ID: %d", event.event_id);
                    break;
            }
        }
    }
    
    ESP_LOGI(TAG, "系统控制任务结束");
    vTaskDelete(NULL);
}

/**
 * @brief RTC同步定时器回调函数
 */
static void rtc_sync_timer_callback(void *arg)
{
    system_control_send_event(SYS_EVENT_RTC_SYNC, 1, 0, 0);
}

/**
 * @brief 温度读取定时器回调函数
 */
static void temp_read_timer_callback(void *arg)
{
    system_control_send_event(SYS_EVENT_TEMP_READ, 1, 0, 0);
}

/**
 * @brief 处理蜂鸣器请求事件
 */
static esp_err_t handle_beep_request(const system_event_t *event)
{
    uint32_t current_time = xTaskGetTickCount();
    
    // 350ms防抖检查
    if ((current_time - system_state.last_beep_time) >= pdMS_TO_TICKS(200)) {
        esp_err_t ret = i2c_mcu_beep();
        if (ret == ESP_OK) {
            system_state.last_beep_time = current_time;
            vTaskDelay(pdMS_TO_TICKS(10)); // IIC操作间隔
        } else {
            ESP_LOGE(TAG, "蜂鸣器响应失败");
        }
        return ret;
    } else {
        ESP_LOGD(TAG, "蜂鸣器防抖，忽略请求");
        return ESP_OK;
    }
}

/**
 * @brief 处理背光更新事件（增强版本，支持重试机制）
 */
static esp_err_t handle_backlight_update(const system_event_t *event)
{
    uint8_t level = (uint8_t)event->param1;
    if (level > 100) level = 100;
    if (level <= 0) level = 0;  
    
    esp_err_t ret = ESP_FAIL;
    int retry_count = 0;
    const int max_retries = 3;
    
    // 重试机制：最多重试3次
    while (retry_count < max_retries) {
        ret = i2c_mcu_set_backlight(level);
        if (ret == ESP_OK) {
            // 成功后短暂延时，确保MCU处理完成
            vTaskDelay(pdMS_TO_TICKS(20));
            break;
        } else {
            retry_count++;
            ESP_LOGW(TAG, "背光设置失败，重试 %d/%d, 错误码: %d", retry_count, max_retries, ret);
            
            // 重试前稍长延时，让IIC总线稳定
            vTaskDelay(pdMS_TO_TICKS(50));
        }
    }
    
    if (ret == ESP_OK) {
        system_state.last_bl_level = level;
        
        // 保存新的背光值到flash中
        SetBL_level(level);
        
        ESP_LOGI(TAG, "背光设置成功: %d%%, 已保存到flash (重试%d次)", level, retry_count);
    } else {
        ESP_LOGE(TAG, "背光设置最终失败，已重试%d次", max_retries);
        
        // 即使IIC命令失败，也保存到flash，避免参数丢失
        SetBL_level(level);
        system_state.last_bl_level = level;
        ESP_LOGW(TAG, "背光值 %d%% 已保存到flash，但IIC设置失败", level);
    }
    
    vTaskDelay(pdMS_TO_TICKS(10)); // IIC操作间隔
    return ret;
}

/**
 * @brief 处理背光开关事件（增强版本，支持重试机制）
 */
static esp_err_t handle_backlight_onoff(const system_event_t *event)
{
    uint8_t onoff = (uint8_t)event->param1;
    if (onoff > 1) onoff = 1;  // 限制范围
    
    esp_err_t ret = ESP_FAIL;
    int retry_count = 0;
    const int max_retries = 3;
    uint8_t target_level;
    
    if (onoff == 0) {
        // 灭屏：设置背光为0
        target_level = 0;
    } else {
        // 亮屏：获取当前背光值并设置
        uint16_t current_level = GetBL_level();
        if (current_level <= 50) {
            current_level = 50;  // 如果获取失败，使用默认值50
        }
        if (current_level > 100) current_level = 100;  // 限制最大值
        target_level = (uint8_t)current_level;
    }
    
    // 重试机制：最多重试3次
    while (retry_count < max_retries) {
        ret = i2c_mcu_set_backlight(target_level);
        if (ret == ESP_OK) {
            // 成功后短暂延时，确保MCU处理完成
            vTaskDelay(pdMS_TO_TICKS(20));
            break;
        } else {
            retry_count++;
            ESP_LOGW(TAG, "背光开关设置失败，重试 %d/%d, 目标值: %d%%, 错误码: %d", 
                    retry_count, max_retries, target_level, ret);
            
            // 重试前稍长延时，让IIC总线稳定
            vTaskDelay(pdMS_TO_TICKS(50));
        }
    }
    
    if (ret == ESP_OK) {
        if (onoff == 0) {
            ESP_LOGI(TAG, "背光关闭成功（灭屏）(重试%d次)", retry_count);
        } else {
            ESP_LOGI(TAG, "背光开启成功（亮屏），级别: %d%% (重试%d次)", target_level, retry_count);
        }
    } else {
        ESP_LOGE(TAG, "背光开关设置最终失败，目标值: %d%%, 已重试%d次", target_level, max_retries);
    }
    
    vTaskDelay(pdMS_TO_TICKS(10)); // IIC操作间隔
    return ret;
}

/**
 * @brief 处理RTC同步事件（优化版本，减少错误日志）
 */
static esp_err_t handle_rtc_sync(const system_event_t *event)
{
    // 定义临时变量用于接收RTC时间（注意：rtc_get_time的year参数是uint8_t类型，表示年份后两位）
    uint8_t year, month, day, hour, min, sec, week;
    
    // 静态变量，记录上次打印日志的分钟数，用于检测分钟变化
    static uint8_t last_printed_min = 255;  // 初始值设为无效值，确保第一次一定会打印
    
    // 读取RTC时间
    int ret = rtc_get_time(&year, &month, &day, &hour, &min, &sec, &week);
    
    if (ret == 0) {
        // 更新RTC时间缓存（year是0-99，需要转换为完整年份）
        rtc_time_cache.year = 2000 + year;  // 将年份后两位转换为完整年份
        rtc_time_cache.month = month;
        rtc_time_cache.day = day;
        rtc_time_cache.hour = hour;
        rtc_time_cache.min = min;
        rtc_time_cache.sec = sec;
        rtc_time_cache.week = week;
        rtc_time_cache.valid = true;
        
        // 检测分钟是否发生变化，如果变化则打印时间日志
        if (min != last_printed_min) {
            const char* weekday_names[] = {"周日", "周一", "周二", "周三", "周四", "周五", "周六"};
            const char* weekday_name = (week <= 6) ? weekday_names[week] : "未知";
            
            last_printed_min = min;  // 更新上次打印的分钟数
        }
    } else {
        // RTC读取失败，但不影响系统运行
        rtc_time_cache.valid = false;
        
        // 减少错误日志频率，每10次失败才打印一次
        static uint32_t rtc_fail_count = 0;
        rtc_fail_count++;
        if (rtc_fail_count % 10 == 1) {
            ESP_LOGW(TAG, "RTC时间读取持续失败，错误码: %d (已失败%lu次)", ret, (unsigned long)rtc_fail_count);
        }
    }
    
    vTaskDelay(pdMS_TO_TICKS(10)); // IIC操作间隔
    return ESP_OK;  // 总是返回成功，避免阻塞其他事件
}

/**
 * @brief 处理温度读取事件
 */
static esp_err_t handle_temp_read(const system_event_t *event)
{
    int ret = temp_display(NULL, NULL);
    vTaskDelay(pdMS_TO_TICKS(10)); // IIC操作间隔
    return ESP_OK;
}

/**
 * @brief 处理RTC时间设置事件
 */
static esp_err_t handle_set_rtc_time(const system_event_t *event)
{
    // 从事件中提取RTC时间数据
    rtc_time_data_t *rtc_data = (rtc_time_data_t *)event->rtc_data;
    
    // 调用rtc_aip8563模块的rtc_set_time_auto_weekday函数（year需要转换为后两位）
    uint8_t year_2digit = (rtc_data->year >= 2000) ? (rtc_data->year - 2000) : rtc_data->year;
    int ret = rtc_set_time_auto_weekday(year_2digit, rtc_data->month, rtc_data->day,
                                       rtc_data->hour, rtc_data->min, rtc_data->sec);
    
    if (ret == 0) {
        ESP_LOGI(TAG, "RTC时间设置成功: %04d-%02d-%02d %02d:%02d:%02d (weekday自动计算)", 
                rtc_data->year, rtc_data->month, rtc_data->day,
                rtc_data->hour, rtc_data->min, rtc_data->sec);
    } else {
        ESP_LOGE(TAG, "RTC时间设置失败，错误码: %d", ret);
    }
    
    vTaskDelay(pdMS_TO_TICKS(10)); // IIC操作间隔
    return (ret == 0) ? ESP_OK : ESP_FAIL;
}

/**
 * @brief 安全设置背光亮度
 */
static uint16_t set_backlight_safe(void)
{
    uint16_t bl_value = GetBL_level();
    if (bl_value <= 0) bl_value = 50;  // 默认值
    i2c_mcu_set_backlight(bl_value);
    return bl_value;
}

/*puxin add 20250717*/
static esp_err_t handle_wifi_enable(const system_event_t *event)
{
    uint8_t retry_count = 0;
    uint8_t max_retries = 3;
    int ret = 0;
    // 重试机制：最多重试3次
    while (retry_count < max_retries) {
        ret = i2c_mcu_wifi_en(event->param1);
        if (ret == ESP_OK) {
            // 成功后短暂延时，确保MCU处理完成
            vTaskDelay(pdMS_TO_TICKS(20));
            break;
        } else {
            retry_count++;
            ESP_LOGW(TAG, "wifi使能设置失败，重试 %d/%d, 错误码: %d", retry_count, max_retries, ret);
            
            // 重试前稍长延时，让IIC总线稳定
            vTaskDelay(pdMS_TO_TICKS(50));
        }
    }
    return ret;
}

/**
 * @brief 发送系统事件（改进版本，支持队列清理）
 */
esp_err_t system_control_send_event(system_event_id_t event_id, uint8_t enabled, uint32_t param1, uint32_t param2)
{
    if (!system_event_queue) {
        ESP_LOGE(TAG, "事件队列未初始化");
        return ESP_FAIL;
    }
    
    system_event_t event = {
        .event_id = event_id,
        .enabled = enabled,
        .param1 = param1,
        .param2 = param2
    };
    
    BaseType_t ret = xQueueSend(system_event_queue, &event, 0);
    if (ret != pdTRUE) {
        // 队列满时，根据事件类型决定处理策略
        if (event_id == SYS_EVENT_RTC_SYNC) {
            // RTC同步事件可以丢弃，不影响系统运行
            ESP_LOGD(TAG, "RTC同步事件队列满，跳过本次同步");
            return ESP_OK;  // 返回成功，避免过多警告
        } else if (event_id == SYS_EVENT_TEMP_READ) {
            // 温度读取事件可以丢弃
            ESP_LOGD(TAG, "温度读取事件队列满，跳过本次读取");
            return ESP_OK;
        } else {
            // 重要事件（蜂鸣器、背光）需要特殊处理
            if (event_id == SYS_EVENT_BACKLIGHT_UPDATE || event_id == SYS_EVENT_BACKLIGHT_ONOFF) {
                // 背光事件：强制发送，等待队列有空间
                BaseType_t force_ret = xQueueSend(system_event_queue, &event, pdMS_TO_TICKS(100));
                if (force_ret != pdTRUE) {
                    ESP_LOGE(TAG, "背光事件发送失败，队列持续满载");
                    return ESP_FAIL;
                } else {
                    ESP_LOGW(TAG, "背光事件等待队列空间后成功发送");
                    return ESP_OK;
                }
            } else {
                // 其他重要事件（蜂鸣器）警告
                ESP_LOGW(TAG, "重要事件队列满，丢弃事件ID: %d", event_id);
                return ESP_FAIL;
            }
        }
    }
    
    return ESP_OK;
}

/**
 * @brief 请求蜂鸣器响一声（LVGL调用接口）
 */
esp_err_t system_request_beep(void)
{
    return system_control_send_event(SYS_EVENT_BEEP_REQUEST, 1, 0, 0);
}

/**
 * @brief 更新背光亮度（LVGL调用接口）
 */
esp_err_t system_update_backlight(uint8_t level)
{
    return system_control_send_event(SYS_EVENT_BACKLIGHT_UPDATE, 1, level, 0);
}

/**
 * @brief 背光开关控制（LVGL调用接口）
 */
esp_err_t system_backlight_onoff(uint8_t onoff)
{
    return system_control_send_event(SYS_EVENT_BACKLIGHT_ONOFF, 1, onoff, 0);
}

/**
 * @brief 设置RTC时间（LVGL调用接口，自动计算星期几）
 */
esp_err_t system_set_rtc_time(uint16_t year, uint8_t month, uint8_t day, 
                             uint8_t hour, uint8_t min, uint8_t sec)
{
    // 参数验证
    if (year < 2000 || year > 2099 || month < 1 || month > 12 || 
        day < 1 || day > 31 || hour > 23 || min > 59 || sec > 59) {
        ESP_LOGE(TAG, "RTC时间参数无效");
        return ESP_ERR_INVALID_ARG;
    }
    
    // 自动计算星期几
    uint8_t year_2digit = year - 2000;  // 转换为2位年份
    uint8_t week = rtc_calculate_weekday(year_2digit, month, day);
    
    // 创建RTC时间数据
    rtc_time_data_t rtc_data = {
        .year = year,
        .month = month,
        .day = day,
        .hour = hour,
        .min = min,
        .sec = sec,
        .week = week
    };
    
    // 将RTC时间数据打包到事件参数中
    system_event_t event = {
        .event_id = SYS_EVENT_RTC_SET_TIME,
        .enabled = 1,
        .param1 = 0,
        .param2 = 0
    };
    
    // 将RTC数据复制到事件结构体中
    memcpy(event.rtc_data, &rtc_data, sizeof(rtc_time_data_t));
    
    // 发送事件到队列
    if (!system_event_queue) {
        ESP_LOGE(TAG, "事件队列未初始化");
        return ESP_FAIL;
    }
    
    BaseType_t ret = xQueueSend(system_event_queue, &event, 0);
    if (ret != pdTRUE) {
        ESP_LOGW(TAG, "RTC设置事件队列满，丢弃请求");
        return ESP_FAIL;
    }
    
    ESP_LOGI(TAG, "RTC时间设置请求已发送: %04d-%02d-%02d %02d:%02d:%02d 周%d (自动计算)",
            year, month, day, hour, min, sec, week);
    
    return ESP_OK;
}

/**
 * @brief 获取RTC时间缓存（LVGL调用接口，优化版本）
 */
esp_err_t system_get_rtc_time(rtc_time_cache_t *rtc_time)
{
    if (rtc_time == NULL) {
        ESP_LOGE(TAG, "RTC时间输出参数为NULL");
        return ESP_ERR_INVALID_ARG;
    }
    
    if (!rtc_time_cache.valid) {
        // 减少无效缓存的警告频率
        static uint32_t invalid_warn_count = 0;
        invalid_warn_count++;
        if (invalid_warn_count % 20 == 1) {
            ESP_LOGW(TAG, "RTC时间缓存无效 (第%lu次查询)", (unsigned long)invalid_warn_count);
        }
        return ESP_ERR_INVALID_STATE;
    }
    
    // 复制缓存数据到输出参数
    memcpy(rtc_time, &rtc_time_cache, sizeof(rtc_time_cache_t));
    /*puxin 20250725*/
    if(rtc_time->week == 0)
    {
        rtc_time->week = 7;
    }
    
    ESP_LOGD(TAG, "返回RTC时间缓存: %04d-%02d-%02d %02d:%02d:%02d 周%d", 
            rtc_time->year, rtc_time->month, rtc_time->day,
            rtc_time->hour, rtc_time->min, rtc_time->sec, rtc_time->week);
    
    return ESP_OK;
}

/**
 * @brief 停止系统控制任务
 */
esp_err_t system_control_stop(void)
{
    system_state.task_running = false;
    
    // 停止并删除RTC同步定时器
    if (rtc_sync_timer) {
        esp_timer_stop(rtc_sync_timer);
        esp_timer_delete(rtc_sync_timer);
        rtc_sync_timer = NULL;
    }
    
    // 停止并删除温度读取定时器
    if (temp_read_timer) {
        esp_timer_stop(temp_read_timer);
        esp_timer_delete(temp_read_timer);
        temp_read_timer = NULL;
    }
    

    
    // 删除队列
    if (system_event_queue) {
        vQueueDelete(system_event_queue);
        system_event_queue = NULL;
    }
    
    ESP_LOGI(TAG, "系统控制模块停止");
    return ESP_OK;
}

//=============================================================================
// 温控事件管理实现
//=============================================================================

/**
 * @brief 温控处理定时器回调函数
 */
static void temp_control_timer_callback(void *arg)
{
    // 发送温控处理事件
    system_control_send_event(SYS_EVENT_TEMP_CONTROL, 1, TEMP_CTRL_FLAG_PERIODIC_CHECK, 0);
    
    // 同时发送房卡检测事件（与温控处理同步，每秒检测一次）
    system_control_send_event(SYS_EVENT_ROOMCARD_DETECT, 1, 0, 0);
}

/**
 * @brief 初始化温控监控
 */
static esp_err_t init_temp_control_monitor(void)
{
    // 获取当前状态作为初始值
    temp_monitor.last_onoff_state = GetOnOffState();
    temp_monitor.last_work_mode = GetWork_mode();
    temp_monitor.last_setpoint = GetSetPoint();
    temp_monitor.last_room_temp = get_temp_disp();
    temp_monitor.last_update_time = esp_timer_get_time() / 1000000;
    temp_monitor.change_flags = 0;
    temp_monitor.temp_control_enabled = true;
    
    // 初始化AO输出状态
    temp_control_state_t current_state;
    esp_err_t ret = output_control_get_state(&current_state);
    if (ret == ESP_OK) {
        /*temp_monitor.last_ao1_output = current_state.ao1_output;*/
        temp_monitor.last_ao2_output = current_state.ao2_output;
        temp_monitor.last_ao3_output = current_state.ao3_output;
    } else {
        // 如果获取失败，初始化为0
        temp_monitor.last_ao1_output = 0;
        temp_monitor.last_ao2_output = 0;
        temp_monitor.last_ao3_output = 0;
        ESP_LOGW(TAG, "初始化AO输出状态失败，使用默认值0");
    }
    
    return ESP_OK;
}

/**
 * @brief 检查温控相关参数变化
 */
static esp_err_t check_temp_control_changes(void)
{
    temp_monitor.change_flags = 0;  // 清除变化标志
    
    // 1. 检查开关机状态变化
    uint16_t current_onoff = GetOnOffState();
    if (current_onoff != temp_monitor.last_onoff_state) {
        temp_monitor.change_flags |= TEMP_CTRL_FLAG_ONOFF_CHANGED;
        ESP_LOGI(TAG, "开关机状态变化: %d -> %d", temp_monitor.last_onoff_state, current_onoff);
        temp_monitor.last_onoff_state = current_onoff;
    }
    
    // 2. 检查工作模式变化
    uint16_t current_mode = GetWork_mode();
    if (current_mode != temp_monitor.last_work_mode) {
        temp_monitor.change_flags |= TEMP_CTRL_FLAG_MODE_CHANGED;
        const char* mode_names[] = {"自动", "制冷", "制热", "通风"};
        ESP_LOGI(TAG, "工作模式变化: %s -> %s", 
                 mode_names[temp_monitor.last_work_mode], mode_names[current_mode]);
        temp_monitor.last_work_mode = current_mode;
    }
    
    // 3. 检查设定温度变化
    float current_setpoint = GetSetPoint();
    if (current_setpoint != temp_monitor.last_setpoint) {
        temp_monitor.change_flags |= TEMP_CTRL_FLAG_SETPOINT_CHANGED;
        temp_monitor.last_setpoint = current_setpoint;
    }
    
    // 4. 检查房间温度变化（变化超过0.1°C才触发）
    float current_temp = get_temp_disp();
    float temp_diff = current_temp - temp_monitor.last_room_temp;
    if (temp_diff > 0.1f || temp_diff < -0.1f) {
        temp_monitor.change_flags |= TEMP_CTRL_FLAG_TEMP_CHANGED;
        temp_monitor.last_room_temp = current_temp;
    }
    
    // 5. 获取并监控AO1/AO2/AO3开度状态
    temp_control_state_t current_state;
    esp_err_t ret = output_control_get_state(&current_state);
    
    return ESP_OK;
}

/**
 * @brief 处理温控事件
 */
static esp_err_t handle_temp_control(const system_event_t *event)
{
    if (!temp_monitor.temp_control_enabled) {
        return ESP_OK;  // 温控功能已禁用
    }
    
    // 检查参数变化
    esp_err_t ret = check_temp_control_changes();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "检查温控参数变化失败");
        return ret;
    }
    
    // 添加事件参数中的标志位（如强制更新）
    if (event->param1 & TEMP_CTRL_FLAG_FORCE_UPDATE) {
        temp_monitor.change_flags |= TEMP_CTRL_FLAG_FORCE_UPDATE;
    }
    if (event->param1 & TEMP_CTRL_FLAG_PERIODIC_CHECK) {
        temp_monitor.change_flags |= TEMP_CTRL_FLAG_PERIODIC_CHECK;
    }
    
    // 判断是否需要执行温控处理
    bool need_process = false;
    
    if (temp_monitor.change_flags & (TEMP_CTRL_FLAG_ONOFF_CHANGED | 
                                     TEMP_CTRL_FLAG_MODE_CHANGED | 
                                     TEMP_CTRL_FLAG_SETPOINT_CHANGED |
                                     TEMP_CTRL_FLAG_FORCE_UPDATE)) {
        // 关键参数变化，立即处理
        need_process = true;
    } else if (temp_monitor.change_flags & TEMP_CTRL_FLAG_TEMP_CHANGED) {
        // 温度变化，需要处理
        need_process = true;
    } else if (temp_monitor.change_flags & TEMP_CTRL_FLAG_PERIODIC_CHECK) {
        // 周期性检查，始终处理以保证系统稳定运行
        need_process = true;
        ESP_LOGI(TAG, "周期性温控检查");
    }
    
    // 执行温控处理
    if (need_process) {
        ret = output_control_process();
        if (ret != ESP_OK) {
            ESP_LOGE(TAG, "温控处理失败: %s", esp_err_to_name(ret));
            return ret;
        }
        
        // 更新最后处理时间
        temp_monitor.last_update_time = esp_timer_get_time() / 1000000;
    }
    
    return ESP_OK;
}

/**
 * @brief 启动温控事件管理
 */
esp_err_t system_start_temp_control(void)
{
    temp_monitor.temp_control_enabled = true;
    ESP_LOGI(TAG, "温控事件管理已启动");
    
    // 立即触发一次温控处理
    return system_control_send_event(SYS_EVENT_TEMP_CONTROL, 1, TEMP_CTRL_FLAG_FORCE_UPDATE, 0);
}

/**
 * @brief 停止温控事件管理
 */
esp_err_t system_stop_temp_control(void)
{
    temp_monitor.temp_control_enabled = false;
    ESP_LOGI(TAG, "温控事件管理已停止");
    
    // 停止所有温控输出
    return output_control_stop_all();
}

/**
 * @brief 强制触发温控处理
 */
esp_err_t system_trigger_temp_control(void)
{
    if (!temp_monitor.temp_control_enabled) {
        ESP_LOGW(TAG, "温控功能已禁用，忽略触发请求");
        return ESP_ERR_INVALID_STATE;
    }
    
    ESP_LOGI(TAG, "强制触发温控处理");
    return system_control_send_event(SYS_EVENT_TEMP_CONTROL, 1, TEMP_CTRL_FLAG_FORCE_UPDATE, 0);
}

//=============================================================================
// 房卡检测事件管理实现
//=============================================================================

/**
 * @brief 处理房卡检测事件（每秒执行一次，与温控处理同步）
 */
static esp_err_t handle_roomcard_detect(const system_event_t *event)
{
    // 检查外部输入参数，只有当GetExternal_Input()=2时才进行房卡检测
    int ex_input = GetExternal_Input();
    if (ex_input == 2) {
        // 调用房卡检测函数
        int roomcard_status = check_roomcard();
        if (roomcard_status >= 0) {
        } else {
            ESP_LOGW(TAG, "房卡检测失败，错误码: %d", roomcard_status);
        }
    }  
    vTaskDelay(pdMS_TO_TICKS(10)); // IIC操作间隔
    return ESP_OK;
}

/**
 * @brief 启动房卡检测事件管理
 */
esp_err_t system_start_roomcard_detect(void)
{
    ESP_LOGI(TAG, "房卡检测事件管理已启动");
    return ESP_OK;
}

/**
 * @brief 停止房卡检测事件管理
 */
esp_err_t system_stop_roomcard_detect(void)
{
    ESP_LOGI(TAG, "房卡检测事件管理已停止");
    return ESP_OK;
}

/**
 * @brief 强制触发房卡检测
 */
esp_err_t system_trigger_roomcard_detect(void)
{
    ESP_LOGI(TAG, "强制触发房卡检测");
    return system_control_send_event(SYS_EVENT_ROOMCARD_DETECT, 1, 0, 0);
} 