#include "web.h"
#include "mongoose.h"
#include "thread.h"
#include "list.h"
#include "sys/time.h"
#include "power.h"
#include "paras.h"
#include "sensor.h"
#include "breaker.h"
#include "cascade.h"
#include "cfg.h"
#include "lcd.h"
#include <stdio.h>
#include "datadef.h"
#include "cascade.h"
#include "snmp.h"
#include "net.h"
#include "cfg.h"
#include "lcd.h"
#include "wanning.h"
#include "time.h"
#include "cJSON.h"
#include "json_handle.h"
#include "mbedtls/md5.h"

static char* g_product_t_ac_type_str[3] = {
    "L1",
    "L2",
    "L3",
};


#define TIMER_INTERVAL      1000
#define ONCE_SEND_CNT       13
#define FN_MAX  20

typedef void (*http_fn_t)(void *arg);

#define USE_MG716
typedef struct mg_mgr mg_mgr_t;

#ifdef USE_MG716
typedef struct mg_tls_opts mg_tls_t;
#endif

typedef struct {
    http_fn_t  f;
    char       *uri;
}mg_fn_t;




typedef struct {
    pthread_t       tid;
    
    mg_mgr_t        mgr;
#ifdef USE_MG716
    mg_tls_t        tls;
#else
    mg_opts_t       opts;
#endif
		int              cnt;
		mg_fn_t    fn[FN_MAX];
    
    handle_t        list;
    char            rootDir[MG_PATH_MAX];
    char            *buf;
    int             buflen;
    
    uint8_t         cur_addr;
}web_handle_t;



typedef struct mg_connection mg_conn_t;

#ifdef USE_MG716

static void timer_fn(void *arg)
{
    int r;
    web_handle_t *h=(web_handle_t*)arg;
    list_node_t *ln=NULL;
    mg_conn_t* c;
    
    r = list_take_node(h->list, &ln, 0);
    if(r==0) {
        node_t *n=&ln->data;
        for (c = h->mgr.conns; c != NULL; c = c->next) {
            //ws_send_pkt(h, c, n->tp, n->buf, n->dlen, 1);
        }
        list_back_node(h->list, ln);
    }
}
#else
typedef struct mg_serve_http_opts mg_opts_t;
#define MG_PATH_MAX  128
static void set_timer(struct mg_connection *c, int ms)
{
    mg_set_timer(c, mg_time()+ms/1000.0f);
}
#endif

typedef struct {
    struct mg_connection *c;
    int     ev;
    void    *ev_data;
}mg_stream_t;


static web_handle_t webHandle={0};


static void httpAddCallback(char *uri, http_fn_t f)
{
    //mg_handle_t *h=&webHandle.mg;
    if(webHandle.cnt<FN_MAX-1) {
       webHandle.fn[webHandle.cnt].uri = uri;
       webHandle.fn[webHandle.cnt].f   = f;
       webHandle.cnt++;
    }
}
static int http_reply(void *conn, int status, char *ack)
{
     int r=0;

    mg_stream_t *s=(mg_stream_t*)conn;
    r = mg_http_reply2(s->c, status, "",  ack);

    return r;
}

static int is_ws(mg_conn_t *c)
{
    int r=0;
#ifdef USE_MG716
    r = c->is_websocket?1:0;
#else
    r = (c->flags & MG_F_IS_WEBSOCKET)?1:0;
#endif
    return r;
}
static int ws_send(mg_conn_t *c, void *data, int len, int isbin)
{
    if(!c || !data || len<=0) {
        return -1;
    }
    //LOGD("____ws_send, len: %d\n", len);
    
#ifdef USE_MG716
    mg_ws_send(c, data, len, isbin?WEBSOCKET_OP_BINARY:WEBSOCKET_OP_TEXT);
#else
    mg_send_websocket_frame(c, isbin?WEBSOCKET_OP_BINARY:WEBSOCKET_OP_TEXT, data, len);
#endif
    
    return 0;
}

static void send_user_info(web_handle_t *h, mg_conn_t *c)
{
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	wb_send_user_t *data1 = (wb_send_user_t *)(&hdr->data);
	memset(data1,0,sizeof(wb_send_user_t));
	paras_data_t* para=paras_get();
	
	
	user_data_t *data = &para->user;
	
	data1->count = data->user_count;
	
	
	for(int i = 0; i < data->user_count;i++)
	{
		data1->users[i].roul_id = data->config[i].role_id;
		strcpy(data1->users[i].user,data->config[i].user_name);
		strcpy(data1->users[i].date,data->config[i].date);
		strcpy(data1->users[i].time,data->config[i].time);
	}

	hdr->magic = PKT_MAGIC;
	hdr->addr  = 0;
	hdr->type  = NEW_PKT_TYPE_USER;
	hdr->nack  = 0;
	hdr->subtype = 0;
	hdr->dlen = data1->count * sizeof(user_t) + sizeof(data1->count);

	uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
}

static void send_add_user_func(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	char date[32]={0};
	char time_s[32] = {0};
	unsigned char digest[16]={0};
	char output[33] = {0};
	mbedtls_md5_context ctx={0};
	uint8_t flag = USER_SUCCESS;
	
	web_user_add_t * user_add = (web_user_add_t *)&(ctrl->user_add);
	pkt_hdr_t *hdr=(pkt_hdr_t*)(h->buf);
		
	paras_data_t* para=paras_get();
	
	printf("hdr  = %x\n",(uint32_t)hdr);
	time_t t=time(NULL);
  struct tm *tm=localtime(&t);


	
	hdr->magic = PKT_MAGIC;
	hdr->addr  = 0;
	hdr->type  = NEW_PKT_TYPE_USER;
	hdr->nack  = 0;
	hdr->subtype = NEW_SUB_PKT_TYPE_USER_ADD;
	hdr->dlen = 1;	
	
	sprintf(date,"%04d%/%02d/%02d",(tm->tm_year+1900), tm->tm_mon+1, tm->tm_mday);
	sprintf(time_s,"%02d%:%02d:%02d",tm->tm_hour, tm->tm_min, tm->tm_sec);
	
	for(int i = 0; i < para->user.user_count;i++)
	{
		if(strcmp(user_add->user,para->user.config[i].user_name) == 0)
		{
			flag = USER_EXIST;			//user_add exist
			break;
		}
	}
	if(flag  == 0)
	{
		if(para->user.user_count >= 10)
		{
			flag = USER_OVER_TEN;
		}else
		{
			para->user.user_count++;
			strcpy(para->user.config[para->user.user_count-1].user_name,user_add->user);
			para->user.config[para->user.user_count-1].role_id = user_add->permition;
			strcpy(para->user.config[para->user.user_count-1].date,date);
			strcpy(para->user.config[para->user.user_count-1].time,time_s);
			mbedtls_md5_init(&ctx);
			mbedtls_md5_starts(&ctx);
			mbedtls_md5_update(&ctx, user_add->password, strlen(user_add->password));
			mbedtls_md5_finish(&ctx, digest);
			mbedtls_md5_free(&ctx);
			for (int k = 0; k < 16; k++) {
					sprintf(&output[k * 2], "%02x", digest[k]);
			}
			output[33] = '\0';
			strcpy(para->user.config[para->user.user_count-1].password_md5,output);
			paras_user_save();
		}
	}
	uint8_t *data =  (uint8_t *)(&hdr->data);

	*data = flag;
	uint32_t xlen = sizeof(uint8_t) + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
	
	//printf("send len = %d\n",xlen);
}



