/*
 * @Author: mbw
 * @Date: 2024-10-23 17:14:16
 * @LastEditors: mbw && 1600520629@qq.com
 * @LastEditTime: 2024-12-01 14:44:58
 * @FilePath: \ble_bjq_ch303rct6_ml307\applications\main.c
 * @Descrt_thread_
 *
 * Copyright (c) 2024 by ${git_name_email}, All Rights Reserved.
 */
#include "ch32v30x.h"
#include <rtthread.h>
#include <rthw.h>
#include "drivers/pin.h"
#include <board.h>
#include "drv_gpio.h"

#include "bsp_beep.h"
#include "bsp_led.h"
#include "bsp_rtc.h"
#include "bsp_flash.h"
#include "bsp_hr.h"
#include "bsp_mq.h"
#include "bsp_button.h"
#include "bsp_mb26.h"
#include "bsp_vin_detection.h"
#include "user_sys.h"

#define LOG_TAG "main"
#define LOG_LVL LOG_LVL_DBG
#include <ulog.h>

static rt_uint32_t event_flags[kMaxEventcnt] = {0};

struct rt_event alarm_event;

rt_bool_t is_event_initialized = RT_FALSE; // 是否初始化完成

TsSysControl SysControl;

struct rt_timer work_cnt_timer;
void Send_Laser_Alarm_Event(AlarmEvent event_type);

TeCalibrationStatus g_Calibration_status = kNotCalibrated;
static void Set_Event(AlarmEvent event_type)
{
    if (event_type < kMaxEventcnt)
    {
        event_flags[event_type] = (1 << event_type);
    }
}

void SYS_EventInit(void)
{
    if (!is_event_initialized)
    {
        if (rt_event_init(&alarm_event, "alarm_event", RT_IPC_FLAG_PRIO) == RT_EOK)
        {

            for (AlarmEvent event = kPowerOnEvent; event < kMaxEventcnt; event++)
            {
                Set_Event(event);
            }
            is_event_initialized = RT_TRUE;
        }
        else
        {
            is_event_initialized = RT_FALSE;
            LOG_E("Alarm event init failed!");
        }
    }
}

rt_uint32_t Get_Sys_Event_Flag(AlarmEvent event_type)
{
    if (is_event_initialized == RT_TRUE)
    {
        if (event_type < kMaxEventcnt)
        {
            return event_flags[event_type];
        }
    }
    return kMaxEventcnt;
}

void Send_Laser_Alarm_Event(AlarmEvent event_type)
{

    if (is_event_initialized == RT_TRUE)
    {
        rt_event_send(&alarm_event, Get_Sys_Event_Flag(event_type));
        LOG_D("Send_Laser_Alarm_Event = %d", SysControl.status);
    }
    else
    {
        is_event_initialized = RT_FALSE;
        LOG_E("Alarm event no init !");
    }
}

int _Self_Check_Mode(void)
{
    LED_STOP(r);
    LED_STOP(g);
    LED_STOP(y);

    LED_CTRL(g, "500,500", 1);
    LED_START(g);
    rt_thread_mdelay(500);

    LED_CTRL(y, "500,500", 1);
    LED_START(y);
    rt_thread_mdelay(500);

    LED_CTRL(r, "500,500", 1);
    LED_START(r);
    rt_thread_mdelay(500);
    BEEP_SELF_CHECK;
    rt_thread_mdelay(2000);
    // 第5s关闭电磁阀
    LOG_I("自检电磁阀动作");

    LOG_I("自检风机动作");

    return RT_EOK;
}

