#include <common/sys_config.h>
#include <components/log.h>
#include <modules/wifi.h>
#include <components/netif.h>
#include <components/event.h>
#include <string.h>

#include "bk_private/bk_init.h"
#include <components/system.h>
#include <os/os.h>
#include <os/mem.h>
#include <modules/pm.h>

#include "app_event.h"
#include "media_app.h"
#include "led_blink.h"

#include "countdown.h"
#include "components/bluetooth/bk_dm_bluetooth.h"
#include "boarding_service.h"
#include "bk_factory_config.h"
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
#include "aud_intf.h"
#include "aud_intf_types.h"
#endif
#if CONFIG_NETWORK_AUTO_RECONNECT
#include "bk_genie_smart_config.h"
#endif
#include "bat_monitor.h"
#include "bk_ota_private.h"

#define TAG "app_evt"

#define LOGI(...) BK_LOGI(TAG, ##__VA_ARGS__)
#define LOGW(...) BK_LOGW(TAG, ##__VA_ARGS__)
#define LOGE(...) BK_LOGE(TAG, ##__VA_ARGS__)
#define LOGD(...) BK_LOGD(TAG, ##__VA_ARGS__)


typedef struct
{
    beken_thread_t thread;
    beken_queue_t queue;
} app_evt_info_t;

typedef struct
{
    uint32_t event;
    uint32_t param;
} app_evt_msg_t;

extern void lvgl_app_init(void);
extern void lvgl_app_deinit(void);
extern bk_err_t agora_stop(void);
extern bk_err_t video_turn_on(void);
extern bk_err_t video_turn_off(void);

static app_evt_info_t app_evt_info;

//image recognition mode switch
#define CONFIG_IR_MODE_SWITCH_TASK_PRIORITY 4
static beken_thread_t config_ir_mode_switch_thread_handle = NULL;
uint8_t ir_mode_switching = 0;
extern bool agora_runing;
extern bool g_agent_offline;
extern bool video_started;
extern uint8_t lvgl_app_init_flag;

bk_err_t app_event_send_msg(uint32_t event, uint32_t param)
{
    bk_err_t ret;
    app_evt_msg_t msg;

    msg.event = event;
    msg.param = param;

    ret = rtos_push_to_queue(&app_evt_info.queue, &msg, BEKEN_NO_WAIT);
    if (BK_OK != ret)
    {
        LOGE("%s, %d : %d fail \n", __func__, __LINE__, event);
        return BK_FAIL;
    }

    return BK_FAIL;
}

void app_event_asr_evt_callback(media_app_evt_type_t event, uint32_t param)
{
    LOGD("asr event callback: %x\n", event);

    /*Do not do anything blocking here */

    switch (event)
    {
        case MEDIA_APP_EVT_ASR_WAKEUP_IND:
            app_event_send_msg(APP_EVT_ASR_WAKEUP, 0);
            break;
        case MEDIA_APP_EVT_ASR_STANDBY_IND:
            app_event_send_msg(APP_EVT_ASR_STANDBY, 0);
            break;
    }
}

static uint8_t ota_event_callback(evt_ota event_param)
{

    switch(event_param)
    {
        case EVT_OTA_START:
            app_event_send_msg(APP_EVT_OTA_START, 0);
            break;
        case EVT_OTA_FAIL:
            app_event_send_msg(APP_EVT_OTA_FAIL, 0);
            break;
        case EVT_OTA_SUCCESS:
            app_event_send_msg(APP_EVT_OTA_SUCCESS, 0);
            break;
        default :
            break;
    }
    return 0;
}

static uint8_t battery_event_callback(evt_battery event_param)
{
    switch(event_param)
    {
        case EVT_BATTERY_CHARGING:
            app_event_send_msg(APP_EVT_CHARGING, 0);
            break;
        case EVT_BATTERY_LOW_VOLTAGE:
            app_event_send_msg(APP_EVT_LOW_VOLTAGE, 0);
            break;
        case EVT_SHUTDOWN_LOW_BATTERY:
            app_event_send_msg(APP_EVT_SHUTDOWN_LOW_BATTERY, 0);
            break;
        default :
            break;
    }
    return 0;
}

