#include "communication_cmd.hpp"
#include <boost/algorithm/string.hpp>
#include <zlog.h>
#include "common/global.hpp"
#include "mqttclient/mqtt_client.h"
#include "dbaccess/sql_db.hpp"
#include "platform/platform_init.hpp"
#include "utility/md5.h"
#include "utility/calculation.hpp"
#include "scheduler/schedule.hpp"

extern zlog_category_t *zct;

std::string JsonData::JsonCmd_Cgi_26(Param_26 &param) {
    Json::Value jsonVal;
    jsonVal.clear();

    jsonVal["cmd"] = "26";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = " ";

    char looseValue[10] = {0x00};
    readStringValue("config", "loose", looseValue, (char *)GlobalConfig::Config_G.c_str());
    Json::Value jsArray;
    array_t arrRes;
    arrRes = sqlite_db_ctrl::instance().GetDataMultiLineTransaction(T_SENSOR_INFO(TNAME), "*", NULL);
    int iResult = arrRes.size();
    if (iResult > 0) {
        int packgeNo = param.mPackageFlag;
        int packgeMax = 0;
        int packgeNum = 0;
        jsonVal["package"] = packgeNo;
        int lastSize = iResult % 10;
        int index = iResult / 10;
        if (lastSize > 0 && index > 0) {
            packgeMax = index + 1;
            if (packgeNo + 1 == packgeMax) {
                packgeNum = iResult;
                jsonVal["packageMax"] = index + 1;
            } else {
                packgeNum = (packgeNo + 1) * 10;
                jsonVal["packageMax"] = index + 1;
            }
        } else if (lastSize == 0 && index > 0) {
            packgeNum = (packgeNo + 1) * 10;
            packgeMax = index;
            jsonVal["packageMax"] = index;
        } else if (lastSize > 0 && index == 0) {
            packgeNum = lastSize;
            packgeMax = index + 1;
            jsonVal["packageMax"] = index;
        }
        for (int j = packgeNo * 10; j < packgeNum; j++) {
            Json::Value jsSensorData;
            jsSensorData["dataNodeNo"] = arrRes[j][0];
            jsSensorData["dataNodeName"] = arrRes[j][1];
            jsSensorData["initFlag"] = atoi(arrRes[j][2].c_str());
            jsSensorData["accFlag"] = atoi(arrRes[j][3].c_str());
            jsSensorData["zigbeeFlag"] = atoi(arrRes[j][4].c_str());
            jsSensorData["temTopFlag"] = atoi(arrRes[j][5].c_str());
            jsSensorData["temBotFlag"] = atoi(arrRes[j][6].c_str());
            jsSensorData["hardVersion"] = arrRes[j][8];
            jsSensorData["softVersion"] = arrRes[j][9];
            jsSensorData["bpNo"] = arrRes[j][10];
            jsSensorData["serialNo"] = arrRes[j][11];
            jsSensorData["firstPowerTime"] = arrRes[j][12];
            jsSensorData["WakeupTime"] = atoi(arrRes[j][13].c_str());
            jsSensorData["StaticTime"] = atoi(arrRes[j][14].c_str());
            jsSensorData["WaveTime"] = atoi(arrRes[j][15].c_str());
            jsSensorData["BateryV"] = arrRes[j][16];
            jsSensorData["ProductNo"] = arrRes[j][17];
            jsSensorData["configFlag"] = atoi(arrRes[j][18].c_str());
            jsSensorData["startBrands"] = arrRes[j][19];
            jsSensorData["stopBrands"] = arrRes[j][20];
            jsSensorData["featureInterVal"] = atoi(arrRes[j][21].c_str());
            jsSensorData["waveInterVal"] = atoi(arrRes[j][22].c_str());
            jsSensorData["samplingRate"] = atoi(arrRes[j][23].c_str());
            jsSensorData["range"] = atoi(arrRes[j][25].c_str());
            jsSensorData["envelopeBandPass"] = arrRes[j][26];
            jsSensorData["faultFrequency"] = arrRes[j][27];
            jsSensorData["zigbeePanId"] = arrRes[j][28];
            jsSensorData["zigbeeChannel"] = (arrRes[j][29]);
            jsSensorData["zigbeeAddr"] = arrRes[j][30];
            jsSensorData["zigbeeLongAddr"] = arrRes[j][31];
            jsSensorData["zigbeeDesAddr"] = arrRes[j][32];
            jsSensorData["ZigbeePower"] = atoi(arrRes[j][33].c_str());
            jsSensorData["ZigbeeRetry"] = atoi(arrRes[j][34].c_str());
            jsSensorData["ZigbeeRetryGap"] = atoi(arrRes[j][35].c_str());
            jsSensorData["ACCSampleTime"] = atoi(arrRes[j][36].c_str());
            jsSensorData["status"] = atoi(arrRes[j][37].c_str());
            jsSensorData["timeStamp"] = arrRes[j][38];
            jsSensorData["viff"] = atoi(arrRes[j][39].c_str());
            std::vector<std::string> vParam;
            boost::split(vParam, arrRes[j][42], boost::is_any_of(","), boost::token_compress_on);

            if (vParam.size() > 1)
                jsSensorData["loose"] = vParam[1];
            else
                jsSensorData["loose"] = "0";

            std::vector<std::string> vParamRSSI;
            boost::split(vParamRSSI, arrRes[j][40], boost::is_any_of(","), boost::token_compress_on);
            if (vParamRSSI.size() > 1) {
                jsSensorData["RSSI"] = arrRes[j][40];
            } else {
                jsSensorData["RSSI"] = "0," + arrRes[j][40];
            }
            jsSensorData["update"] = atoi(arrRes[j][41].c_str());
            jsSensorData["MeasurementID"] = arrRes[j][44];
            jsSensorData["battery"] = arrRes[j][43];
            jsSensorData["nodeWaveSend"] = arrRes[j][45];
            jsSensorData["upgradeStatus"] = arrRes[j][46];
            jsArray.append(jsSensorData);
        }
    } else {
        jsArray.resize(0);
        jsonVal["success"] = true;
    }
    jsonVal["gatewayMac"] = GlobalConfig::MacAddr_G;
    jsonVal["gatewayIP"] = GlobalConfig::IpAddr_G;
    jsonVal["content"]["dataNodeArray"] = jsArray;
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_54(Param_54 &param) {
    Json::Value jsonVal;
    jsonVal.clear();

    jsonVal["cmd"] = "54";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = " ";

    Json::Value jsArray, nodeArray, gatewayArray;
    array_t arrRes;
    arrRes = sqlite_db_ctrl::instance().GetDataMultiLineTransaction(T_SENSOR_INFO(TNAME), "*", NULL);
    int iResult = arrRes.size();
    if (iResult > 0) {
        int packgeNo = param.mPackageFlag;
        int packgeMax = 0;
        int packgeNum = 0;
        jsonVal["package"] = packgeNo;
        int lastSize = iResult % 10;
        int index = iResult / 10;
        if (lastSize > 0 && index > 0) {
            packgeMax = index + 1;
            if (packgeNo + 1 == packgeMax) {
                packgeNum = iResult;
                jsonVal["packageMax"] = index + 1;
            } else {
                packgeNum = (packgeNo + 1) * 10;
                jsonVal["packageMax"] = index + 1;
            }
        } else if (lastSize == 0 && index > 0) {
            packgeNum = (packgeNo + 1) * 10;
            packgeMax = index;
            jsonVal["packageMax"] = index;
        } else if (lastSize > 0 && index == 0) {
            packgeNum = lastSize;
            packgeMax = index + 1;
            jsonVal["packageMax"] = index;
        }

        for (int j = packgeNo * 10; j < packgeNum; j++) {
            Json::Value nodeArray;
            char hex[100];
            nodeArray.append(arrRes[j][0]);
            stringToHex(arrRes[j][1].c_str(), hex);
            nodeArray.append(hex);
            for (int k = 2; k <= 46; ++k) {
                nodeArray.append(arrRes[j][k]);
            }            
            jsArray.append(nodeArray);
        }

    } else {
        jsArray.resize(0);
        jsonVal["success"] = true;
    }
    Json::Value jsSystemSetting, jsonValnet, jsonValnet1, jsSystemInfo, jsonValZigbee;
    Json::Value jsBody;

    jsSystemSetting["ServerIpAddress"] = ReadStrByOpt(SERVERCONFIG, "Server", "localServerIpAddress");
    jsSystemSetting["ServerPort"] = (ReadStrByOpt(SERVERCONFIG, "Server", "localServerPort").c_str());
    jsSystemSetting["CommMode"] = (ReadStrByOpt(SERVERCONFIG, "Server", "CommMode").c_str());
    jsSystemSetting["UserName"] = ReadStrByOpt(SERVERCONFIG, "Server", "UserName");
    jsSystemSetting["Password"] = ReadStrByOpt(SERVERCONFIG, "Server", "Password");
    jsSystemSetting["APN"] = ReadStrByOpt(SERVERCONFIG, "Server", "APN");
    jsBody["ServerConfig"] = jsSystemSetting;
    jsonVal["content"] = jsBody;

#ifdef G2UL_GATEWAY
    jsonValnet1["dnsName"] = ReadStrByOpt(NETWORKCONFIG, "eth1", "dnsName");
    jsonValnet1["networkPortStatus"] = ReadStrByOpt(NETWORKCONFIG, "eth1", "networkPortStatus");
    jsonValnet1["gateway"] = ReadStrByOpt(NETWORKCONFIG, "eth1", "gateway");
    jsonValnet1["subnetMask"] = ReadStrByOpt(NETWORKCONFIG, "eth1", "subnetMask");
    jsonValnet1["dataWatchIpAddress"] = ReadStrByOpt(NETWORKCONFIG, "eth1", "ipAddress");
    jsonValnet1["hostName"] = ReadStrByOpt(NETWORKCONFIG, "eth1", "hostName");
    jsonVal["content"]["eth1"] = jsonValnet1;
    jsonVal["content"]["gatewaytype"] = 1;
#endif

    jsSystemInfo["GateWayVersion"] = ReadStrByOpt(SYSTEMINFOFILE, "Version", "GateWayVersion");
    jsSystemInfo["SystemVersion"] = ReadStrByOpt(SYSTEMINFOFILE, "Version", "SystemVersion");
    jsSystemInfo["WebVersion"] = ReadStrByOpt(SYSTEMINFOFILE, "Version", "WebVersion");
    jsSystemInfo["GateWayHwVesion"] = ReadStrByOpt(SYSTEMINFOFILE, "Version", "GateWayHwVesion");
    jsSystemInfo["GateWayProduct"] = ReadStrByOpt(SYSTEMINFOFILE, "Version", "GateWayProduct");
    jsonVal["content"]["SystemInfo"] = jsSystemInfo;

    jsonValZigbee["channel"] = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "channel");
    jsonValZigbee["PanID"] = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "PanID");
    jsonVal["content"]["zigbee"] = jsonValZigbee;

    jsonVal["gatewayMac"] = GlobalConfig::MacAddr_G;
    jsonVal["gatewayIP"] = GlobalConfig::IpAddr_G;
    jsonVal["content"]["dataNodeArray"] = jsArray;
    jsonVal["content"]["gateWay"] = gatewayArray;
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_27(Param_27 &param) {
    Json::Value jsonVal;
    jsonVal.clear();

    jsonVal["cmd"] = "27";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = " ";
    char whereCon[128] = {0};
    char localtimestamp[32] = {0};
    if (param.mDataNodeNo.length() > 0 && param.mType == "DELETE") {
        sprintf(whereCon, "%s= '%s'", T_SENSOR_INFO(DATANODENO), param.mDataNodeNo.c_str());
        sqlite_db_ctrl::instance().DeleteTableData(T_SENSOR_INFO(TNAME), whereCon);
        memset(whereCon,0,sizeof(whereCon));
        sprintf(whereCon, "%s= '%s'", T_SENSOR_INFO(DATANODENO), param.mMeasurementID.c_str());
        sqlite_db_ctrl::instance().DeleteTableData(T_DATA_INFO(TNAME), whereCon);
        sqlite_db_ctrl::instance().DeleteTableData(T_DATASTATIC_INFO(TNAME), whereCon);
        sqlite_db_ctrl::instance().DeleteTableData(T_BATTERY_INFO(TNAME), whereCon);
        sqlite_db_ctrl::instance().DeleteTableData(" t_battery_history ", whereCon);
        memset(whereCon,0,sizeof(whereCon));
        sprintf(whereCon, "channelID like '%%%s%%'", param.mMeasurementID.c_str());
        sqlite_db_ctrl::instance().DeleteTableData(" t_data_waveSend ", whereCon);
        char szTableName[50] = {0x00};
        sprintf(szTableName, "DROP TABLE t_data_%s", param.mMeasurementID.c_str());
        sqlite_db_ctrl::instance().CreateTable(szTableName);
        memset(szTableName, 0x00, sizeof(szTableName));
        sprintf(szTableName, "DROP TABLE t_dataStatic_%s", param.mMeasurementID.c_str());
        sqlite_db_ctrl::instance().CreateTable(szTableName);
        uint16_t short_addr;
        char *end_ptr = NULL;
        short_addr = strtol(param.mShortAddr.c_str(), &end_ptr, 16);
        zlog_warn(zct,"delete short_addr = %02x%02x",UINT16_HIGH(short_addr),UINT16_LOW(short_addr));
        scheduler::instance().ClearScheduleCfg(short_addr);

    } else if (param.mDataNodeNo.length() > 0 && param.mType == "CORRECT") {
        char updateSql[1024] = {0};
        sprintf(whereCon, "%s= '%s'", T_SENSOR_INFO(DATANODENO), param.mDataNodeNo.c_str());
        GetTimeNet(localtimestamp, 1);
        sprintf(updateSql, "LooseValue = '0,2,");
        std::string strUpdateSql = std::string(updateSql) + std::string(localtimestamp) + "' ";
        sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), strUpdateSql.c_str(), whereCon);
    } else {
        jsonVal["success"] = false;
        jsonVal["message"] = "没有传感器号";
    }
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_28(Param_28 &param) {
    Json::Value jsonVal;
    jsonVal.clear();

    jsonVal["cmd"] = "28";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = "";

    if (param.mDataNodeNo.length() > 0) {
        char updateColumn[128] = {0};
        char whereCon[64] = {0};
        sprintf(whereCon, "dataNodeNo='%s'", param.mDataNodeNo.c_str());
        sprintf(updateColumn, "dataNodeName='%s'", param.mDataNodeName.c_str());
        sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateColumn, whereCon);
    } else {
        jsonVal["success"] = false;
        jsonVal["message"] = "没有传感器号";
    }
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_29(Param_29 &param) {
    Json::Value jsonVal;
    Json::Value jsBody;
    Json::Value SystemSetting;
    jsonVal.clear();
    jsonVal["cmd"] = "29";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = " ";
    std::vector<float> vecWave;
    char whereCon[64] = {};
    sprintf(whereCon, "dataNodeNo='%s'", param.mDataNodeNo.c_str());
    vec_t res = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), " * ", whereCon);
    char localtimestamp[32] = {0};
    std::string strWaveData = "";
    std::string filename = "/opt/data/" + param.mChannelId + ".dat";
    if (access(filename.c_str(), 0) >= 0) {
        std::ifstream inFile(filename.c_str(), std::ios::in | std::ios::binary);
        if (!inFile) {
            zlog_error(zct, "read channel data error, filename:%s", filename.c_str());
            jsonVal["success"] = false;
            jsonVal["message"] = "error";
        } else {
            float fTemp = 0.0f;
            inFile.read((char *)localtimestamp, sizeof(localtimestamp));
            while (inFile.read((char *)&fTemp, sizeof(fTemp))) {
                vecWave.push_back(fTemp);
            }

            int flag = param.mPackageFlag;
            flag = (flag + 1) * 1024;
            int number = vecWave.size();
            int start = param.mPackageFlag * 1024;
            if (number < 1024) {
                flag = number;
                start = 0;
            }
            char buf[32];
            for (int i = start; i < flag; i++) {
                if (i == start) {
                    memset(buf, 0, 32);
                    sprintf(buf, "%.2f", vecWave[i]);
                    std::string waveTemp(buf);
                    strWaveData = waveTemp;

                } else {
                    memset(buf, 0, 32);
                    sprintf(buf, "%.2f", vecWave[i]);
                    std::string waveTemp(buf);
                    strWaveData = strWaveData + "," + waveTemp;
                }
            }
            int max = number / 1024;
            if (max == 0 && number > 0) {
                max = 1;
            }
            jsBody["packageMax"] = max;
        }

    } else {
        jsonVal["success"] = false;
        jsonVal["message"] = "没有数据文件";
    }
    jsBody["channelId"] = param.mChannelId;
    jsBody["package"] = param.mPackageFlag;
    zlog_info(zct, "vecWave.size() = %d,sample = %d,second = %f", vecWave.size(), atoi(res[23].c_str()), float(vecWave.size() / atoi(res[23].c_str())));
    std::string::size_type comper = param.mChannelId.find("Z");
    if (comper != std::string::npos && res[17] == "02") {
        jsBody["second"] = float((float)vecWave.size() / (float)atoi(res[23].c_str()));
    } else if (res[17] == "01") {
        jsBody["second"] = float((float)vecWave.size() / (float)atoi(res[23].c_str()));
    } else {
        jsBody["second"] = 1;
    }

    jsBody["Data"] = strWaveData;
    jsBody["timestamp"] = std::string(localtimestamp);
    jsonVal["content"] = jsBody;
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_30(Param_30 &param) {
    Json::Value jsonVal;
    Json::Value jsBody;
    Json::Value SystemSetting;
    jsonVal.clear();

    jsonVal["cmd"] = "30";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = "";
    std::string strWaveData;
    std::string filename = "/opt/data/" + param.mChannelId + ".dat";
    char localtimestamp[32] = {0};
    std::vector<float> vecWave;
    std::vector<float> hanningWave;
    std::vector<float> addhanningWave;
    std::vector<float> fftWave;
    int sampleRateReference = 0;
    /* 新增代码 */
    char whereCon[64] = {};
    sprintf(whereCon, "dataNodeNo='%s'", param.mDataNodeNo.c_str());
    vec_t res = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), " * ", whereCon);
    if (access(filename.c_str(), 0) >= 0) {
        std::ifstream inFile(filename.c_str(), std::ios::in | std::ios::binary);
        if (!inFile) {
            zlog_error(zct, "read channel data error, filename:%s", filename.c_str());
            jsonVal["success"] = "false";
            jsonVal["message"] = "error";
        } else {
            float fTemp = 0.0f;

            inFile.read((char *)localtimestamp, sizeof(localtimestamp));
            std::string::size_type comper = param.mChannelId.find("Z");
            if (comper != std::string::npos && res[17] == "02") {
                while (inFile.read((char *)&fTemp, sizeof(fTemp))) {
                    vecWave.push_back(fTemp);
                }
                //进行傅立叶变换
                Calculation::FFTSpec(vecWave, fftWave);
                sampleRateReference = 1000;

            } else {
                while (inFile.read((char *)&fTemp, sizeof(fTemp))) { // 取8K进行计算
                    vecWave.push_back(fTemp);
                }

                //进行傅立叶变换
                Calculation::FFTSpec(vecWave, fftWave);
                sampleRateReference = 1024;
            }
            int flag = param.mPackageFlag;
            flag = (flag + 1) * sampleRateReference;
            int number = fftWave.size();
            int start = param.mPackageFlag * sampleRateReference;
            if (number < sampleRateReference) {
                flag = number;
                start = 0;
            }
            char buf[32];
            for (int i = start; i < flag; i++) {
                if (i == start) {
                    memset(buf, 0, 32);
                    sprintf(buf, "%.6f", fftWave[i]);
                    std::string waveTemp(buf);
                    strWaveData = waveTemp;

                } else {
                    memset(buf, 0, 32);
                    sprintf(buf, "%.6f", fftWave[i]);
                    std::string waveTemp(buf);
                    strWaveData = strWaveData + "," + waveTemp;
                }
            }

            int max = number / sampleRateReference;
            if (max == 0 && number > 0) {
                max = 1;
            }
            jsBody["packageMax"] = max;
        }
    } else {
        jsonVal["success"] = false;
        jsonVal["message"] = "没有数据文件";
    }

    jsBody["channelId"] = param.mChannelId;
    jsBody["package"] = param.mPackageFlag;
    jsBody["timestamp"] = std::string(localtimestamp);
    jsBody["Data"] = strWaveData;

    double resolution = 0.0;
    int SampleRate = 0;
    zlog_info(zct, "sensor type %s", res[17].c_str());
    if (res[17] == "01") {
        SampleRate = atoi(res[23].c_str());
        zlog_info(zct, "sample_rate=%d", SampleRate);
        resolution = (((double)SampleRate / 1000) * 1016) / vecWave.size();

    } else if (res[17] == "02") {
        std::string::size_type comper = param.mChannelId.find("Z");
        if (comper != std::string::npos) {
            SampleRate = atoi(res[23].c_str());
            resolution = (double)SampleRate / vecWave.size();
            zlog_info(zct, "sample_rate=%d,resolution = %f", SampleRate, resolution);
        } else {
            SampleRate = 8192;
            zlog_info(zct, "sample_rate=%d", SampleRate);
            if (vecWave.size() < 8192) {
                resolution = (double)SampleRate / vecWave.size();
            } else {
                resolution = (double)SampleRate / 8192;
            }
        }
    }

    zlog_info(zct, "the sample rate is %d,the resolution %f", SampleRate, resolution);
    char buf[32];
    memset(buf, 0, 32);
    sprintf(buf, "%f", resolution);
    jsBody["resolution"] = std::string(buf);

    jsonVal["content"] = jsBody;
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_40(Param_40 &param) {
    Json::Value jsonVal;
    Json::Value jsBody;
    Json::Value SystemSetting;
    jsonVal.clear();

    jsonVal["cmd"] = "40";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = "";
    int i = 0;
    int sampleRateReference = 0;
    std::vector<float> vecWave;
    char whereCon[64] = {0};
    sprintf(whereCon, "dataNodeNo='%s'", param.mDataNodeNo.c_str());
    vec_t res = sqlite_db_ctrl::instance().GetDataSingleLine(T_SENSOR_INFO(TNAME), " * ", whereCon);
    std::string strWaveData;
    std::string filename = "/opt/data/" + param.mChannelId + ".dat";
    char localtimestamp[32] = {0};
    if (access(filename.c_str(), 0) >= 0) {
        std::ifstream inFile(filename.c_str(), std::ios::in | std::ios::binary);
        if (!inFile) {
            zlog_error(zct, "read channel data error, filename:%s", filename.c_str());
            jsonVal["success"] = "false";
            jsonVal["message"] = "error";
        } else {
            float fTemp = 0;

            std::vector<float> envWave;
            std::vector<float> hanningWave;
            std::vector<float> addhanningWave;
            inFile.read((char *)localtimestamp, sizeof(localtimestamp));
            std::string::size_type comper = param.mChannelId.find("Z");
            if (comper != std::string::npos && res[17] == "02") {
                while (inFile.read((char *)&fTemp, sizeof(fTemp))) {
                    vecWave.push_back(fTemp);
                }
                //添加汉宁窗
                Calculation::Hanning(vecWave, hanningWave);
                for (size_t i = 0; i < vecWave.size(); i++) {
                    addhanningWave.push_back(vecWave[i] * hanningWave[i]);
                }

                //进行傅立叶变换
                if (param.StartFrequency == 0) {
                    param.StartFrequency = 3000;
                    param.EndFrequency = 5000;
                }

                Calculation::envSpec(addhanningWave, envWave, param.StartFrequency, param.EndFrequency);
                sampleRateReference = 1000;

            } else {
                while (inFile.read((char *)&fTemp, sizeof(fTemp))) { // 取8K进行计算
                    if (i < 8192) {
                        vecWave.push_back(fTemp);
                    } else {
                        break;
                    }
                    i++;
                }
                if (vecWave.size() < 8192) {
                    for (int i = vecWave.size(); i < 8192; i++) {
                        vecWave.push_back(0);
                    }
                }

                //添加汉宁窗
                Calculation::Hanning(vecWave, hanningWave);
                for (size_t i = 0; i < vecWave.size(); i++) {
                    addhanningWave.push_back(vecWave[i] * hanningWave[i]);
                }

                //进行傅立叶变换
                if (param.StartFrequency == 0) {
                    param.StartFrequency = 3000;
                    param.EndFrequency = 5000;
                }

                Calculation::envSpec(addhanningWave, envWave, param.StartFrequency, param.EndFrequency);
                sampleRateReference = 1024;
            }
            /*for(int i = 0; i < envWave.size();i++){
                envWave[i] = envWave[i]*2;
            }*/

            zlog_info(zct, "2---------------------------------------------->%d", envWave.size());
            zlog_info(zct, "2---------------------------------------------->%f", envWave[10]);

            zlog_info(zct, "after fft--------------------------------------------------->fftWave.size()=%d", envWave.size());

            int flag = param.mPackageFlag;
            flag = (flag + 1) * sampleRateReference;
            int number = envWave.size();
            int start = param.mPackageFlag * sampleRateReference;
            zlog_info(zct, "param.mPackageFlag = %d", param.mPackageFlag);
            zlog_info(zct, "param.start = %d", start);
            zlog_info(zct, "param.flag = %d", flag);
            if (number < sampleRateReference) {
                flag = number;
                start = 0;
            }
            char buf[32];
            for (int i = start; i < flag; i++) {
                if (i == start) {
                    memset(buf, 0, 32);
                    sprintf(buf, "%.6f", envWave[i]);
                    std::string waveTemp(buf);
                    strWaveData = waveTemp;

                } else {
                    memset(buf, 0, 32);
                    sprintf(buf, "%.6f", envWave[i]);
                    std::string waveTemp(buf);
                    strWaveData = strWaveData + "," + waveTemp;
                }
            }

            int max = number / sampleRateReference;
            if (max == 0 && number > 0) {
                max = 1;
            }
            jsBody["packageMax"] = max;
        }
    } else {
        jsonVal["success"] = false;
        jsonVal["message"] = "没有数据文件";
    }

    jsBody["channelId"] = param.mChannelId;
    jsBody["package"] = param.mPackageFlag;
    jsBody["timestamp"] = std::string(localtimestamp);
    jsBody["Data"] = strWaveData;

    double resolution = 0.0;
    int SampleRate = 0;
    zlog_info(zct, "sensor type %s", res[17].c_str());
    if (res[17] == "01") {
        SampleRate = atoi(res[23].c_str());
        zlog_info(zct, "sample_rate=%d", SampleRate);
        resolution = (((double)SampleRate / 1000) * 1016) / 8192;
    } else if (res[17] == "02") {
        std::string::size_type comper = param.mChannelId.find("Z");
        if (comper != std::string::npos) {
            SampleRate = atoi(res[23].c_str());

            resolution = (double)SampleRate / vecWave.size();
            zlog_info(zct, "sample_rate=%d,resolution = %f", SampleRate, resolution);
        } else {
            SampleRate = 8000;
            zlog_info(zct, "sample_rate=%d", SampleRate);
            resolution = (((double)SampleRate / 1000) * 1024) / 8192;
        }
    }

    zlog_info(zct, "the sample rate is %d,the resolution %f", SampleRate, resolution);
    char buf[32];
    memset(buf, 0, 32);
    sprintf(buf, "%f", resolution);
    jsBody["resolution"] = std::string(buf);

    jsonVal["content"] = jsBody;
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_41(std::vector<Param_41> &param, int isServer) {
    Json::Value jsonVal;
    jsonVal.clear();

    jsonVal["cmd"] = "41";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = " ";

    char whereCon[1024] = {0};
    char updateSql[1024] = {0};

    for (size_t i = 0; i < param.size(); i++) {

        if (!isServer)
            sprintf(whereCon, "dataNodeNo='%s'", param[i].mdataNodeNo.c_str());
        else
            sprintf(whereCon, "MeasurementID ='%s'", param[i].mdataNodeNo.c_str());

        std::string zigbeeShortAddr = sqlite_db_ctrl::instance().GetData(T_SENSOR_INFO(TNAME), " zigbeeShortAddr ", whereCon);
       
        uint16_t short_addr;
        char *end_ptr = NULL;
        short_addr = strtol(zigbeeShortAddr.c_str(), &end_ptr, 16);
        int res = scheduler::instance().UpdateSensorConfig(short_addr);
        if (res != 0){
            jsonVal["success"] = false;
            jsonVal["message"] = "update error";
            return show_value_.write(jsonVal);
        }
        char dataNodeName[100] = {0x00};
        hexToAscii(param[i].mdataNodeName.c_str(), dataNodeName);
        zlog_info(zct, "str = %s", dataNodeName);
        zlog_info(zct, "dataNodeName = %s", param[i].mdataNodeName.c_str());
        int dataNodeNameLength = param[i].mdataNodeName.length();
        if (dataNodeNameLength != 0) {
            sprintf(updateSql, "dataNodeName = '%s',ZigbeePower = '%d',ZigbeeRetry = '%d',range='%d',samplingRate='%d',AccSampleTime = '%d',\
				startBrands = '%s',stopBrands = '%s',envelopeBandPass = '%s',viff = '%d',faultFrequency = '%s' ,MeasurementID = '%s' ,UpdateFlag = -1",
                    dataNodeName, param[i].ZigbeePower, param[i].ZigbeeRetry, param[i].mrange, param[i].msamplingRate, param[i].mAccSampleTime, param[i].mstartBrands.c_str(), param[i].mstopBrands.c_str(),
                    param[i].menvelopeBandPass.c_str(), param[i].mviff, param[i].mfaultFrequency.c_str(), param[i].mMeasurementID.c_str());
        } else if (dataNodeNameLength == 0) {
            sprintf(updateSql, "ZigbeePower = '%d',ZigbeeRetry = '%d',range='%d',samplingRate='%d',AccSampleTime = '%d',\
				startBrands = '%s',stopBrands = '%s',envelopeBandPass = '%s',viff = '%d',faultFrequency = '%s',MeasurementID = '%s',UpdateFlag = 0",
                    param[i].ZigbeePower, param[i].ZigbeeRetry,  param[i].mrange, param[i].msamplingRate, param[i].mAccSampleTime, param[i].mstartBrands.c_str(), param[i].mstopBrands.c_str(), param[i].menvelopeBandPass.c_str(),
                    param[i].mviff, param[i].mfaultFrequency.c_str(), param[i].mMeasurementID.c_str());
        }
         int iRet = sqlite_db_ctrl::instance().UpdateTableData(T_SENSOR_INFO(TNAME), updateSql, whereCon);
        memset(whereCon, 0x00, sizeof(whereCon));
        memset(updateSql, 0x00, sizeof(updateSql));
        if (iRet != 0) jsonVal["success"] = false;
    }
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_42(Param_42 &param) {
    Json::Value jsonVal;
    jsonVal.clear();
    jsonVal["cmd"] = "42";
    jsonVal["dataNodeGatewayNo"] = GlobalConfig::MacAddr_G;
    jsonVal["success"] = true;
    jsonVal["message"] = "上传成功!";
    char cmd[100] = {0x00};
    strcpy(cmd, "rm -rf /tmp/cgic*");
    system(cmd);
    if (param.fileName == "DataNode.tar") {
        std::string strcmd = "tar xvf /opt/";
        strcmd = strcmd + param.fileName;
        strcmd = strcmd + " -C /opt/";
        zlog_info(zct, "strcmd = %s", strcmd.c_str());
        system(strcmd.c_str());
    } else if (param.fileName == "rfsbu.tar") {
        zlog_info(zct, "update rfsbu.tar");
        sleep(3);
        zlog_info(zct, "strcmd = %s", param.fileName.c_str());
        int iRet = system("/opt/opt.sh");
        zlog_info(zct, "iRet = %d", iRet);
        if (iRet == -1) {
            zlog_error(zct, "system() error");
        }
    } else if (param.fileName == "update.json") {
        zlog_info(zct, "strcmd = %s", param.fileName.c_str());

        ReadStrConfig("/opt/update.json");
    } else if (param.fileName == "backup.json") {
        ImportConfig("/opt/backup.json");
    } else if (param.fileName == "DataNode.csv") {
        zlog_info(zct, "strcmd = %s", param.fileName.c_str());

        int iRet = UpdataDataNodeConfig("/opt/DataNode.csv");
        std::string str = std::to_string(iRet) + "个传感器更新成功";
        if (iRet < 0) {
            jsonVal["success"] = false;
            jsonVal["message"] = "更新失败!";
        } else {
            jsonVal["success"] = true;
            jsonVal["message"] = str;
        }

    }
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_31(Param_31 &param) {
    Json::Value jsonVal;
    jsonVal.clear();
    jsonVal["cmd"] = "31";
    if (0 == param.mMode) {
        WriteStr2Config(ZIGBEECONFIG, "Zigbee", "channel", param.mChannelId);
        WriteStr2Config(ZIGBEECONFIG, "Zigbee", "PanID", param.mPanID);
        char whereCon[1024] = {0};
		char updateSql[1024] = { 0 };
		sprintf(updateSql, "zigbeePanID = '%s',zigbeeChannel = '%s'",\
				param.mPanID.c_str(),param.mChannelId.c_str());
		sprintf(whereCon, "gatewayMAC='%s'", GlobalConfig::MacAddr_G.c_str());
		sqlite_db_ctrl::instance().UpdateTableData(T_GATEWAY_INFO(TNAME), updateSql, whereCon);
		system("reboot");
    }
    Json::Value jsBody;
    jsonVal["message"] = "设置完成";
    jsonVal["success"] = true;
    jsBody["channel"] = ReadStrByOpt(ZIGBEECONFIG, "Zigbee", "channel");
    jsBody["panID"] = GlobalConfig::ZigbeeInfo_G.PanID;
    jsBody["RetryNum"] = GlobalConfig::ZigbeeInfo_G.RetryNum;
    jsBody["TranTimeout"] = GlobalConfig::ZigbeeInfo_G.TranTimeout;
    jsBody["status"] = "1";
    jsonVal["content"] = jsBody;

    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_32(Param_32 &param) {
    Json::Value jsonVal;
    jsonVal.clear();

    jsonVal["cmd"] = "32";
    jsonVal["success"] = true;
    jsonVal["message"] = "";
    Json::Value jsBody;
    std::string strWaveData;

    jsBody["channelId"] = param.mChannelId;
    jsBody["package"] = param.mPackageFlag;
    jsBody["Data"] = strWaveData;

    jsonVal["content"] = jsBody;
    return show_value_.write(jsonVal);
}

std::string JsonData::JsonCmd_Cgi_43() {
    Json::Value jsonVal;
    jsonVal.clear();
    jsonVal["success"] = true;
    jsonVal["message"] = "";
    return show_value_.write(jsonVal);
}