#include "include.h"
#include "func.h"
#include "app_variable.h"

#if TRACE_EN
#define TRACE(...)              printf(__VA_ARGS__)
#else
#define TRACE(...)
#endif

//血氧外设接口
static void sensor_blood_oxygen_start(void);
static void sensor_blood_oxygen_stop(void);
static uint8_t sensor_blood_oxygen_data_get(void);
static bool sensor_blood_oxygen_wear_sta_get(void);

//血氧检测状态
enum {
	BO_STA_IDLE,		    //空闲
	BO_STA_WORKING,		    //检测中
	BO_STA_UNWEAR,			//未佩戴
};

//组件ID
enum {
    //按键
	COMPO_ID_BTN = 1,  
    COMPO_ID_PIC_BG,        
	COMPO_ID_PIC_CLICK,     
	COMPO_ID_TXT_TIPS,	
    COMPO_ID_TXT_RESULT,
    COMPO_ID_TXT_RESULT_MAX,
    COMPO_ID_TXT_RESULT_MIN,
    COMPO_ID_PIC_BT_LEF,
    COMPO_ID_PIC_BT_CEN,
    COMPO_ID_PIC_BT_RIG,
    COMPO_ID_PIC_UNWEAR,	
};

typedef struct f_blood_oxygen_t_ {
    page_tp_move_t *ptm;
	uint8_t det_sta;
    uint8_t value;
    bool touch;
    u32 tick;
    s16 lef_x;
    s16 cen_x;
    s16 rig_x;
    u8 sec;
} f_blood_oxygen_t;

char buf_spo2[4] = {0},buf_max[4] = {0},buf_min[4] = {0};

