#include "SH_LocalServer.hpp"

namespace {
    PlatformInit *platform = PlatformInit::instance();
}

LocalServer::LocalServer()
{

}

LocalServer::~LocalServer()
{
    print_info("~LocalServer is called!\n");
	LOG_INFO("~LocalServer is called!\n");
}

void LocalServer::HandleFromServer(const char *pData_r, int pLen, const char *topic)
{
	 if(pLen == 0) {
	        return;
	    }

	    std::string data_r = (std::string)(pData_r);
	    LOG_INFO("MQTT recv  base64 %s\n",data_r.c_str());
	    print_brown("pData base : %s \n", data_r.c_str());
	    char *base64_data = new char[data_r.length()];
	    memset(base64_data, 0, data_r.length());
	    Secure::instance()->Base64Decode(data_r.c_str(), (unsigned char*)base64_data);
	    std::string pData = std::string(base64_data);
	    delete[] base64_data;
	    LOG_INFO("MQTT recv  %s\n",pData.c_str());
	    print_brown("pData : %s \n", pData.c_str());
	    Json::Reader recvReader;
		Json::Value recvValue;
	    Json::Value recvBody;
		if (recvReader.parse(pData, recvValue)) {
			int cmdType = atoi(recvValue["cmd"].asString().c_str());
			if(cmdType == 41){
				recvBody = recvValue["cmdBody"];
			}else{
				std::string cmdBody = recvValue["cmdBody"].asString();
				if (!recvReader.parse(cmdBody, recvBody)) {
					print_error("recv body error");
					return;
				}
			}

	        switch (cmdType) {
	        	case 7:{
	        		JsonData jd;
	        		std::string data = jd.JsonCmd_07();
	        		data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	        	}break;
	            case 10:{
	                recvValue["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
	                recvValue["status"] = "ACK";
	                Json::FastWriter fw;
	                std::string strjson = fw.write(recvValue);
	                data_publish(strjson.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	                //system("echo 1 > /CIDW/start");
	                sleep(1);
	                system("reboot");
	            }
	            break;
	            case 12:{
	              /*  std::string strBody = recvValue["cmdBody"].asString();
	                Json::Value jsBody;
	                if (!recvReader.parse(strBody, jsBody)) {
	                    return;
	                }*/
	                std::string timestamp = recvBody["timestamp"].asString();
	                unsigned long itimestamp = atol(timestamp.c_str());
	                SetTime(itimestamp);
	                mssleep(200);
	                system("hwclock -w");
	                if (!recvValue["ZoneId"].isNull() && recvValue["ZoneId"].asString().length() > 0) {
	                    std::string zoneid = recvValue["ZoneId"].asString();
	                    ZoneConfig(zoneid);
	                }
	               /* Json::Value retVal;
	                retVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
	                retVal["cmd"] = 12;
	                retVal["success"] = true;
	                retVal["message"] = "校时成功";
	                Json::FastWriter fw;
	                std::string strjson = fw.write(retVal);
	                data_publish(strjson.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());*/
	            }
	            break;
	            case 13:{
	                std::string type = recvValue["type"].asString();
	                if (type.compare("delete") == 0) {
	                    WriteStr2Config(SERVERCONFIG, "Server", "localServerIpAddress", "0.0.0.0");
	                    GlobalConfig::ServerIP.clear();
	                    exit(0);
	                }
	            }
	            break;
	            case 20:{
	                Param_20 param;
	                param.mCmdSerial = recvValue["cmdSerial"].asString();
	                std::string type = recvBody["type"].asString();
	                if (0 == type.compare("SET")) {
	                    param.mMode = 0;
	                    param.mDataWatchName = recvBody["SystemInfo"]["dataNodeGatewayName"].asString();
	                    param.mDataWatchAssetId = recvBody["SystemInfo"]["dataNodeGatewayAssetId"].asString();
	                    param.mDataWatchAddedBy = recvBody["SystemInfo"]["dataNodeGatewayAddedBy"].asString();
	                } else {
	                    param.mMode = 1;
	                }
	                JsonData jd;
	                std::string data = jd.JsonCmd_20(param);
	                print_info("20 data: %s\n", data.c_str());
	                data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	            }
	            break;
	            case 22:{
	                Param_22 param;
	                std::string type = recvBody["type"].asString();
	                param.mCmdSerial = recvValue["cmdSerial"].asString();

	                if (0 == type.compare("SET")) {
	                    param.mMode = 0;
	                    param.mTimeZone = recvBody["timezone"].asString();
	                    ZoneConfig(param.mTimeZone);
	                } else {
	                    param.mMode = 1;
	                }
	                JsonData jd;
	                std::string data = jd.JsonCmd_22(param);
	                data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	            }
	            break;
	            case 23:{
	                std::string type = recvBody["type"].asString();
	                Param_23 param;
	                param.mCmdSerial = recvValue["cmdSerial"].asString();
	                if (0 == type.compare("SET")) {
	                    param.mMode = 0;
	                    param.mServerIp = recvBody["localServerIpAddress"].asString();
	                    param.mPort = to_string(recvBody["localServerPort"].asInt());
	                    param.mCommMode = to_string(recvBody["CommMode"].asInt());
	                } else {
	                    param.mMode = 1;
	                }
	                JsonData jd;
	                std::string data = jd.JsonCmd_23(param);
	                data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	            }
	            break;
	            case 25:{
	                Param_25 param;
	                param.mCmdSerial = recvValue["cmdSerial"].asString();
	                std::string type = recvBody["type"].asString();
	                if (0 == type.compare("SET")) {
	                    param.mDnsName = recvBody["dnsName"].asString();
	                    param.mGateway = recvBody["gateway"].asString();
	                    param.mHostName = recvBody["hostName"].asString();
	                    param.mIp = recvBody["dataWatchIpAddress"].asString();
	                    param.mSubnetMask = recvBody["subnetMask"].asString();
	                    param.mNetworkPortStatus = recvBody["networkPortStatus"].asString();
	                    param.mMode = 0;
	                } else {
	                    param.mMode = 1;
	                }
	                JsonData jd;
	                std::string data = jd.JsonCmd_25(param);
	                data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	              //  platform->EquipIpInit();
	            }
	            break;
	            case 26:{
	                Param_26 param;
	                param.mCmdSerial = recvValue["cmdSerial"].asString();
	                std::string type = recvBody["type"].asString();
	                if (0 == type.compare("GET")) {
	                    param.mMode = 0;
	                } else {
	                    param.mMode = 1;
	                }
	                JsonData jd;
	                std::string data = jd.JsonCmd_26(param);
	                data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	              //  platform->EquipIpInit();
	            }
	            break;
	            case 27:{
	                Param_27 param;
	                param.mCmdSerial = recvValue["cmdSerial"].asString();

	                JsonData jd;
	                std::string data = jd.JsonCmd_27(recvBody);
	                data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	            }
	            break;
	            case 50:{
	            	 JsonData jd;
	            	 std::string data = jd.JsonCmd_50(recvBody);
	            	 data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	            }break;
	            case 41:{

	            	JsonData jd;
					Param_41 param;
					std::vector<Param_41> param41;
					for(int i = 0; i < recvBody.size();i++){
						param.mdataNodeNo = recvBody[i]["dataNodeNo"].asString();
						param.mfeatureInterVal = recvBody[i]["featureInterVal"].asInt();
						param.mwaveInterVal = recvBody[i]["waveInterVal"].asInt();
						param.msamplingRate = recvBody[i]["samplingRate"].asInt();
						param.mrange = recvBody[i]["range"].asInt();
						param.mAccSampleTime = recvBody[i]["ACCSampleTime"].asInt();
						param.mstartBrands = recvBody[i]["startBrands"].asString();
						param.mstopBrands = recvBody[i]["stopBrands"].asString();
						param.menvelopeBandPass = recvBody[i]["envelopeBandPass"].asString();
						param.mviff = recvBody[i]["viff"].asInt();
						param.mfaultFrequency = recvBody[i]["faultFrequency"].asString();
						param.ZigbeePower = recvBody[i]["ZigbeePower"].asInt();
						param.ZigbeeRetry = recvBody[i]["ZigbeeRetry"].asInt();
						param41.push_back(param);
					}
					std::string data = jd.JsonCmd_Cgi_41(param41,1);
					char whereCon[64] = { 0 };
					sprintf(whereCon, " UpdateFlag <> 1 ");
					string strData = sql_ctl->GetNodeConfigureInfor(whereCon);
					data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());

	            }
	            break;
	            case 51:{
	            	JsonData jd;
	            	std::string data = jd.JsonCmd_51(recvBody);
	            	data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	            }break;
	            case 52:{
//	            	JsonData jd;
//	            	std::string data = jd.JsonCmd_52(recvBody);
//	            	data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	            }break;
	            case 53:{
	            	JsonData jd;
	            	std::string data = jd.JsonCmd_53(recvBody);
	            	data_publish(data.c_str(), GlobalConfig::Topic_G.mPubCmd.c_str());
	            }
	            break;
	            default:
	            //    data_publish_local(pData.c_str(), GlobalConfig::Topic_G.mPubLocalCmd.c_str());
	            break;
	        }
	        print_brown("cmdType : %d \n", cmdType);

	    } else {
	        print_error("parase fail \n");
	    }
}

std::string LocalServer::HandleCgi_cmd(std::string &pData)
{
try{
    print_purple("HandleCgi Data = %s \n", pData.c_str());
    Json::Features f = Json::Features::strictMode();
    Json::Reader recvReader(f);
    Json::Value recvValue;
    Json::Value recvBody;
    if (recvReader.parse(pData, recvValue)){
        int cmdType = atoi(recvValue["cmd"].asString().c_str());
        std::string cmdBody = "";
        if (!recvValue["cmdBody"].isNull() ) {
            recvBody = recvValue["cmdBody"];
            Json::FastWriter fw;
            cmdBody = fw.write(recvBody);
        }
        switch (cmdType) {
            case 1:{
                Param_01 param;
                std::string type = recvBody["type"].asString();
                if ( 0 == type.compare("login")) {
                    param.mMode = 0;
                    param.mUserName = recvBody["userName"].asString();
                    param.mPassWord = recvBody["passWord"].asString();
                } else if ( 0 == type.compare("upDate")) {
                    param.mMode = 1;
                    param.mUserName = recvBody["userName"].asString();
                    param.mPassWord = recvBody["passWord"].asString();
                    param.mPassWordNew = recvBody["passWordNew"].asString();
                }
                JsonData jd;
                std::string data = jd.JsonCmd_Cgi_01(param); 
                return data;
            }   
            break;
            case 2:{
                Param_02 param;
                std::string type = recvBody["type"].asString();
                if ( 0 == type.compare("SET")) {
                    param.mMode = 0;
                    param.mTimeStamp = recvBody["timeStamp"].asInt();
					param.mSetType = recvBody["setType"].asInt();
                } else if (0 == type.compare("GET")) {
                    param.mMode = 1;
                } 
                JsonData jd;
                std::string data = jd.JsonCmd_Cgi_02(param); 
                return data;                           
            }
            break;
            case 7:{
                JsonData jd;
                std::string data = jd.JsonCmd_Cgi_07(); 
                return data;                
            }   
            break; 
            case 8:{
                JsonData jd;
                std::string data = jd.JsonCmd_Cgi_08(); 
                system("reboot");
                return data; 
            }
            break;
            case 9:{
                JsonData jd;
                Param_09 param;
                param.mPackageFlag = recvBody["package"].asInt();
                std::string data = jd.JsonCmd_Cgi_09(param);
                return data; 
            }
            break;
            case 10:{
                JsonData jd;
                Param_10 param;
                param.strDataNode = recvBody["DataNode"].asString();
                param.strStatic = recvBody["Static"].asString();
                param.straxis = recvBody["Raxis"].asString();
                param.mPackageFlag = recvBody["package"].asInt();
                param.timeStart = recvBody["timeStart"].asString();
                param.timeEnd = recvBody["timeEnd"].asString();
				param.MeasurementID = recvBody["MeasurementID"].asString();
                std::string data = jd.JsonCmd_Cgi_10(param);
                return data;
           }
           break;
            case 11:{
                JsonData jd;
                Param_11 param;
                param.DataNodeNo = recvBody["DataNode"].asString();
                std::string data = jd.JsonCmd_Cgi_11(param);
                return data;
            }
            break;
            case 20:{
                Param_20 param;
                std::string type = recvBody["type"].asString();
                if (0 == type.compare("SET")) {
                    param.mMode = 0;
                    param.mDataWatchName = recvBody["SystemInfo"]["dataNodeGatewayName"].asString();
                    param.mDataWatchAssetId = recvBody["SystemInfo"]["dataNodeGatewayAssetId"].asString();
                    param.mDataWatchAddedBy = recvBody["SystemInfo"]["dataNodeGatewayAddedBy"].asString();
                } else {
                    param.mMode = 1;
                }
                JsonData jd;
                std::string data = jd.JsonCmd_Cgi_20(param); 
                return data;                         
            }
            break;
            case 22:{
                Param_22 param;
                std::string type = recvBody["type"].asString();
                param.mCmdSerial = recvValue["cmdSerial"].asString();

                if (0 == type.compare("SET")) {
                    param.mMode = 0;
                    param.mTimeZone = recvBody["SystemSettings"]["timezone"].asString();
                    ZoneConfig(param.mTimeZone);
                } else {
                    param.mMode = 1;
                }
                JsonData jd;
                std::string data = jd.JsonCmd_Cgi_22(param);  
                return data;     
            }
            break;
            case 23:{
                std::string type = recvBody["type"].asString();
                Param_23 param;
                param.mCmdSerial = recvValue["cmdSerial"].asString();
                if (0 == type.compare("SET")) {
                    param.mMode = 0;        
                    param.mServerIp = recvBody["SystemSettings"]["ServerIpAddress"].asString();
                    param.mPort = boost::lexical_cast<std::string>(recvBody["SystemSettings"]["ServerPort"].asInt());
                    param.mCommMode = recvBody["SystemSettings"]["CommMode"].asString();
                    param.mUserName = recvBody["SystemSettings"]["UserName"].asString();
                    param.mPassword = recvBody["SystemSettings"]["Password"].asString();
                    param.mAPN = recvBody["SystemSettings"]["APN"].asString();
                } else {
                    param.mMode = 1;
                }
                JsonData jd;
                std::string data = jd.JsonCmd_Cgi_23(param);

                return data;
            }
            break;         
            case 25:{
                Param_25 param;
                std::string type = recvBody["type"].asString();
                if (0 == type.compare("SET")) {
                	param.mNet = recvBody["net"].asString();
                    param.mDnsName = recvBody["dnsName"].asString();
                    param.mGateway = recvBody["gateway"].asString();
                    param.mHostName = recvBody["hostName"].asString();
                    param.mIp = recvBody["dataWatchIpAddress"].asString();
                    param.mSubnetMask = recvBody["subnetMask"].asString();
                    param.mNetworkPortStatus = recvBody["networkPortStatus"].asString(); 
                    param.mMode = 0; 
                }else{
					param.mMode = 1;
				}
                JsonData jd;
                std::string data = jd.JsonCmd_Cgi_25(param);
                //platform->EquipIpInit();
                return data;
            }
            break;
            case 26:{
                JsonData jd;
                Param_26 param;
                param.mPackageFlag = recvBody["package"].asInt();
                std::string data = jd.JsonCmd_Cgi_26(param);
 //               print_info("data = %s\n",data.c_str());
                return data;
            }
            break;
            case 27:{
                Param_27 param;
                param.mDataNodeNo = recvBody["dataNodeNo"].asString();
				param.mType = recvBody["type"].asString();
                JsonData jd;                
                std::string data = jd.JsonCmd_Cgi_27(param);
                return data;
            }
            break;
            case 28:{
                Param_28 param;
                param.mDataNodeNo = recvBody["dataNodeNo"].asString();
                param.mDataNodeName = recvBody["dataNodeName"].asString();
                JsonData jd;                
                std::string data = jd.JsonCmd_Cgi_28(param);
                return data;
            }
            break;
            case 29:{
                JsonData jd;
                Param_29 param;
                param.mChannelId = recvBody["channelId"].asString();
                param.mPackageFlag = recvBody["package"].asInt();
                param.mDataNodeNo = recvBody["dataNodeNo"].asString();
                std::string data = jd.JsonCmd_Cgi_29(param);
                return data;
            }
            break;
            case 30:{
	             JsonData jd;
		         Param_30 param;
	             param.mChannelId = recvBody["channelId"].asString();
                 param.mPackageFlag = recvBody["package"].asInt();
                 param.mDataNodeNo = recvBody["dataNodeNo"].asString();
				 std::string data = jd.JsonCmd_Cgi_30(param);
		         return data;
		    }
			break;
			case 31:{
				JsonData jd;
				Param_31 param;
				std::string data;
				std::string type = recvBody["type"].asString();
				if(0 == type.compare("SET"))
				{
					param.mMode = 0;
					param.mChannelId = recvBody["channel"].asString();
					param.mPanID = recvBody["PanID"].asString();
					data = jd.JsonCmd_Cgi_31(param);
					sleep(1);
					system("reboot");

				}else{
					param.mMode = 1;
				    data = jd.JsonCmd_Cgi_31(param);
				}
				// std::string data = jd.JsonCmd_Cgi_31(param);
				return data;
			}
			break;
			case 40:{
				JsonData jd;
				Param_40 param;
				param.mChannelId = recvBody["channelId"].asString();
			    param.mPackageFlag = recvBody["package"].asInt();
			    param.mDataNodeNo = recvBody["dataNodeNo"].asString();
			    param.StartFrequency = recvBody["StartFrequency"].asInt();
			    param.EndFrequency = recvBody["EndFrequency"].asInt();
				std::string data = jd.JsonCmd_Cgi_40(param);
				return data;
			}
			break;
			case 41:{
				JsonData jd;
				Param_41 param;
				std::vector<Param_41> param41;
				for(int i = 0; i < recvBody.size();i++){
					param.mdataNodeNo = recvBody[i]["dataNodeNo"].asString();
					param.mfeatureInterVal = recvBody[i]["featureInterVal"].asInt();
					param.mwaveInterVal = recvBody[i]["waveInterVal"].asInt();
					param.msamplingRate = recvBody[i]["samplingRate"].asInt();
					param.mrange = recvBody[i]["range"].asInt();
					param.mAccSampleTime = recvBody[i]["ACCSampleTime"].asInt();
					param.mstartBrands = recvBody[i]["startBrands"].asString();
					param.mstopBrands = recvBody[i]["stopBrands"].asString();
					param.menvelopeBandPass = recvBody[i]["envelopeBandPass"].asString();
					param.mviff = recvBody[i]["viff"].asInt();
					param.mfaultFrequency = recvBody[i]["faultFrequency"].asString();
					param.mdataNodeName = recvBody[i]["dataNodeName"].asString();
					param.ZigbeePower = recvBody[i]["ZigbeePower"].asInt();
					param.ZigbeeRetry = recvBody[i]["ZigbeeRetry"].asInt();
					param.mMeasurementID = recvBody[i]["MeasurementID"].asString();
					param41.push_back(param);
				}
				std::string data = jd.JsonCmd_Cgi_41(param41);
				char whereCon[64] = { 0 };
				sprintf(whereCon, " UpdateFlag <> 1 ");
				string strData = sql_ctl->GetNodeConfigureInfor(whereCon);
				data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
				return data;
			}
			break;
			case 42:{
				JsonData jd;
				Param_42 param;
				param.fileName = recvBody["fileName"].asString();
				std::string data = jd.JsonCmd_Cgi_42(param);
				return data;
			}
			break;
			case 50:{
				JsonData jd;
				std::string data = jd.JsonCmd_Cgi_50();
				return data;
			}

			break;
			case 51:{
				JsonData jd;
				Param_51 param;
				std::string type = recvBody["type"].asString();
				if(0 == type.compare("SET")){
					param.mMode = 0;
					param.strGateWayMAC = recvBody["gateWayNo"].asString();
					param.strGateWayLocation = recvBody["gateWayLocation"].asString();

				}else{
					param.mMode = 1;
				}
				std::string data = jd.JsonCmd_Cgi_51(param);
				return data;
			}
			break;
			case 52:{
			    Param_52 param;
			    param.mCmdSerial = recvValue["cmdSerial"].asString();
			    std::string type = recvBody["type"].asString();
			    if (0 == type.compare("SCAN")) {
			       param.mMode = 0;
			    }
			    if (0 == type.compare("SET")) {
			        param.mMode = 1;
			        param.mSsid = recvBody["ssid"].asString();
			        param.mPassWord = recvBody["password"].asString();
			    }
			    if (0 == type.compare("GET")) {
			        param.mMode = 2;
			    }
			    if (0 == type.compare("CLEAN")) {
			        param.mMode = 3;
			    }
			    JsonData jd;
			    std::string data = jd.JsonCmd_Cgi_52(param);
			    return data;
			}
			break;
			case 53:{
				JsonData jd;
				Param_53 param;
				std::vector<Param_53> param53;
				for(int i = 0; i < recvBody.size();i++){
					param.mdataNodeNo = recvBody[i]["dataNodeNo"].asString();
					param.mUpdateKey = recvBody[i]["updateKey"].asString();
					param.mUpdateValue = recvBody[i]["updateValue"].asString();
					param.mUpdateKey2 = recvBody[i]["updateKey2"].asString();
					param.mUpdateValue2 = recvBody[i]["updateValue2"].asString();
					param.mUpdateKey3 = recvBody[i]["updateKey3"].asString();
					param.mUpdateValue3 = recvBody[i]["updateValue3"].asString();
					param53.push_back(param);
				}
				std::string data = jd.JsonCmd_Cgi_53(param53);
				char whereCon[64] = { 0 };
				sprintf(whereCon, "UpdateFlag <> 0 ");
				string strData = sql_ctl->GetNodeConfigureInfor(whereCon);
				data_publish(strData.c_str(), GlobalConfig::Topic_G.mPubConfig.c_str());
				return data;
			}break;
			case 54:{
                JsonData jd;
                Param_54 param;
                param.mPackageFlag = recvBody["package"].asInt();
                std::string data = jd.JsonCmd_Cgi_54(param);
                return data;
            }
            break;
			case 55:{
	             JsonData jd;
		         Param_55 param;
	             param.mChannelId = recvBody["channelId"].asString();
                 param.mPackageFlag = recvBody["package"].asInt();
                 param.mDataNodeNo = recvBody["dataNodeNo"].asString();
				 std::string data = jd.JsonCmd_Cgi_55(param);
		         return data;
		    }
			break;
			case 56:{
	             JsonData jd;
		         Param_56 param;
	             param.mChannelId = recvBody["channelId"].asString();
                 param.mPackageFlag = recvBody["package"].asInt();
                 param.mDataNodeNo = recvBody["dataNodeNo"].asString();
				 std::string data = jd.JsonCmd_Cgi_56(param);
		         return data;
		    }
			break;
            default:
                JsonData jd;
                std::string data = jd.JsonCmd_Cgi_default();                
                return data;
            break;
        }
    }
} catch(...){
    Json::Value jsVal;
    jsVal["success"] = false;
    jsVal["message"] = "未知错误";
    Json::FastWriter fw;
    return fw.write(jsVal);
}
}