#ifndef _COMMONFUNC_
#define _COMMONFUNC_

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>
#include <stdlib.h>
#include <memory.h>
#include <string>
#include <list>
#include <boost/algorithm/string/split.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <iostream> 
#include <fstream> 
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <boost/lexical_cast.hpp>
#include <sys/statfs.h>
#include <json/json.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <memory.h>
#include <sys/ipc.h>//ipc
#include <sys/shm.h>
#include "dirent.h"
#include <iconv.h>
#include <termios.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <netdb.h>
#include "Mutex.h"

typedef  struct statfs DISK,*pDISK;

#define SECTION_MAX_LEN 256
#define STRVALUE_MAX_LEN 256
#define LINE_CONTENT_MAX_LEN 256
//配置文件位置
#define NETWORK "/etc/network/interfaces"
#define SYSTEMINFOFILE "/opt/configenv/SystemInfo.json"        //系统信息
#define SERVERCONFIG "/opt/configenv/ServerConfig.json"
#define NETWORKCONFIG "/opt/configenv/NetWorkConfig.json"
#define SOFTWARE_RUN_LOG  "/opt/log/"
#define BOARDTYPE "/opt/configenv/boardtype"   //设备类型
#define ZIGBEECONFIG "/opt/configenv/ZigbeeConfig.json" 


#define SN "/opt/system/sn" //设备序列号
#define SYSTEMSTART "/opt/system/start"  //系统启动类型标志  0：正常启动  1：重启   2:
#define BUILD_UINT16(x,y)           (((x & 0x00FFu) << 8u) | (y & 0x00FFu))
#define BUILD_UINT2(x,y)           (((x) << 2u) | (y))
// 生成UINT32 数据
#define BUILD_UINT32(u,v,x,y)        (((u & 0x00FFu) << 24u) | (v & 0x00FFu) << 16u) | (((x & 0x00FFu) << 8u) | (y & 0x00FFu))
// 获取UINT32的高低字节
#define UINT32_HIGH_1(x)            ((x & 0xFF000000u) >> 24u)
#define UINT32_HIGH_2(x)            ((x & 0x00FF0000u) >> 16u)
#define UINT32_LOW_1(x)             ((x & 0x0000FF00u) >>  8u)
#define UINT32_LOW_2(x)             ((x & 0x000000FFu))
#define	GET_BIT(x, bit)	((x & (1 << bit)) >> bit)	/* 获取第bit位 */
// 获取UINT32的高低字节
#define UINT16_HIGH(x)            ((x & 0xFF00u) >> 8u)
#define UINT16_LOW(x)             ((x & 0x00FFu))


#define GENERAL_BUF_SIZE 128*1024*10
using namespace std;




enum TIME_SIZE{
    TIME_MINUTE=5,
    TIME_SECEOND=8
};

struct DevData{
    char mData[128];
    char mDataMing[128];
    int mLen;
    DevData():mLen(0){
        memset(mData, 0, 128);
        memset(mDataMing, 0, 128);
    }
};
struct compressWaveChannel
{
	int compressChannelX;
    int compressChannelY;
    int compressChannelZ;
	int CountX;
	int CountY;
	int CountZ;
	compressWaveChannel(){
		compressChannelX = 0;
		compressChannelY = 0;
		compressChannelZ = 0;
		CountX = 0;
	 	CountY = 0;
	 	CountZ = 0;
	}
};

struct DevDataOfGwid{
    std::string mDevdata;
    std::string mDevid;
    bool mIsSimulate;
    DevDataOfGwid():mDevdata(""),mDevid(""),mIsSimulate(false){
    }
};

typedef void (*onReceiveUart) (DevDataOfGwid &devData);

struct sys_data {
	char data[10240];
};

typedef struct {
	int total;
	int count;
	int type;
    int number;
	int flag;
    char channelId[16];
	char SensorEngineeringUnit[32];
	float waveData[32000];
} WAVE_CONTAIN;



struct ZigbeeInfo {
	int DevMode;
	int Channel;
	std::string PanID;
	std::string MyAddr;
	std::string DstAddr;
	std::string RetryNum;
	std::string TranTimeout;
};