#if CONFIG_OTA_DISPLAY_PICTURE_DEMO
extern bk_err_t audio_turn_on(void);
bk_err_t bk_ota_reponse_state_to_audio(int ota_state)
{
	int ret = BK_FAIL;
	LOGI("%s ota_state :%d\n", __func__,ota_state);
	if(audio_turn_on() != BK_OK)
	{
		LOGE("%s audion turn off :%d\n", __func__);
		return ret;
	}

	switch (ota_state)
	{
		case APP_EVT_OTA_SUCCESS : //success
			#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
			ret = bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_OTA_UPDATE_SUCCESS);
			#endif
		break;
		case APP_EVT_OTA_FAIL : //fail
			#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
			ret = bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_OTA_UPDATE_FAIL);
			#endif
		break;
		default:
			break;
	}
	LOGI("%s complete %x\n", __func__, ret);
	return ret;
}
#endif

//red:if high priority conflicts with low-priority, should stay at high priority states
enum {
	WARNING_PROVIOSION_FAIL,	//LED_FAST_BLINK_RED
	WARNING_WIFI_FAIL,		//LED_FAST_BLINK_RED
	WARNING_RTC_CONNECT_LOST,	//LED_FAST_BLINK_RED
	WARNING_AGENT_OFFLINE,	//LED_FAST_BLINK_RED
    WARNING_AGENT_AGENT_START_FAIL,  //LED_FAST_BLINK_RED

	WARNING_LOW_BATTERY,	//LED_SLOW_BLINK_RED
}warning_t;
#define HIGH_PRIORITY_WARNING_MASK ((1<<WARNING_PROVIOSION_FAIL) | (1<<WARNING_WIFI_FAIL) | (1<<WARNING_RTC_CONNECT_LOST) | (1<<WARNING_AGENT_OFFLINE) | (1<<WARNING_AGENT_AGENT_START_FAIL))
#define LOW_PRIORITY_WARNING_MASK ((1<<WARNING_LOW_BATTERY))
#define AI_RTC_CONNECT_LOST_FAIL   (1<<WARNING_RTC_CONNECT_LOST)
#define AI_AGENT_OFFLINE_FAIL      (1<<WARNING_AGENT_OFFLINE)
#define WIFI_FAIL  (1<<WARNING_WIFI_FAIL)
//green led, or red/green alternate led
enum {
	INDICATES_WIFI_RECONNECT,	//LED_FAST_BLINK_GREEN
	INDICATES_PROVISIONING,		//LED_REG_GREEN_ALTERNATE
	INDICATES_POWER_ON,  		//LED_ON_GREEN  default at power-on state, so green is always on
	INDICATES_STANDBY,			//LED_SLOW_BLINK_GREEN
	INDICATES_AGENT_CONNECT,	//LED_FAST_BLINK_GREEN at WIFI connection but no access to the AI AGENT
}indicates_t;


#define COUNTDOWN_INFINITE 0xFFFFFFFF
/* 新增倒计时票源类型,按照优先级排序*/
typedef enum {
    COUNTDOWN_TICKET_PROVISIONING,   // 配网倒计时(5分钟), 最高优先级
    COUNTDOWN_TICKET_NETWORK_ERROR,  //网络错误倒计时(5分钟) ，中优先级
    COUNTDOWN_TICKET_STANDBY,        // 待机倒计时(3分钟)，低优先级
    COUNTDOWN_TICKET_OTA,      // OTA 事件，特殊逻辑，不参与比较
    COUNTDOWN_TICKET_MAX
} countdown_ticket_t;