static void send_user_delete_func(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	web_user_delete_t * user_delete = &ctrl->user_delete;
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	uint8_t flag = USER_DELETE_SUCCESS;
	
	paras_data_t* para=paras_get();	
	user_data_t back_user = {0};
	int j = 0;
	
	for(int i = 0;i < para->user.user_count;i++)
	{
		if(strcmp(para->user.config[i].user_name,user_delete->user) == 0)
		{
		}else
		{
			back_user.config[j++] = para->user.config[i];
		}
	}
	back_user.user_count = j;
	//memset(&para->user,0,sizeof(para->user));
	para->user = back_user;
	paras_user_save();
	
	uint8_t *data =  (uint8_t *)(&hdr->data);
	hdr->magic = PKT_MAGIC;
	hdr->addr  = 0;
	hdr->type  = NEW_PKT_TYPE_USER;
	hdr->nack  = 0;
	hdr->subtype = NEW_SUB_PKT_TYPE_USER_DELETE;
	hdr->dlen = 1;	
	*data = flag;
	uint32_t xlen = sizeof(uint8_t) + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
}

static void send_user_update_func(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	web_user_update_t *user_update = &ctrl->user_update;
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	uint8_t flag = USER_DELETE_SUCCESS;
	paras_data_t* para=paras_get();
	
	unsigned char digest[16]={0};
	char output[33] = {0};
	mbedtls_md5_context ctx={0};
	for(int i = 0; i < para->user.user_count;i++)
	{
		if(strcmp(user_update->user,para->user.config[i].user_name) == 0)
		{
			mbedtls_md5_init(&ctx);
			mbedtls_md5_starts(&ctx);
			mbedtls_md5_update(&ctx, user_update->old_password, strlen(user_update->old_password));
			mbedtls_md5_finish(&ctx, digest);
			mbedtls_md5_free(&ctx);
			for (int k = 0; k < 16; k++) {
					sprintf(&output[k * 2], "%02x", digest[k]);
			}
			output[33] = '\0';			
			if(strcmp(output,para->user.config[i].password_md5) == 0)
			{
				mbedtls_md5_init(&ctx);
				mbedtls_md5_starts(&ctx);
				mbedtls_md5_update(&ctx, user_update->new_password, strlen(user_update->new_password));
				mbedtls_md5_finish(&ctx, digest);
				mbedtls_md5_free(&ctx);
				for (int k = 0; k < 16; k++) {
						sprintf(&output[k * 2], "%02x", digest[k]);
				}
				output[33] = '\0';					
				strcpy(para->user.config[i].password_md5,output);
				paras_user_save();
			}else
			{
				flag = USER_UPDATE_PASSERR;
			}
			break;
		}
	}
	
	uint8_t *data =  (uint8_t *)(&hdr->data);
	hdr->magic = PKT_MAGIC;
	hdr->addr  = 0;
	hdr->type  = NEW_PKT_TYPE_USER;
	hdr->nack  = 0;
	hdr->subtype = NEW_SUB_PKT_TYPE_USER_UPDATE;
	hdr->dlen = 1;	
	*data = flag;
	uint32_t xlen = sizeof(uint8_t) + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
}




static void send_login_func(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	uint8_t flag = 0;
	uint8_t *data =  (uint8_t *)(&hdr->data);
	
	paras_data_t* para=paras_get();
	
	unsigned char digest[16]={0};
	char output[33] = {0};
	mbedtls_md5_context ctx={0};

	for(int i = 0; i < para->user.user_count;i++)
	{
		if(strcmp(ctrl->login.user,para->user.config[i].user_name) == 0)
		{
				mbedtls_md5_init(&ctx);
				mbedtls_md5_starts(&ctx);
				mbedtls_md5_update(&ctx, (const unsigned char *)ctrl->login.password, strlen(ctrl->login.password));
				mbedtls_md5_finish(&ctx, digest);
				mbedtls_md5_free(&ctx);

				for (int k = 0; k < 16; k++) {
					sprintf(&output[k * 2], "%02x", digest[k]);
				}
				output[33] = '\0';
				if(strcmp(output,para->user.config[i].password_md5) == 0)
				{
					flag = 1;
				}else
				{
					flag = 2;
				}
			//printf("user=%s output: %s\n",ctrl->login.user,output);
			break;
		}
	}
	hdr->magic = PKT_MAGIC;
	hdr->addr  = 0;
	hdr->type  = MEW_PKT_TYPE_LOGIN;
	hdr->nack  = 0;
	hdr->subtype = 0;
	hdr->dlen = 1;
	
	*data = flag;
	uint32_t xlen = sizeof(uint8_t) + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
}


static void send_sys(web_handle_t *h, mg_conn_t *c)
{
	time_t t=time(NULL);
  struct tm *tm=localtime(&t);
	paras_data_t* para=paras_get();
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	
	hdr->magic = PKT_MAGIC;
  hdr->addr  = 0;
  hdr->type  = NEW_PKT_TYPE_DEVICE_INFO;
  hdr->nack  = 0;
	hdr->subtype = 0;
	
	web_device_info_t *data_info = (web_device_info_t *)(&hdr->data);
	memset(data_info,0,sizeof(web_device_info_t));
	
	sprintf(data_info->date,"%04d%/%02d/%02d",(tm->tm_year+1900), tm->tm_mon+1, tm->tm_mday);
	sprintf(data_info->time,"%02d%:%02d:%02d",tm->tm_hour, tm->tm_min, tm->tm_sec);
	data_info->zone = (rt_tz_get()/3600);
	
	strcpy(data_info->soft_version,VERSION);
	strcpy(data_info->hard_version,VERSION);
	data_info->chs = power_get_all()->chs;
	data_info->board_cnt = power_data_get_board_cnt();
	data_info->power_type = para->prod.type;
	hdr->dlen  = sizeof(web_device_info_t);
	uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
}