struct ZIGBEE {
	char   reserve[4];
	char   DevName[16];
	char   DevPwd[16];
	unsigned char DevMode;
	unsigned char Chan;
	short PanID;
	short MyAddr;
	unsigned char MyIEEE[8];
	short DstAddr;
	unsigned char DstIEEE[8];
	unsigned char Reserve0;
	unsigned char PowerLevel;
	unsigned char RetryNum;
	unsigned char TranTimeout;
	unsigned char Serial_Rate;
	unsigned char Serial_DataB;
	unsigned char Serial_StopB;
	unsigned char Serial_ParityB;
	unsigned char Reserve[10];
};


struct RecvData {
	unsigned char Head[3];
	unsigned char ShortAddr[2];
	unsigned char Type;
	unsigned char Order;
	unsigned char Data[92];
	unsigned char Crc;
};

struct DataNodeInfo {
	int InitFlag;
	int AccFlag;
	int ZigbeeFlag;
	int TemTopFlag;
	int TemBotFlag;
	int EquipSta;//设备状态
	std::string ZigbeeLongAddr;
	std::string HardVersion;
	std::string SoftVersion;
	std::string BpNo;
	std::string SerialNo;
	std::string FirstPowerTime;
	int WakeupTime;
	int StaticTime;
	int WaveTime;
	int BateryV;
	std::string ProductNo;
	int RSSI;	// 接收信号强度
	int ConfigFlag;
	unsigned int FeatureInterVal; //特征值发送时间间隔，单位分钟
	unsigned int WaveInterVal;	  //原始数据发送时间间隔，单位分钟
	std::string ZigbeePanId;
	int ZigbeeChannel;
	std::string ZigbeeShortAddr;
	std::string ZigbeeDesAddr;
	int ZigbeePower;
	int ZigbeeRetry;
	int ZigbeeRetryGap;
	int Range;//量程
	int SamplingRate;//采样率
	int ACCSampleTime;//采样时间

	std::string StartBrands;	//频带能量参数 1,2,3,4,5,START
	std::string StopBrands;		//频带能量参数 1,2,3,4,5,END

	std::string EnvelopeBandPass;	//冲击带通频率
	std::string FaultFrequency;		//故障频率1,2,3,4

	std::string ConfigDate;//配置时间
	int VIntegralFilterFrequency;//速度积分滤波频率
	DataNodeInfo(){
		FeatureInterVal = 0;WaveInterVal = 0;
	}

};

struct DataRecvStatic {
	float TemTop;
	float TemBot;
	int Dip;
	int Voltage;
	float nodeWorkTime;
	float nodeSendTime;
	
};

struct DataRecvDym {
	float DiagnosisPk;
	float IntegratPk;
	float IntegratRMS;
	float RmsValues;
	float EnvelopEnergy;
	float Amp1;
	float Amp2;
	float Amp3;
	float Amp4;
	float Amp5;
	long  Time;
	float Phase1;
	float Phase2;
	float Phase3;
	float Phase4;
};

struct TopicList{
    std::string mPubData;        //每秒特征数据上传主题
    std::string mPubStatus;      //状态上传主题
	std::string mPubHeart;
    std::string mPubConfig;      //上传配置主题
    std::string mSubData;        //订阅主题
	std::string mPubWaveData;    //原始数据发布主题
	std::string mPubWaveSecondData;    //原始数据发布主题
	std::string mPubCmd;         //命令控制发布主题
	std::string mPubRep;
	std::string mPubTiming;		//校时

	std::string mPubLocalWifi;
	std::string mPubLocalWaveServer;
	std::string mPubLocalWaveQt;
	std::string mPubLocalTrigger;
	std::string mPubLocalConfig;
	std::string mPubLocalCmd;
};


//系统描述文件数据定义
typedef struct
{
	string siteID;				    //Unique ID for each site
	string siteName;   			    //Controller site name
	string siteCountry;			    //Controller location country
	string siteProvince;			//province
	string siteCity;				//city
	double siteLongitude;		    //longitude
	double siteLatitude;			//latitude
	string siteTimeZone;
	string plantName;				//Unique plant number
	string plantNo;
	string equipmentName;		    //Equipment Description in the plant
	string equipmentNo;
	string dataWatchName;    		//DNS Name for the DataWatch
	long dataWachAddedDate;		    //Date of settings’ creation (Time Stamp)
	string dataWatchAssetID;		//Unique equipment Asset ID
	string deviceType;
	string dataWachAddedBy;		    //User who edited settings
	string serialNumber;
	string softVersion;

}SystemInfo;

