#pragma once
#include <queue>
#include <string>
#include<map>
using namespace std;

#define Nan 0x7fc00000

#define INVLID_LOCATION (0)

//物理量类型。
//注意:不同的物理量可以有相同的单位，只是物理应用场景不同。
//根据物理量类型可以确定单位
enum PHYSICAL_TYPE {
	PTH_CUSTOM = 0,		//自定义类型。是一个json对象字符串
	PTH_TEMP = 1,		//温度,℃
	PTH_HUMIDITY = 2,	//湿度,RH
	PTH_PRESSURE = 3,	//压力,mPa
	PTH_ELECTRIC = 4,	//电流,mA
	PTH_VOLTAGE = 5,	//电压,V
	PTH_LIQUID = 6,		//液位,mm
	PTH_DISTANCE = 7,	//距离,mm
	PTH_DISPLACEMENT = 8,//位移,mm
	PTH_POWER = 9,       //阻力,N
	PTH_GAP = 10,        //缺口,mm
	PTH_GONGLV = 11,	//功率
	PTH_ACCELERATION = 12,//加速度
	PTH_LUX = 13,		//光强
	PTH_DISOLVED_OXYGEN = 14,//溶解氧
	PTH_GONGLV_COS = 15,//功率因数
	PTH_VIDEO = 16,//视频
	PTH_VOICE = 17,//语音
	PTH_AMOUNT = 18,//数量计数 默认个
	PTH_SPEED = 19,//速度 km/h
	PTH_LAST//始终保持在最后，用于记录类型总数
};

const CString PHYSICAL_TYPE_DESC[] = {
	 _TEXT("自定义"),   _TEXT("温度"),   _TEXT("湿度"),
	_TEXT("压力"),   _TEXT("电流"),   _TEXT("电压"),
	_TEXT("液位"),   _TEXT("距离"),   _TEXT("位移"),
	_TEXT("阻力"),   _TEXT("缺口"),   _TEXT("功率"),
	_TEXT("加速度"), _TEXT("光强"),	  _TEXT("溶解氧"),
	_TEXT("功率因数"), _TEXT("视频"),	  _TEXT("语音"),
	 _TEXT("计数"), _TEXT("速度")
};


//不取一些一般人都不认识的英文了，此枚举统一用拼音
//枚举值存配置文件，不可修改，向后添加
enum MONITOR_OBJ_TYPE {
	MOT_COMMON = 0,
	MOT_PROJECT = 1, //监控服务
	MOT_DaoCha = 2,//道岔
	MOT_ZZJ = 3,//转辙机
	MOT_QuDongDianLu = 4,//驱动电路
	MOT_MJQ = 5,//密检器
	MOT_STATION = 6, //站点
	
	MOT_MP_GROUP = 99,//监测点组 //这个类型后期考虑废弃了
	MOT_MP = 100,//监测点 看作某物理空间下的一个虚拟仪表 其中可进一步细分为“缺口监测点”、“阻力监测点”、“伤损指数监测点”等具体的监测点
	MOT_RAIL_GROUP = 101,//铁轨组 例如 尖轨、心轨、翼轨等等
	MOT_RAIL_PART = 102,//铁轨段 例如 尖轨下的某个区段等等
	MOT_AMO = 200,//活动监测对象
	MOT_MP_PROP = 301//监测点属性  虚拟仪表可以测量多项数据
};


namespace MO_TYPE {
	const string project = "project";
	const string station = "station";
	const string daocha = "daocha";
	const string zzj = "zzj";
	const string qddl = "qddl";
	const string mjq = "mjq";
	const string mp = "mp";
	const string rail_func = "rail_func";
	const string rail_part = "rail_part";
	const string mp_prop = "mp_prop";
	const string mp_group = "mp_group";
};