//创建血氧窗体，创建窗体中不要使用功能结构体 func_cb.f_cb
compo_form_t *func_blood_oxygen_form_create(void)
{
    component_t *compo;

    //新建窗体和背景
    compo_form_t *frm = compo_form_create(true);
    compo = (component_t *)compo_picturebox_create(frm, UI_BUF_BLOOD_OXYGEN_BLOOD_OXYGEN_BIN);
    compo_picturebox_set_pos((compo_picturebox_t *)compo, 10+13, 26+13);
    compo_setid(compo, COMPO_ID_PIC_BG);
    //中间网格
    compo_form_add_image(frm, UI_BUF_HEART_RATE_HR_BG_BIN, GUI_SCREEN_CENTER_X, 70+25);
    //下方左边绿色小三角
    compo_form_add_image(frm, UI_BUF_HEART_RATE_UP_BIN, 12 + 4, 138+ 4);
    //下方右边红色小三角
    compo_form_add_image(frm, UI_BUF_HEART_RATE_DOWN_BIN, 81 + 4, 138+ 4);
    //设置标题栏
    compo_form_set_mode(frm, COMPO_FORM_MODE_SHOW_TITLE | COMPO_FORM_MODE_SHOW_TIME);
    compo_form_set_title(frm, i18n[STR_BLOOD_OXYGEN]);

    //测量血氧值
    compo_textbox_t *txt_val = compo_textbox_create(frm, 4);
    compo_textbox_set_font(txt_val, UI_BUF_0FONT_FONT_DIN_PRO_NUM_20_BIN);
    compo_setid(txt_val, COMPO_ID_TXT_RESULT);
    // compo_textbox_set_align_center(txt_val, false);
    compo_textbox_set_pos(txt_val, GUI_SCREEN_CENTER_X, 26+13);
    compo_textbox_set(txt_val, "---%");

	//血氧值最大值
    txt_val = compo_textbox_create(frm, 4);
    compo_textbox_set_font(txt_val, UI_BUF_0FONT_FONT_BIN);
    compo_setid(txt_val, COMPO_ID_TXT_RESULT_MAX);
    // compo_textbox_set_align_center(txt_val, false);
    compo_textbox_set_pos(txt_val, 35, 140);
    if(SysVariable.heartRateModule.maxSpo2!=0)
    {
        sprintf(buf_max,"%d",SysVariable.heartRateModule.maxSpo2);
        compo_textbox_set(txt_val, buf_max);
    }
    else
        compo_textbox_set(txt_val, "---%");

	//血氧值最小值
    txt_val = compo_textbox_create(frm, 4);
    compo_textbox_set_font(txt_val, UI_BUF_0FONT_FONT_BIN);
    compo_setid(txt_val, COMPO_ID_TXT_RESULT_MIN);
    // compo_textbox_set_align_center(txt_val, false);
    compo_textbox_set_pos(txt_val, 104, 140);
    if(SysVariable.heartRateModule.minSpo2!=0)
    {
        sprintf(buf_min,"%d",SysVariable.heartRateModule.minSpo2);
        compo_textbox_set(txt_val, buf_min);
    }
    else
        compo_textbox_set(txt_val, "---%");



    //动画
    compo_picturebox_t *pic_lef = compo_picturebox_create(frm, UI_BUF_BLOOD_OXYGEN_DT_BIN);
    compo_setid(pic_lef, COMPO_ID_PIC_BT_LEF);
    compo_picturebox_set_pos(pic_lef, GUI_SCREEN_WIDTH/4, 70+25);
    compo_picturebox_set_visible(pic_lef, false);          //触摸按下的效果图先设置不可见

    compo_picturebox_t *pic_cen = compo_picturebox_create(frm, UI_BUF_BLOOD_OXYGEN_DT_BIN);
    compo_setid(pic_cen, COMPO_ID_PIC_BT_CEN);
    compo_picturebox_set_pos(pic_cen, GUI_SCREEN_WIDTH/4 * 3, 70+25);
    compo_picturebox_set_visible(pic_cen, false);          //触摸按下的效果图先设置不可见

    compo_picturebox_t *pic_rig = compo_picturebox_create(frm, UI_BUF_BLOOD_OXYGEN_DT_BIN);
    compo_setid(pic_rig, COMPO_ID_PIC_BT_RIG);
    compo_picturebox_set_pos(pic_rig, GUI_SCREEN_WIDTH/4 * 5, 70+25);
    compo_picturebox_set_visible(pic_rig, false);          //触摸按下的效果图先设置不可见

	// //图像按钮
	// compo = (component_t *)compo_button_create_by_image(frm, UI_BUF_COMMON_BUTTON_BIN);
    // compo_setid(compo, COMPO_ID_BTN);
    // compo_button_set_pos((compo_button_t *)compo, GUI_SCREEN_CENTER_X, 252);
    // compo = (component_t *)compo_picturebox_create(frm, UI_BUF_COMMON_BUTTON_CLICK_BIN);
    // compo_setid(compo, COMPO_ID_PIC_CLICK);
    // compo_picturebox_set_pos((compo_picturebox_t *)compo, GUI_SCREEN_CENTER_X, 252);
    // compo_picturebox_set_visible((compo_picturebox_t *)compo, false);                   //触摸按下的效果图先设置不可见

    // //按钮上的文本
    // compo = (component_t *)compo_textbox_create(frm, 6);
    // compo_setid(compo, COMPO_ID_TXT_TIPS);
    // compo_textbox_set_pos((compo_textbox_t *)compo, GUI_SCREEN_CENTER_X, 252);
    // compo_textbox_set((compo_textbox_t *)compo, i18n[STR_START]);

    //测量结果
    // compo = (component_t *)compo_textbox_create(frm, 4);
    // compo_setid(compo, COMPO_ID_TXT_RESULT);
    // compo_textbox_set_pos((compo_textbox_t *)compo, GUI_SCREEN_CENTER_X, 260);
    // compo_textbox_set_visible((compo_textbox_t *)compo, false);

    //未佩戴提示
    // compo = (component_t *)compo_picturebox_create(frm, UI_BUF_BLOOD_OXYGEN_EXPLAIN_BIN);
    // compo_setid(compo, COMPO_ID_PIC_UNWEAR);
    // compo_picturebox_set_pos((compo_picturebox_t *)compo, GUI_SCREEN_CENTER_X, GUI_SCREEN_CENTER_Y);
    // compo_picturebox_set_visible((compo_picturebox_t *)compo, false);        

    return frm;
}