static void reboot_sys(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	(void)ctrl;
	system("reboot");
}



static void send_sensor_info(web_handle_t *h, mg_conn_t *c)
{
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	hdr->magic = PKT_MAGIC;
  hdr->addr  = 0;
  hdr->type  = NEW_PKT_TYPE_SENSOR;
  hdr->nack  = 0;
	hdr->subtype = 0;
	web_sensor_info_t *sensor_info = (web_sensor_info_t *)(&hdr->data);
	sensor_all_t *sensor = sensor_get_data();
	
	memset(sensor_info,0,sizeof(web_sensor_info_t)*4);
	
	strcpy(sensor_info[0].name,sensor->data[0].info.name);
	sensor_info[0].status = sensor->data[0].info.status;
	sensor_info[0].value = sensor->data[0].val[0].value;
	sensor_info[0].v_max = sensor->data[0].val[0].thr.max;
	sensor_info[0].v_min = sensor->data[0].val[0].thr.min;
	sensor_info[0].v_max_wrn = sensor->data[0].val[0].s_alarm.max_up;
	sensor_info[0].v_min_wrn = sensor->data[0].val[0].s_alarm.min_down;
	
	strcpy(sensor_info[1].name,sensor->data[0].info.name);
	sensor_info[1].status = sensor->data[0].info.status;
	sensor_info[1].value = sensor->data[0].val[1].value;
	sensor_info[1].v_max = sensor->data[0].val[1].thr.max;
	sensor_info[1].v_min = sensor->data[0].val[1].thr.min;
	sensor_info[1].v_max_wrn = sensor->data[0].val[1].s_alarm.max_up;
	sensor_info[1].v_min_wrn = sensor->data[0].val[1].s_alarm.min_down;
	
	strcpy(sensor_info[2].name,sensor->data[1].info.name);
	sensor_info[2].status = sensor->data[1].info.status;
	sensor_info[2].value = sensor->data[1].val[0].value;
	sensor_info[2].v_max = sensor->data[1].val[0].thr.max;
	sensor_info[2].v_min = sensor->data[1].val[0].thr.min;
	sensor_info[2].v_max_wrn = sensor->data[1].val[0].s_alarm.max_up;
	sensor_info[2].v_min_wrn = sensor->data[1].val[0].s_alarm.min_down;
	
	
	strcpy(sensor_info[3].name,sensor->data[2].info.name);
	sensor_info[3].status = sensor->data[2].info.status;
	sensor_info[3].value = sensor->data[2].val[0].value;
	sensor_info[3].v_max = sensor->data[2].val[0].thr.max;
	sensor_info[3].v_min = sensor->data[2].val[0].thr.min;
	sensor_info[3].v_max_wrn = sensor->data[2].val[0].s_alarm.max_up;
	sensor_info[3].v_min_wrn = sensor->data[2].val[0].s_alarm.min_down;
	
	hdr->dlen  = sizeof(web_sensor_info_t) * 4;
	uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);	
}



static void send_power_info(web_handle_t *h, mg_conn_t *c)
{
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	hdr->magic = PKT_MAGIC;
  hdr->addr  = 0;
  hdr->type  = NEW_PKT_TYPE_ELE_INFO;
  hdr->nack  = 0;
	hdr->subtype = NEW_SUB_PKT_TYPE_ELE_DATA_INFO;	
	info_new_t *power_info = (info_new_t *)(&hdr->data);
	power_handle_new_t *p_handle = power_get_all();
	
	lock_on(p_handle->lck);
	int chn = p_handle->chs;
	
	//max translate 32
	for(int i = 0; i < chn;i++)
	{
		 power_info[i] = p_handle->pch[i].info;
	}
	lock_off(p_handle->lck);
	hdr->dlen  = sizeof(info_new_t) * chn;
	uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
}

static void send_power_all(web_handle_t *h, mg_conn_t *c)
{
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	hdr->magic = PKT_MAGIC;
  hdr->addr  = 0;
  hdr->type  = NEW_PKT_TYPE_ELE_INFO;
  hdr->nack  = 0;
	hdr->subtype = NEW_SUB_PKT_TYPE_ELE_DATA_ALL;	
	power_t *power_all = (power_t *)(&hdr->data);
	power_handle_new_t *p_handle = power_get_all();
	lock_on(p_handle->lck);
	power_all[0] = p_handle->total.all;
	for(int i =0;i < 3;i++)
	{
		power_all[i+1] = p_handle->total.all_l[i];
	}
	lock_off(p_handle->lck);
	hdr->dlen  = sizeof(power_t) * 4;
	uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
}

static void send_power_thr(web_handle_t *h, mg_conn_t *c)
{
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	hdr->magic = PKT_MAGIC;
  hdr->addr  = 0;
  hdr->type  = NEW_PKT_TYPE_ELE_INFO;
  hdr->nack  = 0;
	hdr->subtype = NEW_SUB_PKT_TYPE_ELE_DATA_THR;	
	power_handle_new_t *p_handle = power_get_all();	
	thr_t *_data = (thr_t *)(&hdr->data);
	int chn = p_handle->chs;
	for(int i =0; i < chn;i++)
	{
		_data[i] = p_handle->pch[i].thr;
	}
	hdr->dlen  = sizeof(thr_t) * chn;
	uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
}

static void set_power_ctrl(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	power_handle_new_t *p_handle = power_get_all();
	uint8_t channle = ctrl->cnt_ctrl.chn;
	if(channle > p_handle->chs || ctrl == NULL)
		return;
	uint8_t saddr = p_handle->pch[channle].info.addr;
	uint8_t b_addr = p_handle->pch[channle].info.sch;
	p_handle->set_status(saddr,b_addr,ctrl->cnt_ctrl.status);
}

static void set_power_all_ctrl(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	power_handle_new_t *p_handle = power_get_all();
	p_handle->set_all_status(ctrl->all_ctrl.status);
}

static void set_power_consum_clear(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	power_handle_new_t *p_handle = power_get_all();
	uint8_t channle = ctrl->clear.chn;
	if(channle > p_handle->chs || ctrl == NULL)
		return;
	uint8_t saddr = p_handle->pch[channle].info.addr;
	uint8_t b_addr = p_handle->pch[channle].info.sch;
	p_handle->set_consumer_clear(saddr,b_addr);
}



static void set_power_delay(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	power_handle_new_t *p_handle = power_get_all();
	uint8_t channle = ctrl->delay.chn;
	if(channle > p_handle->chs || ctrl == NULL)
		return;
	uint8_t saddr = p_handle->pch[channle].info.addr;
	uint8_t b_addr = p_handle->pch[channle].info.sch;
	uint8_t open = ctrl->delay.open;
	uint8_t close = ctrl->delay.close;
	p_handle->set_delay(saddr,b_addr,open,close);
}