const map<string, string> MO_TYPE_DESC = {
	{MO_TYPE::project,"监控服务"},
	{MO_TYPE::station,"站点"},
	{MO_TYPE::daocha,"道岔"},
	{MO_TYPE::zzj,"转辙机"},
	{MO_TYPE::mp,"监测点"},
	{MO_TYPE::rail_func,"功能铁轨"},
	{MO_TYPE::rail_part,"铁轨区段"},
	{MO_TYPE::mp_prop,"监测点属性"},
	{MO_TYPE::mp_group,"监测点组"},
	{MO_TYPE::qddl,"驱动电路"},
	{MO_TYPE::mjq,"密检器"},
	{to_string(MOT_PROJECT), "监控服务"},
	{to_string(MOT_DaoCha), "道岔"},
	{to_string(MOT_ZZJ), "转辙机"},
	{to_string(MOT_QuDongDianLu), "驱动电路"},
	{to_string(MOT_MJQ), "密检器"},
	{to_string(MOT_STATION), "站点"},
	{to_string(MOT_MP_GROUP), "监测点组"},
	{to_string(MOT_MP), "监测点"},
	{to_string(MOT_RAIL_GROUP), "铁轨组"},
	{to_string(MOT_RAIL_PART), "铁轨段"},
	{to_string(MOT_AMO), "活动监测对象"},
	{to_string(MOT_MP_PROP), "监测点属性"},
};


//采集对象来自于一种采集设备，该采集设备专用于采集某一种监测对象，包含了约定的一组数据
enum ACQ_OBJ_TYPE {
	AOT_UNKNOWN = 0,
	AOT_ZZJ_QDDL = 1,//驱动电路
	AOT_ZZJ_ZHENGDONG = 2,//转辙机基座振动
	AOT_ZZJ_ELECPARAM = 3,//转辙机电参数
	AOT_ZZJ_POWER = 4,//扳动阻力
	AOT_ZZJ_YY = 5,//扳动油压
	AOT_JIAYOU_PIPE_PRESSURE = 6,
	ACQ_LEFT_YOUYA = 7,//左转换油压
	ACQ_RIGHT_YOUYA = 8,//右转换油压
	ACQ_CHUAN_LEFT_YOUYA = 9,//串左转换油压
	ACQ_CHUAN_RIGHT_YOUYA = 10,//串右转换油压
	ACQ_FIRST_MOVE_PRESSURE = 11,//一动转换油压/阻力
	ACQ_SECOND_MOVE_PRESSURE = 12,//二动转换油压/阻力
	ACQ_THIRD_MOVE_PRESSURE = 13,//三动转换油压/阻力
	ACQ_CROSS_GAP = 14,//过车缺口
	ACQ_CROSS_MIETIE_GAP = 15,//过车密贴缺口
	ACQ_CROSS_CHILI_GAP = 16,//过车斥离缺口
	ACQ_CROSS_ZHENDONG = 17,//过车振动
	ACQ_MOVE_MIETIE_GAP = 18,//转换密贴缺口
	ACQ_MOVE_CHILI_GAP = 19,//转换斥离缺口
	ACQ_LOAD_OVER_UNUSUAL = 20,//负载监测过载异常曲线
	ACQ_LOAD_SHORT_UNUSUAL = 21,//负载监测短路异常曲线
	ACQ_LOAD_FIRE_UNUSUAL = 22,//负载监测打火异常曲线
	ACQ_LASTTYPE = 23,
	ACQ_MOVE_CROSS_WEIYI = 24,  //扳动过车位移曲线 跟徐嘉庆定义调试
};



enum DATA_ATTRIBUTE_VAL_TYPE {
	DAVT_STR,
	DAVT_FLOAT,
};

//应用层协议类型
enum APP_LAYER_PROTO_TYPE {
	PROTOCOL_UNKNOWN = 0,
	PROTOCOL_DSP,
	PROTOCOL_JDSP,//基于json的dsp协议也可以套在dsp协议内
	PROTOCOL_315,
	PROTOCOL_JEP,
	PROTOCOL_MODBUS_RTU,
	PROTOCOL_WEIBO,
	PROTOCOL_SIMPLE_AI,//仅用于信号灯单帧协议的测试通信
	PROTOCOL_WEBSOCKET,
};

