#include "SH_LocalServer.hpp"

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

LocalServer::LocalServer()
{

}

LocalServer::~LocalServer()
{
    print_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);
	    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;

	    print_brown("pData : %s \n", pData.c_str());
	    Json::Reader recvReader;
		Json::Value recvValue;
	    Json::Value recvBody;
		if (recvReader.parse(pData, recvValue)) {
	        std::string cmdBody = recvValue["cmdBody"].asString();
	        if (!recvReader.parse(cmdBody, recvBody)) {
	            print_error("recv body error");
	            return;
	        }
		//	recvBody = recvValue["cmdBody"];
			std::string str = recvBody["timestamp"].asString();
	        int cmdType = atoi(recvValue["cmd"].asString().c_str());
	        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");
	                boost::this_thread::sleep(boost::posix_time::seconds(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 = boost::lexical_cast<unsigned long>(timestamp);
	                SetTime(itimestamp);
	                boost::this_thread::sleep(boost::posix_time::milliseconds(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 = boost::lexical_cast<std::string>(recvBody["localServerPort"].asInt());
	                    param.mCommMode = boost::lexical_cast<std::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 51:{
	            	JsonData jd;
	            	std::string data = jd.JsonCmd_51(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();
                } 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;
                std::string data = jd.JsonCmd_Cgi_09(); 
                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 = boost::lexical_cast<std::string>(recvBody["SystemSettings"]["CommMode"].asInt());
                } 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.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;
                std::string data = jd.JsonCmd_Cgi_26();
                return data;
            }
            break;
            case 27:{
                Param_27 param;
                param.mDataNodeNo = recvBody["dataNodeNo"].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.mChannelId = recvBody["channel"].asInt();
					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;
            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);
}  
}