typedef struct {
	int number;
	std::string SensorEngineeringUnit;
	float waveData[GENERAL_BUF_SIZE];
} WAVE_GENERAL;


typedef struct{
	int zigAckrep;
	int zigAckreset;
	int zigReset;
	int zigDef;
	int alarmLight;
	int commPower;//4G,5G 电源开关
	int vol3_8;//5G 3.8v电源
	int commRest;//4G,5G复位
	int wifiPower;//WiFi 电源开关
	int wifiReset;//WiFi 复位
	int hardWatchDog;
	int power;
	int runLed;
	int errorLed;
	int netResetNet0;
	int netResetNet1;
} GPIOInfo;

struct Param_01 {
	int mMode;   //0:登陆  1:更改密码
	std::string mUserName;
	std::string mPassWord;
	std::string mPassWordNew;
	Param_01():mMode(0), mUserName(""), mPassWord(""), mPassWordNew(""){};
};

struct Param_02 {
	int mMode;   //0:配置时间  1:获取时间 
	int mSetType;
	int mTimeStamp;
	Param_02():mMode(0),mSetType(0),mTimeStamp(0){};
};


struct Param_20 {
    int mMode;  //0: 配置   1:获取
	std::string mCmdSerial;
    std::string mDataWatchName;
    std::string mDataWatchAssetId;
    std::string mDataWatchAddedBy;
    Param_20():mMode(0), mCmdSerial(""), mDataWatchName(""), mDataWatchAssetId(""), mDataWatchAddedBy(""){};
};


struct Param_22 {
    int mMode;
	std::string mCmdSerial;
    std::string mTimeZone;
    Param_22():mMode(0),mCmdSerial(""), mTimeZone(""){};
};


struct Param_23 {
    int mMode;
	std::string mCmdSerial;   
    std::string mServerIp;
	std::string mPort;
	std::string mCommMode;		// 通信模式，有线通信模式 = 1；4G LTE 无线通信模式 = 2
	std::string mUserName;
	std::string mPassword;
	std::string mAPN;
    Param_23():mMode(0),mCmdSerial(""), mServerIp(""),mPort(""),mCommMode(""),mUserName("chaos"),mPassword("HSD272*#xkd"),mAPN(""){};
};


struct Param_24 {
    int mMode; 
	std::string mCmdSerial;  
    std::string mFileServerIp;
	std::string mFilePort;
	std::string mFileServerSwitch;
    Param_24():mMode(0),mCmdSerial(""), mFileServerIp(""),mFilePort(""),mFileServerSwitch(""){};
};

struct Param_25 {
	int mMode;
	std::string mNet;
    std::string mCmdSerial;
    std::string mDnsName;
    std::string mNetworkPortStatus;
    std::string mGateway;
    std::string mSubnetMask;
    std::string mIp;
    std::string mHostName;
    Param_25():mMode(0),mCmdSerial(""), mDnsName(""),mGateway(""),mSubnetMask(""),mIp(""),mHostName(""){};
};

struct Param_09 {
	int mPackageFlag;
	Param_09():mPackageFlag(0){};
};
struct Param_10 {
	std::string strDataNode;
	std::string strStatic;
	std::string straxis;
	std::string timeStart;
	std::string timeEnd;
	std::string MeasurementID;
	int mPackageFlag;
	Param_10():strDataNode(""),strStatic(""),mPackageFlag(0){};
};
struct Param_11 {
	std::string DataNodeNo;
	Param_11():DataNodeNo(""){};
};
struct Param_26 {
	int mMode;
	std::string mCmdSerial;
	std::string mDataNodeNo;
	int mPackageFlag;
	Param_26():mMode(0),mCmdSerial(""),mDataNodeNo(""),mPackageFlag(0){};

};