//数据传输类型
enum class TRANSPORT_CONTROL_PROTOCOL {
	TCR_UDP = 0x00,
	TCR_TCP,
};

//传输层协议类型
//目前包含应用层数据用Can数据包分包传输的3种方式
enum TRANSFER_LAYER_PROTO_TYPE
{
	TLT_UNKNOWN = 0,
	TLT_NONE,//没有传输层协议
	TLT_CAN_LSPEED,//缺口,低速载波中继
	TLT_CAN_WEIBO,//驱动电路,维博
	TLT_CAN_SIGNAL,//仅用于信号灯单帧协议的测试通信
	TLT_WEB_SOCKET,
};

//Can综合监测网关硬件的实现不是透传的。但软件的实现把与Can传感器的通信抽象成是通过透传网关的JEP协议通信
enum COMM_GATEWAY_TYPE {
	GW_UNKNOWN = 0,
	GW_CAN_TRANSPARENT = 1,//Can透传中继，将发送给中继的数据包原样发给中继下端的设备
	GW_CAN2JEP,//将Can包中的数据提取生成JEP数据包，发给设备；低速载波中继属于该类型
	GW_JEP_TRANSPARENT,
};

struct DATA_ATTRIBUTE_CONF {
	CString attribName;
	DATA_ATTRIBUTE_VAL_TYPE attribValType;
	std::vector<CString> attribValRange;
};

//数据属性一般是指数据采集时候的环境特征。因此采用attribute一词
//property也用来表示属性，但一般表示对象的所有物品（原意为财产），因此选用attribute更精确
struct DATA_ATTRIBUTE {
	CString attribName;
	CString attribVal;
	float attribfVal;

	DATA_ATTRIBUTE_VAL_TYPE GetType() {
		if (attribfVal == Nan)
		{
			return DAVT_STR;
		}

		return DAVT_FLOAT;
	}

	DATA_ATTRIBUTE()
	{
		attribfVal = Nan;
	}
};

//数据类型
enum DATA_TYPE {
	DT_CUSTOM = 0,//自定义，表示为1个协议约定的json对象
	DT_ANALOG = 1,//模拟量
	DT_SWITCH = 2,//开关量
	DT_VIDEO = 3,//视频
	DT_LAST//始终保持在最后，用于记录类型总数
};

namespace sap {
	const string mp_data_type_label[] = { _TEXT("自定义"), _TEXT("模拟量"), _TEXT("开关量"), _TEXT("视频"), _TEXT("声音") };
}


//const CString g_strAcqTypeDescribe[] =
//{
//	_TEXT("未指定"), _TEXT("扳动采集"), _TEXT("周期采集"), _TEXT("日常采集"),
//	_TEXT("即时采集"), _TEXT("过车采集"), _TEXT("全站采集"), _TEXT("微机监测请求")
//};


//全局数据通道
struct GLOBAL_DATA_CHANNEL
{
	CString strID;
	CString strLink_MP;

	GLOBAL_DATA_CHANNEL()
	{
		strID = "";
		strLink_MP = "";
	}
};

//设备的物理通信地址。如果是网关下设备，则是ip+id，如果是有ip的设备，则id=""无效
struct EQP_COMM_ADDR {
	CString strIP;//设备通信地址
	CString id;//设备ID
	APP_LAYER_PROTO_TYPE proto;
	TRANSFER_LAYER_PROTO_TYPE tlProto;
	int AcqDevice_Type = -1;   //根据设备类型(JHD_EPQ_TYPE)来决定他的CAN数据收发处理.与tlProto属于同种作用,后续不再抽象tlProto所代表的概念
	COMM_GATEWAY_TYPE gwType;
	TRANSPORT_CONTROL_PROTOCOL transport_mode = TRANSPORT_CONTROL_PROTOCOL::TCR_UDP; //id不为空 表示低速, 低速才有采用
	uint16_t port = 4011; //传输端口
	SOCKET sock;

	int GetID_int() {
		return _ttoi(id);
	}