/* 各票源对应的倒计时时长(毫秒) */
static const uint32_t s_ticket_durations[COUNTDOWN_TICKET_MAX] = {
    [COUNTDOWN_TICKET_PROVISIONING] = 5 * 60 * 1000,  // 5分钟
    [COUNTDOWN_TICKET_NETWORK_ERROR] = 5 * 60 * 1000,  // 5分钟
    [COUNTDOWN_TICKET_STANDBY]      = 3 * 60 * 1000,  // 3分钟
    [COUNTDOWN_TICKET_OTA]    = COUNTDOWN_INFINITE,              // 暂停倒计时
};

static uint32_t s_active_tickets = 0;  // 使用位掩码记录活跃票源

/* 更新倒计时状态 */
static void update_countdown()
{

    // 检查OTA暂停票（最高优先级）
    if(s_active_tickets & (1 << COUNTDOWN_TICKET_OTA)) {
        LOGI("ota event start, stop countdown\r\n");
        stop_countdown();
        return;
    }

    static countdown_ticket_t last_selected_ticket = COUNTDOWN_TICKET_MAX;
    countdown_ticket_t selected_ticket = COUNTDOWN_TICKET_MAX;


    for(int i = 0; i < COUNTDOWN_TICKET_MAX; i++) {
        if (i == COUNTDOWN_TICKET_OTA)
            continue;

        if(s_active_tickets & (1 << i))
        {
            selected_ticket = i;
            break;
        }
    }

    // 应用倒计时裁决结果
    if(selected_ticket != COUNTDOWN_TICKET_MAX) {
        const uint32_t max_duration = s_ticket_durations[selected_ticket];

        bool is_same_event = (selected_ticket == last_selected_ticket);
        bool is_network_error = (selected_ticket == COUNTDOWN_TICKET_NETWORK_ERROR);

        if (selected_ticket != last_selected_ticket || (is_same_event && !is_network_error))
        {
            const uint32_t duration = max_duration;
            start_countdown(duration);
            LOGI("selected_ticket is %d, last_selected_ticket is %d,duration is %d\r\n",selected_ticket , last_selected_ticket, duration);
            last_selected_ticket = selected_ticket;
        }
    } else {
        LOGI("selected_ticket is %d, COUNTDOWN_TICKET_MAX is %d\r\n",selected_ticket , COUNTDOWN_TICKET_MAX);
        LOGI("stop countdown\r\n");
        stop_countdown();
        last_selected_ticket = COUNTDOWN_TICKET_MAX;
    }

}

static void led_blink(uint32_t* warning_state, uint32_t indicates_state)
{
	static uint32_t last_warning_state = 0;
	static uint32_t last_indicates_state = (1<<INDICATES_POWER_ON);

    //indicates
    if(indicates_state & (1<<INDICATES_PROVISIONING))
    {
        led_app_set(LED_REG_GREEN_ALTERNATE, LED_LAST_FOREVER);
    }else if (HIGH_PRIORITY_WARNING_MASK & (*warning_state))
    {
        led_app_set(LED_OFF_GREEN, 0);
    }else{
        if(indicates_state & ((1<<INDICATES_WIFI_RECONNECT) | (1<<INDICATES_AGENT_CONNECT)))
		{
			led_app_set(LED_FAST_BLINK_GREEN, LED_LAST_FOREVER);
		}else if(indicates_state & (1<<INDICATES_STANDBY))
		{
			led_app_set(LED_SLOW_BLINK_GREEN, LED_LAST_FOREVER);
		}else
        {
        led_app_set(LED_OFF_GREEN, 0);
        }
    }

    //warning
    if (indicates_state & (1<<INDICATES_PROVISIONING))
    {
        ;
    }else if(HIGH_PRIORITY_WARNING_MASK & (*warning_state)){
        led_app_set(LED_FAST_BLINK_RED, LED_LAST_FOREVER);
    }else if(LOW_PRIORITY_WARNING_MASK & (*warning_state)){
        led_app_set(LED_SLOW_BLINK_RED, LOW_VOLTAGE_BLINK_TIME);
        *warning_state = *warning_state & ~(1<<WARNING_LOW_BATTERY);
    }else{
        led_app_set(LED_OFF_RED, 0);
    }

    if(indicates_state != last_indicates_state)
	{
		LOGI("indicate=%d,last_indicat=%d,warning_state=%d\r\n", indicates_state, last_indicates_state, *warning_state);
		last_indicates_state = indicates_state;
	}

	if(*warning_state != last_warning_state)
	{
		LOGI("warning=%d,last_warning=%d,indicate=%d\r\n", *warning_state, last_warning_state, indicates_state);
		last_warning_state = *warning_state;
	}

}