static void set_power_thr(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	power_handle_new_t *p_handle = power_get_all();
	uint8_t channle = ctrl->thr.chn;
	thr_t *thr = &ctrl->thr.thr;
	if(channle > p_handle->chs || ctrl == NULL)
		return;
	uint8_t saddr = p_handle->pch[channle].info.addr;
	uint8_t b_addr = p_handle->pch[channle].info.sch;
	p_handle->set_thr(saddr,b_addr,thr);
}

static void set_power_batch_thr(web_handle_t *h, mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	power_handle_new_t *p_handle = power_get_all();
	thr_t *thr = &ctrl->thr.thr;
	if(ctrl == NULL)
		return;
	for(int i=0; i < 32;i++)
	{
		if(p_handle->board[i].flag)
		{
			p_handle->set_batch_thr(i,thr);
		}
	}
}




static void send_power_data(web_handle_t *h, mg_conn_t *c,uint8_t id)
{
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	hdr->magic = PKT_MAGIC;
  hdr->addr  = 0;
  hdr->type  = NEW_PKT_TYPE_ELE_INFO;
  hdr->nack  = 0;
	hdr->subtype = id;	
	power_t *power_data = (power_t *)(&hdr->data);
	power_handle_new_t *p_handle = power_get_all();
	if(id>=3)
		return;
	int chn = p_handle->chs;
	for(int i =0; i < chn;i++)
	{
		power_data[i] = p_handle->pch[i].power[id];
	}
	hdr->dlen  = sizeof(power_t) * chn;
	uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);
}

static void set_sensor_thr(web_handle_t *h,mg_conn_t *c,uint8_t type,wed_set_t *ctrl)
{
	
	(void)h;
	(void)c;
	sensor_data_t *data_temp = NULL;
	sensor_th_t *sensor_temp = NULL;
	int32_t vmax = ctrl->sensor.v_max *100;
	int32_t vmin = ctrl->sensor.v_min *100;
	
	switch(type)
	{
		case NEW_SUB_PKT_TYPE_HUMI:
		{
			data_temp = &sensor_get_data()->data[0];
			sensor_temp = &paras_get()->sensor.sens[0];
			data_temp->val[0].thr.en.th_sen_max_en = vmax ?  1 :  0;
			data_temp->val[0].thr.en.th_sen_min_en = vmin ?  1 :  0;
			
			sensor_temp->th_max_1 = vmax;
			sensor_temp->th_min_1 = vmin;
			data_temp->val[0].thr.max = ctrl->sensor.v_max;
			data_temp->val[0].thr.min = ctrl->sensor.v_min;			
		}
			break;
		case NEW_SUB_PKT_TYPE_TEMP:
		{
			data_temp = &sensor_get_data()->data[0];
			sensor_temp = &paras_get()->sensor.sens[0];
			data_temp->val[1].thr.en.th_sen_max_en = vmax ?  1 :  0;
			data_temp->val[1].thr.en.th_sen_min_en = vmin ?  1 :  0;
			sensor_temp->th_max_2 = vmax;
			sensor_temp->th_min_2 = vmin;
			data_temp->val[1].thr.max = ctrl->sensor.v_max;
			data_temp->val[1].thr.min = ctrl->sensor.v_min;
		}
			break;
		case NEW_SUB_PKT_TYPE_SMOKE:
		{
			data_temp = &sensor_get_data()->data[1];
			sensor_temp = &paras_get()->sensor.sens[1];
			data_temp->val[0].thr.en.th_sen_max_en = vmax ?  1 :  0;
			data_temp->val[0].thr.en.th_sen_min_en = vmin ?  1 :  0;
			
			sensor_temp->th_max_1 = vmax;
			sensor_temp->th_min_1 = vmin;
			data_temp->val[0].thr.max = ctrl->sensor.v_max;
			data_temp->val[0].thr.min = ctrl->sensor.v_min;		
		}
			break;
		case NEW_SUB_PKT_TYPE_CO2:
		{
			data_temp = &sensor_get_data()->data[2];
			sensor_temp = &paras_get()->sensor.sens[2];

			data_temp->val[0].thr.en.th_sen_max_en = vmax ?  1 :  0;
			data_temp->val[0].thr.en.th_sen_min_en = vmin ?  1 :  0;
			
			sensor_temp->th_max_1 = vmax;
			sensor_temp->th_min_1 = vmin;
			data_temp->val[0].thr.max = ctrl->sensor.v_max;
			data_temp->val[0].thr.min = ctrl->sensor.v_min;		
		}
		break;
		default:
			return;
	}
	paras_save();
}

static void send_net_config(web_handle_t *h, mg_conn_t *c)
{
	pkt_hdr_t *hdr=NULL;
	hdr = (pkt_hdr_t*)h->buf;
	hdr->magic = PKT_MAGIC;
  hdr->addr  = 0;
  hdr->type  = NEW_PKT_TYPE_NETWORK;
  hdr->nack  = 0;
	hdr->subtype = 0;	
	network_data_t *net = (network_data_t *)(&hdr->data);
	memset(net,0,sizeof(network_data_t));
	paras_data_t* para=paras_get();
	//*net = para->netwk;
	net_get_ip(net);
	hdr->dlen  = sizeof(network_data_t);
	uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
	ws_send(c, h->buf, xlen, 1);	
}

static void send_rs485_config(web_handle_t *h, mg_conn_t *c)
{
		pkt_hdr_t *hdr=NULL;
		hdr = (pkt_hdr_t*)h->buf;
		hdr->magic = PKT_MAGIC;
		hdr->addr  = 0;
		hdr->type  = NEW_PKT_TYPE_RS485;
		hdr->nack  = 0;
		hdr->subtype = 0;	
		modbus_data_t *md = (modbus_data_t *)(&hdr->data);
		memset(md,0,sizeof(modbus_data_t));
		paras_data_t* para=paras_get();
		*md = para->cas;
		hdr->dlen  = sizeof(modbus_data_t);
		uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
		ws_send(c, h->buf, xlen, 1);		
}