	EQP_COMM_ADDR() {
		strIP = "";
		id = "";//0表示无效，ip即是设备地址
		proto = PROTOCOL_UNKNOWN;
		gwType = GW_UNKNOWN;
		tlProto = TLT_NONE;
		sock = 0;
	}

	EQP_COMM_ADDR(CString a, CString b) : strIP(a), id(b) {
		proto = PROTOCOL_UNKNOWN;
		gwType = GW_UNKNOWN;
		tlProto = TLT_NONE;
	}

	BOOL FromString(CString str)
	{
		int iPos = str.Find('/');
		if (iPos < 0)
		{
			strIP = str;
		}
		else
		{
			strIP = str.Left(iPos);
			id = str.Mid(iPos + 1, str.GetLength() - iPos - 1);
		}

		return TRUE;
	}

	CString ToString()
	{
		CString str;
		if (id == "")
		{
			str = strIP;
		}
		else {
			str.Format(_T("%s/%s"), strIP, id);
		}
		return str;
	}

	BOOL IsValid()
	{
		if (strIP.GetLength() > 0)
			return TRUE;

		return FALSE;
	}

	BOOL operator==(const EQP_COMM_ADDR& right)
	{
		if (strIP.Compare(right.strIP) == 0 && id == right.id)
		{
			return TRUE;
		}
		return FALSE;
	}

	friend bool operator<(const EQP_COMM_ADDR& left, const EQP_COMM_ADDR& right) {
		int ret = left.strIP.Compare(right.strIP);
		if (ret < 0) return true;
		else if (ret == 0 && left.id < right.id) return true;
		else return false;
	}
};


typedef enum recvPktType {
	RECV_PKT_UNKNOWN = -1,//未知
	RECV_PKT_UNCONF = 0,//未配置数据包
	RECV_PKT_ASYN,//通知包
	RECV_PKT_SYNC//响应包
}RecvPktType;


typedef enum EPACKET_DIR {//表示请求, 响应, 通知
	REQ = 0,
	RESP,
	NOTIFY
}ePktDir;

struct PKT_DATA {
	BYTE* m_DataBuf;
	int m_iDataBufLen;
	APP_LAYER_PROTO_TYPE proto;
	EQP_COMM_ADDR addr;
	recvPktType dealType;

	CString m_strCmdName;//命令名称
	CString m_strCmdContent;//命令内容概要
	CString m_strPktDetail;//命令包详细解析信息

	//表示请求, 响应, 通知
	ePktDir m_ePktDir;//数据包方向或类型

	virtual CString GetCmdID() { return _T(""); };
	virtual BOOL UnPack(LPVOID pBuf, int iBufLen, BOOL bGetCmdInfo = FALSE) { return TRUE; };
	virtual CString GetPktDesc() { return _T(""); };//包详细描述信息
	virtual CString GetCmdName() { return _T(""); };
	virtual BOOL UnPack() { return 0; };

	PKT_DATA(BYTE* p, int l)
	{
		m_DataBuf = new BYTE[l];
		memcpy(m_DataBuf, p, l);
		m_iDataBufLen = l;
	}

	PKT_DATA()
	{
		m_DataBuf = NULL;
		m_iDataBufLen = 0;
		dealType = RECV_PKT_UNKNOWN;
	}

	~PKT_DATA()
	{
		if (m_DataBuf)
			delete []m_DataBuf;
	}


	PKT_DATA& operator=(const PKT_DATA& pd)
	{
		if (this == &pd) return *this;//自己不能拷贝

		this->m_iDataBufLen = pd.m_iDataBufLen;
		this->proto = pd.proto;
		this->addr = pd.addr;

		if (pd.m_iDataBufLen > 0)
		{
			if (this->m_DataBuf)
				delete this->m_DataBuf;
			this->m_DataBuf = new BYTE[pd.m_iDataBufLen];
			memcpy(this->m_DataBuf, pd.m_DataBuf, pd.m_iDataBufLen);
		}
		else
		{
			this->m_DataBuf = NULL;
		}
		return *this;
	}
};