void ir_mode_switch_main(void)
{
    if (!agora_runing) {
        BK_LOGW(TAG, "Please Run AgoraRTC First!");
        goto exit;
    }

    ir_mode_switching = 1;

    if (!video_started) {
        bk_genie_upate_agent_info("text_and_image");
        while (g_agent_offline)
        {
            if (!agora_runing)
            {
                goto exit;
            }
            rtos_delay_milliseconds(100);
        }
        video_turn_on();
    } else {
        video_turn_off();
        bk_genie_upate_agent_info("text");
    }

    if (lvgl_app_init_flag == 1) {
        media_app_lvgl_switch_ui();
    }

exit:
    config_ir_mode_switch_thread_handle = NULL;
    ir_mode_switching = 0;
    rtos_delete_thread(NULL);
}

static void app_event_thread(beken_thread_arg_t data)
{
	int ret = BK_OK;

    uint32_t is_standby = 1;
    uint32_t is_joined_agent = 0;

    uint32_t warning_state = 0;
	uint32_t indicates_state = (1<<INDICATES_POWER_ON);

    // uint32_t network_err = 0;
    uint32_t is_network_provisioning = 0;

    s_active_tickets = (1 << COUNTDOWN_TICKET_STANDBY);
    ota_event_callback_register(ota_event_callback);
    update_countdown();

    battery_event_callback_register(battery_event_callback);
    media_app_asr_evt_register_callback(app_event_asr_evt_callback);

    while (1)
    {
        app_evt_msg_t msg;

        ret = rtos_pop_from_queue(&app_evt_info.queue, &msg, BEKEN_WAIT_FOREVER);

        if (ret == BK_OK)
        {
            bool skip_countdown_update = false;
            switch (msg.event)
            {
                case APP_EVT_IR_MODE_SWITCH:
                    if (is_standby == 0) {
                        if (config_ir_mode_switch_thread_handle) {
                            BK_LOGW(TAG, "Last oper for IR_MODE ongoing!\n");
                            break;
                        }
                        BK_LOGW(TAG, "Start to switch image recognition mode!\n");
#if CONFIG_PSRAM_AS_SYS_MEMORY
                        ret = rtos_create_psram_thread(&config_ir_mode_switch_thread_handle,
                                                    CONFIG_IR_MODE_SWITCH_TASK_PRIORITY,
                                                    "ir_mode_switch",
                                                    (beken_thread_function_t)ir_mode_switch_main,
                                                    4096,
                                                    (beken_thread_arg_t)0);
#else
                        ret = rtos_create_thread(&config_ir_mode_switch_thread_handle,
                                                    CONFIG_IR_MODE_SWITCH_TASK_PRIORITY,
                                                    "ir_mode_switch",
                                                    (beken_thread_function_t)ir_mode_switch_main,
                                                    4096,
                                                    (beken_thread_arg_t)0);
#endif
                        if (ret != kNoErr)
                        {
                            BK_LOGE(TAG, "switch image recognition mode fail: %d\r\n", ret);
                            config_ir_mode_switch_thread_handle = NULL;
                        }
                    }
                    break;

                case APP_EVT_ASR_WAKEUP:	//hi armino
                    is_standby = 0;
                    indicates_state &= ~(1<<INDICATES_STANDBY);
                    s_active_tickets &= ~(1 << COUNTDOWN_TICKET_STANDBY);
                    LOGI("APP_EVT_ASR_WAKEUP\n");
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_ASR_WAKEUP);
#endif
                    bk_pm_module_vote_cpu_freq(PM_DEV_ID_AUDIO, PM_CPU_FRQ_480M);
                    bk_wifi_sta_pm_disable();
                    lvgl_app_init();
                    //TODO optimize
                    if (!is_network_provisioning){
                        led_app_set(LED_OFF_GREEN,0);
                    }
                    break;
                case APP_EVT_ASR_STANDBY:	//byebye armino
                    is_standby = 1;
                    indicates_state |= (1<<INDICATES_STANDBY);
                    s_active_tickets |= (1 << COUNTDOWN_TICKET_STANDBY);
                    LOGI("APP_EVT_ASR_STANDBY\n");
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_ASR_STANDBY);
#endif
                    lvgl_app_deinit();
                    bk_wifi_sta_pm_enable();
                    bk_pm_module_vote_cpu_freq(PM_DEV_ID_AUDIO, PM_CPU_FRQ_240M);
                    break;

//-------------------network event start ------------------------------------------------------------------
/*
 * Network abnormal event:APP_EVT_NETWORK_PROVISIONING_FAIL/APP_EVT_RECONNECT_NETWORK_FAIL/APP_EVT_RTC_CONNECTION_LOST/APP_EVT_AGENT_OFFLINE
 * Network resotre event:APP_EVT_AGENT_JOINED
 * If network retore event APP_EVT_AGENT_JOINED comes, it means all of the network abnormal event can be stop
 */
                case APP_EVT_NETWORK_PROVISIONING:
                    LOGI("APP_EVT_NETWORK_PROVISIONING\n");
                    is_network_provisioning = 1;
                    //优先级最高
                    s_active_tickets &= ~(1 << COUNTDOWN_TICKET_NETWORK_ERROR);
                    s_active_tickets |= (1 << COUNTDOWN_TICKET_PROVISIONING);
                    indicates_state |= (1<<INDICATES_PROVISIONING);
                    indicates_state &= ~((1<<INDICATES_AGENT_CONNECT) | (1<<INDICATES_POWER_ON) | (1<<INDICATES_WIFI_RECONNECT));
                    warning_state &= ~ (HIGH_PRIORITY_WARNING_MASK);
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_NETWORK_PROVISION);
#endif
                    break;

                case APP_EVT_NETWORK_PROVISIONING_SUCCESS:
                    indicates_state &= ~(1<<INDICATES_PROVISIONING);
                    indicates_state |= (1<<INDICATES_AGENT_CONNECT);
                    warning_state &= ~(1<<WARNING_PROVIOSION_FAIL);
                    s_active_tickets &= ~(1 << COUNTDOWN_TICKET_PROVISIONING);
                    // s_active_tickets |= (1 << COUNTDOWN_TICKET_STANDBY);
                    LOGI("APP_EVT_NETWORK_PROVISIONING_SUCCESS\n");
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_NETWORK_PROVISION_SUCCESS);
#endif
                    break;

                case APP_EVT_NETWORK_PROVISIONING_FAIL:
                    LOGI("APP_EVT_NETWORK_PROVISIONING_FAIL\n");
                    // network_err = 1;
                    s_active_tickets &= ~(1 << COUNTDOWN_TICKET_PROVISIONING);
                    s_active_tickets |= (1 << COUNTDOWN_TICKET_NETWORK_ERROR);
                    indicates_state &= ~(1<<INDICATES_PROVISIONING);
                    warning_state |= 1<<WARNING_PROVIOSION_FAIL;

