#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_pressure_start(void);
static void sensor_blood_pressure_stop(void);



//血压检测状态
enum {
	BP_STA_IDLE,		    //空闲
	BP_STA_WORKING,		    //检测中
	BP_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_LAST,
    COMPO_ID_PIC_UNWEAR,
    COMPO_ID_PIC_BT_LEF,
    COMPO_ID_PIC_BT_CEN,
    COMPO_ID_PIC_BT_RIG,	
};

//组件ID;
enum {
	COMPO_ID_NUM_BLOODPRESSURE_MAX = 1,
	COMPO_ID_NUM_BLOODPRESSURE_CUR,
	COMPO_ID_NUM_BLOODPRESSURE_MIN,
	COMPO_ID_TEXT_BLOODPRESSURE_TIME,
	COMPO_ID_CHART,
};

typedef struct f_bloodpressure_t_ {
    page_tp_move_t *ptm;
	uint8_t cur_sta;
    uint8_t sbp;
    uint8_t dbp;
    bool touch;
    u32 tick;
    s16 lef_x;
    s16 cen_x;
    s16 rig_x;
    u8 sec;
} f_bloodpressure_t;


//创建血压窗体，创建窗体中不要使用功能结构体 func_cb.f_cb
compo_form_t *func_bloodpressure_form_create(void)
{
    component_t *compo;
    char buf[8] = {0};
    //新建窗体和背景
    compo_form_t *frm = compo_form_create(true);
    compo = (component_t *)compo_picturebox_create(frm, UI_BUF_BLOOD_PRESSURE_ICON_BP_BIN);
    compo_picturebox_set_pos((compo_picturebox_t *)compo, 20+7, 53+25);
    compo_setid(compo, COMPO_ID_PIC_BG);
    //中间网格
    compo_form_add_image(frm, UI_BUF_HEART_RATE_HR_BG_BIN, GUI_SCREEN_CENTER_X, 133+46);
    //下方时间图标
    compo_form_add_image(frm, UI_BUF_COMMON_TIME_BIN, 61 + 10, 258+ 10);
    
    //设置标题栏
    compo_form_set_mode(frm, COMPO_FORM_MODE_SHOW_TITLE | COMPO_FORM_MODE_SHOW_TIME);
    compo_form_set_title(frm, i18n[STR_BLOOD_PRESSURE]);

	//图像按钮
	// 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, 336);
    // 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, 336);
    // 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, 184, 115);
#if defined(__LANGUAGE_SM_CHINESE__)
    if (tjd_Get_Language_Current_Index() == LANGUAGE_TYPE_Chinese)
    {
        compo_textbox_set((compo_textbox_t *)compo, "毫米汞柱");
    }
    else
#endif
    {
        compo_textbox_set((compo_textbox_t *)compo, "mmHg");
    }

    //血压测量结果
    compo_textbox_t *txt_val = compo_textbox_create(frm, 8);
    compo_textbox_set_font(txt_val, UI_BUF_0FONT_FONT_NUM_38_BIN);
    compo_setid(txt_val, COMPO_ID_TXT_RESULT);
    compo_textbox_set_align_center(txt_val, false);
    compo_textbox_set_pos(txt_val, 53, 50);
    compo_textbox_set(txt_val, "---/---");

    //血压  上次测量数值
    txt_val = compo_textbox_create(frm, 8);
    compo_textbox_set_font(txt_val, UI_BUF_0FONT_FONT_BIN);
    compo_setid(txt_val, COMPO_ID_TXT_RESULT_LAST);
    compo_textbox_set_pos(txt_val, GUI_SCREEN_CENTER_X, 265);
    if((SysVariable.heartRateModule.lastBlood_h!=0)||(SysVariable.heartRateModule.lastBlood_l!=0))
    {
	    sprintf(buf,"%d/%d",SysVariable.heartRateModule.lastBlood_h, SysVariable.heartRateModule.lastBlood_l);
        compo_textbox_set(txt_val, buf);
    }
    else
        compo_textbox_set(txt_val, "---/---");

    //未佩戴提示
    // compo = (component_t *)compo_picturebox_create(frm, UI_BUf_bloodpressure_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);        

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

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

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

    return frm;
}