struct PktQueue {
	HANDLE m_mutex;
	std::queue<PKT_DATA*> queueBufPacket;
	PktQueue() {
		m_mutex = CreateMutex(NULL, FALSE, NULL);
	}
	~PktQueue() {
		if (m_mutex) {
			CloseHandle(m_mutex);
			m_mutex = NULL;
		}

		while (!queueBufPacket.empty()) {
			PKT_DATA* pkt = queueBufPacket.front();
			queueBufPacket.pop();
			delete pkt;
		}
	}


	bool Lock() {
		if (m_mutex) {
			WaitForSingleObject(m_mutex, INFINITE);
			return true;
		}
		return false;
	}
	void Unlock() {
		if (m_mutex) ReleaseMutex(m_mutex);
	}
	void Clear();

	PKT_DATA* Pop()
	{
		PKT_DATA* pkt = NULL;
		Lock();
		if (!queueBufPacket.empty()) {
			pkt = queueBufPacket.front();
			queueBufPacket.pop();
			Unlock();
			return pkt;
		}
		else {
			Unlock();
			return NULL;
		}
	}

	inline size_t size()
	{
		return queueBufPacket.size();
	}

	void Push(PKT_DATA* pkt)
	{
		Lock();
		queueBufPacket.push(pkt);
		Unlock();
	}
};


struct PIC_INFO {
	CString strJpgPath;
	int offsetFlag;//偏移标志
	float offsetVal;//偏移值
	float gapVal;//缺口值
	float standardVal;//标准值
	int iW;
	int iH;

	PIC_INFO() {
		strJpgPath = "";
		offsetFlag = 0;
		offsetVal = 0;
		gapVal = 0;
		standardVal = 0;
		iW = 0;
		iH = 0;
	}
};

struct REQ_PARAM {
	int iRetryCount;
	int iWaitTime; //mm单位
	CString strLogMsgWhenSend;
	CString strCmdID; //命令的标识，用来判断响应和请求是否匹配
	REQ_PARAM();
};


enum UI_STYLE {
	DB_FOR_MP = 0,
	DB_FOR_ZZJ
};

//微机监测扳动信号计算结果定反位标志： lutao 2016.12.28
//	1.程序启动，标志 “未知”
//	2.周期采集识别成功，更新标志位 “定位”或者“反位”
//	3.收到扳动信号，如果标志位不是“未知”，则在扳动结束信号时更新该标记位定反位位置
//	4.采集识别成功后， 比对识别结果定反位 和 计算结果定反位， 如果不一致，记录错误信息
enum DAOCHA_POSITION {
	MP_UNKNOWN = 0,
	MP_FIX,
	MP_INVERT,
	MP_FIX2INVERT,
	MP_INVERT2FIX,
};

//WIF 下发的道岔状态
enum class DAOCHA_STATUS_WIF : int8_t
{
	DSW_UNKNOWN = -1,
	DSW_FIX = 0x00,	//定位
	DSW_INVERT = 0x01, //反位
	DSW_MOVING = 0x02, //扳动中
	DSW_MOVED = 0x03, //扳动结束

	DSW_STRAIGHT_LEFT = 0x06,	//直向左侧
	DSW_STRAIGHT_RIGHT = 0x07,	//直向右侧
	DSW_STRAIGHT = 0x08,	//直向
};

struct PLANE_TOPO_VIEW {
	//配置
	BOOL bShow;
	float fX;//相对于左下角的坐标
	float fY;
	float fW;
	float fH;
	CString shape;//取值为rect,circle,text,pic
	CString pic; //图标图片的路径
	CString strDisplayName;
	int iFontSize;

	//运行时
	BOOL bSel;//在界面上是否选中
	BOOL bCalWH;//计算尺寸

	RECT moRc;  //mo在视图上的矩形位置
	void Init()
	{
		bShow = TRUE;
		fX = 50;//相对于左下角的坐标
		fY = 50;
		fW = 2;
		fH = 3;
		shape = "rect";
		iFontSize = 20;
		bSel = FALSE;
		bCalWH = FALSE;
	}

