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

#define TIMER_INTERVAL      1000
#define ONCE_SEND_CNT       13


//#define USE_MG716


typedef struct mg_mgr mg_mgr_t;
typedef struct mg_connection mg_conn_t;

#ifdef USE_MG716
typedef struct mg_tls_opts mg_tls_t;
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;

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;
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 int ws_send_pkt(web_handle_t *h, mg_conn_t *c, uint8_t addr, uint8_t type, void *data, int len, int isbin)
{
    pkt_hdr_t *hdr=NULL;
    
    if(!h->buf || !len || h->buflen<sizeof(pkt_hdr_t)+len) {
        LOGE("____ws_send, para are invalid\n");
        return -1;
    }
    hdr = (pkt_hdr_t*)h->buf;
    
    hdr->magic = PKT_MAGIC;
    hdr->addr  = addr;
    hdr->type  = type;
    hdr->nack  = 0;
    hdr->dlen  = len;
    memcpy(hdr->data, data, len);

    ws_send(c, hdr, len+sizeof(pkt_hdr_t), isbin);
    
    return 0;
}

static void send_powerc(web_handle_t *h, mg_conn_t *c, uint8_t addr)
{
    int i=0,j,xlen,offset,times,left;
    pkt_hdr_t *hdr=NULL;
    power_all_t all;
    
    if(addr==0) {
        power_data_get(&all);
    }
    else {
        cascade_power_get(&all);
    }
    
    if(all.chs==0 || h->buf==NULL ) {
        return;
    }
    hdr = (pkt_hdr_t*)h->buf;
    
    hdr->magic = PKT_MAGIC;
    hdr->addr  = addr;
    hdr->type  = PKT_TYPE_POWER_CH;
    hdr->nack  = 0;
		int count = all.chs;
		int bag = 0;
		

#if 1  
	
		do{
			bag ++;
			if(count <= ONCE_SEND_CNT)
			{
				for(j=0;j<count;j++)
				{
					offset = j*sizeof(power_ch_t);
					memcpy(hdr->data+offset, &all.pch[i*ONCE_SEND_CNT+j],sizeof(power_ch_t));
					hdr->flag = (-1);
				}
				xlen = sizeof(power_ch_t) * count + sizeof(pkt_hdr_t);
				hdr->dlen  = xlen-sizeof(pkt_hdr_t);
				i += count;
				count -= count;
			}else
			{
				for(j=0;j<ONCE_SEND_CNT;j++)
				{
					offset = j*sizeof(power_ch_t);
					memcpy(hdr->data+offset, &all.pch[i*ONCE_SEND_CNT+j],sizeof(power_ch_t));
				}
				xlen = sizeof(power_ch_t) * ONCE_SEND_CNT + sizeof(pkt_hdr_t);
				hdr->dlen  = xlen-sizeof(pkt_hdr_t);
				count -= ONCE_SEND_CNT;
				hdr->flag = bag;
				i += ONCE_SEND_CNT;
			}
			

			ws_send(c, h->buf, xlen, 1);
		}while(count > 0);
		
#endif
}
static void send_powert(web_handle_t *h, mg_conn_t *c, uint8_t addr)
{
    int i,r;
    power_all_t all;
    
    if(addr==0) {
        power_data_get(&all);
    }
    else {
        cascade_power_get(&all);
    }
    ws_send_pkt(h, c, addr, PKT_TYPE_POWER_TOTAL, &all.ttl, sizeof(power_total_t), 1);
}
static void send_sensor(web_handle_t *h, mg_conn_t *c, uint8_t addr)
{
    int i,j,xlen,offset,times,left;
    pkt_hdr_t *hdr=NULL;
    sensor_all_t all;
    
    sensor_data_get(&all);
    if(all.cnt==0 || h->buf==NULL ) {
        return;
    }
    hdr = (pkt_hdr_t*)h->buf;
    
    hdr->magic = PKT_MAGIC;
    hdr->addr  = addr;
    hdr->type  = PKT_TYPE_SENSOR;
    hdr->nack  = 0;
    
    times = all.cnt/ONCE_SEND_CNT;
    for(i=0; i<times; i++) {
        for(j=0; j<ONCE_SEND_CNT; j++) {
            offset = j*sizeof(sensor_data_t);
            memcpy(hdr->data+offset, &all.data[i*ONCE_SEND_CNT+j], sizeof(sensor_data_t));
        }
        xlen = ONCE_SEND_CNT*sizeof(sensor_data_t)+sizeof(pkt_hdr_t);
        hdr->dlen  = xlen-sizeof(pkt_hdr_t);
        ws_send(c, h->buf, xlen, 1);
    }
    
    left = all.cnt%ONCE_SEND_CNT;
    for(i=0; i<left; i++) {
        offset = i*sizeof(sensor_data_t);
        memcpy(hdr->data+offset, &all.data[all.cnt-left+i], sizeof(sensor_data_t));
    }
    xlen = (all.cnt%ONCE_SEND_CNT)*sizeof(breaker_data_t)+sizeof(pkt_hdr_t);
    hdr->dlen  = xlen-sizeof(pkt_hdr_t);
    ws_send(c, h->buf, xlen, 1);
    sensor_data_free(&all);
}
static void send_breaker(web_handle_t *h, mg_conn_t *c, uint8_t addr)
{
    int i,j,xlen,offset,times,left;
    pkt_hdr_t *hdr=NULL;
    breaker_all_t all;
    
    breaker_data_get(&all);
    if(all.cnt==0 || h->buf==NULL ) {
        return;
    }
    hdr = (pkt_hdr_t*)h->buf;
    
    hdr->magic = PKT_MAGIC;
    hdr->addr  = addr;
    hdr->type  = PKT_TYPE_SENSOR;
    hdr->nack  = 0;
    
    times = all.cnt/ONCE_SEND_CNT;
    for(i=0; i<times; i++) {
        for(j=0; j<ONCE_SEND_CNT; j++) {
            offset = j*sizeof(breaker_data_t);
            memcpy(hdr->data+offset, &all.data[i*ONCE_SEND_CNT+j], sizeof(breaker_data_t));
        }
        xlen = ONCE_SEND_CNT*sizeof(breaker_data_t)+sizeof(pkt_hdr_t);
        hdr->dlen  = xlen-sizeof(pkt_hdr_t);
        ws_send(c, h->buf, xlen, 1);
    }
    
    left = all.cnt%ONCE_SEND_CNT;
    for(i=0; i<left; i++) {
        offset = i*sizeof(breaker_data_t);
        memcpy(hdr->data+offset, &all.data[all.cnt-left+i], sizeof(breaker_data_t));
    }
    xlen = (all.cnt%ONCE_SEND_CNT)*sizeof(breaker_data_t)+sizeof(pkt_hdr_t);
    hdr->dlen  = xlen-sizeof(pkt_hdr_t);
    ws_send(c, h->buf, xlen, 1);
    
    breaker_data_free(&all);
}