void Work_Cnt_Timer_Callback(void *parameter)
{
    work_duration++;
    if (IS_EndOfLife()) // 每天检测一下是否过期
    {
        if (Flash_GetNum_Records(kRecordSensoEndOfLife) == 0)
        {
            Flash_Write_Record(kRecordSensoEndOfLife);
        }
        Send_Laser_Alarm_Event(kSensorFailureEvent);
    }
}
int main(void)
{
// 定义超时时间，单位为毫秒
#define TIMEOUT_MS     3 * 60 * 1000
#define WORK_TIMER_CNT (1000 * 60 * 60 * 24)
    rt_err_t result = RT_EINVAL;
    rt_uint32_t received_event;

    rt_kprintf("JT-DT-YD4N02A Software version: %02X\r\n", (uint8_t)Flash_Get_SysCfg(kSwVerId));
    // 读取历史记录总数
    Flash_GetTotalRecord(&TotalRecords);
    g_Calibration_status = Flash_Get_Calibration_State();
    if (g_Calibration_status == kNotCalibrated)//没标定
    {
        LED_STOP(r);                                       
        LED_STOP(y);                                        
        LED_CTRL(g, "1000,500", -1);                        
        LED_START(g);

        uint16_t ticks = 0, gas_calibration_voltage;
        while (1)
        {
            gas_calibration_voltage = Get_Gas_VoltageInt1000x();
            LOG_D("ticks[%d] gas_calibration_voltage = %d", ticks++, gas_calibration_voltage);

            if (g_Calibration_status == kNotCalibrated)//没标定
            {
                if (ticks > TIMEOUT_MS)
                {
                    if(gas_calibration_voltage > (MQ_VOLTAGE_ALARM_DEFAULT - 500)
                        && gas_calibration_voltage < (MQ_VOLTAGE_ALARM_DEFAULT + 500))
                    {
                        uint8_t calibration_buf[2] = {0};
                        calibration_buf[0] = gas_calibration_voltage << 8;// 低字节
                        calibration_buf[1] = gas_calibration_voltage >> 8;//高字节
                        LOG_D("calibration_buf[0] = %X calibration_buf[1] = %X", calibration_buf[0], calibration_buf[1]);
                        Flash_Sys_Cfg(kAlarmLValueId, calibration_buf, 2);
                        // 标定完成打开绿灯常亮,蜂鸣器叫一下
                        BEEP_CALIBRATION_OK;
                        LED_STOP(g);
                        LED_ON(g);
                        Flash_Set_Calibration_State(kSysGasCalibStatus);
                        g_Calibration_status = kSysGasCalibStatus;
                    }
                }
            }
            rt_thread_mdelay(1000);
        }
    }
    else
    {
        SYS_EventInit();
        work_duration = Flash_Get_WorkDuration();
        rt_timer_init(&work_cnt_timer,
                      "work_cnt_timer",
                      Work_Cnt_Timer_Callback,
                      RT_NULL,
                      WORK_TIMER_CNT,
                      RT_TIMER_FLAG_PERIODIC);
        rt_timer_start(&work_cnt_timer);
        if (Get_VIN_VoltageInt1000x() > 10000)
        {
            // 检测上电/掉电复位标志
            if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET) // TODO:这块超级电容会造成掉电重启，并且标志是上电复位，只能通过其超级电容造成复位时事件创建失败进行判断，不治本
            {
                Send_Laser_Alarm_Event(kPowerOnEvent);
                TotalRecords.power_on++;
                RCC_ClearFlag();
            }
            else
            {
                Send_Laser_Alarm_Event(kPreheatingEvent); // 这一句的作用是设备不是掉电重启的情况，直接进入预热模式
            }
        }
        else
        {
            LOG_D("欠压复位\r\n");
        }

        while (1)
        {
            result = rt_event_recv(&alarm_event,
                                   Get_Sys_Event_Flag(kPowerOnEvent) |              // 上电
                                       Get_Sys_Event_Flag(kPowerDownEvent) |        // 掉电
                                       Get_Sys_Event_Flag(kPreheatingEvent) |       // 预热
                                       Get_Sys_Event_Flag(kNormalDetectionEvents) | // 正常检测
                                       Get_Sys_Event_Flag(kAlarmExceptionEvent) |   // 寿命到期
                                       Get_Sys_Event_Flag(kAlarmEvent) |            // 报警
                                       Get_Sys_Event_Flag(kAlarmRcyEvent) |         // 报警恢复
                                       Get_Sys_Event_Flag(kSelfCheckEvent) |        // 自检
                                       Get_Sys_Event_Flag(kFaultEvent) |            // 故障模式
                                       Get_Sys_Event_Flag(kFaultRcyEvent) |         // 故障恢复
                                       Get_Sys_Event_Flag(KMuteEvent),              // 消音
                                   RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                                   RT_WAITING_FOREVER, &received_event);
            if (result == RT_EOK)
            {
                if (is_event_initialized == RT_TRUE)
                {
                    if (received_event & Get_Sys_Event_Flag(kPowerOnEvent)) // 上电
                    {
                        LOG_D("上电模式");
                        LOG_D("is_event_initialized :%d", is_event_initialized);
                        SysControl.status = kPowerOnEvent;

                        Flash_Write_Record(kRecordPowerOn);
                        Send_Laser_Alarm_Event(kPreheatingEvent);
                    }
                    else if (received_event & Get_Sys_Event_Flag(kPreheatingEvent)) // 预热
                    {
                        LOG_D("预热模式");

                        SysControl.last_status = SysControl.status;
                        SysControl.status      = kPreheatingEvent;

                        LED_STOP(r);
                        LED_STOP(g);
                        LED_STOP(y);
                        LED_CTRL(g, "500,2500", -1);
                        LED_START(g);
                        rt_thread_mdelay(1000);
                        LED_CTRL(y, "500,2500", -1);
                        LED_START(y);
                        rt_thread_mdelay(1000);
                        LED_CTRL(r, "500,2500", -1);
                        LED_START(r);
                        rt_thread_mdelay(1000);

                        BEEP_PREAT_OK;
                        LED_STOP(r);
                        LED_STOP(g);
                        LED_STOP(y);
                        LOG_D("预热完成");
                        Send_Laser_Alarm_Event(kNormalDetectionEvents);
                    }
                    else if (received_event & Get_Sys_Event_Flag(kNormalDetectionEvents)) // 正常检测
                    {
                        LOG_D("正常检测模式");

                        SysControl.last_status = SysControl.status;
                        SysControl.status      = kNormalDetectionEvents;
#if (NB_MODULE_SWITCH == 1)
                        if (mb26_conncet_tcp_flag)
                        {
                            LED_G_INTERNET;
                        }
                        else
                        {
#endif
                            LED_G_NORMAL;
#if (NB_MODULE_SWITCH == 1)
                        }
#endif
                        rt_thread_mdelay(10);
                        LOG_D("LED_G_NORMAL");
                    }
                    else if (received_event & Get_Sys_Event_Flag(kAlarmExceptionEvent)) // 浓度异常
                    {
                        LOG_D("浓度异常模式");

                        SysControl.last_status = SysControl.status;
                        SysControl.status      = kAlarmExceptionEvent;

                        LED_R_ALARM;
                        LOG_D("LED_R_ALARM");
                    }
                    else if (received_event & Get_Sys_Event_Flag(kAlarmEvent)) // 报警
                    {
                        LOG_D("报警模式");

                        SysControl.last_status = SysControl.status;
                        SysControl.status      = kAlarmEvent;

                        Flash_Write_Record(kRecordAlarm); // 写入flash报警信息

                        LED_R_ALARM;
                        BEEP_ALARM;

#if (NB_MODULE_SWITCH == 1)
                        Mb26_Send_Event(kMb26AlarmEvent);
#endif
                    }
                    else if (received_event & Get_Sys_Event_Flag(kAlarmRcyEvent)) // 报警恢复
                    {
                        LOG_D("报警恢复模式");

                        SysControl.last_status = SysControl.status;
                        SysControl.status      = kAlarmRcyEvent;

                        Flash_Write_Record(kRecordAlarmRcy);

                        BEEP_STOP;

#if (NB_MODULE_SWITCH == 1)
                        Mb26_Send_Event(kMb26AlarmRcyEvent);
#endif

                        Send_Laser_Alarm_Event(kNormalDetectionEvents);
                    }
                    else if (received_event & Get_Sys_Event_Flag(kFaultEvent)) // 故障
                    {
                        LOG_D("故障模式");

                        SysControl.last_status = SysControl.status;
                        SysControl.status      = kFaultEvent;

                        Flash_Write_Record(kRecordFault);

                        LED_Y_FAULT;
                        BEEP_FAULT;

#if (NB_MODULE_SWITCH == 1)
                        Mb26_Send_Event(kMb26FaultEvent);
#endif
                    }
                    else if (received_event & Get_Sys_Event_Flag(kFaultRcyEvent)) // 故障恢复
                    {
                        LOG_D("故障恢复模式");

                        SysControl.last_status = SysControl.status;
                        SysControl.status      = kFaultRcyEvent;

                        Flash_Write_Record(kRecordFaultRcy);

                        BEEP_STOP;

                        Send_Laser_Alarm_Event(kNormalDetectionEvents);
#if (NB_MODULE_SWITCH == 1)
                        Mb26_Send_Event(kMb26FaultRcyEvent);
#endif
                    }
                    else if (received_event & Get_Sys_Event_Flag(KMuteEvent)) // 消音
                    {
                        LOG_D("消音模式");
                        SysControl.last_status = SysControl.status;
                        SysControl.status      = KMuteEvent;

#if (NB_MODULE_SWITCH == 1)
                        Mb26_Send_Event(kMb26SilenceEvent);
#endif
                        BEEP_STOP;
                    }

                    else if (received_event & Get_Sys_Event_Flag(kPowerDownEvent)) // 掉电
                    {
                        LOG_D("掉电模式");

                        SysControl.last_status = SysControl.status;
                        SysControl.status      = kPowerDownEvent;

                        // 写入掉电记录
                        Flash_Write_Record(kRecordPowerDown);

                        Flash_Set_WorkDuration(work_duration); // 写入工作时长
#if (NB_MODULE_SWITCH == 1)
                        Mb26_Send_Event(kMb26PowerDownEvent);
#endif
                        LOG_D("Enter AnalogWatchdog Interrupt");

                        Flash_Set_WorkDuration(work_duration); // 重启前保存参数
                        // 等待180s,要是还没断电就重启
                        for (uint8_t i = 0; i < 180; i++)
                        {
                            rt_thread_mdelay(1000);
                            LOG_D(" %d s", i);
                        }
                        NVIC_SystemReset(); // 直接重启系统
                    }
                    else if (received_event & Get_Sys_Event_Flag(kSelfCheckEvent)) // 自检
                    {
                        LOG_D("自检模式");

                        SysControl.last_status = SysControl.status;
                        LOG_D("Self Check Mode SysControl.last_status:%d", SysControl.last_status);
                        SysControl.status = kSelfCheckEvent;

                        _Self_Check_Mode();
                        Send_Laser_Alarm_Event(SysControl.last_status);
#if (NB_MODULE_SWITCH == 1)
                        Mb26_Send_Event(kMb26SelfCheckEvent);
#endif
                    }
                    else if (received_event & Get_Sys_Event_Flag(kSensorFailureEvent)) // 失效
                    {
                        LOG_D("传感器失效模式");

                        SysControl.last_status = SysControl.status;
                        SysControl.status      = kSensorFailureEvent;

                        if (Flash_GetNum_Records(kRecordSensoEndOfLife) == 0)
                        {
                            Flash_Write_Record(kRecordSensoEndOfLife);
                        }
                        BEEP_END_OF_LIFE;
                        LED_Y_END_OF_LIFE;
                    }
                }
            }
        }
    }
}