	PLANE_TOPO_VIEW()
	{
		Init();
	}
};


enum ALARM_EVENT_TYPE {
	AET_RECOVER = 0, //报警恢复
	AET_OCCUR = 1, //报警产生
};


enum ALARM_LEVEL {
	AL_UNKNOWN,
	AL_NORMAL,
	AL_PRE_ALARM,
	AL_ALARM, //不区分等级
	AL_ALARM_L4,
	AL_ALARM_L3,
	AL_ALARM_L2,
	AL_ALARM_L1, //一级等级最高
};

//Can总线协议
//连续bit转换成字节,高位在前  ":"符号为取位域
//取位域时,先取低位,再取高位
struct NET_CAN_ORG  //size = 5 bytes
{
	BYTE DLC : 4;
	BYTE CAN : 4;
	BYTE ID29_25 : 5;  //ID高位在前.是这个字节中的低5位
	BYTE Invalid : 3;  //29个bit,4个字节中有3个bit无效
	BYTE ID24_17;
	BYTE ID16_9;
	BYTE ID8_1;
};

/*
比特序(bit order)
字节序是一个对象中的多个字节之间的顺序问题，比特序就是一个字节中的8个比特位(bit)之间的顺序问题。一般情况下系统的比特序和字节序是保持一致的。
一个字节由8个bit组成，这8个bit也存在如何排序的情况，跟字节序类似的有最高有效比特位、最低有效比特位。
比特序1 0 0 1 0 0 1 0在大端系统中最高有效比特位为1、最低有效比特位为0，字节的值为0x92。在小端系统中最高、最低有效比特位则相反为0、1，字节的值为0x49。
跟字节序类似，要想保持一个字节值不变那么就要使系统能正确的识别最高、最低有效比特位。
*/


struct NET_CAN_HEAD_V2//size = 5 bytes
{
	BYTE DLC : 4;   //DLC 每帧字节数(1-8)
	BYTE r0 : 2;   //bit4-5
	BYTE RTR : 1;  //bit6
	BYTE IDE : 1;  //bit7=1表示扩展帧=0表示标准帧
	BYTE Address1 : 1;
	BYTE B : 1;       //广播   0：普通帧  1：广播帧
	BYTE G : 1;       //优先级  0：高级  1：低级
	BYTE MS : 1;      //M/S   0:自主帧 1：应答帧
	BYTE DIR : 1;     //DIR   0:下发  1:上送
	BYTE R0 : 3;      //头部预留3位置
	BYTE Type : 3;    //Type   100，4 自主单帧   000，0 应答单帧  011，3，非结束多帧  010，2，结束多帧
	BYTE Address : 5;//地址
	BYTE InxFrame;//Index of frame  从0开始编号
	BYTE SumFrame;//Sum of frame
	NET_CAN_HEAD_V2()
	{
		r0 = 0;
		RTR = 0;
		IDE = 1;
		DLC = 0;
		Address1 = 0;
		B = 0;
		G = 0;
		MS = 0;
		DIR = 0x0;
		R0 = 0;
		Type = 0;
		Address = 0;
		SumFrame = 0x0;
		InxFrame = 0x0;
	}
};

struct CAN_PKT_V2//size = 13字节
{
	NET_CAN_HEAD_V2 sHead;
	BYTE arrData[8];
	CAN_PKT_V2()
	{
		ZeroMemory(arrData, sizeof(arrData));
	}

	int getID()
	{
		BYTE bAddress = ((sHead.Address1) << 5) | (sHead.Address);
		return (int)bAddress;
	}
};