//动画滚动
static void func_animation_roll(void)
{
    f_blood_oxygen_t *f_blood_oxygen = (f_blood_oxygen_t *)func_cb.f_cb;
    compo_picturebox_t *pic_lef = compo_getobj_byid(COMPO_ID_PIC_BT_LEF);
    compo_picturebox_t *pic_cen = compo_getobj_byid(COMPO_ID_PIC_BT_CEN);
    compo_picturebox_t *pic_rig = compo_getobj_byid(COMPO_ID_PIC_BT_RIG);

    if (SysVariable.heartRateModule.spo2 > 0){
        if ((SysVariable.heartRateModule.timeOutFlag == true) || (SysVariable.heartRateModule.measureEndFlag == true))
        {
                
        }
        else{
            if (tick_check_expire(f_blood_oxygen->tick, 100)){
                f_blood_oxygen->tick = tick_get();

                f_blood_oxygen->lef_x -=  2;
                f_blood_oxygen->cen_x -=  2;
                f_blood_oxygen->rig_x -=  2;


                if(f_blood_oxygen->lef_x < (-GUI_SCREEN_WIDTH/4))
                    f_blood_oxygen->lef_x = GUI_SCREEN_WIDTH/4*5;

                if(f_blood_oxygen->cen_x < (-GUI_SCREEN_WIDTH/4))
                    f_blood_oxygen->cen_x = GUI_SCREEN_WIDTH/4*5;

                if(f_blood_oxygen->rig_x < (-GUI_SCREEN_WIDTH/4))
                    f_blood_oxygen->rig_x = GUI_SCREEN_WIDTH/4*5;
            }
        }
        

        compo_picturebox_set_pos(pic_lef, f_blood_oxygen->lef_x, 70+25);
        compo_picturebox_set_visible(pic_lef, true);          //触摸按下的效果图先设置不可见

        compo_picturebox_set_pos(pic_cen, f_blood_oxygen->cen_x, 70+25);
        compo_picturebox_set_visible(pic_cen, true);          //触摸按下的效果图先设置不可见

        compo_picturebox_set_pos(pic_rig, f_blood_oxygen->rig_x, 70+25);
        compo_picturebox_set_visible(pic_rig, true);          //触摸按下的效果图先设置不可见        
    }
    
}

//触摸按钮效果处理
static void func_blood_oxygen_button_touch_handle(void)
{
    f_blood_oxygen_t *f_bo = (f_blood_oxygen_t *)func_cb.f_cb;
    int id = compo_get_button_id();

    if (COMPO_ID_BTN != id) {
        return ;
    }
    
    //触摸效果图设置可见
    compo_picturebox_t *pic_click = compo_getobj_byid(COMPO_ID_PIC_CLICK);
    compo_picturebox_set_visible(pic_click, true);    
    f_bo->touch = true;   
}

//释放按钮效果处理
// static void func_blood_oxygen_button_release_handle(void)
// {
//     //触摸效果图设置不可见
//     compo_picturebox_t *pic_click = compo_getobj_byid(COMPO_ID_PIC_CLICK);
//     compo_picturebox_set_visible(pic_click, false);       
// }

//单击按钮
// static void func_blood_oxygen_button_click(void)
// {
//     f_blood_oxygen_t *f_bo = (f_blood_oxygen_t *)func_cb.f_cb;
//     component_t *compo;
    
//     //未佩戴下退出
//     if (BO_STA_UNWEAR == f_bo->det_sta) {
//         compo = compo_getobj_byid(COMPO_ID_PIC_UNWEAR);
//         compo_picturebox_set_visible((compo_picturebox_t *)compo, false);
//         compo = compo_getobj_byid(COMPO_ID_PIC_BG);
//         compo_picturebox_set_visible((compo_picturebox_t *)compo, true);
//     }

//     int id = compo_get_button_id();
//     if (COMPO_ID_BTN != id) {
//         return ;
//     }