struct Param_27 {
    int mMode;
	std::string mCmdSerial;
	std::string mDataNodeNo; 
	std::string mType;
    Param_27():mMode(0),mCmdSerial(""),mDataNodeNo(""),mType(""){};

};


struct Param_28 {
	int mMode;
	std::string mDataNodeNo;
	std::string mDataNodeName;
    Param_28():mMode(0),mDataNodeNo(""),mDataNodeName(""){};
};

struct Param_29 {
    int mMode;  
	std::string mCmdSerial;
	std::string mChannelId;
    std::string mDataNodeNo;
	int mPackageFlag;
    Param_29():mMode(0),mCmdSerial(""),mChannelId(""),mDataNodeNo(""),mPackageFlag(0){};
};

struct Param_30 {
    int mMode;  
	std::string mChannelId; 
	std::string mDataNodeNo;
	int mPackageFlag;
    Param_30():mMode(0),mChannelId(""),mDataNodeNo(""),mPackageFlag(0){};
};
struct Param_40 {
    int mMode;
	std::string mChannelId;
	std::string mDataNodeNo;
	int mPackageFlag;
	int StartFrequency;
	int EndFrequency;
	Param_40():mMode(0),mChannelId(""),mDataNodeNo(""),mPackageFlag(0),StartFrequency(0),EndFrequency(0){};
};
struct Param_41 {
	std::string mdataNodeName;
	std::string mdataNodeNo;
	std::string mMeasurementID;
	int mfeatureInterVal;
	int mwaveInterVal;
	int msamplingRate;
	int mrange;
	int mAccSampleTime;
	std::string mstartBrands;
	std::string mstopBrands;
	std::string menvelopeBandPass;
	int mviff;
	std::string mfaultFrequency;
	int ZigbeePower;
	int ZigbeeRetry;
	std::string nodeWaveSend;
	Param_41():mdataNodeName(""),mdataNodeNo(""),mfeatureInterVal(0),mwaveInterVal(0),msamplingRate(0),mrange(0),mAccSampleTime(0),\
			mstartBrands(""),mstopBrands(""),menvelopeBandPass(""),mviff(0),mfaultFrequency(""),mMeasurementID{""},nodeWaveSend{""}{};
};
struct Param_42 {
	string fileName;
	Param_42():fileName(""){};
};

struct Param_31 {
	int mMode;
	//int mChannelId; 
	std::string mChannelId;
	std::string mPanID;
	Param_31():mMode(0),mChannelId(""),mPanID(""){};
};


struct Param_32 {
    int mMode;
	std::string mChannelId;
	int mPackageFlag;
    Param_32():mMode(0),mChannelId(""),mPackageFlag(0){};
};
struct Param_33 {
    int mMode;  
	std::string mUnit; 
    Param_33():mMode(0),mUnit(""){};
};

struct Param_34 {
    int mMode;  
	std::string mBeforeTime;
	std::string mAfterTime;
	Param_34():mMode(0),mBeforeTime(""),mAfterTime(""){};
};

struct Param_35 {
    int mMode;
	std::string mTriggerInterValTime;
	std::string mTriggerInterValSwitch;
	Param_35():mMode(0),mTriggerInterValTime(""),mTriggerInterValSwitch(){};
};

struct Param_36 {
    int mMode;  
	std::string mTriggerTime;
	std::string mTriggerTimeSwitch;
	Param_36():mMode(0),mTriggerTime(""),mTriggerTimeSwitch(){};
};

struct Param_37 {
    int mMode;  
	std::string mTriggerDelayTime;
	std::string mTriggerDelaySwitch;
	Param_37():mMode(0),mTriggerDelayTime(""),mTriggerDelaySwitch(){};
};

struct Param_39 {
    int mMode;  
	int mPage;
	int mNumber;
};

struct Param_45 {
    int mMode;  //0: 配置   1:获取
	std::string mCmdSerial;
    std::string mCountryId;
    std::string mProvincesId ;
    std::string mCityListId;
    Param_45():mMode(0),mCmdSerial(""), mCountryId(""),mProvincesId(""),mCityListId(""){};
};