static void send_net(web_handle_t *h, mg_conn_t *c)
{
	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  = PKT_TYPE_PARAS;
  hdr->nack  = 0;
	hdr->subtype = SUB_TYPE_PARAS_NETWORK;	

	network_data_t data = {0};
	
	data = para->netwk;
	hdr->dlen  = sizeof(network_data_t);
	memcpy(hdr->data,&data,hdr->dlen);
	
	uint32_t xlen = sizeof(pkt_hdr_t) + sizeof(network_data_t);
	ws_send(c, h->buf, xlen, 1);
	//ws_send(c, h->buf, hdr->dlen, 1);	
}


static void send_misc(web_handle_t *h, mg_conn_t *c)
{
	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  = PKT_TYPE_PARAS;
  hdr->nack  = 0;
	hdr->subtype = SUB_TYPE_PARAS_MISC;	
	
	
	misc_data_t data = {0};
	
	data = para->misc;
	hdr->dlen  = sizeof(misc_data_t);
	
	
	ws_send(c, h->buf, hdr->dlen, 1);
	
}


static void send_smnp(web_handle_t *h, mg_conn_t *c)
{
	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  = PKT_TYPE_PARAS;
  hdr->nack  = 0;
	hdr->subtype = SUB_TYPE_PARAS_SNMP;	
	hdr->flag = 0;
	hdr->dlen = 0;
	
	snmp_data_t data = {0};
	
	
	data = para->snmp;
	hdr->dlen  = sizeof(snmp_data_t);
	memcpy(hdr->data,&data,hdr->dlen);
	uint32_t xlen = sizeof(pkt_hdr_t) + sizeof(snmp_data_t);
	ws_send(c, h->buf, xlen, 1);
}

static void send_modbus(web_handle_t *h, mg_conn_t *c)
{
	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  = PKT_TYPE_PARAS;
  hdr->nack  = 0;
	hdr->subtype = SUB_TYPE_PARAS_MODBUS;	
	hdr->flag = 0;
	hdr->dlen = 0;
	
	modbus_data_t data = {0};
	
	data = para->cas;
	hdr->dlen  = sizeof(modbus_data_t);
	memcpy(hdr->data,&data,hdr->dlen);
	uint32_t xlen = sizeof(pkt_hdr_t) + sizeof(modbus_data_t);
	ws_send(c, h->buf, xlen, 1);
}


