#include "user_server.h"
#include "user_elect.h"
#include "user_led.h"
#include "dip_sw.h"
#include "user_ws2812b.h"

tmosTaskID user_server_task_id = INVALID_TASK_ID;
static uint32_t offline_timeout = CAN_OFFLINE_TIMEOUT_DEFAULT / USER_SERVER_INTERVAL;
static bool offline_stat = false;
static uint8_t can_idx = 0xFF;
static cabi_data_s cabi_data = {
	.elect_stat = {
		.left_elect_stat = 0,
		.right_elect_stat = 0,
	},
	.light_stat = {
		.left_light_bright = 0,
		.right_light_bright = 0,
		.left_pwm_bright = 0,
		.right_pwm_bright = 0,
	},
	.left_rgb = {
        .red = 0,
        .green = 0,
        .blue = 0,
    },
	.right_rgb = {
        .red = 0,
        .green = 0,
        .blue = 0,
    },
    .humidity = 0xFF,
    .temperature = -3000,
};

static can_open_data_s can_open_data;

/*******************************************************************************
  * @函数名称   prvUser_server_dev_type_protocol
  * @函数说明   设备类型索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_dev_type_protocol(void)
{
    if(can_open_data.subidx == REG_DEV_TYPE_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_WORD;
            s_data.idx = REG_DEV_TYPE_IDX;
            s_data.subidx = REG_DEV_TYPE_SUBIDX;
            s_data.data[0] = DEV_TYPE;
            s_data.data[1] = DEV_TYPE >> 8;
            s_data.data[2] = 0;
            s_data.data[3] = 0;
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = can_open_data.ins;
            s_data.idx = REG_DEV_TYPE_IDX;
            s_data.subidx = REG_DEV_TYPE_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_version_protocol
  * @函数说明   版本号索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_version_protocol(void)
{
    if(can_open_data.subidx == REG_VERSION_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_DWORD;
            s_data.idx = REG_VERSION_IDX;
            s_data.subidx = REG_VERSION_SUBIDX;
            s_data.data[0] = HARDWARE_VERSION;
            s_data.data[1] = HARDWARE_VERSION >> 8;
            s_data.data[2] = SOFTWARE_VERSION;
            s_data.data[3] = SOFTWARE_VERSION >> 8;
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = can_open_data.ins;
            s_data.idx = REG_VERSION_IDX;
            s_data.subidx = REG_VERSION_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_elect_stat_protocol
  * @函数说明   电磁锁控制索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_elect_stat_protocol(void)
{
    if(can_open_data.subidx == REG_ELECT_STAT_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_WORD;
            s_data.idx = REG_ELECT_STAT_IDX;
            s_data.subidx = REG_ELECT_STAT_SUBIDX;
            memset(s_data.data, 0, 4);
            memcpy(s_data.data,(uint8_t *)&(cabi_data.elect_stat), 2);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else if(can_open_data.ins == S_INS_WR_WORD)
        {
            cabi_elect_control_s elect;
            memcpy((uint8_t *)&elect, can_open_data.data, 2);

            can_open_data_s s_data;
            s_data.ins = R_INS_WR_SUCC;
            s_data.idx = REG_ELECT_STAT_IDX;
            s_data.subidx = REG_ELECT_STAT_SUBIDX;
            memset(s_data.data, 0, 4);
            memcpy(s_data.data,(uint8_t *)&elect, 2);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        
            if(elect.left_elect_enable == 1 && elect.left_elect_control == 1)
            {
                vUser_elect_open(LEFT_IDX);
            }
            
            if(elect.right_elect_enable == 1 && elect.right_elect_control == 1)
            {
                vUser_elect_open(RIGHT_IDX);
            }
        }
        else{
            can_open_data_s s_data;
            s_data.ins = can_open_data.ins;
            s_data.idx = REG_ELECT_STAT_IDX;
            s_data.subidx = REG_ELECT_STAT_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_light_stat_protocol
  * @函数说明   照明控制索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_light_stat_protocol(void)
{
    if(can_open_data.subidx == REG_LIGHT_STAT_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_DWORD;
            s_data.idx = REG_LIGHT_STAT_IDX;
            s_data.subidx = REG_LIGHT_STAT_SUBIDX;
            memcpy(s_data.data,(uint8_t *)&(cabi_data.light_stat), 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else if(can_open_data.ins == S_INS_WR_DWORD)
        {
            cabi_light_control_s light;
            memcpy((uint8_t *)&light, can_open_data.data, 4);

            can_open_data_s s_data;
            s_data.ins = R_INS_WR_SUCC;
            s_data.idx = REG_LIGHT_STAT_IDX;
            s_data.subidx = REG_LIGHT_STAT_SUBIDX;
            memcpy(s_data.data,(uint8_t *)&light, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        
            if(light.left_light_enable == 1)
            {
                uint16_t value = (light.left_light_bright > 100)?100:light.left_light_bright;
                vUser_led_set_bright(LEFT_LIGHT, value);
            }

            if(light.right_light_enable == 1)
            {
                uint16_t value = (light.right_light_bright > 100)?100:light.right_light_bright;
                vUser_led_set_bright(RIGHT_LIGHT, value);
            }

            if(light.left_pwm_enable == 1)
            {
                uint16_t value = (light.left_pwm_bright > 100)?100:light.left_pwm_bright;
                vUser_led_set_bright(LEFT_PWM, value);
            }

            if(light.right_pwm_enable == 1)
            {
                uint16_t value = (light.right_pwm_bright > 100)?100:light.right_pwm_bright;
                vUser_led_set_bright(RIGHT_PWM, value);
            }

        }
        else{
            can_open_data_s s_data;
            s_data.ins = can_open_data.ins;
            s_data.idx = REG_LIGHT_STAT_IDX;
            s_data.subidx = REG_LIGHT_STAT_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_rgb_stat_protocol
  * @函数说明   RGB灯索引解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_rgb_stat_protocol(void)
{
    if(can_open_data.subidx == REG_RGB_STAT_LEFT_ID_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_DWORD;
            s_data.idx = REG_RGB_STAT_ID_IDX;
            s_data.subidx = REG_RGB_STAT_LEFT_ID_SUBIDX;
            memcpy(s_data.data,(uint8_t *)&(cabi_data.left_rgb), 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else if(can_open_data.ins == S_INS_WR_DWORD)
        {
            cabi_rgb_stat_s rgb;
            memcpy((uint8_t *)&rgb, can_open_data.data, 4);

            can_open_data_s s_data;
            s_data.ins = R_INS_WR_SUCC;
            s_data.idx = REG_RGB_STAT_ID_IDX;
            s_data.subidx = REG_RGB_STAT_LEFT_ID_SUBIDX;
            memcpy(s_data.data,(uint8_t *)&rgb, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        
            memcpy((uint8_t *)&(cabi_data.left_rgb),(uint8_t *)&rgb, 4);

            uint32_t timeValue = ((uint32_t)cabi_data.left_rgb.flickerTime + 1) * 100 * ((cabi_data.left_rgb.flickerType == 1)?10:1);

            vUser_ws2812b_set_lock_stat(LEFT_IDX, (rgb.lock == 1)?true:false, cabi_data.left_rgb.flickerstat + 1, 
                                        cabi_data.left_rgb.red, cabi_data.left_rgb.green, cabi_data.left_rgb.blue, timeValue);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = can_open_data.ins;
            s_data.idx = REG_RGB_STAT_ID_IDX;
            s_data.subidx = REG_RGB_STAT_LEFT_ID_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
    else if(can_open_data.subidx == REG_RGB_STAT_RIGHT_ID_SUBIDX)
    {
        if(can_open_data.ins == S_INS_RD)
        {
            can_open_data_s s_data;
            s_data.ins = R_INS_RD_DWORD;
            s_data.idx = REG_RGB_STAT_ID_IDX;
            s_data.subidx = REG_RGB_STAT_RIGHT_ID_SUBIDX;
            memcpy(s_data.data,(uint8_t *)&(cabi_data.right_rgb), 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
        else if(can_open_data.ins == S_INS_WR_DWORD)
        {
            cabi_rgb_stat_s rgb;
            memcpy((uint8_t *)&rgb, can_open_data.data, 4);

            can_open_data_s s_data;
            s_data.ins = R_INS_WR_SUCC;
            s_data.idx = REG_RGB_STAT_ID_IDX;
            s_data.subidx = REG_RGB_STAT_RIGHT_ID_SUBIDX;
            memcpy(s_data.data,(uint8_t *)&rgb, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        
            memcpy((uint8_t *)&(cabi_data.right_rgb),(uint8_t *)&rgb, 4);

            uint32_t timeValue = ((uint32_t)cabi_data.left_rgb.flickerTime + 1) * 100 * ((cabi_data.left_rgb.flickerType == 1)?10:1);

            vUser_ws2812b_set_lock_stat(RIGHT_IDX, (cabi_data.right_rgb.lock == 1)?true:false, cabi_data.right_rgb.flickerstat + 1, 
                                        cabi_data.right_rgb.red, cabi_data.right_rgb.green, cabi_data.right_rgb.blue, timeValue);
        }
        else{
            can_open_data_s s_data;
            s_data.ins = can_open_data.ins;
            s_data.idx = REG_RGB_STAT_ID_IDX;
            s_data.subidx = REG_RGB_STAT_RIGHT_ID_SUBIDX;
            memset(s_data.data, 0, 4);
            vUser_can_send_data((uint8_t *)&s_data, 8);
        }
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_can_protocol
  * @函数说明   can总线协议解析
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_can_protocol(void)
{
    bool stat = false;
    switch(can_open_data.idx)
    {
        case REG_DEV_TYPE_IDX:prvUser_server_dev_type_protocol();stat = true;break;
        case REG_VERSION_IDX:prvUser_server_version_protocol();stat = true;break;
        case REG_ELECT_STAT_IDX:prvUser_server_elect_stat_protocol();stat = true;break;
        case REG_LIGHT_STAT_IDX:prvUser_server_light_stat_protocol();stat = true;break;
        case REG_RGB_STAT_ID_IDX:prvUser_server_rgb_stat_protocol();stat = true;break;
        default:break;
    }

    if(stat == true)
    {
        offline_timeout = CAN_OFFLINE_TIMEOUT_DEFAULT / USER_SERVER_INTERVAL;
        if(offline_stat == true)
        {
            offline_stat = false;
            vUser_led_set_alarm_view(LED_ALL_ALARM_OFFLINE, false);
            vUser_ws2812b_set_alarm_view(LEFT_IDX, WS2812B_ALL_ALARM_OFFLINE, false);
            vUser_ws2812b_set_alarm_view(RIGHT_IDX, WS2812B_ALL_ALARM_OFFLINE, false);
        }
    }
}

/*******************************************************************************
  * @函数名称   ble_action_rst_pro
  * @函数说明   重启倒计时
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint8_t rst_timeout = 5;
static void ble_action_rst_pro(void)
{
    if(rst_timeout == 0)
    {
        /* Software reset */
        NVIC_SystemReset();
    }
    else{
	    rst_timeout--;
	    PRINT("Restart countdown %d second\n", rst_timeout);
    }
}

