#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"

#define TIMER_INTERVAL      1000
#define ONCE_SEND_CNT       13


#define USE_MG716
typedef struct mg_mgr mg_mgr_t;

#ifdef USE_MG716
typedef struct mg_tls_opts mg_tls_t;
#endif
typedef struct {
    pthread_t       tid;
    
    mg_mgr_t        mgr;
#ifdef USE_MG716
    mg_tls_t        tls;
#else
    mg_opts_t       opts;
#endif
    
    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 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_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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	sensor_data_t *data_temp = NULL;
	sensor_th_t *sensor_temp = NULL;
	uint32_t vmax = ctrl->sensor.v_max *100;
	uint32_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;
	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)
{
	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)
{
	web_rs485_t *rs485 = &ctrl->rs485;
	cascade_reset_new(rs485->mode,rs485->addr,rs485->baud);
}

static void web_snmp_set(web_handle_t *h,mg_conn_t *c,wed_set_t *ctrl)
{
	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)
{
	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;
			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;
//		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;
        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 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");
		//cs_log_set_level(3);
#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));
    }

    //if (mg_http_listen(&h->mgr, https_addr, http_fn, (void*)1) == NULL) {
    //    MG_ERROR(("cannot listen on %s\n", https_addr));
    //}
    
    //mh->tls.cert = mg_str(file_load2("/root/run/app/cert/server.crt",0));
    //mh->tls.key = mg_str(file_load2("/root/run/app/cert/server.key",0));
    //mh->tls.name = mg_url_host(https_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
		//mg_set_timer(nc,500);
		//mg_timer_add(&h->mgr, 500, MG_TIMER_REPEAT, timer_fn, h);
		
		
    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);
}