static void sendntp(web_handle_t *h, mg_conn_t *c)
{
	time_t t=time(NULL);
  struct tm *tm=localtime(&t);
	char date[40] = {0};
	char _time[40] = {0};
	snprintf(date, 40, "%04d%/%02d/%02d", (tm->tm_year+1900), tm->tm_mon+1, tm->tm_mday);
	snprintf(_time, 40, "%04d%:%02d:%02d", tm->tm_hour, tm->tm_min, tm->tm_sec);
	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  = PKT_TYPE_PARAS;
  hdr->nack  = 0;
	hdr->subtype = SUB_TYPE_PARAS_NTP;
	
	system_data_t data = {0};
	data.lang = para->sys.lang;
	data.tzone = para->sys.tzone;
	sprintf(data.sys_time,"%s %s",date,_time);
	
	memcpy(hdr->data, &data, sizeof(system_data_t));
	hdr->dlen  = sizeof(system_data_t);
	ws_send(c, h->buf, hdr->dlen, 1);
}

static void send_dlist(web_handle_t *h, mg_conn_t *c)
{
    int i,j=0,r;
    dev_list_t dl;
    slave_list_t sl;
    
    r = cascade_get_dlist(&dl);
    if(r==0) {
        sl.cnt = dl.cnt-1;
        if(sl.cnt>0) {
            for(i=1; i<dl.cnt; i++) {
                sl.addr[j++] = dl.slave[i].addr;
            }
            ws_send_pkt(h, c, 0, PKT_TYPE_POWER_TOTAL, &sl, 1+sl.cnt, 1);
        }
        cascade_free_dlist(&dl);
    } 
}