static void send_snmp_config(web_handle_t *h, mg_conn_t *c)
{
		pkt_hdr_t *hdr=NULL;
		hdr = (pkt_hdr_t*)h->buf;
		hdr->magic = PKT_MAGIC;
		hdr->addr  = 0;
		hdr->type  = NEW_PKT_TYPE_SNMP;
		hdr->nack  = 0;
		hdr->subtype = 0;	
		snmp_data_t *snmp = (snmp_data_t *)(&hdr->data);
		memset(snmp,0,sizeof(snmp_data_t));
		paras_data_t* para=paras_get();
		*snmp = para->snmp;
		hdr->dlen  = sizeof(snmp_data_t);
		uint32_t xlen = hdr->dlen + sizeof(pkt_hdr_t);
		ws_send(c, h->buf, xlen, 1);		
}

static void web_set_network(web_handle_t *h,mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	web_net_t *net = &ctrl->net;
	if(net->mode == 0 || net->mode == 1)
	{
		if(net->mode == 0)
		{
			if(sys_ip_check(net->dns1) && sys_ip_check(net->dns2));
			{
				net_ipaddr_set(net);
			}
		}else
		{
			if(sys_ip_check(net->dns1) 
					&& sys_ip_check(net->dns2) 
					&& sys_ip_check(net->gateway) 
					&& sys_ip_check(net->ipaddr)
					&& sys_ip_check(net->mask))
			{
				net_ipaddr_set(net);
			}
		}
	}
}


static void web_set_rs485(web_handle_t *h,mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	web_rs485_t *rs485 = &ctrl->rs485;
#if SUPPORT_CASCADE_QMODBUS
	cascade_reset_new(rs485->mode,rs485->addr,rs485->baud);
#endif
}

static void web_snmp_set(web_handle_t *h,mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	web_snmp_t *snmp= &ctrl->snmp;
	paras_data_t* para=paras_get();
	snmp_data_t *p_snmp = &para->snmp;
	int len1 = strlen(snmp->publics);
	int len2 = strlen(snmp->privates);
	if(snmp->trapmode == 1)
	{
		if(sys_ip_check(snmp->nms_ip))
		{
			if(len1>0 && len2 > 0)
			{
				*p_snmp = *snmp;
				paras_save();
				snmp_strap_set();
			}
		}
	}else
	{
		if(len1>0 && len2 > 0)
		{
			strcpy(p_snmp->publics,snmp->publics);
			strcpy(p_snmp->privates,snmp->privates);
			p_snmp->trapmode = snmp->trapmode;
			paras_save();
			snmp_strap_set();
		}
	}
}

static void web_set_ntp(web_handle_t *h,mg_conn_t *c,wed_set_t *ctrl)
{
	(void)h;
	(void)c;
	web_device_t *device= &ctrl->device;
	paras_data_t* para=paras_get();
	para->sys.tzone = device->zone;
	rt_tz_set(device->zone * 3600);
	int lenth = strlen(device->date_time);
	for(int i = 0; i < lenth;i++)
	{
			if(device->date_time[i] <'0' || device->date_time[i] > '9')
			{
				device->date_time[i]=' ';
			}
	}
	system(device->date_time);
	paras_save();
}
static void send_his_alarm(web_handle_t *h, mg_conn_t *c)
{
		pkt_hdr_t *hdr=NULL;
		hdr = (pkt_hdr_t*)h->buf;
		hdr->magic = PKT_MAGIC;
		hdr->addr  = 0;
		hdr->type  = NEW_PKT_TYPE_WANNING;
		hdr->nack  = 0;
		hdr->subtype = 0;	
		
		uint16_t *count = (uint16_t *)(&hdr->data[0]);	
		*count = wanning_get_count();
		waning_info_t *wanning = (waning_info_t *)(&hdr->data[2]);	
		wanning_get(wanning, count);
	
		hdr->dlen = (*count)*sizeof(waning_info_t)+2;
		
		uint32_t xlen = (*count)*sizeof(waning_info_t)+sizeof(pkt_hdr_t) + 2;
		ws_send(c, h->buf, xlen, 1);	
}

static int ws_handle_new(web_handle_t *h, pkt_hdr_t *hdr, mg_conn_t *c)
{
	  int r=0;
    
    if (!is_ws(c)) {
        return -1;
    }	
    if(hdr->magic!=PKT_MAGIC) {
        LOGE("___ magic: 0x%x is wrong!, correct is: 0x%x\n", hdr->magic, PKT_MAGIC);
        return -1;
    }
		wed_set_t *ctrl = (wed_set_t*)(hdr->data);
		switch(hdr->type) {
			case NEW_PKT_TYPE_DEVICE_INFO:
			{
				if(hdr->dlen == 0)
					send_sys(h,c);
				else
				{
					reboot_sys(h,c,ctrl);
				}
			}
			break;
			case NEW_PKT_TYPE_ELE_INFO:
			{
				switch (hdr->subtype)
				{
					case NEW_SUB_PKT_TYPE_ELE_DATA_ALL:
					{
						send_power_all(h,c);
					}
					break;
					case NEW_SUB_PKT_TYPE_ELE_DATA_INFO:
					{
						send_power_info(h,c);
					}
					break;
					case NEW_SUB_PKT_TYPE_ELE_DATA_L1:
					{
						send_power_data(h,c,NEW_SUB_PKT_TYPE_ELE_DATA_L1);
					}
					break;
					case NEW_SUB_PKT_TYPE_ELE_DATA_L2:
					{
						send_power_data(h,c,NEW_SUB_PKT_TYPE_ELE_DATA_L2);
					}
					break;
					case NEW_SUB_PKT_TYPE_ELE_DATA_L3:
					{
						send_power_data(h,c,NEW_SUB_PKT_TYPE_ELE_DATA_L3);
					}
					break;
					case NEW_SUB_PKT_TYPE_ELE_DATA_THR:
					{
						if(hdr->dlen == 0)
							send_power_thr(h,c);
						else
						{
							set_power_thr(h,c,ctrl);
						}
					}
					break;
					case NEW_SUB_PKT_TYPE_ELE_DELAY:
					{
						if(hdr->dlen > 0) {
							set_power_delay(h,c,ctrl);
						}						
					}	
					break;
					case NEW_SUB_PKT_TYPE_ELE_CTRL:
					{
						if(hdr->dlen > 0)	{
							set_power_ctrl(h,c,ctrl);
						}
					}	
					break;
					case NEW_SUB_PKT_TYPE_ELE_ALL_CTRL:
					{
						if(hdr->dlen > 0)	{
							set_power_all_ctrl(h,c,ctrl);
						}
					}
					break;
					case NEW_SUB_PKT_TYPE_ELE_CLEAR_CONSUMER:
					{
						if(hdr->dlen > 0)	{
							set_power_consum_clear(h,c,ctrl);
						}
					}
					break;
					case NEW_SUB_PKT_TYPE_ELE_BATCH:
					{
						if(hdr->dlen > 0)
						{
							set_power_batch_thr(h,c,ctrl);
						}
					}
					break;
					default:
						break;
				}
			}
			break;
			case NEW_PKT_TYPE_SENSOR:
			{
				if(hdr->dlen == 0)
				{
					send_sensor_info(h,c);
				}else
				{
					set_sensor_thr(h,c,hdr->subtype,ctrl);
				}
			}
			break;
			case NEW_PKT_TYPE_NETWORK:
			{
				if(hdr->dlen == 0)
				{
					send_net_config(h,c);
				}else
				{
					web_set_network(h,c,ctrl);
				}
			}
			break;
			case NEW_PKT_TYPE_RS485:
			{
				if(hdr->dlen == 0)
				{
					send_rs485_config(h,c);
				}else
				{
					web_set_rs485(h,c,ctrl);
				}
			}
			break;
			case NEW_PKT_TYPE_SNMP:
			{
				if(hdr->dlen == 0)
				{
					send_snmp_config(h,c);
				}else
				{
					web_snmp_set(h,c,ctrl);
				}				
			}
			break;
			case NEW_PKT_TYPE_NTP:
			{
				web_set_ntp(h,c,ctrl);
			}
			break;
			case NEW_PKT_TYPE_WANNING:
			{
				if(hdr->dlen == 0)
				{
					send_his_alarm(h,c);
				}else
				{
					switch(hdr->subtype)
					{
						case NEW_SUB_PKT_TYPE_WANNING_CLEAN:
							wanning_clean();
						break;
						case NEW_SUB_PKT_TYPE_WANNING_SOUND_LIGHT_CLEAN:
						{
							led_reset();
							beep_reset();
						}
						break;
					}
				}
			}
			break;
			case MEW_PKT_TYPE_LOGIN:
			{
				send_login_func(h,c,ctrl);
			}
			break;
			case NEW_PKT_TYPE_USER:
			{
				if(hdr->dlen == 0)
				{
					send_user_info(h,c);
				}else
				{		
					switch(hdr->subtype)
					{
						case NEW_SUB_PKT_TYPE_USER_ADD:
						{
							send_add_user_func(h,c,ctrl);
						}
							break;
						case NEW_SUB_PKT_TYPE_USER_UPDATE:
						{
							send_user_update_func(h,c,ctrl);
						}
							break;
						case NEW_SUB_PKT_TYPE_USER_DELETE:
						{
							send_user_delete_func(h,c,ctrl);
						}
							break;
						default:
							break;
					}
				}
			}
			break;
			default:
				break;
		}
		return 0;
}