//动画滚动
static void func_animation_roll(void)
{
    f_bloodpressure_t *f_bloodpressure = (f_bloodpressure_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.blood_h > 0){
        if ((SysVariable.heartRateModule.timeOutFlag == true) || (SysVariable.heartRateModule.measureEndFlag == true))
        {
                
        }
        else{
            if (tick_check_expire(f_bloodpressure->tick, 100)){
                f_bloodpressure->tick = tick_get();

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


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

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

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

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

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

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


// 触摸按钮效果处理
static void func_bloodpressure_button_touch_handle(void)
{
    f_bloodpressure_t *f_bp = (f_bloodpressure_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_bp->touch = true;   
}

//释放按钮效果处理
// static void func_bloodpressure_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_bloodpressure_button_click(void)
{
    f_bloodpressure_t *f_bp = (f_bloodpressure_t *)func_cb.f_cb;
    component_t *compo;
    
    //未佩戴下退出
    // if (BP_STA_UNWEAR == f_bp->cur_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_bp->cur_sta) {
        case BP_STA_IDLE: {
            sensor_blood_pressure_stop();
            sensor_blood_pressure_start();
            compo = compo_getobj_byid(COMPO_ID_TXT_TIPS);
            compo_textbox_set((compo_textbox_t *)compo, i18n[STR_MEASURING]);
            f_bp->cur_sta = BP_STA_WORKING;
        }break;

        case BP_STA_WORKING: 
        case BP_STA_UNWEAR: {
            sensor_blood_pressure_stop();
            compo = compo_getobj_byid(COMPO_ID_TXT_TIPS);
            compo_textbox_set((compo_textbox_t *)compo, i18n[STR_START]);
            f_bp->cur_sta = BP_STA_IDLE;
        }break;
    }    
}

//未佩戴和佩戴处理
// static void func_bloodpressure_unwear_handle(bool wear)
// {
//     f_bloodpressure_t *f_bp = (f_bloodpressure_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_bp->sbp = 0;
//         f_bp->dbp = 0;
//         compo = compo_getobj_byid(COMPO_ID_TXT_RESULT);
//         compo_textbox_set_visible((compo_textbox_t *)compo, false);
//     }
// }

//血压功能事件处理
static void func_bloodpressure_process(void)
{
    f_bloodpressure_t *f_bp = (f_bloodpressure_t *)func_cb.f_cb;

    compo_textbox_t *compo_txt = NULL;
    char buf[8] = {0};

     if (SysVariable.heartRateModule.openStatus == true) {
          reset_sleep_delay_all();
    }

    if (SysVariable.heartRateModule.blood_h > 0) {
		compo_txt = (compo_textbox_t *)compo_getobj_byid(COMPO_ID_TXT_RESULT);
        snprintf(buf, sizeof(buf), "%d/%d", SysVariable.heartRateModule.blood_h, SysVariable.heartRateModule.blood_l);
        compo_textbox_set(compo_txt, buf);
	}

    if(SysVariable.heartRateModule.lastBlood_h > 0){
        compo_txt = (compo_textbox_t *)compo_getobj_byid(COMPO_ID_TXT_RESULT_LAST);
        snprintf(buf, sizeof(buf), "%d/%d", SysVariable.heartRateModule.lastBlood_h, SysVariable.heartRateModule.lastBlood_l);
        compo_textbox_set(compo_txt, buf);
    }


    func_animation_roll();
    // 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_bp->tick, 100)){
        f_bp->tick = tick_get();
        if(++f_bp->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_bloodpressure_message(size_msg_t msg)
{
    switch (msg) {
    case MSG_CTP_TOUCH:
        func_bloodpressure_button_touch_handle();
        break;

	case MSG_CTP_CLICK:
        func_bloodpressure_button_click();
        break;

    default:
        func_message(msg);
        break;
    }
}

//进入血压功能
static void func_bloodpressure_enter(void)
{
    func_cb.f_cb = func_zalloc(sizeof(f_bloodpressure_t));
    func_cb.frm_main = func_bloodpressure_form_create();

    f_bloodpressure_t *f_bp = (f_bloodpressure_t *)func_cb.f_cb;
    f_bp->lef_x = GUI_SCREEN_WIDTH/4 ;
    f_bp->cen_x = GUI_SCREEN_WIDTH/4*3 ;
    f_bp->rig_x = GUI_SCREEN_WIDTH/4*5 ;
    sensor_blood_pressure_stop();
    sensor_blood_pressure_start();
    f_bp->cur_sta = BP_STA_WORKING;
}

//退出血压功能
static void func_bloodpressure_exit(void)
{
    func_cb.last = FUNC_BLOOD_PRESSURE;

    f_bloodpressure_t *f_bp = (f_bloodpressure_t *)func_cb.f_cb;
    if (BP_STA_IDLE != f_bp->cur_sta) {
        sensor_blood_pressure_stop();
    }
    func_cb.last = FUNC_BLOOD_PRESSURE;
}

//血压功能
void func_bloodpressure(void)
{
    printf("%s\n", __func__);
    func_bloodpressure_enter();
    while (func_cb.sta == FUNC_BLOOD_PRESSURE) {
        func_bloodpressure_process();
        func_bloodpressure_message(msg_dequeue());
    }
    func_bloodpressure_exit();
}

//血压外设接口
static void sensor_blood_pressure_start(void)
{
	bsp_sensor_hr_start(MeasureMode_Blood);
    return ;
}

static void sensor_blood_pressure_stop(void)
{
    bsp_sensor_hr_stop();
    return ;
}