struct Param_46 {
	int mMode;
	std::string mFileName;
	Param_46():mMode(0),mFileName(""){};
};

struct Param_47 {
	int mMode;
	std::string mFileName;
	Param_47():mMode(0),mFileName(""){};
};
struct Param_51 {
	int mMode;
	string strGateWayMAC;
	string strGateWayLocation;
	Param_51():mMode(-1),strGateWayLocation(""){};
};
struct Param_52 {
	int mMode;
	std::string mCmdSerial;
	string mSsid;
	string mPassWord;
};
struct Param_53 {
	int mMode;
	string mdataNodeNo;
	string mUpdateKey;
	string mUpdateValue;
	string mUpdateKey2;
	string mUpdateValue2;
	string mUpdateKey3;
	string mUpdateValue3;
	Param_53():mUpdateKey2(""),mUpdateValue2(""),mUpdateKey3(""),mUpdateValue3(""){};
};
struct Param_54 {
	int mMode;
	std::string mCmdSerial;
	std::string mDataNodeNo;
	int mPackageFlag;
	Param_54():mMode(0),mCmdSerial(""),mDataNodeNo(""),mPackageFlag(0){};

};

struct Param_55 {
    int mMode;
	std::string mChannelId;
	std::string mDataNodeNo;
	int mPackageFlag;
	int StartFrequency;
	int EndFrequency;
	Param_55():mMode(0),mChannelId(""),mDataNodeNo(""),mPackageFlag(0),StartFrequency(0),EndFrequency(0){};
};

struct Param_56 {
    int mMode;
	std::string mChannelId;
	std::string mDataNodeNo;
	int mPackageFlag;
	int StartFrequency;
	int EndFrequency;
	Param_56():mMode(0),mChannelId(""),mDataNodeNo(""),mPackageFlag(0),StartFrequency(0),EndFrequency(0){};
};

typedef struct DataNodeUpdate{
	std::string	strUpdataFileName;
	std::string	strSoftVersion;
	std::vector <std::string> hwVersion;
};


struct ethtool_value {
      unsigned int   cmd;
      unsigned int   data;
};

extern std::string GBKToUTF8(const std::string& strGBK);
extern std::string UTFtoGBK(const char* utf8);
extern void hexToAscii(const char* hexStr, char* asciiStr);
extern void stringToHex(const char* str, char* hexStr);
extern string GetLocalTimeWithMs(void);
extern void InitGpio(unsigned int gpioN,unsigned int inout);
extern int gpio_set(unsigned int gpioN,char x);
extern int gpio_read(unsigned int gpioN);
extern int config_uart(const char* Port,speed_t speed);
extern int write_data(int fd, char *buff, int len);
extern int read_data(int fd, char *buff, int len, int timeout);
extern int ModifyMac(char* buff);
extern void mssleep(unsigned long microseconds);
//extern int str_recv(int fd, char srcshow,char* buffer);
/**
* @brief 系统运行时输入入参进行系统软件版本查询
* @param argv 输入参数 -vV版本查询  --debugmode日志调试模式
* @return 函数返回0执行成功
*/
extern int CheckFileVersion(int argc, char** argv);   

/**
* @brief 获取当前实时时间
* @return 时间string 例：2018-11-18 17:16:10
*/
extern std::string GetCurrentTime();                   

/**
* @brief  和系统交互函数
* @param cmd  要发出的系统命令 例：ls
* @param buf  系统返回的数据存在buf里
* @return -1：失败 0：成功
*/
extern int system_custom(const char *cmd, char *buf);


//extern int uartreadhandle();

/**
* @brief  向日志写入内存信息
*/
extern void WriteMemoryInfo();

/**
* @brief  获取当前日期
* @return 当前日期的string
*/
extern std::string GetDayDate();

/**
* @brief  获取当前时间 例 12：00
* @return void 
*/
extern void GetTime_(char * time_buff,TIME_SIZE len) ;

/**
* @brief  获取当前时间戳
* @param timebuf 定义的buf存储数据
* @param type 0 是毫秒级的时间戳  1 秒级的时间戳
* @return void
*/
extern void GetTimeNet(char* timebuf, int type);
extern std::string GetRTC(char* timebuf, int& millisecond);
/**
* @brief  从配置文件中读取数据
* @param filename 配置文件名
* @param config 配置选项
* @param option 具体配置参数
* @return std::string  返回要获取的参数数据
*/
extern std::string ReadStrByOpt(std::string filename, std::string config, std::string option);