static void http_fn(mg_conn_t *c, int ev, void *ev_data)
{
    int r,flag=0;
    web_handle_t *h=&webHandle;
	  mg_stream_t s={c,ev,ev_data};
//		LOGD("connect --------%lx\n",c);

#ifdef USE_MG716
    if (ev == MG_EV_HTTP_MSG) {
        struct mg_http_message *hm = (struct mg_http_message *) ev_data;

        for(int i=0; i<h->cnt; i++) {
            if (h->fn[i].f && h->fn[i].uri && mg_match(hm->uri, mg_str(h->fn[i].uri), NULL)) {
                h->fn[i].f(&s); flag = 1; break;
            }
        }				
				if(flag == 0)
				{
					if (mg_match(hm->uri, mg_str("/ws"), NULL)) {
							mg_ws_upgrade(c, hm, NULL);
					} else if (mg_match(hm->uri, mg_str("/rest"), NULL)) {
							// Serve REST response
							mg_http_reply(c, 200, "", "{\"result\": %d}\n", 123);
					} else {
							struct mg_http_serve_opts opts = {.root_dir = h->rootDir};
							mg_http_serve_dir(c, hm, &opts);
					}
				}
    }
    else if(ev == MG_EV_ACCEPT) {
        if (c->fn_data) {
            mg_tls_init(c, &h->tls);
        }
//        paras_data_t *p=paras_get();
//        ws_send_pkt(h, c, 0, PKT_TYPE_PARAS, p, sizeof(paras_data_t), 1);
    }
    else if(ev == MG_EV_WS_MSG) {
        struct mg_ws_message *wm = (struct mg_ws_message *) ev_data;
        pkt_hdr_t *hdr=(pkt_hdr_t*)wm->data.buf;
        ws_handle_new(h, hdr, c);
    }else if(ev == MG_EV_CLOSE)
		{
			//mg_close_conn(c);
		}
#else
    if (ev == MG_EV_HTTP_REQUEST) {
        mg_serve_http(c, (struct http_message *)ev_data, h->opts);
    }
    else if(ev == MG_EV_WEBSOCKET_HANDSHAKE_DONE) {
        paras_data_t *p=paras_get();
        ws_send_pkt(h, c, 0, PKT_TYPE_PARAS, p, sizeof(paras_data_t), 1);
        set_timer(c, TIMER_INTERVAL);
    }
    else if(ev == MG_EV_WEBSOCKET_FRAME) {
        struct websocket_message *wm = (struct websocket_message *) ev_data;
        pkt_hdr_t *hdr=(pkt_hdr_t*)wm->data;
        ws_handle(h, hdr, c);
    }
    else if(ev==MG_EV_TIMER) {
				
    }
#endif
}





static  char ack_str[2048] = {0};