//     switch (f_bo->det_sta) {
//         case BO_STA_IDLE: {
//             sensor_blood_oxygen_stop();
//             sensor_blood_oxygen_start();
//             compo = compo_getobj_byid(COMPO_ID_TXT_TIPS);
//             compo_textbox_set((compo_textbox_t *)compo, i18n[STR_MEASURING]);
//             f_bo->det_sta = BO_STA_WORKING;
//         }break;

//         case BO_STA_WORKING: 
//         case BO_STA_UNWEAR: {
//             sensor_blood_oxygen_stop();
//             compo = compo_getobj_byid(COMPO_ID_TXT_TIPS);
//             compo_textbox_set((compo_textbox_t *)compo, i18n[STR_START]);
//             f_bo->det_sta = BO_STA_IDLE;
//         }break;
//     }    
// }

//未佩戴和佩戴处理
// static void func_blood_oxygen_unwear_handle(bool wear)
// {
//     f_blood_oxygen_t *f_bo = (f_blood_oxygen_t *)func_cb.f_cb;
//     component_t *compo;

//     if (wear) {
//         compo = compo_getobj_byid(COMPO_ID_PIC_UNWEAR);
//         compo_picturebox_set_visible((compo_picturebox_t *)compo, false);

//         compo = compo_getobj_byid(COMPO_ID_PIC_BG);
//         compo_picturebox_set_visible((compo_picturebox_t *)compo, true);

//         compo = compo_getobj_byid(COMPO_ID_TXT_TIPS);
//         compo_textbox_set((compo_textbox_t *)compo, i18n[STR_MEASURING]);
//     } else {
//         compo = compo_getobj_byid(COMPO_ID_PIC_UNWEAR);
//         compo_picturebox_set_visible((compo_picturebox_t *)compo, true);

//         compo = compo_getobj_byid(COMPO_ID_PIC_BG);
//         compo_picturebox_set_visible((compo_picturebox_t *)compo, false);

//         compo = compo_getobj_byid(COMPO_ID_TXT_TIPS);
//         compo_textbox_set((compo_textbox_t *)compo, i18n[STR_WRIST_OFF]);

//         f_bo->value = 0;
//         compo = compo_getobj_byid(COMPO_ID_TXT_RESULT);
//         compo_textbox_set_visible((compo_textbox_t *)compo, false);
//     }
// }

//血氧功能事件处理
static void func_blood_oxygen_process(void)
{
    f_blood_oxygen_t *f_bo = (f_blood_oxygen_t *)func_cb.f_cb;
    s32 dx, dy;
    compo_textbox_t *compo_txt = NULL;
    compo_page_move_process(f_bo->ptm);
    func_animation_roll();
    
     if (SysVariable.heartRateModule.openStatus == true) {
          reset_sleep_delay_all();
    }
    //血氧值刷新
    if (SysVariable.heartRateModule.spo2 > 0) {
		compo_txt = (compo_textbox_t *)compo_getobj_byid(COMPO_ID_TXT_RESULT);
        snprintf(buf_spo2, sizeof(buf_spo2), "%d%%", SysVariable.heartRateModule.spo2);
        compo_textbox_set(compo_txt, buf_spo2);
	}

    if(SysVariable.heartRateModule.maxSpo2 > 0){
        compo_txt = (compo_textbox_t *)compo_getobj_byid(COMPO_ID_TXT_RESULT_MAX);
        snprintf(buf_max, sizeof(buf_max), "%d%%", SysVariable.heartRateModule.maxSpo2);
        compo_textbox_set(compo_txt, buf_max);
    }

    if(SysVariable.heartRateModule.minSpo2 > 0){
        compo_txt = (compo_textbox_t *)compo_getobj_byid(COMPO_ID_TXT_RESULT_MIN);
        snprintf(buf_min, sizeof(buf_min), "%d%%", SysVariable.heartRateModule.minSpo2);
        compo_textbox_set(compo_txt, buf_min);
    }
    // if(SysVariable.heartRateModule.is_farway_hand  == true){
    //     func_popup_new(POPUP_ID_FARWAY_HAND_REMINDER);
    // }

#ifdef TJD_GUI_Remind_slip_wrist_Show
    //脱腕检测
    if (tick_check_expire(f_bo->tick, 100)){
        f_bo->tick = tick_get();
        if(++f_bo->sec > 30)
        {
            if(SysVariable.heartRateModule.is_farway_hand  == true){
                func_switch_to_assign_screen(FUNC_FARWAY_HAND, false);
            // func_switch_to(FUNC_FARWAY_HAND, FUNC_SWITCH_LR_ZOOM_RIGHT);  //右滑界面
            }
        }
    }
#endif
    func_process();
}