/**
* @brief  写配置文件
* @param filename 配置文件名
* @param config 配置选项
* @param option 具体配置参数
* @param value 具体的数据值
* @return int  0：配置成功
*/
extern int WriteStr2Config(std::string filename, std::string config, std::string option, std::string value, bool listable = false);

/**
* @brief  获取设备的MAC地址做为设备的唯一标识
* @return std::string  Mac地址
*/
extern std::string GetLocalMac(const char* net);

/**
* @brief  获取设备IP
* @return std::string  IP地址
*/
extern std::string IpAddrInit();

/**
* @brief  获取正在工作的网卡
* @return std::string  
*/
extern std::string GetWorkNic();

/**
* @brief  获取系统基本信息
* @return std::string  CPU MEM DISK info
*/
extern std::string GetSysInfo();

/**
* @brief  去掉字符串所有空格
* @return std::string 
*/
extern std::string & ClearAllSpace(std::string &str);

/**
* @brief  调用接口写入data数据
* @return void 
*/
extern void StartWriteToDat();

/**
* @brief  循环检测文件
* @return void 
*/
extern void BackupDatFile();

/**
* @brief  降采样
* @return double
*/
extern float * ReSample(int WaveDataLength, int N, int *NewWaveDataLength, std::vector<float> & WaveData);

/**
* @brief  设置系统时间
* @return int
*/
extern int SetTime(unsigned long seconds, int milliseconds = 0);

/**
* @brief  删除配置文件
* @return int
*/
extern void RemoveConfig();

/**
* @brief  获取文件内容
* @param filename 文件名
* @param line 第几行
* @return std::string
*/
extern std::string GetFileContent(std::string filename, int line);

/**
* @brief 配置时区
* @param zoneid 时区ID
* @return void
*/
extern void ZoneConfig(std::string zoneid);

/**
* @brief  获取系统基本信息
* @return std::string  CPU MEM DISK info
*/
extern std::string GetSysStatus();
double GetHardDiskFree();
extern bool CheckIP(const char *ip);

bool IsValidMask(std::string mask);
//read update config file
extern std::vector <DataNodeUpdate> ReadStrUpdate(std::string filename);

extern void ReadStrConfig(std::string filename);
extern void ImportConfig(std::string filename);
extern int UpdataDataNodeConfig(std::string filename);
extern char* solve(char *dest,const char *src);
extern void swap(char *data);
extern int hexStringToBytes(const char* hexStr, unsigned char* bytes, size_t bytesSize);

extern int OpenWatchDog();
extern int WriteWatchDog(int fd);
extern int CloseWatchDog(int fd);
//获取4G信号强度
extern int getcsq();
extern std::string GetGwIp_(const char *eth_name);
extern string GetOneContent(const char* szData, int nRow, const char* szSeparate);
extern int readStringValue(const char* section, char* key, char* val, const char* file);
extern int writeStringVlaue(const char* section, char* key, char* val, const char* file);
extern int readIntValue(const char* section, char* key, const char* file);
extern int writeIntValue(const char* section, char* key, int val, const char* file);

int getDiskInfo(char* diskTotal,char* diskFree);

void timeout(int signo);
unsigned short cal_chksum(unsigned short *addr,int len);
int pack(int pkt_no,char *sendpacket);
int send_packet(int pkt_no,char *sendpacket);
int recv_packet(int pkt_no,char *recvpacket);
int unpack(int cur_seq,char *buf,int len);
void tv_sub(struct timeval *out,struct timeval *in);
void _CloseSocket();

int socketHeart(const char* pSendData);

extern bool NetIsOk();
extern int Ping( const char *ips, int timeout);
extern int get_netlink_status(const char *if_name);
extern int compareVersions(const std::string& version1, const std::string& version2);
extern void Binary_Bit(unsigned char* p_data, unsigned char position, int flag);
extern Mutex g_tDbMutex;
#endif