#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_NETWORK_PROVISION_FAIL);
#endif
                    break;

                case APP_EVT_RECONNECT_NETWORK:
                    LOGI("APP_EVT_RECONNECT_NETWORK\n");
                    warning_state &= ~(1<<WARNING_WIFI_FAIL);
                    indicates_state |= (1<<INDICATES_WIFI_RECONNECT);
                    indicates_state &= ~(1<<INDICATES_POWER_ON);
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_RECONNECT_NETWORK);
#endif
                    break;

                case APP_EVT_RECONNECT_NETWORK_SUCCESS:
                    LOGI("APP_EVT_RECONNECT_NETWORK_SUCCESS\n");
                    s_active_tickets &= ~(1 << COUNTDOWN_TICKET_PROVISIONING);
                    if (warning_state & WIFI_FAIL)
                    {
                        if (is_joined_agent && is_standby)
                        {
                            indicates_state |= (1<<INDICATES_STANDBY);
                        }

                    }else{
                        indicates_state |= (1<<INDICATES_AGENT_CONNECT);
                    }

					warning_state &= ~(1<<WARNING_WIFI_FAIL);
                    indicates_state &= ~(1<<INDICATES_WIFI_RECONNECT);

#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_RECONNECT_NETWORK_SUCCESS);
#endif
                    break;

                case APP_EVT_RECONNECT_NETWORK_FAIL:
                    s_active_tickets |= (1 << COUNTDOWN_TICKET_NETWORK_ERROR);
                    LOGI("APP_EVT_RECONNECT_NETWORK_FAIL\n");
                    // network_err = 1;
                    warning_state |= 1<<WARNING_WIFI_FAIL;
                    indicates_state &= ~(1<<INDICATES_WIFI_RECONNECT);
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_RECONNECT_NETWORK_FAIL);
#endif
                    break;

                case APP_EVT_RTC_CONNECTION_LOST:
                    // network_err = 1;
                    LOGI("APP_EVT_RTC_CONNECTION_LOST\n");
                    warning_state |= 1<<WARNING_RTC_CONNECT_LOST;
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_RTC_CONNECTION_LOST);
#endif
                    break;


                case APP_EVT_RTC_REJOIN_SUCCESS:
                    LOGI("APP_EVT_RTC_REJOIN_SUCCESS\n");
                    warning_state &= ~(1<<WARNING_RTC_CONNECT_LOST);
                    if (is_joined_agent && is_standby)
                    {
                        indicates_state |= (1<<INDICATES_STANDBY);
                    }
                    break;

                case APP_EVT_AGENT_JOINED:	//doesn't know whether restore from error
                    is_joined_agent = 1;
                    s_active_tickets &= ~(1 << COUNTDOWN_TICKET_NETWORK_ERROR);
                    indicates_state &= ~(1<<INDICATES_AGENT_CONNECT);
                    warning_state &= ~((1<<WARNING_RTC_CONNECT_LOST) | (1<<WARNING_AGENT_OFFLINE) | (1<<WARNING_WIFI_FAIL) | 1<<WARNING_AGENT_AGENT_START_FAIL);
                    LOGI("APP_EVT_AGENT_JOINED \n");
                    //TODO optimize
                    is_network_provisioning = 0;
                    indicates_state &= ~(1<<INDICATES_PROVISIONING);
                    if(is_standby)  //mie
                    {
                        indicates_state |= (1<<INDICATES_STANDBY);
                    }
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_AGENT_JOINED);
#endif
                    break;
                case APP_EVT_AGENT_OFFLINE:
                    // network_err = 1;
                    is_joined_agent = 0;
                    s_active_tickets |= (1 << COUNTDOWN_TICKET_NETWORK_ERROR);
                    LOGI("APP_EVT_AGENT_OFFLINE\n");
                    warning_state |= 1<<WARNING_AGENT_OFFLINE;
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_AGENT_OFFLINE);
#endif
                    break;

                case APP_EVT_AGENT_START_FAIL:
                    s_active_tickets |= (1 << COUNTDOWN_TICKET_NETWORK_ERROR);
                    LOGI("APP_EVT_AGENT_START_FAIL\n");
                    warning_state |= 1<<WARNING_AGENT_AGENT_START_FAIL;
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_AGENT_START_FAIL);
#endif
                    break;

                case APP_EVT_AGENT_DEVICE_REMOVE:
                    LOGI("APP_EVT_AGENT_DEVICE_REMOVE\n");
                    agora_stop();
                    break;