static int ws_handle(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;
    }
    
    if(hdr->addr>0 && h->cur_addr!=hdr->addr) {
        //paras_data_t *p=paras_get();
        //cascade_reinit();
    }
    
    //LOGD("_____ ws handle, type: %d, flag: %d\n", hdr->type, hdr->flag);
    switch(hdr->type) {
        case PKT_TYPE_PARAS:
        {
            int flag=0;
            paras_data_t* para=paras_get();
            switch(hdr->subtype) {
                
                case SUB_TYPE_PARAS_SYS:
                {
									if(hdr->dlen>0) {
                    system_data_t *sys=(system_data_t*)hdr->data;
                    if(sys->lang<LANG_ID_MAX && sys->lang!=para->sys.lang) {
                        para->sys.lang = sys->lang;
                    }
                    if(sys->tzone<LANG_ID_MAX && sys->tzone!=para->sys.tzone) {
                        para->sys.tzone = sys->tzone;
                        rt_tz_set(para->sys.tzone*3600);
                    }
										char str[32] = {0};
										int lenth = strlen(sys->sys_time);
										for(int i = 0; i < lenth;i++)
										{
											if(sys->sys_time[i] <'0' || sys->sys_time[i] > '9')
											{
												sys->sys_time[i]=' ';
											}
										}
										sprintf(str,"date %s",sys->sys_time);
                    system(str);
										
                    if(flag) {
                        paras_save();
                    }
									}else
									{
										sendntp(h, c);
									}
                }
                break;
                
                case SUB_TYPE_PARAS_MODBUS:
                {
									if(hdr->dlen>0) {
                    modbus_data_t *p=(modbus_data_t*)hdr->data;
//                    cascade_reinit(p->mode, p->addr, p->baud);
                    para->cas = *p;
//                    paras_save();
									cascade_reset(p->mode,p->addr);
									}else
									{
										send_modbus(h, c);
									}
                }
                break;
                
                case SUB_TYPE_PARAS_MISC:
                {
									if(hdr->dlen>0) {
                    misc_data_t *p=(misc_data_t*)hdr->data;
                    
                    if(p->rotate!=para->misc.rotate) {
                        lcd_rotate(p->rotate);
                    }
                    
                    para->misc = *p;
                    paras_save();
									}else
									{
										send_misc(h, c);
									}
                }
                break;
                
                case SUB_TYPE_PARAS_PROD:
                {
									if(hdr->dlen>0) {
                    //product_data_t *p=(product_data_t*)hdr->data;
									}else
									{
										
									}
                }
                break;
                
                case SUB_TYPE_PARAS_SERV:
                {
									if(hdr->dlen>0) {
									}else
									{
									}
                  //  service_data_t *p=(service_data_t*)hdr->data;
                }
                break;
                
                case SUB_TYPE_PARAS_NETWORK:
                {
									if(hdr->dlen>0) {
										
                    network_data_t *p=(network_data_t*)hdr->data;
										paras_data_t *para = paras_get();
										net_ipaddr_set(p);
										para->netwk = *p;
										paras_save();
									}else
									{
										send_net(h, c);
									}
//                    extern void set_dns(uint8_t dns_num, char* dns_server);
//                    extern void set_if(char* netif_name, char* ip_addr, char* gw_addr, char* nm_addr);
//                    set_if("e0", p->ipaddr, p->gateway, p->mask);
//                    set_dns(0, p->dns1); 
//									  set_dns(1, p->dns2);
										
                }
                break;
								case SUB_TYPE_PARAS_SNMP:
								{
									
									if(hdr->dlen>0) {
										snmp_data_t *p=(snmp_data_t*)hdr->data;
										
										paras_data_t *para = paras_get();
										strcpy(para->snmp.publics,p->publics);
										strcpy(para->snmp.nms_ip,p->nms_ip);
										//para->snmp = *p;
										snmp_strap_set();
										paras_save();
									}else
									{
										send_smnp(h, c);
									}
									
								}
								break;
                
            }
        }
        break;
        
        case PKT_TYPE_POWER_CH:
        {
            if(hdr->dlen>0) {
                power_ch_t *pch=(power_ch_t*)hdr->data;
                switch(hdr->subtype) {
                    case SUB_TYPE_POWER_SWITCH:
                    {
                        if(hdr->addr==0) {
                            //r = power_set_ch_sw(pch->info.ch, pch->power[0].status);
														power_set_ch_sw_n(pch);
                        }
                        else {
                            
                        }
                    }
                    break;
                    
                    case SUB_TYPE_POWER_ALARM:
                    {
                        if(hdr->addr==0) {
                            r = power_set_alarm(pch);
                        }
                        else {
                            
                        }
                    }
                    break;
                    
                    case SUB_TYPE_POWER_THRESHOLD:
                    {
                        if(hdr->addr==0) {
                            r = power_set_threshold(pch);
                        }
                    }
                    break;
                    
                    case SUB_TYPE_POWER_OPEN_DELAY:
                    {
                        if(hdr->addr==0) {
                            r = power_set_open_delay(pch);
                        }
                        else {
                            
                        }
                    }
                    break;
                    
                    case SUB_TYPE_POWER_CLOSE_DELAY:
                    {
                        if(hdr->addr==0) {
                            r = power_set_close_delay(pch);
                        }
                        else {
                            
                        }
                    }
                    break;
										case SUB_TYPE_POWER_CONSUMER_CLEAR:
										{
                        if(hdr->addr==0) {
                            r = power_set_clear_consumer(pch);
                        }
                        else {
                            
                        }											
										}
                }
            }
            else {
                send_powerc(h, c, hdr->addr);
            }
        }
        break;
        
        case PKT_TYPE_POWER_TOTAL:
        {
            LOGD("_____ send_powert\n");
            send_powert(h, c, hdr->addr);
        }
        break;
        
        case PKT_TYPE_CH_ALL:
        {
            if(hdr->addr==0) {
                power_set_all_sw(hdr->flag);
            }
            else {
                
            }
        }
        break;
        
        case PKT_TYPE_POWER_RESET:
        {
            if(hdr->addr==0) {
                r = power_reset();
            }
            else {
                
            }
        }
        break;
        
        case PKT_TYPE_SCAN:
        {
            if(hdr->addr==0) {
                r = power_scan();
            }
            else {
                
            }
        }
        break;
        
        case PKT_TYPE_FACTORY:
        {
            if(hdr->addr==0) {
                //r = power_scan();
            }
            else {
                
            }
        }
        break;
        
        case PKT_TYPE_SENSOR:
        {
            send_sensor(h, c, hdr->addr);
        }
        break;
        
        case PKT_TYPE_BREAKER:
        {
            send_breaker(h, c, hdr->addr);
        }
        break;
        
        case PKT_TYPE_FILE:
        {
            
        }
        break;
        
        case PKT_TYPE_SLAVE_LIST:
        {
            send_dlist(h, c);
        }
        break;
    }
}

static void http_fn(mg_conn_t *c, int ev, void *ev_data)
{
    int r,flag=0;
    web_handle_t *h=&webHandle;

#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(h, hdr, 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) {
        list_node_t *ln=NULL;
        r = list_take_node(h->list, &ln, 0);
        if(r==0) {
            node_t *n=&ln->data;
            ws_send_pkt(h, c, 0, n->tp, n->buf, n->dlen, 1);
            list_back_node(h->list, ln);
        }
    }
#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, "/sd");

#ifdef USE_MG716
    mg_log_set(MG_LL_VERBOSE);
    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, "/sd");
    
    mg_set_protocol_http_websocket(nc);
    h->opts.document_root = h->rootDir;
    h->opts.enable_directory_listing = "yes";
#endif
    
    while(th->quit==0) {
        mg_mgr_poll(&h->mgr, 300);
    }
    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);
}