#include <map>
#include <time.h>
#include <math.h>
#include <string.h>
#include <cstdlib>
#include <linux/types.h>
#include <sys/sysinfo.h>
#include <boost/typeof/typeof.hpp>
#include "SH_ThreadFunc.hpp"
#include "../API_log/SH_log.h"
#include "../uart/SH_Uart.hpp"
#include "../common/SH_CommonFunc.hpp"
#include "../dial5G/Dial.h"
#include "../wifi/wpa_client.h"
#include <dirent.h>
#include "../localserver/cmt_server.hpp"

std::unique_ptr<CMTServer> g_mgr_server;

namespace{
Uart *pUart = Uart::instance();
LocalServer *cidwServer = LocalServer::instance();
}

static std::string serverPort;
static std::string uptime;
static long long connect_lost_time = 0; //ms
static long long connect_time = 0; //ms

Dial dial;
int fd  = -1;

void CheckThread()
{
    print_info("ENTER CHECK THREAD \n");
    std::string runinfo = "ENTER CHECK THREAD ";
	LOG_INFO(runinfo.c_str());
    int heart_count = 0;

    int time_check = 0;
    int reset_flag = 0;
    int online_check = 0;
    int HardStatus = 0;
    int logClean = 0;
    int Battery = 0;
    int UpdateZigbee = 0;
    int commSignal = 0;
    int loose_check = 0;
    int mqttresend = 0;
    int rebootsystem = 0;
    int ModifyAddr = 0;
    int wifi_reconnect_count = 0;
    int checkNet0 = 0;
    int connectCount = 0;

    while (GlobalConfig::QuitFlag_G) {
		GlobalConfig::threadStatus = 1;
        sleep(1);
		if(GlobalConfig::EnterZigBeeWaveTransmittingFlag_G == ENTER_TRANSMITTING_STATUS) {
        	GlobalConfig::EnterZigBeeWaveTransmittingCnt_G ++;
        	if(GlobalConfig::EnterZigBeeWaveTransmittingCnt_G >= 180) {
        		GlobalConfig::EnterZigBeeWaveTransmittingFlag_G  = NO_ENTER_TRANSMITTING_STATUS;
        		GlobalConfig::EnterZigBeeWaveTransmittingCnt_G   = 0;
        		LOG_ERROR("[---- ZigBee error--!] ZigBee PanID is 9999 over time for 3 minutes !\n");
        		// 重新写入 0x8888
        		unsigned short shortAddr = 0x8888;
        		pUart->modify_LocalAddr(0x8888);
        		GlobalConfig::Zigbee_G.MyAddr = 0x8888;
        		// 延时1秒
        		sleep(1);
        		// 重新读回 GlobalConfig::ZigbeeInfo_G.PanID
        		pUart->UpdateZigbeeInfoCtrl();
        		pUart->bUpdateconfig = false;
        		pUart->bUpdate = false;
				pUart->bSendTimeStamp = false; 
        		// 延时1秒
        		sleep(1);
        		std::string str("8888");
        		if( GlobalConfig::ZigbeeInfo_G.MyAddr.compare(str) == 0 ){
        			LOG_INFO("[---- ZigBee INFO ----!] ZigBee PanID come back to be 8888 !\n");
        		}
        		else {
        			LOG_ERROR("[---- ZigBee error--!] ZigBee PanID cannot come back to be 8888 !\n");
        		}
        	}
			continue;
        }
    	if (10 == heart_count) {
            if (GlobalConfig::LinkCount > 30) {
				LOG_ERROR("MQTT connect failed\n");
#ifdef IMX6UL_GATEWAY
				char connect[10]={0x00};		
				readStringValue("config", "connect",connect,(char*)GlobalConfig::Config_G.c_str());
				if(atoi(connect)){		
					LOG_ERROR("MQTT connect failed,reboot\n");
                	exit(0);
				}
#endif
            }
            std::string ipTemp = IpAddrInit();
            GlobalConfig::IpAddr_G = ipTemp;
            if ( 0 != ipTemp.compare(GlobalConfig::IpAddr_G)) {
                //exit(0);
            }          
		    heart_count = 0;
    	}
#ifdef G2UL_GATEWAY
    	if(checkNet0 == 5){
    		checkNet0 = 0;
    		int iStatus = get_netlink_status("eth0");
    		if(iStatus == 1 && GlobalConfig::net0Status == 0){
    			system("ifconfig eth0:1 192.168.188.188  netmask 255.255.255.0");
    		}
    		GlobalConfig::net0Status = iStatus;
    	}
#endif
        if (180 == time_check) {//2h  7200
            char buf[256] = {0};
			char buf2[256] = {0};
            sprintf(buf, "{\"dataNodeGatewayNo\":\"%s\",\"cmd\":\"12\",\"status\":\"REQ\"}", 
                                        GlobalConfig::MacAddr_G.c_str());  
			sprintf(buf2, "{\"dataWatchNo\":\"%s\",\"cmd\":\"12\",\"status\":\"REQ\"}", 
                                        GlobalConfig::MacAddr_G.c_str()); 							
            std::string str = std::string(buf);
			std::string str2 = std::string(buf2);
            time_check = 0;
            int iRet = data_publish(str.c_str(), GlobalConfig::Topic_G.mPubTiming.c_str());
			iRet = data_publish(str.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
			iRet = data_publish(str2.c_str(), GlobalConfig::Topic_G.mPubTiming.c_str());
			iRet = data_publish(str2.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
            if(iRet != 0 )
            {
				LOG_ERROR("MQTT connect failed ,time check\n");
#ifdef Q4G_MODULE
				// if(fd){
				// 	LOG_ERROR("MQTT connect failed ,4G Module\n");
				// 	write_data(fd,"AT+CFUN=1,1\r\n",15);
				// 	system("reboot");
				// }
			#ifdef G2UL_GATEWAY
				char localtimestamp[32] = { 0 };
    			GetTimeNet(localtimestamp, 1);
				char whereCon[100]={0};
				sprintf(whereCon,"DATE(timestamp, 'unixepoch') = DATE('now') ORDER BY timeStamp DESC limit 0,1");
				std::string strCount = sql_ctl->GetData(" reboot_record ", "count", whereCon);
				if (atoi(strCount.c_str()) < 3)//当天大于三次不再重启进程
				{
					char insertSql[64] = {0};
					sprintf(insertSql, "'%s',%d,'%s'",localtimestamp,atoi(strCount.c_str())+1,"4G connect failed ");
					sql_ctl->InsertData(" reboot_record ", insertSql);
					gpio_set(GlobalConfig::GPIO_G.commPower,0);
					LOG_DEBUG("commPower start\n");
					sleep(2);
					gpio_set(GlobalConfig::GPIO_G.commPower,1);
					LOG_DEBUG("commPower  End\n");
					sleep(2);
					system("reboot");
				}else{
					LOG_ERROR("Q4G_MODULE error\n");
				}
			#endif

				
#endif				
            	
#ifdef IMX6UL_GATEWAY
				char connect[10]={0x00};		
				readStringValue("config", "connect",connect,(char*)GlobalConfig::Config_G.c_str());
				if(atoi(connect)){		
					LOG_ERROR("MQTT connect failed,time check ,reboot\n");
                	exit(0);
				}
#endif
#ifdef NR5G_MODULE
#ifdef IMX6UL_GATEWAY
				dial.closePort();
				gpio_set(GlobalConfig::GPIO_G.commRest,0);
				LOG_DEBUG("GPIO 8 start\n");
				sleep(2);
				gpio_set(GlobalConfig::GPIO_G.commRest,1);
				LOG_DEBUG("GPIO 8 End\n");
				sleep(20);
				dial.openPort("/dev/ttyUSB2");
				dial.setState();
#endif
#ifdef G2UL_GATEWAY
				dial.closePort();
				gpio_set(GlobalConfig::GPIO_G.commPower,0);
				LOG_DEBUG("commPower start\n");
				sleep(2);
				gpio_set(GlobalConfig::GPIO_G.commPower,1);
				LOG_DEBUG("commPower  End\n");
				sleep(20);
				connectCount ++;
				if(connectCount > 10){
					LOG_ERROR("5G reset error ,reboot!\n");
					system("reboot");
				}
#ifndef NR5G_MEIGE
				dial.openPort("/dev/ttyUSB2");
				dial.setState();
#else
				char szquectel[100]={0x00};
				std::string strAPN = ReadStrByOpt(SERVERCONFIG, "Server", "APN");
				sprintf(szquectel,"/opt/quectel-CM/Meig-CM -s %s &",strAPN.c_str());
				system(szquectel);
#endif
#endif
#endif
#ifdef  WIFI_MODULE
				LOG_ERROR("WiFi reset!\n");
#ifdef IMX6UL_GATEWAY
				gpio_set(GlobalConfig::GPIO_G.wifiReset,0);
				sleep(5);
				gpio_set(GlobalConfig::GPIO_G.wifiReset,1);
				sleep(5);
				wifi::WPAClient wpa;
				wpa.ReconnectWiFi();
				system("/etc/init.d/wpa_restart");
				system("udhcpc -i wlan2 &");
#endif
#ifdef G2UL_GATEWAY
				system("/etc/init.d/wpa_restart");
				sleep(5);
				string strip = GetGwIp_("wlan0");
				print_info("strip = %s\n",strip.c_str());
				if (strip.compare("0.0.0.0") != 0) {

				}else{
					gpio_set(GlobalConfig::GPIO_G.wifiReset,1);
					sleep(5);
					gpio_set(GlobalConfig::GPIO_G.wifiReset,0);
					sleep(30);
					wifi::WPAClient wpa;
					wpa.ReconnectWiFi();
					system("/etc/init.d/wpa_restart");
					sleep(5);
					system("udhcpc -b -i wlan0 &");
				}
#endif
#endif
            }else{
            	connectCount = 0;
            }
        }
        if(HardStatus == 3600){//one hour 3600
        	JsonData jd;
        	std::string data = jd.JsonCmd_07();
        	data_publish(data.c_str(), GlobalConfig::Topic_G.mPubStatus.c_str());
        	HardStatus = 0;
			int hour = 0;
			struct tm *tm_info = get_current_date();
			hour = tm_info->tm_hour;
			print_info("hour = %d\n",hour);
			int statistics = readIntValue( "config", "statistics",(char*)GlobalConfig::Config_G.c_str());
			if(statistics == 0 && hour > 13 ){
				writeIntValue("config", "statistics",1,(char*)GlobalConfig::Config_G.c_str());
				sql_ctl->CalculateData();
			}else if(statistics == 1 && hour < 13){
				writeIntValue("config", "statistics",0,(char*)GlobalConfig::Config_G.c_str());
			}
	
        }
        if(mqttresend == 7200){
        	mqttresend = 0;
        	LOG_INFO("mqttresend check\n");
        	Json::Value jsHeart;
        	Json::FastWriter fw;
        	jsHeart["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
        	jsHeart["status"] = "online_V" + GlobalConfig::Version;
        	jsHeart["IP"] = GlobalConfig::IpAddr_G;
        	std::string strJson = fw.write(jsHeart);
        	int iRet = data_publish(strJson.c_str(), GlobalConfig::Topic_G.mPubHeart.c_str());
        	if(iRet == 0){
        		sql_ctl->QueryofflineData();
        	}

        }

        if (1800 == online_check) {
        	online_check = 0;
        	int Count = sql_ctl->GetTableRows(T_SENSOR_INFO(TNAME), NULL);
        	if(Count > 0){
        		JsonData jd;
        		jd.DataNodeStatusCheck();
        		Param_29 param;
        		std::string cmd29 = jd.JsonCmd_29(param);
        		int iRet = data_publish(cmd29.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
        		char localtimestamp[32] = { 0 };
        		GetTimeNet(localtimestamp, 1);
            	std::string nowTimetamp = std::string(localtimestamp);
            	char selectCon[128] = { 0 };
            	sprintf(selectCon, " sendMsg <> '' ORDER BY timeStamp DESC  LIMIT 0,1");
            	sleep(1);
            	std::string  strTime = sql_ctl->GetData(T_DATASTATIC_INFO(TNAME), "timeStamp", selectCon);
            	long lTime = atol(nowTimetamp.c_str())-atol(strTime.c_str());
            	LOG_INFO("online check = %d\n",lTime);
            	if(lTime > 1800){
            		LOG_ERROR("nowTimetamp = %s,lastTime = %s,lTime = %d\n",nowTimetamp.c_str(),strTime.c_str(),lTime);
            	}
        	}
        }
		if(7200 == Battery){
        	Battery = 0;
			LOG_INFO("Battery\n");
        	sql_ctl->CalculateBattery();
        }

        if(3500 == loose_check){
			LOG_INFO("loosecheck\n");
        	loose_check = 0;
        	sql_ctl->CalculateDip();
        }
        if(ModifyAddr == 3600) {
			LOG_INFO("ModifyAddr check\n");
			ModifyAddr = 0;
			if(pUart->bModifyAddr){
				LOG_ERROR("ModifyAddr failed \n");
				exit(0);
			}
        }

        if(18000 == commSignal){ //5h
        	Json::Value jsBody,jsonVal;
        	Json::FastWriter showValue;
        	if(GlobalConfig::NetStatus  == "\"NOCONN\"" || GlobalConfig::NetStatus  == "\"CONNECT\""){
        		if(GlobalConfig::NetSignal == 0){
        			jsBody["communicationSignal"] = "未知";
        		}
        		else if(GlobalConfig::NetSignal > -80){
        	    	jsBody["commSignal"] = "优";
        	    }else if(GlobalConfig::NetSignal > -90 && GlobalConfig::NetSignal < -80){
        	    	jsBody["commSignal"] = "良";
        	    }else if(GlobalConfig::NetSignal > -105 && GlobalConfig::NetSignal < -90){
        	    	jsBody["commSignal"] = "一般";
        	    }else if(GlobalConfig::NetSignal < -105){
        	    	jsBody["commSignal"] = "弱";
        	    }else if(GlobalConfig::NetSignal < -115){
        	    	jsBody["commSignal"] = "不稳定";
        	    }

        	 }else if(GlobalConfig::NetStatus  == "\"SEARCH\""){
        	    jsBody["commSignal"] = "搜索网络";
        	 }else if(GlobalConfig::NetStatus  == "\"LIMSRV\""){
        	    jsBody["commSignal"] = "未插卡";
        	 }else{
        	    jsBody["commSignal"] = "未知";
        	 }

        	jsonVal["cmd"] = "53";
        	std::string dataBody = showValue.write(jsBody);
        	jsonVal["cmdBody"] = dataBody;
        	data_publish(showValue.write(jsonVal).c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
        }
        if(21600 == logClean){
        	logClean = 0;
        	DIR *dp; //创建一个指向root路径下每个文件的指针
        	struct dirent *dirp;
        	string root="/opt/log/";
        	if((dp = opendir(root.c_str()))==NULL)
        	    cout << "can't open"<< root << endl;
        	while((dirp = readdir(dp)) != NULL){

        	    if((!strcmp(dirp->d_name,".")||(!strcmp(dirp->d_name,".."))))
        	    	continue;
        	    struct timeval curTime;
        	    gettimeofday(&curTime, NULL);
        	    char buffer[80] = {0};
        	    char fileMonth[11] = {0};
        	    char todayMonth[11]={0};
        	    char fileDay[11] = {0};
        	    char todayDay[11]={0};
        	    struct tm nowTime;
        	    localtime_r(&curTime.tv_sec, &nowTime);//把得到的值存入临时分配的内存中，线程安全
        	    strftime(buffer, sizeof(buffer), "%Y-%m-%d", &nowTime);
        	    memcpy(fileDay,dirp->d_name+8,2);
        	    memcpy(todayDay,buffer+8,2);
        	    memcpy(fileMonth,dirp->d_name+5,2);
        	    memcpy(todayMonth,buffer+5,2);
        	    string filename = root + string(dirp->d_name);
        	    if(atoi(fileMonth) == atoi(todayMonth) ? abs(atoi(todayDay) - atoi(fileDay)) > 15: abs(abs(30-(atoi(fileDay)) + atoi(todayDay))) > 15){
        	    	LOG_INFO("filename = %s\n",filename.c_str());
        	    	remove(filename.c_str());
        	    }

        	}
			char localtimestamp[32] = { 0 };
    		GetTimeNet(localtimestamp, 1);
			char whereCon[1024] = {0};
#ifdef G2UL_GATEWAY			
			sprintf(whereCon," timestamp < '%ld' ",atol(localtimestamp) - 2592000 * 2); //删除2个月前的数据
#endif
#ifdef IMX6UL_GATEWAY			
			sprintf(whereCon," timestamp < '%ld' ",atol(localtimestamp) - 2592000); //删除1个月前的数据
#endif
			sql_ctl->DeleteTableData(" t_battery_history ",whereCon);
        	/*staticData = 0;
        	Json::Value jsHeart;
        	Json::FastWriter fw;
        	jsHeart["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
        	jsHeart["status"] = "online";
        	std::string strJson = fw.write(jsHeart);
        	int iRet = data_publish(strJson.c_str(), GlobalConfig::Topic_G.mPubHeart.c_str());
        	if(iRet == 0){
        		JsonData jd;
        		std::string data = jd.JsonCmd_52();
        	}
        	double freeDisk = GetHardDiskFree();
        	if(freeDisk < 90){
        	      char whereCon[512] = {0x00};
        	      time_t timestamp;
        	      long timeStamp =  time(&timestamp) ;//秒级时间戳
        	      memset(whereCon,0x00,sizeof(whereCon));
        	      sprintf(whereCon,"sendMsg = '0' and timeStamp < '%s'",timeStamp-1); //1 week
        	      sql_ctl->DeleteTableData(T_DATA_INFO(TNAME),whereCon,0);
        	      sql_ctl->DeleteTableData(T_DATASTATIC_INFO(TNAME),whereCon,0);
        	 }*/

        }
#ifdef WIFI_MODULE
        if (wifi_reconnect_count == 600) {  // 每 10分钟，重连WiFi网络
        	wifi_reconnect_count = 0;
            wifi::WPAClient wpa;
            std::string netssid = wpa.GetNetSsid();
            std::string currentssid = "";
            if (0 == netssid.compare("")) {
                netssid = wpa.GetNetSsid();
            }

            if (netssid.length() > 0) {
               currentssid = wpa.GetCurrentSSID();
               if (currentssid.length() > 0) {
                   char buf[64] = {0};
                   std::string rssiSend = "";
#ifdef G2UL_GATEWAY
                   rssiSend = "/usr/sbin/wpa_cli signal_poll|grep RSSI | cut -f 2 -d '='";
#endif

#ifdef IMX6UL_GATEWAY
                   rssiSend = "/opt/Cidn/wpa_cli signal_poll|grep RSSI | cut -f 2 -d '='";
#endif
                   system_custom(rssiSend.c_str(), buf);
                   std::string Rssi = std::string(buf);

                   memset(buf, 0, 64);
                   sprintf(buf, "wifi:true Rssi:%s", Rssi.c_str());
                   print_info("%s\n", buf);
                   LOG_INFO("%s\n",buf);

               } else {
                   std::string runinfo = "wifi:false\n";
                   print_info("%s\n", runinfo.c_str());
               }
            }
            if (wpa.ReconnectWiFi()) {
                print_info("wifi reconnect ok\n");
            }
         }
#endif

        if ( reset_flag > 7200)  {
            reset_flag = 0;
            //exit(0);
        }
        Battery ++;
        reset_flag++;
        time_check++;
        heart_count++;
        online_check++;
        HardStatus ++;
        logClean ++ ;
        loose_check ++;
        ModifyAddr ++;
        mqttresend ++;
#ifdef G2UL_GATEWAY
        checkNet0 ++;
#endif
#ifdef WIFI_MODULE
        wifi_reconnect_count ++;
#endif

    }
}

void StartCgiServer()
{
    print_info("start deal cgi\n");
    TcpCgi *tcpCgi = TcpCgi::instance();
    while (1) {
        tcpCgi->startCgiServer(); 
        sleep(10);
    }
}
void RunLED()
{
	while(1){
		gpio_set(GlobalConfig::GPIO_G.runLed,1);
		sleep(1);
		gpio_set(GlobalConfig::GPIO_G.runLed,0);
		sleep(1);
	}
}
void StartCMTServer() {
	sleep(2);
    boost::asio::io_service io_service;   
    g_mgr_server = std::make_unique<CMTServer>(io_service, 10000);
    io_service.run();
}
void HeartRep()
{
	int count = 0;
    while(1) {
        Json::Value jsHeart;
        Json::FastWriter fw;
        jsHeart["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
        jsHeart["status"] = "online_V" + GlobalConfig::Version;
        jsHeart["IP"] = GlobalConfig::IpAddr_G;
        std::string strJson = fw.write(jsHeart);
        int iRet = data_publish(strJson.c_str(), GlobalConfig::Topic_G.mPubHeart.c_str());
        print_info("heart = %s,iRet = %d\n",strJson.c_str(),iRet);
        if(iRet != 0){
        	//count ++;
        	gpio_set(GlobalConfig::GPIO_G.errorLed,1);
        	sleep(1);
        	gpio_set(GlobalConfig::GPIO_G.errorLed,0);
        	sleep(1);
        	gpio_set(GlobalConfig::GPIO_G.errorLed,1);
        	sleep(1);
        	gpio_set(GlobalConfig::GPIO_G.errorLed,0);
        	sleep(1);
        	gpio_set(GlobalConfig::GPIO_G.errorLed,1);
        	sleep(1);
        	GlobalConfig::serverStatus = 1;
        }else{
        	GlobalConfig::serverStatus = 0;
        	count = 0;
        	gpio_set(GlobalConfig::GPIO_G.errorLed,0);
        }
        //gpio_set(GlobalConfig::GPIO_G.errorLed,0);
//        if(count > 0){
//        	bool status = Ping( GlobalConfig::ServerIP.c_str(), 10000);
//        	if(status != 0)
//        		//LOG_INFO("===========net status ========failed heart count %d\n",count);
//        	if(status != 0 && count > 30){
//        		LOG_ERROR("heart send failed,heart count %d\n",count);
//        		count = 0;
//        		sleep(20);
//        		gpio_set(GlobalConfig::GPIO_G.power,1);
//        	}
//        }
//        if(count > 1000){
//        	gpio_set(GlobalConfig::GPIO_G.power,1);
//        	count = 0;
//        }
//        write_data(fd,"AT+QENG=\"servingcell\"\r\n",27);
//        //sleep(1);
//        char buff[1024]={0x00};
//        int ret = read_data(fd, buff, 1024, 10);
//        print_info("ret = %d,buff = %s\n",ret,buff);
//        const char *str2 = "+QENG: ";
//        char csq[128] = {0};
//        char *pdata = strstr((char*)buff, str2);
//        if(pdata){
//        	strncpy(csq, pdata+7, sizeof(csq));
//        }
//        else {
//        }
//
//        	 //printf("SIM-CSQ: %s\n", csq);
//        GlobalConfig::NetStatus = GetOneContent(csq,1,",");
//        string  signal  = GetOneContent(csq,13,",");
//        GlobalConfig::NetSignal = atoi(signal.c_str());
//        print_info("NetStatus = %s,NetSignal = %d\n",GlobalConfig::NetStatus.c_str(),GlobalConfig::NetSignal);

        //GlobalConfig::NetSignal  = getcsq();
        /*if(GlobalConfig::NetSignal  <= -105 ){
        	gpio_set(130,1);
        }else if(GlobalConfig::NetSignal > -105 ){
        	gpio_set(130,0);
        }else{
        	gpio_set(130,1);
        }*/
        sleep(10);
        //socketHeart(strJson.c_str());
    }
}

void GetCSQ()
{
#ifdef NR5G_MODULE
	//5G
	int iRet = -1;
open5G:
	iRet = dial.openPort("/dev/ttyUSB2");
	if (iRet < 0){
		sleep(5);
		goto open5G;
	}
#ifdef NR5G_MEIGE
	dial.closePort();
	char szquectel[100]={0x00};
	std::string strAPN = ReadStrByOpt(SERVERCONFIG, "Server", "APN");
	sprintf(szquectel,"/opt/quectel-CM/Meig-CM -s %s &",strAPN.c_str());
	system(szquectel);
#else
	dial.recvData();
#endif
#endif
#ifdef Q4G_MODULE
	//4G
	
open4G:
	fd = config_uart("/dev/ttyUSB2",115200);
	if (fd < 0){
		sleep(5);
		goto open4G;
	}
	char szbuffer[200]={0x00};
	int offSize = 0;
	int timeoutflag = 0;
	write_data(fd,"AT+QENG=\"servingcell\"\r\n",27);
	while(1){
		char buff[1024]={0x00};
		int ret = read_data(fd, buff, 1024, 10);
		if(ret <= 0){
			timeoutflag ++;
			if(timeoutflag > 5){
				print_info("timeoutflag = %d\n",timeoutflag);
				timeoutflag = 0;
				const char *str2 = "+QENG: ";
				char csq[128] = {0};
				char *pdata = strstr((char*)szbuffer, str2);
				if(pdata){
					strncpy(csq, pdata+7, sizeof(csq));

					//printf("SIM-CSQ: %s\n", csq);
					GlobalConfig::NetStatus = GetOneContent(csq,1,",");
					string  signal  = GetOneContent(csq,13,",");
					GlobalConfig::NetSignal = atoi(signal.c_str());
					GlobalConfig::NetType = GetOneContent(csq,2,",");
					print_info("NetStatus = %s,NetSignal = %d\n",GlobalConfig::NetStatus.c_str(),GlobalConfig::NetSignal);

				}
				memset(szbuffer,0x00,sizeof(szbuffer));
				offSize = 0;
				write_data(fd,"AT+QENG=\"servingcell\"\r\n",27);
			}
			usleep(10000);
		}else if(ret > 0){
			print_info("ret = %d,buff = %s\n",ret,buff);
			memcpy(szbuffer + offSize,buff,ret);
			offSize = offSize + ret;
			print_info("szbuffer = %s\n",szbuffer);
			continue;
		}
		sleep(10);
	}
#endif
}
void Dial5G()
{
	sleep(2);
dial5G:
	if(dial.m_fd > 0){
		dial.dial5G();
	}else{
		sleep(5);
		goto dial5G;
	}
}
void UartStart()
{
	print_info("2222222222222\n");
   // onReceiveUart cb = (onReceiveUart)&ProtoConvert::HandleFromUart;
   // pUart->setCallBack(cb);
	print_info("zigAckrep = %d,zigAckreset = %d,zigReset = %d,errorLed = %d,power = %d",\
	GlobalConfig::GPIO_G.zigAckrep,GlobalConfig::GPIO_G.zigAckreset,GlobalConfig::GPIO_G.zigReset,GlobalConfig::GPIO_G.errorLed,\
	GlobalConfig::GPIO_G.power);
	InitGpio(GlobalConfig::GPIO_G.zigAckrep,0);//ACK
	InitGpio(GlobalConfig::GPIO_G.zigAckreset,1);//ACK	reset
	InitGpio(GlobalConfig::GPIO_G.zigReset,1);//Zigbee reset
	gpio_set(GlobalConfig::GPIO_G.zigAckreset,1);
	gpio_set(GlobalConfig::GPIO_G.zigReset,1);
	print_info("GPIO Init1\n");

#ifdef IMX6UL_GATEWAY
	InitGpio(GlobalConfig::GPIO_G.errorLed,1);//指示灯
	gpio_set(GlobalConfig::GPIO_G.errorLed,0);
	InitGpio(GlobalConfig::GPIO_G.power,1);//power reset
	gpio_set(GlobalConfig::GPIO_G.power,0);
#endif
#ifdef G2UL_GATEWAY
	InitGpio(GlobalConfig::GPIO_G.runLed,1);
	InitGpio(GlobalConfig::GPIO_G.errorLed,1);
	gpio_set(GlobalConfig::GPIO_G.runLed,1);
	gpio_set(GlobalConfig::GPIO_G.errorLed,0);
	InitGpio(GlobalConfig::GPIO_G.netResetNet0,1);
	gpio_set(GlobalConfig::GPIO_G.netResetNet0,0);
#endif
	GlobalConfig::Zigbee_G.Serial_Rate = 0x07;
	GlobalConfig::Zigbee_G.Serial_DataB = 0x08;
	GlobalConfig::Zigbee_G.Serial_StopB = 0x01;
	pUart->InitUart(B115200);
	char buffer[1100]={0x00};

	sleep(1);
	pUart->UartRecv(pUart->fd,1,buffer);
	sleep(1);

}
void InitModule()
{

#ifdef NR5G_MODULE
#ifdef G2UL_GATEWAY

	InitGpio(GlobalConfig::GPIO_G.commPower,1);//4G,5G模组供电，
	gpio_set(GlobalConfig::GPIO_G.commPower,1);
	InitGpio(GlobalConfig::GPIO_G.vol3_8,1);//5G 高电平3.8V，低电平3.3V
	gpio_set(GlobalConfig::GPIO_G.vol3_8,1);

	InitGpio(GlobalConfig::GPIO_G.commRest,1);
	gpio_set(GlobalConfig::GPIO_G.commRest,0);//高电平复位
#endif
#ifdef IMX6UL_GATEWAY
	InitGpio(GlobalConfig::GPIO_G.commRest,1);
	gpio_set(GlobalConfig::GPIO_G.commRest,1);//
#endif
#endif
#ifdef Q4G_MODULE
#ifdef G2UL_GATEWAY
	system("killall daemon_CM");
	InitGpio(GlobalConfig::GPIO_G.commPower,1);//4G,5G模组供电，
	gpio_set(GlobalConfig::GPIO_G.commPower,1);
	InitGpio(GlobalConfig::GPIO_G.commRest,1);
	gpio_set(GlobalConfig::GPIO_G.commRest,0);//高电平复位
	sleep(10);
	char szquectel[100]={0x00};
	std::string strAPN = ReadStrByOpt(SERVERCONFIG, "Server", "APN");
	sprintf(szquectel,"/opt/quectel-CM/quectel-CM -s %s &",strAPN.c_str());
	system(szquectel);
	sleep(2);
	system("/opt/Cidn/daemon_CM &");
#endif
#endif
#ifdef WIFI_MODULE
	print_info("Init WiFi!\n");

#ifdef IMX6UL_GATEWAY
	InitGpio(GlobalConfig::GPIO_G.wifiReset,1);//WiFi模组复位，0复位，1取消复位
	gpio_set(GlobalConfig::GPIO_G.wifiReset,1);
	sleep(10);
	wifi::WPAClient wpa;
	wpa.ReconnectWiFi();
	system("/etc/init.d/wpa_restart");
	system("udhcpc -i wlan2 &");
#endif
#ifdef G2UL_GATEWAY
	InitGpio(GlobalConfig::GPIO_G.wifiReset,1);//WiFi模组复位，1复位，0取消复位
	gpio_set(GlobalConfig::GPIO_G.wifiReset,0);
	InitGpio(GlobalConfig::GPIO_G.wifiPower,1);//WiFi模组上电
	gpio_set(GlobalConfig::GPIO_G.wifiPower,1);
	sleep(10);
	wifi::WPAClient wpa;
	wpa.ReconnectWiFi();
	system("/usr/sbin/wpa_supplicant -Dnl80211 -iwlan0 -c/etc/wpa_supplicant.conf &");
	system("udhcpc -b -i wlan0 &");
#endif
#endif
}

void TestUart()
{
	pUart->InitTestUart(B115200);
	pUart->ReadTestUart();
}
void UartStartWave()
{
    pUart->DealWaveThread();
}

void StartUdpSys()
{ 
    UdpSys *udpsys = UdpSys::instance();
    udpsys->StartConnectSysUdp();
}
void WatchDog()
{
	int fd = OpenWatchDog();
	while(1){
		WriteWatchDog(fd);
		sleep(50);
	}
	close(fd);
}
static const char* LOCAL_WILL_TOPIC = "up/uart/will";
void my_publish_callback(struct mosquitto *mosq, void *obj, int mid)
{

}

void my_connect_callback(struct mosquitto *mosq, void *obj, int result)
{
    struct userdata *ud;
    ud = (struct userdata *)obj;

    if (!result){
        for (int i = 0; i < ud->topic_count; i++){
            print_purple("mosquitto_subscribe ud->topics[%d]:%s\n", i, ud->topics[i]);
            int iret = mosquitto_subscribe(mosq, NULL, ud->topics[i], ud->topic_qos);
            print_purple("mosquitto_subscribe ret:%d\n", iret);
        }

        int iret = mosquitto_subscribe(mosq, NULL, GlobalConfig::Topic_G.mSubData.c_str(), 1);
        print_debug("mosquitto_subscribe's return value: %d\n", iret);

        char gwTime[32] = { 0 };
        GetTimeNet(gwTime, 0);
        connect_time = strtoll(gwTime, NULL, 10);
        print_debug("connect_time:%lld\n", connect_time);
        long long difftime_ms = connect_time - connect_lost_time;
        if (difftime_ms > 20*1000) { // 超过20秒，判定为连接断开
            char reply_string[256] = {0};
            std::string startStatus = "0";
            if (access(SYSTEMSTART, 0) >= 0) {
                startStatus = GetFileContent(SYSTEMSTART, 1);
            }
            sprintf(reply_string, "{\"dataNodeGatewayNo\":\"%s\",\"softVersion\":\"%s\",\"status\":\"%s\"}", 
                                    GlobalConfig::MacAddr_G.c_str(), GlobalConfig::Version.c_str(), startStatus.c_str());
            
            Json::Value jsData;
            Json::Value jsVal;
            Json::FastWriter fw;
            jsData["cmd"] = "15";
            jsData["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;                

            std::string strCmd15 = fw.write(jsData);

            std::string instr = std::string(reply_string);
            std::string topic = "equipment/state/" + GlobalConfig::MacAddr_G;
            int ret = data_publish(instr.c_str(), topic.c_str());
            if (ret != MOSQ_ERR_SUCCESS) {
                print_debug("Publish failed:%d, %s\n", ret, instr.c_str());
                disconnect();
            }
        }
        GlobalConfig::LinkStatus_G = 1;
        print_debug("Connect to server success.\n"); 

        // std::string cmd20 = JsonCmd_Cgi_20();
        // data_publish(cmd20.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());  

        char buf[256] = {0};
        sprintf(buf, "{\"dataNodeGatewayNo\":\"%s\",\"cmd\":\"12\",\"status\":\"REQ\"}", 
                                    GlobalConfig::MacAddr_G.c_str());  
        std::string str = std::string(buf);
   //     data_publish(str.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
        std::string runinfo = "本地服务器连接成功";
                
    }
    else{
        if (result && !ud->quiet){
            fprintf(stderr, "%s\n", mosquitto_connack_string(result));
            if(result == 1) {
                //Connection Refused: unacceptable protocol version
            } else if (result == 2) {
                //Connection Refused: identifier rejected
            } else if (result == 3) {
                //Connection Refused: server unavailable
            } else if (result == 4) {
                //Connection Refused: bad user name or password
             //   exit(0);
            } else if (result == 5) {
                //Connection Refused: not authorized
            }
        }
    }
}

void my_disconnect_callback(struct mosquitto *mosq, void *obj, int result)
{
    int ret = 0;
    ret = disconnect();
    //LOG_ERROR("The MQTT connection lost:%d\n", ret);
    print_debug("The MQTT connection lost\n");
    char gwTime[32] = { 0 };
    GetTimeNet(gwTime, 0);
    uptime = std::string(gwTime);
    connect_lost_time = strtoll(uptime.c_str(), NULL, 10);
    print_debug("connect_lost_time:%lld\n", connect_lost_time);
    GlobalConfig::LinkStatus_G = 0;
    GlobalConfig::LinkCount = GlobalConfig::LinkCount + 1;

#ifdef WIFI_MODULE
    char buf[128] = {0};
    std::string wpa_state = "";
#ifdef G2UL_GATEWAY
    wpa_state = "/usr/sbin/wpa_cli status|grep wpa_state | cut -f 2 -d '='";
#endif

#ifdef IMX6UL_GATEWAY
    wpa_state = "/opt/Cidn/wpa_cli status|grep wpa_state | cut -f 2 -d '='";
#endif
    system_custom(wpa_state.c_str(), buf);
    std::string state = std::string(buf);
    std::string RSSI_cmd = "";
#ifdef G2UL_GATEWAY
    RSSI_cmd = "/usr/sbin/wpa_cli signal_poll|grep RSSI | cut -f 2 -d '='";
#endif
#ifdef IMX6UL_GATEWAY
    RSSI_cmd = "/opt/Cidn/wpa_cli signal_poll|grep RSSI | cut -f 2 -d '='";
#endif
    system_custom(RSSI_cmd.c_str(), buf);
    std::string RSSI = std::string(buf);

    int iRet = reconnect();
    memset(buf, 0, sizeof(buf));
    sprintf(buf, "wifi RSSI:%s,state:%s,MQTT reconnect :%d\n", RSSI.c_str(),state.c_str(),iRet);
    //LOG_WARN(" %s\n",buf);
    int status = Ping( GlobalConfig::ServerIP.c_str(), 10000);;
    //LOG_WARN(" netStatus %d\n",status);
    print_info("%s\n", buf);

#else
    // int iRet = reconnect();
	// print_info("reconnect = %d\n",iRet);
#endif

}

void my_message_callback(struct mosquitto *mosq, void *obj, const struct mosquitto_message *message)
{
    struct userdata *ud;
    bool res;
    assert(obj);
    ud = (struct userdata *)obj;
    
    if (message->retain && ud->no_retain) return;
    if (ud->filter_outs) {
        for (int i = 0; i < ud->filter_out_count; i++) {
            mosquitto_topic_matches_sub(ud->filter_outs[i], message->topic, &res);
            if (res) return;
        }
    }

    if (ud->verbose) {
        if (message->payloadlen) {
            std::string strtopic(message->topic);
            print_info("strtopic : %s \n", strtopic.c_str());
            cidwServer->HandleFromServer((const char *)message->payload,message->payloadlen,message->topic);
            if (ud->eol) {
                print_brown("\n");
            }
        } else {
            if (ud->eol) {
                print_brown("%s (null)\n", message->topic);
            }
        }
        fflush(stdout);
    } else {
        if (message->payloadlen) {
            fwrite(message->payload, 1, message->payloadlen, stdout);
            if (ud->eol) {
                print_red("\n");
            }
            fflush(stdout);
        }
    }
}

void my_subscribe_callback(struct mosquitto *mosq, void *obj, int mid, int qos_count, const int *granted_qos)
{
    int i;
    struct userdata *ud;
    assert(obj);
    ud = (struct userdata *)obj;
    if (!ud->quiet) print_brown("Subscribed (mid: %d): %d", mid, granted_qos[0]);
    for (i = 1; i < qos_count; i++){
        if (!ud->quiet) print_brown(", %d", granted_qos[i]);
    }
}

void my_log_callback(struct mosquitto *mosq, void *obj, int level, const char *str)
{
    if (level == MOSQ_LOG_ERR) {
        //LOG_ERROR("%s\n", str);
    } else if (level == MOSQ_LOG_WARNING) {
        //LOG_WARN("%s\n", str);
    } else if (level == MOSQ_LOG_NOTICE) {
        //LOG_INFO("%s\n", str);
    }
}

void StartMqttClient()
{
	print_info("start mqtt \n");
    std::string runinfo = "MQTT通信模块启动";
      
    while (1) 
	{
        if (GlobalConfig::ServerIP.length() > 0) {
            std::string strEqupNo = GlobalConfig::MacAddr_G;
            std::string strVersion = GlobalConfig::Version;
            std::string salt;
            register_collback(my_connect_callback, my_message_callback, my_subscribe_callback, my_log_callback, my_disconnect_callback, my_publish_callback);
            start_client(strEqupNo.c_str(), GlobalConfig::MacAddr_G.c_str(), GlobalConfig::ServerIP.c_str(), strVersion.c_str(), "11111111", salt);
        }
        sleep(3);
    }
}


void SearchThread()
{
    std::string runinfo = "设备搜索模块启动";

    while (GlobalConfig::QuitFlag_G) {
        if (GlobalConfig::IpAddr_G.length() > 0 && 0 != GlobalConfig::IpAddr_G.compare("0.0.0.0")) {
        	print_info("%s\n",runinfo.c_str());
            boost::asio::io_service io_service;
            SearchDev *searchDevObj = new SearchDev(io_service);
            searchDevObj->MultiCastRecv();
            io_service.run();
            delete searchDevObj;
        }
        sleep(5);
        print_error("SearchThred restart.\n");
    }
}


void RecvUpdateFile()
{
    boost::asio::io_service iosev; 
    boost::asio::ip::tcp::acceptor acceptor(iosev,
                                            boost::asio::ip::tcp::endpoint(
                                                boost::asio::ip::tcp::v4(), 7304));
    for(;;) {
        boost::asio::ip::tcp::socket socket(iosev);
        acceptor.accept(socket);
        boost::system::error_code  ec; 
        if(ec) {
            print_error("%s\n", boost::system::system_error(ec).what());
            //return -1;
        }
        FILE *fp;
        char buffer[1024];
        size_t len = 0;
        int write_len;
        bzero(buffer,1024);
        fp = fopen("/tmp/upgrade.tar.gz", "w");
        if(NULL == fp ) {
            print_info("File:\t Can Not Open To Write\n");
            exit(1);
        }   
        while(len = socket.read_some(boost::asio::buffer(buffer),ec)) {
            if(len < 0) {
                print_info("Receive Data From Server Failed! \n");
                break;
            }
            write_len = fwrite(buffer, sizeof(char), len, fp);
            if(write_len < len) {
                print_info("File:test Write Failed!\n");
                break;
            }
            bzero(buffer, 1024);
        }
        print_info("Receive File From Server Finished! \n");
        fclose(fp);
        Json::Value jsData;
        Json::FastWriter fw;
        jsData["cmd"] = "03";
        jsData["updatefilename"] = "updatefile";
        std::string str = fw.write(jsData);
        system("/etc/init.d/sysupgrade.sh");
    } 
}