static void overChannelStatusMonitoring(void* conn)
{
	cJSON *cjson=NULL;
	channel_power_request req = {0};
	memset(ack_str,0,sizeof(ack_str));
	mg_stream_t *s=(mg_stream_t*)conn;
  struct mg_http_message *hm=s->ev_data;
	char *rx_body_buf=(char*)hm->body.buf;
  char *rx_Head_buf = (char*)hm->head.buf;
	power_handle_new_t *p_handle = power_get_all();
	wed_set_t ctrl = {0};
	cjson = json_to_chn_pwr_status_monitor(rx_body_buf,&req);
	if(cjson == NULL)
		return;
	if(strcmp(req.type,"chnInfo")==0)
	{
		if(req.pro_ch_id > 0)
		{
			uint8_t channle = req.pro_ch_id - 1;
			if(channle > p_handle->chs)
				return;
			power_ch_new_t *pch = &p_handle->pch[channle];
			int ph = 0;
			if(p_handle->product->type == PDU_AC_I3O1_H || p_handle->product->type == PDU_AC_I3O1)
			{
				ph=pch->info.pse.ph-1;
				uint8_t wanning = 0;
				uint32_t ph_all_wanning =  *(uint32_t*) (&pch->info.alarm);
				wanning = (ph_all_wanning >> (ph*8)) & 0XFF;    //get phse wanning
				wanning_type_t wan = *(wanning_type_t *)(&wanning);
				sprintf(ack_str,CHANNEL_SINGLE_RES_TYPE,pch->info.name,req.pro_ch_id,pch->power[ph].voltage,
																							pch->power[ph].current,pch->power[ph].power,
																							pch->power[ph].app_power,pch->power[ph].freq,
																							pch->power[ph].factor,pch->power[ph].consump,
																							pch->thr.v_upper,pch->thr.v_lower,
																							pch->thr.c_upper,pch->thr.p_upper,
																							pch->thr.w_upper,
																							pch->info.open_delay,pch->info.close_delay,pch->info.status,
																							wan.v_upper,wan.v_lower,wan.c_upper,wan.p_upper,wan.w_upper,
																							g_product_t_ac_type_str[ph]);
			}else 
			{
				sprintf(ack_str,CHANNEL_SINGLE_RES_TYPE,pch->info.name,req.pro_ch_id,pch->power[0].voltage,
																							pch->power[0].current,pch->power[0].power,
																							pch->power[0].app_power,pch->power[0].freq,
																							pch->power[0].factor,pch->power[0].consump,
																							pch->thr.v_upper,pch->thr.v_lower,
																							pch->thr.c_upper,pch->thr.p_upper,
																							pch->thr.w_upper,
																							pch->info.open_delay,pch->info.close_delay,
																							pch->info.status,
																							pch->info.alarm.l1_v_upper,
																							pch->info.alarm.l1_v_lower,pch->info.alarm.l1_c_upper,
																							pch->info.alarm.l1_p_upper,pch->info.alarm.l1_w_upper,				
				"");
			}
		}
	}else if(strcmp(req.type,"chnWanInfo")==0)
	{
		//CHANEL_WANNING_INFO_TYPE
		if(req.pro_ch_id > 0)
		{
			uint8_t channle = req.pro_ch_id - 1;
			if(channle > p_handle->chs)
				return;
			power_ch_new_t *pch = &p_handle->pch[channle];
			int ph = 0;
			if(p_handle->product->type == PDU_AC_I3O1_H || p_handle->product->type == PDU_AC_I3O1)
			{
				uint8_t wanning = 0;
				uint32_t ph_all_wanning =  *(uint32_t*) (&pch->info.alarm);
				ph=pch->info.pse.ph-1;
				wanning = (ph_all_wanning >> (ph*8)) & 0XFF;    //get phse wanning
				wanning_type_t wan = *(wanning_type_t *)(&wanning);
				sprintf(ack_str,CHANEL_WANNING_INFO_TYPE,pch->info.name,req.pro_ch_id,
										wan.v_upper,wan.v_lower,wan.c_upper,wan.p_upper,wan.w_upper,g_product_t_ac_type_str[ph]);
				
			}else
			{
				sprintf(ack_str,CHANEL_WANNING_INFO_TYPE,pch->info.name,req.pro_ch_id,pch->info.alarm.l1_v_upper,
																							pch->info.alarm.l1_v_lower,pch->info.alarm.l1_c_upper,
																							pch->info.alarm.l1_p_upper,pch->info.alarm.l1_w_upper,"");
			}
		}
	}
	else if(strcmp(req.type,"open")==0 || strcmp(req.type,"close")==0)
	{
		ctrl.cnt_ctrl.status = strcmp(req.type,"open")==0 ? 1 : 0;
		ctrl.cnt_ctrl.chn = req.pro_ch_id - 1;
		set_power_ctrl(NULL,NULL,&ctrl);
		sprintf(ack_str,SUCESS_RSP);
	}else if(strcmp(req.type,"setInterval")==0)
	{
		ctrl.delay.open = req.open;
		ctrl.delay.close = req.close;
		ctrl.delay.chn = req.pro_ch_id -1;
		set_power_delay(NULL,NULL,&ctrl);
		sprintf(ack_str,SUCESS_RSP);
	}else if(strcmp(req.type,"setThreshold")==0)
	{
		ctrl.thr.chn = req.pro_ch_id - 1;
		power_ch_new_t *pch = &p_handle->pch[ctrl.thr.chn];
		ctrl.thr.thr = pch->thr;
		ctrl.thr.thr.v_upper = req.v_max;
		ctrl.thr.thr.v_lower = req.v_min;
		ctrl.thr.thr.c_upper = req.i_max;
		ctrl.thr.thr.p_upper = req.p_max;
		ctrl.thr.thr.w_upper = req.w_max;
		set_power_thr(NULL,NULL,&ctrl);
		sprintf(ack_str,SUCESS_RSP);
	}else if(strcmp(req.type,"clearConsumer")==0)
	{
		ctrl.clear.chn = req.pro_ch_id - 1;
		set_power_consum_clear(NULL,NULL,&ctrl);
		sprintf(ack_str,SUCESS_RSP);
	}
	cJSON_Delete(cjson);
	http_reply(conn, 200, ack_str);
}


static void overallStatusMonitoring(void* conn)
{
	cJSON *cjson=NULL;
	all_power_request req = {0};
	memset(ack_str,0,sizeof(ack_str));
	mg_stream_t *s=(mg_stream_t*)conn;
  struct mg_http_message *hm=s->ev_data;
	char *rx_body_buf=(char*)hm->body.buf;
  char *rx_Head_buf = (char*)hm->head.buf;
	wed_set_t ctrl = {0};
	power_handle_new_t *p_handle = power_get_all();
	cjson = json_to_all_pwr_status_monitor(rx_body_buf,&req);	
	if(cjson == NULL)
		return;
	if(strcmp(req.type,"allInfo")==0)
	{
		if(req.ph_id== 0)
		{
			sprintf(ack_str,ALL_INFO_RES_TYPE,req.ph_id,p_handle->total.all.voltage,
																									p_handle->total.all.current,
																									p_handle->total.all.power,
																									p_handle->total.all.app_power,
																									p_handle->total.all.factor,
																									p_handle->total.all.consump,
																								  "ALL");
		}else
		{
			 sprintf(ack_str,ALL_INFO_RES_TYPE,req.ph_id,p_handle->total.all_l[req.ph_id-1].voltage,
																									p_handle->total.all_l[req.ph_id-1].current,
																									p_handle->total.all_l[req.ph_id-1].power,
																									p_handle->total.all_l[req.ph_id-1].app_power,
																									p_handle->total.all_l[req.ph_id-1].factor,
																									p_handle->total.all_l[req.ph_id-1].consump,
																								  g_product_t_ac_type_str[req.ph_id-1]);
		}
	}else if(strcmp(req.type,"open")==0 || strcmp(req.type,"close")==0)
	{
		int status = strcmp(req.type,"open")==0 ? 1 : 0;
		p_handle->set_all_status(status);
		sprintf(ack_str,SUCESS_RSP);
	}else if(strcmp(req.type,"setBatchThreshold")==0)
	{
			*(uint16_t*)(&ctrl.thr.thr.en) = 0xFFFF;
			ctrl.thr.thr.v_upper = req.v_max;
			ctrl.thr.thr.v_lower = req.v_min;
			ctrl.thr.thr.c_upper = req.i_max;
			ctrl.thr.thr.p_upper = req.p_max;
			ctrl.thr.thr.w_upper = req.w_max;
			set_power_batch_thr(NULL,NULL,&ctrl);
			sprintf(ack_str,SUCESS_RSP);
	}
	cJSON_Delete(cjson);
	http_reply(conn, 200, ack_str);
}