#ifdef TEST_ENABLE
static void SYS_Set_RtcProductTime(int argc, char **argv)
{
    if (argc == 7)
    {
        int year   = atoi(argv[1]);
        int mon    = atoi(argv[2]);
        int day    = atoi(argv[3]);
        int hour   = atoi(argv[4]);
        int min    = atoi(argv[5]);
        int second = atoi(argv[6]);
        RTC_SetTime(2000 + year, mon, day, hour, min, second);
        RTC_GetTime();
        LOG_D("RTC: %4d-%02d-%02d, %02d:%02d:%02d", RtcDateTime.year, RtcDateTime.month, RtcDateTime.day,
              RtcDateTime.hour, RtcDateTime.minute, RtcDateTime.second);

        // 设置出厂时间
        Flash_SetProductTimeLimit(2000 + year, mon, day, hour, min, second, kFactoryTimeId);
        // 到期时间自动 + 5年30天
        Set_ExpirationTime(MAX_EXPIRATION_DAYS);
    }
    else
    {
        LOG_E("SYS_Set_RtcProductTime      --use _cmd_ [2000 + y] [m] [d] [h] [m] [s]");
    }
}
MSH_CMD_EXPORT(SYS_Set_RtcProductTime, "SYS_Set_RtcProductTime");

#endif