//-------------------network event end ------------------------------------------------------------------////


                case APP_EVT_LOW_VOLTAGE:
                    LOGI("APP_EVT_LOW_VOLTAGE\n");
                    skip_countdown_update = true;
                    warning_state |= 1<<WARNING_LOW_BATTERY;
#if CONFIG_AUD_INTF_SUPPORT_PROMPT_TONE
                    bk_aud_intf_voc_play_prompt_tone(AUD_INTF_VOC_LOW_VOLTAGE);
#endif
                    break;

                case APP_EVT_CHARGING:
                    LOGI("APP_EVT_CHARGING\n");
                    skip_countdown_update = true;
					warning_state &= ~(1<<WARNING_LOW_BATTERY);
                    break;

                case APP_EVT_SHUTDOWN_LOW_BATTERY:
                    LOGI("APP_EVT_SHUTDOWN_LOW_BATTERY\n");
                    skip_countdown_update = true;
                    bk_config_sync_flash();
                    break;

                case APP_EVT_CLOSE_BLUETOOTH:
                    LOGI("APP_EVT_CLOSE_BLUETOOTH\n");
                    bk_genie_boarding_deinit();
                    bk_bluetooth_deinit();
                    break;

                // OTA相关事件
                case APP_EVT_OTA_START:
                    LOGI("APP_EVT_OTA_START\n");
                    s_active_tickets |= (1 << COUNTDOWN_TICKET_OTA);
                    break;

                case APP_EVT_OTA_SUCCESS:
                    LOGI("APP_EVT_OTA_SUCCESS\n");
                    s_active_tickets &= ~(1 << COUNTDOWN_TICKET_OTA);
                    #if CONFIG_OTA_DISPLAY_PICTURE_DEMO
                    bk_ota_reponse_state_to_audio(msg.event);
                    #endif
                    break;

                case APP_EVT_OTA_FAIL:
                    LOGI("APP_EVT_OTA_FAIL\n");
                    s_active_tickets &= ~(1 << COUNTDOWN_TICKET_OTA);
                    #if CONFIG_OTA_DISPLAY_PICTURE_DEMO
                    bk_ota_reponse_state_to_audio(msg.event);
                    #endif
                    break;

                default:
                    break;
            }
            if(!skip_countdown_update)
            {
                update_countdown();
            }

			//led blink by states
            led_blink(&warning_state, indicates_state);
        }
    }

    LOGI("%s, exit\r\n", __func__);
    rtos_delete_thread(NULL);
}



void app_event_init(void)
{
    int ret = BK_FAIL;

    os_memset(&app_evt_info, 0, sizeof(app_evt_info_t));

    ret = rtos_init_queue(&app_evt_info.queue,
                          "ae_queue",
                          sizeof(app_evt_msg_t),
                          15);

    if (ret != BK_OK)
    {
        LOGE("%s, init queue failed\r\n", __func__);
        return;
    }

    ret = rtos_create_thread(&app_evt_info.thread,
                             BEKEN_DEFAULT_WORKER_PRIORITY - 1,
                             "ae_thread",
                             (beken_thread_function_t)app_event_thread,
                             1024 * 4,
                             NULL);

    if (ret != BK_OK)
    {
        LOGE("%s, init thread failed\r\n", __func__);
        return;
    }
}