struct NET_CAN_HEAD_XIANGYUAN//size =3 bytes
{
	BYTE DLC :4;		//每帧字节数
	BYTE r0 : 2;
	BYTE RTR : 1;		//帧类型,0数据帧,1远程帧
	BYTE FF : 1;		//帧格式,0标准帧,扩展帧
	BYTE Temp1;
	BYTE Temp2;
	BYTE Address : 5;	//采集机地址
	BYTE G : 1;			//优先级,0高级,1低级
	BYTE MS : 1;		//帧性质,0自主帧,1应答帧
	BYTE DIR : 1;		//DIR方向位,0:上位机到模块,1:模块到上位机
	BYTE r1 : 5;		
	BYTE Type : 3;		//帧类型,100自主单帧,000应答单帧,011非结束多帧,010结束多帧
	NET_CAN_HEAD_XIANGYUAN()
	{
		DLC = 0;
		r0 = 0;
		RTR = 0;
		FF = 0;
		Address = 0;
		G = 0;
		MS = 0;
		DIR = 0;
		r1 = 0;
		Type = 4;
		Temp1 = 0;
		Temp2 = 0;
	}
};

struct CAN_PKT_XIANGYUAN//size = 13字节
{
	NET_CAN_HEAD_XIANGYUAN sHead;
	BYTE arrData[8];
	CAN_PKT_XIANGYUAN()
	{
		ZeroMemory(arrData, sizeof(arrData));
	}

	int getID()
	{
		return (int)sHead.Address;
	}
};

enum ALARM_STATUS {
	AS_NORMAL = 0,
	AS_AlarmHigh,
	AS_ForeAlarmHigh,
	AS_ForeAlarmLow,
	AS_AlarmLow,
};

struct ALARM_LIMIT_CONF {
	float AlarmHigh;		//告警上限
	float ForeAlarmHigh;	//预警上限
	float FormAlarmLow;		//预警下限
	float AlarmLow;			//告警下限

	float GetConf(ALARM_STATUS as)
	{
		if (as == AS_AlarmHigh)
		{
			return AlarmHigh;
		}
		else if (as == AS_ForeAlarmHigh)
		{
			return ForeAlarmHigh;
		}
		else if (as == AS_ForeAlarmLow)
		{
			return FormAlarmLow;
		}
		else if (as == AS_AlarmLow)
		{
			return AlarmLow;
		}
		else
		{
			return 0;
		}
	}

	ALARM_LIMIT_CONF()
	{
		AlarmHigh = .0;
		ForeAlarmHigh = .0;
		FormAlarmLow = .0;
		AlarmLow = .0;
	};
};

typedef struct CGroupInfo_GWWY
{
	bool bSensorKBGiven;//出厂时是否给出传感器KB值
	ALARM_LIMIT_CONF alcGuiju;//轨距
	ALARM_LIMIT_CONF alcPaxing;//爬行
	ALARM_LIMIT_CONF alcMitie;//密贴
	ALARM_LIMIT_CONF alcJBGHY;//基本轨横移
	//工务参数 相关基准值
	float m_standard_gj;
	float m_standard_mt;
	float m_standard_px;
	float m_standard_jbghy;
	float m_standard_kc;
	CGroupInfo_GWWY()
	{
		bSensorKBGiven = 0;

		alcGuiju.AlarmHigh = 18;
		alcGuiju.ForeAlarmHigh = 15;
		alcGuiju.FormAlarmLow = -15;
		alcGuiju.AlarmLow = -18;

		alcPaxing.AlarmHigh = 18;
		alcPaxing.ForeAlarmHigh = 15;
		alcPaxing.FormAlarmLow = -15;
		alcPaxing.AlarmLow = -18;

		alcMitie.AlarmHigh = 18;
		alcMitie.ForeAlarmHigh = 15;
		alcMitie.FormAlarmLow = -15;
		alcMitie.AlarmLow = -18;

		alcJBGHY.AlarmHigh = 18;
		alcJBGHY.ForeAlarmHigh = 15;
		alcJBGHY.FormAlarmLow = -15;
		alcJBGHY.AlarmLow = -18;

		m_standard_gj = 1435.0;
		m_standard_mt = .0;
		m_standard_px = .0;
		m_standard_jbghy=.0;
		m_standard_kc = 160.0;
	}
}CGroupInfo_GWWY, * PCGroupInfo_GWWY;