//血氧功能消息处理
static void func_blood_oxygen_message(size_msg_t msg)
{
    f_blood_oxygen_t *f_bo = (f_blood_oxygen_t *)func_cb.f_cb;
    switch (msg) {
    case MSG_CTP_TOUCH:
        // func_blood_oxygen_button_touch_handle();
        compo_page_move_touch_handler(f_bo->ptm);
        break;

	case MSG_CTP_CLICK:
    case MSG_CTP_SHORT_UP:
    case MSG_CTP_SHORT_DOWN:
    case MSG_CTP_LONG:
        break;
        func_blood_oxygen_button_click();
        break;

	case MSG_QDEC_BACKWARD:
    if (func_cb.flag_sort) {    //快捷应用状态下不滚动页面
        func_message(msg);
    } else {
        // compo_page_move_set_by_pages(f_bo->ptm, -1);
    }
	break;

    case MSG_QDEC_FORWARD:
        if (func_cb.flag_sort) {
            func_message(msg);
        } else {
            // compo_page_move_set_by_pages(f_bo->ptm, 1);
        }
		break;
    default:
        func_message(msg);
        break;
    }
}

//进入血氧功能
static void func_blood_oxygen_enter(void)
{
    func_cb.f_cb = func_zalloc(sizeof(f_blood_oxygen_t));
    func_cb.frm_main = func_blood_oxygen_form_create();

    f_blood_oxygen_t *f_blood_oxygen = (f_blood_oxygen_t *)func_cb.f_cb;
	f_blood_oxygen->ptm = (page_tp_move_t *)func_zalloc(sizeof(page_tp_move_t));
    f_blood_oxygen->lef_x = GUI_SCREEN_WIDTH/4 ;
    f_blood_oxygen->cen_x = GUI_SCREEN_WIDTH/4*3 ;
    f_blood_oxygen->rig_x = GUI_SCREEN_WIDTH/4*5 ;
    sensor_blood_oxygen_stop();
    sensor_blood_oxygen_start();

    f_blood_oxygen->det_sta = BO_STA_WORKING;
	// bsp_sensor_hr_start(MeasureMode_Spo2);
}

//退出血氧功能
static void func_blood_oxygen_exit(void)
{
    f_blood_oxygen_t *f_bo = (f_blood_oxygen_t *)func_cb.f_cb;
    if (BO_STA_IDLE != f_bo->det_sta) {
        sensor_blood_oxygen_stop();
    }
    if (f_bo->ptm) {
        func_free(f_bo->ptm);
    }
    func_cb.last = FUNC_BLOOD_OXYGEN;

}

//血氧功能
void func_blood_oxygen(void)
{
    printf("%s\n", __func__);
    func_blood_oxygen_enter();
    while (func_cb.sta == FUNC_BLOOD_OXYGEN) {
        func_blood_oxygen_process();
        func_blood_oxygen_message(msg_dequeue());
    }
    func_blood_oxygen_exit();
}


//血氧外设接口
static void sensor_blood_oxygen_start(void)
{
    // bsp_sensor_hr_start(1);
    bsp_sensor_hr_start(MeasureMode_Spo2);
    return ;
}

static void sensor_blood_oxygen_stop(void)
{
    bsp_sensor_hr_stop();

    return ;
}

static uint8_t sensor_blood_oxygen_data_get(void)
{
    return 0;
}

static bool sensor_blood_oxygen_wear_sta_get(void)
{
    return bsp_sensor_hr_wear_sta_get();
}