/*******************************************************************************
  * @函数名称   prvUser_server_can_offline_check
  * @函数说明   CAN总线离线检测
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_server_can_offline_check(void)
{
    if(offline_timeout > 0)
    {
        if(offline_timeout == 1)
        {
            if(offline_stat == false)
            {
                offline_stat = true;
                vUser_led_set_alarm_view(LED_ALL_ALARM_OFFLINE, true);
                vUser_ws2812b_set_alarm_view(LEFT_IDX, WS2812B_ALL_ALARM_OFFLINE, true);
                vUser_ws2812b_set_alarm_view(RIGHT_IDX, WS2812B_ALL_ALARM_OFFLINE, true);
            }
        }
        offline_timeout--;
    }
}

/*******************************************************************************
  * @函数名称   user_server_task_process_event
  * @函数说明   task的event处理回调函数,需要在注册task时候,传进去
  * @输入参数  	task_id：任务ID
               events：事件
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static uint16_t user_server_task_process_event(uint8_t task_id, uint16_t events)
{
    //event 处理
    if(events & (1 << SERVER_QUEUE_TIME))
    {
        prvUser_server_can_offline_check();
        return (events ^ (1 << SERVER_QUEUE_TIME)); //异或的方式清除该事件运行标志，并返回未运行的事件标志
    }

    if(events & (1 << SERVER_QUEUE_CAN))
    {
        prvUser_server_can_protocol();
        return (events ^ (1 << SERVER_QUEUE_CAN)); //异或的方式清除该事件运行标志，并返回未运行的事件标志
    }

    if(events & (1 <<SERVER_BLE_RST))
    {
        ble_action_rst_pro();
        return (events ^ (1 << SERVER_BLE_RST)); //异或的方式清除该事件运行标志，并返回未运行的事件标志
    }

    return 0;
}

/*******************************************************************************
  * @函数名称   vUser_server_task_start
  * @函数说明   定时任务开始
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_server_task_start(void)
{
    bStatus_t stat = tmos_start_reload_task(user_server_task_id, (1 << SERVER_QUEUE_TIME), MS1_TO_SYSTEM_TIME(USER_SERVER_INTERVAL));
}

/*******************************************************************************
  * @函数名称   vUser_server_get_cabi_data
  * @函数说明   获取控制板数据变量
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   控制板数据变量指针
*******************************************************************************/
cabi_data_s *vUser_server_get_cabi_data(void)
{
    return &cabi_data;
}