//应用服务器基类 Application Layer Server
class CALServer {
public:
	virtual BOOL OnRecvAppLayerData(BYTE* pData, int iLen, void* pCltInfo) { return 0; }
	virtual BOOL OnRecvAppLayerPkt(BYTE* pData, int iLen, void* pCltInfo) { return 0; }
};

struct APP_LAYER_CLIENT {
	int iTLProto; //应用层的传输层协议 可以是websocket  websocket相对于 tcpServer 属于应用层数据。相对于jdsp，属于传输层协议
	int iALProto;
	APP_LAYER_CLIENT()
	{
		iTLProto = 0;
		iALProto = 0;
	}
};

//传输层服务器基类。Transportation Layer Server
//当JDSP协议 套用在 DSP或者315中使用时 ,315服务被看作是JDSP服务的传输层服务
//该类被AppLayerServer调用，因此参数中的clientInfo都是appClientInfo
class CTLServer {
public:
	virtual bool SendAppLayerData(BYTE* pData, int iLen, void* pAppLayerCltInfo) { return 0; }
	virtual vector<void*> GetSessionList() { vector<void*> v; return v; }
};


//OPEC体系
class CControlExecutor {
public:
	virtual BOOL ExecuteControl(CString strCtrlType,/*in*/vector<DATA_ATTRIBUTE>& ctrlParam, /*out*/vector<DATA_ATTRIBUTE>& executeInfo) { return 0; };
};

class CAcqEqp : public CControlExecutor
{
public:
	virtual BOOL ExecuteControl(CString strCtrlType,/*in*/vector<DATA_ATTRIBUTE>& ctrlParam, /*out*/vector<DATA_ATTRIBUTE>& executeInfo) { return 0; };
};


struct MP_ALARM_CONF_HIGHLOW_LIMIT {
	BOOL Enable_AH;			//告警启用
	float alm_High;			//告警上限
	BOOL Enable_PAH;		//预警启用
	float prealm_High;		//预警上限
	BOOL Enable_PAL;		//预警启用
	float prealm_Low;		//预警下限
	BOOL Enable_AL;			//告警启用
	float alm_Low;			//告警下限
	int highLevel;			//告警上限等级
	int lowLevel;			//告警下限等级

	MP_ALARM_CONF_HIGHLOW_LIMIT()
	{
		Enable_AH = 0;
		Enable_PAH = 0;
		Enable_PAL = 0;
		Enable_AL = 0;

		alm_High = 2;
		prealm_High = 1;
		prealm_Low = -1;
		alm_Low = -2;
		highLevel = 0;
		lowLevel = 0;
	}
};


struct MP_ATTRIB {
	CString m_strName;//监测点名称
	CString m_strUnit;//单位
	CString m_strPhysicalType;
	string m_strAlias;
	CString m_strCalFormula;
	CString low_limit;//值有效范围-低限
	CString high_limit;//值有效范围-高限
};

//监测点数据呈现方式：类似于伤损监测中采集的单条曲线数据和单频点数据，两个监测点:区段1&70KHZ
enum MP_DISPLAYDATATYPE
{
	eMP_DPT_UNKNOWN = 0,
	eMP_DPT_POINT,
	eMP_DPT_CURVE,
};

const CString MP_DISPLAYDATATYPE_DESC[] = {
	_TEXT(""),_TEXT("静态数据"),_TEXT("曲线数据"),
};


//zgw 伤损算法相关
struct  CPoint2D {
	int m_x = 0;
	int m_y = 0;
	CPoint2D() {
	}
	CPoint2D(int x, int y) {
		m_x = x;
		m_y = y;
	}
};

struct  CPoint2DInfo {
	CPoint2D m_pt2d;
	string m_type="peak"; //peak valley
	CPoint2DInfo(int x, int y, string type) {
		m_pt2d.m_x = x;
		m_pt2d.m_y = y;
		m_type = type;
	}
};
////