static void sensorStatusMonitoring(void* conn)
{
	cJSON *cjson=NULL;
	sensor_request req = {0};
	memset(ack_str,0,sizeof(ack_str));
	mg_stream_t *s=(mg_stream_t*)conn;
  struct mg_http_message *hm=s->ev_data;
	char *rx_body_buf=(char*)hm->body.buf;
	sensor_all_t *sensor = sensor_get_data();
	wed_set_t ctrl = {0};
	cjson = json_to_sensor_status_monitor(rx_body_buf,&req);
	if(cjson == NULL)
		return;
	//SENSOR_INFO_RES_TYPE
	if(strcmp(req.type,"sensorInfo")==0)
	{
		switch(req.sensor_id)
		{
			case NEW_SUB_PKT_TYPE_HUMI:
			{
				sprintf(ack_str,SENSOR_INFO_RES_TYPE,req.sensor_id,
										"Humidity",sensor->data[0].val[0].value,
										sensor->data[0].val[0].thr.max,sensor->data[0].val[0].thr.min,
										sensor->data[0].val[0].s_alarm.max_up,sensor->data[0].val[0].s_alarm.min_down,
										sensor->data[0].info.status);
			}
				break;
			case NEW_SUB_PKT_TYPE_TEMP:
			{
				sprintf(ack_str,SENSOR_INFO_RES_TYPE,req.sensor_id,
										"Temperature",sensor->data[0].val[1].value,
										sensor->data[0].val[1].thr.max,sensor->data[0].val[1].thr.min,
										sensor->data[0].val[1].s_alarm.max_up,sensor->data[0].val[1].s_alarm.min_down,
										sensor->data[0].info.status);
			}
				break;
			case NEW_SUB_PKT_TYPE_SMOKE:
			{
				sprintf(ack_str,SENSOR_INFO_RES_TYPE,req.sensor_id,
										"Smoke",sensor->data[1].val[0].value,
										sensor->data[1].val[0].thr.max,sensor->data[1].val[0].thr.min,
										sensor->data[1].val[0].s_alarm.max_up,sensor->data[1].val[0].s_alarm.min_down,
										sensor->data[1].info.status);
			}
				break;
			case NEW_SUB_PKT_TYPE_CO2:
			{
				sprintf(ack_str,SENSOR_INFO_RES_TYPE,req.sensor_id,
										"CO2",sensor->data[2].val[0].value,
										sensor->data[2].val[0].thr.max,sensor->data[2].val[0].thr.min,
										sensor->data[2].val[0].s_alarm.max_up,sensor->data[2].val[0].s_alarm.min_down,
										sensor->data[2].info.status);
			}
				break;
			default:
				break;
		}
	}else if(strcmp(req.type,"sensorSet")==0)
	{
		switch(req.sensor_id)
		{
			case  NEW_SUB_PKT_TYPE_HUMI:
		  case  NEW_SUB_PKT_TYPE_TEMP:
			case  NEW_SUB_PKT_TYPE_SMOKE:
			case  NEW_SUB_PKT_TYPE_CO2:
			{
				ctrl.sensor.v_max = req.s_max;
				ctrl.sensor.v_min = req.s_min;
				set_sensor_thr(NULL,NULL,req.sensor_id,&ctrl);
				sprintf(ack_str,SUCESS_RSP);
			}
			break;
		}
	}
	cJSON_Delete(cjson);
	http_reply(conn, 200, ack_str);
}




static int webSetCallback(void)
{
  httpAddCallback("/pdu/channelStatusMonitoring", overChannelStatusMonitoring);
	httpAddCallback("/pdu/overallStatusMonitoring", overallStatusMonitoring);
  httpAddCallback("/pdu/sensorStatusMonitoring", sensorStatusMonitoring);
//  httpAddCallback("/pdu/alarmProtect", alarmProtect);
//	httpAddCallback("/pdu/alarmProtect", equipmentMintenance);

  return 0;
}




static void web_thread(void *arg)
{
    mg_conn_t *nc;
    const char *http_addr="http://[::]:80";
    const char *https_addr="https://[::]:443";
    thread_handle_t *th=(thread_handle_t*)arg;
    web_handle_t *h=(web_handle_t*)th->attr->arg;

    strcpy(h->rootDir, "/nor/web");
#ifdef USE_MG716
    mg_log_set(MG_LL_ERROR);
    mg_mgr_init(&h->mgr);

    //mg_timer_add(&h->mgr, TIMER_INTERVAL, MG_TIMER_REPEAT, timer_fn, h);
    if (mg_http_listen(&h->mgr, http_addr, http_fn, NULL) == NULL) {
        MG_ERROR(("cannot listen on %s\n", http_addr));
    }

#else
    mg_mgr_init(&h->mgr, NULL);
    nc = mg_bind(&h->mgr, "80", http_fn);
		
    strcpy(h->rootDir, "/nor/web");
    
    mg_set_protocol_http_websocket(nc);
    h->opts.document_root = h->rootDir;
    h->opts.enable_directory_listing = "yes";
#endif

		webSetCallback();
		
    while(th->quit==0) {
        mg_mgr_poll(&h->mgr, 50);
    }
    mg_mgr_free(&h->mgr);
}


int web_init(void)
{
    list_cfg_t lc={0,0,10};
    web_handle_t *h=&webHandle;
    
    memset(h, 0, sizeof(web_handle_t));
    h->list = list_init(&lc);
    
    h->buflen = sizeof(pkt_hdr_t)+sizeof(power_ch_t)*ONCE_SEND_CNT+8;
    h->buf = (char*)malloc(h->buflen);
    
    thread_start(THREAD_ID_WEB, web_thread, h);
    return 0;
}



int web_post(int type, void *data, int len)
{
    struct mg_connection *c;
    web_handle_t *h=&webHandle;
    
    return list_append(h->list, type, data, len);
}