/*******************************************************************************
  * @函数名称   vUser_can_recv_data_callback
  * @函数说明   can接收数据上报回调
  * @输入参数  	data：数据指针
               size：数据长度
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvUser_can_recv_data_callback(uint8_t *data, uint8_t size)
{
    memcpy(&can_open_data, data, sizeof(can_open_data_s));
    bStatus_t stat = tmos_start_task(user_server_task_id, (1 << SERVER_QUEUE_CAN), MS1_TO_SYSTEM_TIME(1));
}

/*******************************************************************************
  * @函数名称   vUser_elect_upload_stat_callback
  * @函数说明   设置钥匙位电磁锁状态回调
  * @输入参数   idx：左边或者右边
                stat：电磁锁是否锁死
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void vUser_elect_upload_stat_callback(uint8_t idx, bool stat)
{
	if(idx == LEFT_IDX)
	{
		cabi_data.elect_stat.left_elect_stat = (stat == true)?1:0;
	}
	else if(idx == RIGHT_IDX)
	{
		cabi_data.elect_stat.right_elect_stat = (stat == true)?1:0;
	}
}

/*******************************************************************************
  * @函数名称   prvDipsw_upload_callback
  * @函数说明   地址读取回调
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
static void prvDipsw_upload_callback(uint8_t addr)
{
    vUser_can_set_addr(addr);

    if(addr != can_idx)
    {
        can_idx = addr;
        if(addr > 0)
        {
            vUser_led_set_alarm_view(LED_ALL_ALARM_CAN_IDX_ERROR, false);
            vUser_ws2812b_set_alarm_view(LEFT_IDX, WS2812B_ALL_ALARM_CAN_IDX_ERROR, false);
            vUser_ws2812b_set_alarm_view(RIGHT_IDX, WS2812B_ALL_ALARM_CAN_IDX_ERROR, false);
        }
        else{
            vUser_led_set_alarm_view(LED_ALL_ALARM_CAN_IDX_ERROR, true);
            vUser_ws2812b_set_alarm_view(LEFT_IDX, WS2812B_ALL_ALARM_CAN_IDX_ERROR, true);
            vUser_ws2812b_set_alarm_view(RIGHT_IDX, WS2812B_ALL_ALARM_CAN_IDX_ERROR, true);
        }
    }
}

/*******************************************************************************
  * @函数名称   vUser_server_init
  * @函数说明   初始化
  * @输入参数  	无
  * @输出参数   无
  * @返回参数   无
*******************************************************************************/
void vUser_server_init(void)
{
    vUser_can_set_recv_data_func(prvUser_can_recv_data_callback);
    vUser_elect_set_upload_stat_func(vUser_elect_upload_stat_callback);
    vDipsw_set_upload_func(prvDipsw_upload_callback);

    user_server_task_id  = TMOS_ProcessEventRegister(user_server_task_process_event);
    PRINT("user_server_task_id=%d\n", user_server_task_id);
}