// YAServerDlg.h : 头文件
#pragma once
#include "afxwin.h"
#include "resource.h"
#include "structdef.h"
#include "constdef.h"
#include "def_msg.h"
#include "socketdef.h"
#include "ReportCtrl/ReportCtrl.h"
#include <sio_client.h>
#include "../thirdparty/include/iocp/Src/TcpServer.h"
#include "../thirdparty/include/iocp/Global/helper.h"
#include "afxcmn.h"
#include "./SyncTime/SyncManager.h"
#include "classdef.h"
#include "QueueStrManager.h"
#include "uwb_msg_def.h"
#include <json/json.h>
#include "MysqlConnPool.h"
#include "carManager.h"
#include "./MysqlConnectPool/CDBConnPool.h"

struct area;
struct point_2;

extern BOOL m_log_sys_status;

//using namespace sio;
using namespace std;
using namespace HostServer;

struct  _SLS // system_limit_setting
{
	unsigned int over_count_person; // 井下人员超员
	unsigned int over_count_vehicle; // 井下车辆超员
	unsigned int over_time_person; // 井下人员超时
	unsigned int over_time_vehicle; // 井下车辆超时
	double over_speed; // 井下车辆超速

	// lihongzhen  2017/8/18 考勤偏移时间
	int att_starttime_offset_staff;
	int att_endtime_offset_staff;
	int att_starttime_offset_vehicle;
	int att_endtime_offset_vehicle; 
	uint64_t att_person_thre_hour;
	//车辆防追尾配置数据
	double rear_end_d;
	time_t rear_end_t;
	double geofault_warn_dis;
};

struct _DBS // db setting
{
	string host;
	string user;
	string password;
	string dbname;
	string encoding;
	int port;
};
struct ReaderInfo_
{
	int state; // 0 连接
	DWORD reader_id; // 分站号
	DEVICE_TYPE reader_type; // 通信分站、读卡分站
};
struct SpecialCard
{
	std::map<int,std::vector<int>> m_map;
	void insert(int areaid,int cardid)
	{
		auto it = m_map.find(areaid);
		if (it == m_map.end())
		{
			std::vector<int> tmp;
			tmp.push_back(cardid);
			m_map.insert(std::make_pair(areaid,tmp));
		}
		else
		{
			auto iter = std::find(it->second.begin(),it->second.end(),cardid);
			if (iter == std::end(it->second))
				it->second.push_back(cardid);
		}
	}
	bool find(int areaid,int cardid)
	{
		auto it = m_map.find(areaid);
		if (it == m_map.end())
			return true;
		else
		{
			auto iter = std::find(it->second.begin(),it->second.end(),cardid);
			if (iter == std::end(it->second))
				return false;
		}
		return true;
	}
	std::string to_str()
	{
		std::stringstream ss;
		for(const auto s:m_map)
		{
			ss<<"areaId:"<<s.first<<'{';
			for (const auto x:s.second)
			{
				ss<<x<<",";
			}
			ss<<"}";
		}
		return std::move(ss.str());
	}
};
struct _SOCK
{
	CString sip;
	CONNID dwConnID;
	//int state; // 0 连接
	//DWORD reader_id; // 分站号
	//DEVICE_TYPE reader_type; // 通信分站、读卡分站
	std::list<ReaderInfo_> m_reader;
	bool findReader(DWORD readerId)
	{
		bool b = false;
		for (const auto & r :m_reader)
		{
			if (r.reader_id == readerId)
			{
				b = true;
				break;
			}
		}
		return b;
	}
	ReaderInfo_ & get(DWORD readerId)
	{
		auto it = std::find_if(m_reader.begin(),m_reader.end(),[readerId](const ReaderInfo_ & r){
			if (r.reader_id == readerId)
				return true;
			else
			{
				return false;
			}
		});
		return *it;
	}
};

struct _SOCKET_BUFFER
{
	CONNID dwConnID;
	BYTE pData[LENGTH_MSG_1M]; 
	WORD wLen;
	WORD wReadLen;

	_SOCKET_BUFFER(){
		dwConnID = 0;
		wLen = 0;
		wReadLen = 0;
		memset(pData,0,LENGTH_MSG_1M*sizeof(BYTE));
	}
};

//extern DWORD WINAPI _exec_sql(LPVOID lparam);
extern DWORD WINAPI _exec_sql(const char* lparam);

// CYAServerDlg 对话框
class CYAServerDlg : public CDialogEx, public CTcpServerListener
{
	typedef map<string, std::shared_ptr<Card>> CardMap;
	typedef map<CString, std::shared_ptr<_SOCK>> SocketMap;
	typedef map<CString, std::shared_ptr<_SOCKET_BUFFER>> SocketBufferMap;
	typedef map<INT64, std::shared_ptr<YaEvent>> EventMap;
	typedef map<int, std::shared_ptr<LightCallInfo>> LightCallMap;

	typedef map<int, std::shared_ptr<area>> Area_Map; //lemon 2017/11/20

	struct LogMsg
	{
		CString strFile;
		CString strLog;
		bool isNeedTime;
	};
	struct DataMsg
	{
		CONNID dwConnID;
		int iLength;
		BYTE* pData;		
	};
	// 构造
public:
	CYAServerDlg(CWnd* pParent = NULL);	// 标准构造函数
	~CYAServerDlg();
	// 对话框数据
	enum { IDD = IDD_YASERVER_DIALOG };
	void uwb_alarm(std::map<uint64_t,std::string>&m2,bool flag,std::shared_ptr<NAMESPACE_POINT::card_interface>c);
	void uwb_putDb(std::vector<std::string> &v);
	void record_staff_count(int num);
protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV 支持
private:
	//---lemon smooth----
	NAMESPACE_POINT::CarManager * m_carmanage;
	std::unique_ptr<std::thread> m_Pthread;
	void run();
	void run_sensor();
	bool m_bStop;
	time_t time_interval;
	SpecialCard m_sc;
	struct vInfo
	{
		vInfo()
		{
			is_alarm=false;
			real_end_start_time=0;
			backfired_start_time=0;
		}
		void push(const std::string & c1, const std::string &c2)
		{
			m_cid[0]=c1;
			m_cid[1]=c2;
			std::sort(m_cid.begin(),m_cid.end());
		}
		std::string getKey() const
		{
			return m_cid[0]+"&"+m_cid[1];
		}
		bool is_alarm;
		std::array<std::string,2> m_cid;
		time_t real_end_start_time ;
		time_t backfired_start_time;
	};
	std::map<std::string,vInfo> m_CloserVehicle;
	//---lemon smooth----
	virtual EnHandleResult OnPrepareListen(ITcpServer* pSender, SOCKET soListen);
	virtual EnHandleResult OnAccept(ITcpServer* pSender, CONNID dwConnID, SOCKET soClient);
	virtual EnHandleResult OnSend(ITcpServer* pSender, CONNID dwConnID, const BYTE* pData, int iLength);
	virtual EnHandleResult OnReceive(ITcpServer* pSender, CONNID dwConnID, const BYTE* pData, int iLength);
	virtual EnHandleResult OnClose(ITcpServer* pSender, CONNID dwConnID, EnSocketOperation enOperation, int iErrorCode);
	virtual EnHandleResult OnShutdown(ITcpServer* pSender);
	virtual void OnReConnect(unsigned, unsigned);
	// 实现
protected:
	HICON m_hIcon;

	// 生成的消息映射函数
	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	DECLARE_MESSAGE_MAP()
public:
	CButton m_btStart;
	CButton m_btStop;
	CMenu m_mnMain;
	afx_msg LRESULT on_monitor(WPARAM wParam, LPARAM lParam);
	afx_msg void OnBnStop();
	afx_msg void OnBnStart();	
	afx_msg void OnBnExit();
	afx_msg void OnBnSyncTime();
	afx_msg void OnMenuDb();
	afx_msg void OnMenuLog();
	afx_msg void OnMenuParam();
	afx_msg void OnBnCallHisData();
public: 
	// ui operation
	CTcpServer _server; // 启动的socket server，用来接收分站数据
	HostServer::SyncManager syncmanager; // 时间同步计算
	EnAppState m_enState; // 系统运行状态，用来控制界面按钮禁用状态
	CRITICAL_SECTION m_csRemoveSocket;
	CRITICAL_SECTION m_csRefreshList;
	CRITICAL_SECTION m_csParseDataServer;
	CRITICAL_SECTION m_csSyncTime;
	CRITICAL_SECTION m_csCallInfo;
	CRITICAL_SECTION m_csHandUp;
	CRITICAL_SECTION m_csAreaList;
	CRITICAL_SECTION m_MC_Lock;
	CRITICAL_SECTION m_csCoalDrvingFaceList;
	QueueStrManager* m_qsmSQL;

	bool is_start_tcp;
	void set_app_state(EnAppState eas);
	void start_tcp_server(); 
	void stop_tcp_server();	
public:
	CString m_strConncetion; // 数据库连接字符串
	int m_nPort; // 启动端口
	int m_nCountClick;

	YADB::_DB_POOL_SETTING_ m_DBSetting; //数据库池连接配置

	CWinThread* m_thread_monitor; // 与监控程序通信线程
	CWinThread* m_thread_timer; // timer的线程，脱离UI线程，不使用ontimer
	unsigned int m_uint_state; // 采集状态
	// bit 0, 服务状态，运行或者关闭
	// bit 1, 采集状态，正常或异常
	// bit 2, 分站状态，有中断或没有
	// bit 3, websocket状态，连接未连接
	// bit 4, 数据库状态，连接未连接
	time_t m_time_last_rec; // 最后接收到分站数据的时间
	bool is_websocket_ok;  // websocket 连接状态
	bool is_websocket_login; // websocket登录状态
	// 多web变量
	bool is_websocket_login_ex;
	bool is_websocket_ok_ex;

	bool is_server_ok;  // tcp server 启动状态
	bool is_database_ok;  // 数据库连接状态

	int m_shift_id; // 当前班次
	BOOL m_bUseFilter; // 是否使用滤波

	int m_nFilterType; // 滤波类型,当前主要为卡尔曼滤波
	int m_nMallocTimes; // 

	//BOOL m_log_sys_status;
	// 日志开关，用来设置是否将日志输出
	BOOL m_log_raw_data;  // 原始数据16进制
	BOOL m_log_parse_data; // 原始数据，解析后的10进制
	BOOL m_log_send_package; // 向web端发送的json
	BOOL m_log_recv_package; // 接收web端的json
	BOOL m_log_locate_data; // 定位数据输出，解析的卡数据、计算出的定位结果、算法过程中的结果

	SocketMap mp_socket_list; // 已连接的socket列表，即已连接的分站列表
	SocketBufferMap mp_socket_buffer_list; // socket数据包分片缓存列表

	ReaderMap mp_reader_list; // 所有分站
	ReaderMap mp_ctrl_reader_list; // 所有控制分站
	AreaMap mp_area_list; // 所有区域
	BigSmallReaderMap mp_bigsmall_reader_list;	//保存大小分站的所属关系
	DrivingfaceWarningPointMap mp_drivingface_warning_point_list; // 掘进面告警点列表
	DrivingfaceWarningPointMapAll mp_drivingface_warning_point_list_all;//掘进面告警全列表
	//地质断层告警
	WarningPoint_Map m_WarningPoint_list;

	SpecilaAreaEntryMap mp_special_area_entry_list; //特殊区域入口
	DrivingfaceRenderMap mp_driving_face_render_list; //掘进面分站基点配置信息
	DrivingfaceCardMap mp_driving_face_card_list;//掘进面标识卡配置信息 lemon
	WorkTypePermissionMap mp_worktype_permission_list;// lemon 2017/07/31
	RulesMap m_rules_list; // 车辆考勤规则列表
	MapInfoMap mp_map_list; // 所有地图
	LandmarkInfoMap mp_landmark_list; // 所有地图地标
	MapDirectionInfoMap mp_map_direction_list; //地图坐标系X轴正方向与地理北方的夹角
	DeptMap mp_dept_list; // 所有部门
	BanShiftMap mp_banshift_list; // 班次信息
	OccLevelMap mp_occlevel_list; // 所有职务级别

	AlarmTypeMap mp_alarm_type_list; // 告警类型列表
	SectionMap mp_section_list; // 路段列表
	ChamberMap mp_chamber_list; // 硐室列表
	LightMap   mp_light_list; // 交通灯列表
	LightGroupMap mp_light_group_list; // 交通灯灯组列表

	unsigned long long m_Start_time;  // 程序启动的时间
	CardMap mp_card_list_all; // 所有卡
	CardMap mp_card_list_down_vehicle; // 井下车辆
	CardMap mp_card_list_down_person;  // 井下人员
	CardMap mp_card_list_up_person; // 升井人员
	CardMap mp_card_list_down_adhoc;   //井下自组网卡
	PatrolTaskCheckMap mp_card_task_list; // 巡检任务
	LeaderArrangeMap mp_leaderarrange_list; // 领导带班
	VehicleTypeAttRuleMap mp_att_area_list; // 考勤区域列表，不同车辆类型，区域可能不同
	MeetingInfoMap mp_meetinginfo_list; // 会车相关车辆信息

	AreaMap mp_workingface_area_list;		//工作面区域
	CoalMiningRegularCycleMap m_coalmining_regularcycle_list;//挖煤机正规循环率计算中间值
	CoalWorkfaceVehicleMap m_coalWorkfaceVehicleMap; // 采煤机工作面与车卡ID绑定表
	CoalMiningAreaMap m_coalmining_area_list;//综采面计算挖煤机正规循环率的参数

	CoalDrvingfaceCardMap mp_coaldringface_card_list;  // 采煤机/掘进机卡列表
	CardVehicleMap  m_card_vehicle;  // 车卡对应车卡ID
	CardWorkfaceMap m_card_workface; // 车卡对应工作面

	VehicleDriverPosMap m_vehicleDriverPosMap;//车辆和司机位置的平均位置//
	DeptVehicleDriverMap m_deptVehicleDriverMap;//部门与车辆和司机对应表//
	WorkfaceDriverAlarmMap m_WorkfaceDriverAlarmMap;//工作面车辆与报警参数对应表

	std::shared_ptr<ReaderPathMap> mp_reader_path_list_tof;	//当前地图的所有分站的覆盖范围
	std::shared_ptr<TDOAReaderPathMap> mp_reader_path_list_tdoa; 
	std::shared_ptr<CardMap> mp_card_list_over_time_person;	// 超时人员	
	std::shared_ptr<CardMap> mp_card_list_forbidden_person; // 进入限制区域人员
	std::shared_ptr<CardMap> mp_card_list_help; // 呼救人员
	std::shared_ptr<CardMap> mp_card_list_area_over_time_person; // 区域超时是人员
	std::shared_ptr<CardMap> mp_card_list_forbidden_vehicle; // 进入限制区域车辆
	std::shared_ptr<CardMap> mp_card_list_over_time_vehicle; // 超时车辆
	std::shared_ptr<CardMap> mp_card_list_over_speed_vehicle; // 超速车辆
	std::shared_ptr<CardMap> mp_card_list_area_over_time_vehicle; // 区域超时车辆
	std::shared_ptr<CardMap> mp_card_list_over_count_person; // 人员超员
	std::shared_ptr<CardMap> mp_card_list_over_count_vehicle; //车辆超员

	std::shared_ptr<AreaMap> mp_area_over_count_person; // 人员超员区域
	std::shared_ptr<AreaMap> mp_area_over_time_person; // 人员超时区域
	std::shared_ptr<AreaMap> mp_area_forbidden_person; // 有人限制区域
	std::shared_ptr<AreaMap> mp_area_over_count_vehicle; // 车辆超员区域
	std::shared_ptr<AreaMap> mp_area_over_time_vehicle; // 车辆超时区域
	std::shared_ptr<AreaMap> mp_area_forbidden_vehicle; // 有车限制区域

	std::shared_ptr<CardMap> mp_card_warning_point_alarm;//lemon
	std::shared_ptr<CardMap> mp_card_geofault_alarm;//lemon
	std::shared_ptr<CardMap> mp_card_list_motionless;
	std::shared_ptr<CardMap> mp_card_drivingface_eara_alarm;//lemon 20017/07/31 人员进入掘进机告警区域
	std::shared_ptr<EventMap> mp_event_list; // 事件列表
	std::shared_ptr<LightCallMap> mp_light_call_list; // 控制红绿等命令列表
	std::shared_ptr<CalDataMap> mp_ins_cal_data_list;
	std::shared_ptr<HandUpVehicleMap> mp_card_hand_up_list;//wangsiping 2017/10/11 手动拖动过的车辆card list
	std::shared_ptr<MovingReaderMap> mp_moving_reader_list;		//add by zhuyf 2017/10/18 人卡上车功能实现
	std::vector<DrivinfaceReaderTopology> vt_drivingface_reader_topology;	//存放掘进面的大小分站拓扑关系

	unordered_map<unsigned long long, unsigned short> umpRootSyncNum;  // 每个root的同步序号
	std::shared_ptr<Area_Map> mp_area_list_;
	CallInfoUserMap mp_user_call_info; // 用户呼叫信息

	_SLS sls_setting; // 系统参数配置
	_DBS m_db_setting; // 数据库参数配置
	_DBS m_db_setting_bk; // 备份库参数配置
	string m_ws_url; // web服务器url
	string m_ws_url_ex; // 多服务器url
	CString m_tcp_host; // 本机接收分站数据的ip

	double m_reader_interval_time;
	INT64 m_event_list[MINE_EVENT_COUNT];
	int cur_shift_id;
	time_t cur_shift_start_time;

	// 采集启动标记
	bool m_bYAserverBoot;
	// 零点处理标记
	bool m_bZero;
public:
	void init_ui(); // 初始化界面
	void init_param(); // 初始化运行参数
	void init_queuestring(); // 初始化数据库缓存队列
	void load_param_from_ini(); // 加载配置文件中参数
	void database_connect(); // 连接数据库
	void stop_and_exit(); // 停止并退出程序
	void set_run_state(); // 修改界面按钮状态

	// 从数据库中初始化数据 
	void init_base_data(); // 
	int init_setting(); // 系统配置
	int init_alarm_type(); // 报警类型
	int init_shift(); // 载入班次信息
	int init_dept(); // 部门列表
	int init_level(); // 级别
	int init_card(string card_id = "");
	int init_special_card(string name = "");
	int init_staffer(string staff_id = "", bool is_card = false); // 人员
	int init_vehicle(string vehicle_id = "", bool is_card = false); // 车辆
	int init_adhoc(string adhoc_id = "",bool is_card = false); // 自组网卡
	int init_map(int map_id = 0); // 地图
	int init_landmark(void); //路标信息
	int init_map_direction(void);//地图坐标系X轴正方向与地理坐标系北方的夹角
	int init_area(int area_id = 0); // 区域
	int init_special_area_entry(void); // 特殊区域入口
	int init_drivingface_card(void);//lemon init drivingface_card..
	int init_sensor();
	int init_coalface_driver_warningparam();
	int init_drivingface_permission_card(void);//lemon 2017/07/31
	int init_drivingface_ref_points();	//zhuyf 2018/12/14
	int init_reader(int reader_id = 0); // 分站
	int init_ctrl_reader(int reader_id = 0); // 控制分站
	int init_antenna(int reader_id = 0); // 天线
	int init_dev_adhoc(int reader_id = 0); // 自组网坐标
	int init_antenna_sync(); // 初始化分站间距离，组装时间同步所需数据
	int init_all_readers_coverage(int reader_id = 0);			//从数据库读取地图集覆盖范围,初始化所有分站的地图集
	int init_tof_all_readers_coverage(int reader_id = 0);			//从数据库读取地图集覆盖范围,初始化所有分站的地图集
	int init_tdoa_all_readers_coverage(int reader_id = 0);			//从数据库读取地图集覆盖范围,初始化所有分站的地图集
	int init_traffic_lights(int light_id = 0);		//初始化红绿灯
	int init_chamber(int chamber_id = 0);				//初始化硐室
	int init_section(int section_id = 0);				//初始化路段
	int init_light_group(int group_id = 0);				//初始化红绿灯组
	int init_light_state(CONNID dwConnID,std::string strIp);
	int init_rules(int rule_id = 0); // 初始化规则表 2017/08/01
	int init_leader_arrange(); // 领导排班
	int init_smart_pointer_var();
	int init_reader_boundary_area(int reader_id = 0);			// 从数据库中读取边界信息初始化分站的边界
	int init_moving_reader(int reader_id = 0);					// 从数据库中读取移动分站配置信息
	void clear_leader_arrange(); // 清空列表
	void clear_att_area();
	int init_handup_vehicle();//初始化手动车辆list,web界面手动拖动车辆图标功能
	int is_in_handup_area(double real_x, double real_y, double list_x, double list_y);//车辆定位是否在手动拖动后的坐标附近
	void erase_handup_vehicle(std::string card_id);//擦除hand_up数据库中的对应记录
	int refresh_handup_list(string cardid);//刷新hand_up list
	void deal_card_msg_handup( std::shared_ptr<Card> card );//手动拖车走业务
	void deal_card_dept_changed(std::shared_ptr<Card> card, int dept_id); // 

	int init_data_coalminingface_RegularCycle();//初始化综采面中计算正规循环率的参数
	int init_data_coalmining_RegularCycle();//初始化采煤机中间计算变量值
	int init_data_pre_coalmining_RegularCycle();//初始化采煤机有关正规循环率计算的先前参数
	int init_restart_halfcoalmining_regularcycle();//初始化半刀未完成的正规循环率情况
	int store_data_coalmining_Regular_cycle(std::shared_ptr<CoalminingRegularCycleDetail> ReguilarCycle );//存储挖煤机每刀开始数据
	int store_halfknife_coalmining_Regular_cycle(std::shared_ptr<CoalminingRegularCycleDetail> reguilarCycle );//存储挖煤机前半刀开始数据
	int Update_data_coalmining_Regular_cycle(std::shared_ptr<CoalminingRegularCycleDetail> reguilarCycle );//存储挖煤机每刀结束数据
	int update_halfknife_coalmining_Regular_cycle(std::shared_ptr<CoalminingRegularCycleDetail> reguilarCycle ); //完成半刀，更新刀数值
	int get_data_coalmining_scheduletimes(int workface_id,double& scheduletimes);//获取综采面的计划刀数
	void find_regularcyclerate_startpoint(CoalFaceStartPos &pos, std::shared_ptr<Card> card,std::shared_ptr<CoalMiningArea> area, int tagNum, std::shared_ptr<CoalMiningRegularCycle> coal); // 查找采煤机起到位置
	//lemon monkey car 2017/09/27
	//void init_monkeycar_info();
	void init_monkeycar_base_info();
	void init_coordinate_string2vec(string  str,vector<point_2>&tmp);
	//int init_patrol_info(int task_id = 0); // 加载巡检任务及巡检路线/
	int init_patrol_info(std::string card_id);
	int delete_patrol_info(std::string card_id);
	int get_help_card_nums();
	int init_att_area(); // 载入考勤区域信息

	// 载入历史数据
	void load_his_data();
	void load_his_area(); // 所在区域
	void load_his_event_data(); // 分站状态
	void load_his_card_postion_vehicle(); // 所在位置
	void load_his_card_postion_staff();
	void load_his_driving_face_card_postion(); // 所在位置

	void load_his_driving_face_card_state(); // 载入掘进面卡状态
	void init_drivingface_warning_point();
	void init_geological_fault();
	void load_his_card_state(); // 加载卡状态
	void load_drivingface_card_curshift_position();//从历史数据中加载掘进机的初始状态。当前班次的开始值
	float get_drivingface_warning_point_dis(std::shared_ptr<Card> card);

	// 载入报警数据
	void load_alarm_reader();

	MYSQL_RES* getMysqlRes(const char* sql);
	// 接口数据解析，为前端发送过来的数据
	void parse_edit_map(int map_id);
	void parse_edit_area(int area_id);
	void parse_edit_reader(int reader_id);
	void parse_edit_card(string card_id);
	void parse_edit_staffer(string staffer_id);
	void parse_edit_vehicle(string vehicle_id);
	void parse_edit_path(int path_id);
	void parse_set_limit_value();
	void parse_call_card();
	void parse_clear_card();
	void parse_deal_help();
	// 初始化websocket
	void ws_init(); // 初始化全局变量
	void ws_open();  // 连接
	void ws_close(); // 关闭
	void ws_login(); // 登录
	void ws_logout(); // 退出

	void ws_init_ex();
	void ws_open_ex();
	void ws_login_ex();
	void ws_logout_ex();

	void clear_listener();  // 程序退出后清空socket连接
	void clear_all_list();  // 程序退出后清空所有缓存列表
	// socket接收数据
	// 数据包结构为： 数据长度 + 特征字 + 分站数据区 + 标识卡数据区（卡数据 * N） + CRC校验码
	void parse_data_server(const BYTE * pData, int nLen, CONNID dwConnId); // 解析socket接收到的数据包，可能有粘包
	void parse_package_data(BYTE* DataBuffer, int nLen, CONNID dwConnID); // 解析分站发送的单个数据包
	// 解析定位数据
	void parse_data_locate_reader(BYTE * DataBuffer, int& nCurPos, int nLen, CONNID dwConnID, int& reader_id); // 分站数据区
	void parse_data_ctrl_reader(BYTE * DataBuffer, int& nCurPos, int nLen, CONNID dwConnID, int& reader_id); // 控制分站数据区
	void parse_data_signal_lamp(BYTE * DataBuffer, int& nCurPos, int nLen, CONNID dwConnID);	//信号灯数据区
	int parse_inav_msg(INAVLocateMsg* msgPtr); // 解析惯导数据
	void deal_inav_locate_msg(INAVLocateMsg* msgPtr, int card_num); // 解析惯导定位数据
	INAV_STATUS calculate_inav_state(INAVLocateData* cardData); // 计算惯导数据
	void calculate_inav_locate_by_magic(std::shared_ptr<Card> card, INAVLocateData* cardData); // 根据地磁数据计算位置
	void write_inav_locate_magic_data(std::shared_ptr<Card> card, INAVLocateData* cardData); // 存储地磁数据计算结果
	void log_card_inav_state(INAV_STATUS card_state, string card_id); // 将惯导数据写入到日志中
	void parse_data_lights_state(BYTE* DataBuffer, int& nCurPos, int reader_id, unsigned short wChr); // 解析交通灯数据
	//int parse_data_locate_card(BYTE* DataBuffer, int& nCurPos, int reader_id, unsigned short wChr);
	int parse_data_moving_reader(BYTE * DataBuffer, int& nCurPos, int nLen, CONNID dwConnID, int& reader_id);			// 解析移动分站 
	int parse_data_moving_reader_card(BYTE* DataBuffer, int& nCurPos, int reader_id);		// 解析分站上传的移动分站卡数据
	unsigned long long  parse_data_locate_card(BYTE* DataBuffer, int& nCurPos, int reader_id, unsigned short wChr, unsigned long long ct_time = 0,int pos = 0);  // 解析单个卡数据
	int get_locate_msg_type(BYTE* DataBuffer); // 获取卡数据定位方式，用来区域tof和tdoa
	std::shared_ptr<Card> parse_tof_locate_msg(TofLocateMsg* DataBuffer, int cardNum); // 解析tof数据
	int parse_data_signal_lamp_req_status(BYTE * DataBuffer, int& nCurPos, CONNID dwConnID, uint32_t& id);	//解析信号灯请求状态指令
	void send_signal_lamp_status(const uint32_t& id);	//下发此红绿灯的状态

	void get_schedulestartuptime(int cardType, std::string strCard,double &scheduleStartupTime,std::string strDate); // 更新开机表字段
	std::string get_json_vehicle_state();  // 构造车卡状态JSON
	void open_machine(std::shared_ptr<Card> card);       // 开机
	void close_machine(std::shared_ptr<Card> card, bool bTimeOut=true);      // 关机
	int restart_update_unprocess_record(); // 重启处理未更新关机时间的记录
	int bind_card_vehicle();      // 绑定车卡与卡号
	int bind_card_workface();     // 绑定车卡与工作面
	void get_shakethrethold(std::shared_ptr<Card> card, int &threshold);   // 取震动阈值，临时方案，linux版再修正
	int zero_update_unprocess_record(time_t tCurTime); // 零点时关机再开机
	int store_machine_state(std::shared_ptr<Card> card); // 存储采煤机/掘进机开关机状态的时间段到数据库

	void parse_data_locate_card_vehicle(BYTE* DataBuffer, int& nCurPos,  std::shared_ptr<Card> card, unsigned short wChr); // 解析单个卡数据，包括tof和toda
	// 根据协议解析分站缓存的历史数据
	void parse_data_locate_reader_his(BYTE * DataBuffer, int nLen, int& nCurPos, int& reader_id, int& nTick, CString& strtime, unsigned short wChr);
	void parse_data_locate_card_his(BYTE* DataBuffer, int& nCurPos, int reader_id, DWORD wTickCount, CString strTime, unsigned short wChr);
	void parse_data_locate_card_his_tdoa(BYTE* DataBuffer, int nLen, int reader_id, DWORD wTickCount, CString strTime);
	void parse_data_locate_card_his_tdoa_package(BYTE* DataBuffer, int nLen, int reader_id, DWORD wTickCount, CString strTime, CString strHistTime);
	void parse_data_locate_card_his_tof_card(BYTE* DataBuffer, int nLen, int reader_id, DWORD wTickCount, CString strTime, CString strHistTime);
	void parse_data_locate_card_his_tdoa_card(BYTE* DataBuffer, int nLen, int reader_id, DWORD wTickCount, CString strTime, CString strHistTime);
	void parse_data_locate_card_his_sync_time(BYTE* DataBuffer, int nLen, CString strTime,  CString strHistTime, WORD wChr);
	// 解析自组网数据
	void parse_data_adhoc(BYTE* DataBuffer, int& nCurPos,  int reader_id);
	// 解析分站时间同步
	void parse_data_reader_synctime(BYTE *DataBuffer, int nLen, int& nCurPos, WORD wChr);

	std::shared_ptr<_SOCK> get_socket_by_Id(CONNID dwConnID); // 从列表中通过connid获取socket
	void add_socket_to_list(CONNID dwConnID, DWORD reader_id, DEVICE_TYPE rt); // 
	int  add_socket_to_list(CONNID dwConnID, DWORD reader_id, DEVICE_TYPE rt,BOOL refresh); // 将新连接的socket添加到列表
	string get_ip_by_id(const CONNID& dwConnID);		//从连接id获得ip地址

	void remove_socket(CONNID dwConnID); // socket连接中断后，从列表中删除
	// 向分站发送数据
	BOOL SendData(CONNID dwConnID, WORD wCharacterWord, int wLength, BYTE* DataBuffer);
	// 将设置的灯添加到列表,同一个灯的状态会覆盖，使用最后一个状态控制
	void add_light_to_call_list(LIGHTS_SELECT_TYPE lst, LIGHT_COLOR clr, LIGHT_CTRL_STATE ctrl, int tkid, LIGHT_SHAPE ls,int light_id = 0);  // 将控制等指令加入到指令列表
	void send_call_light(); // 发送控制等指令
	void send_call_light(BYTE ctrl_cmd, int light_id, int ctrl_type, int ctrl_color,int light_shape); // 
	void send_call_light(int light_id,int color,std::string ip);
	void send_call_light(const int& light_id,const bool& postive,const int& color,const std::string& ip);
	void send_call_light(const int& light_id,const uint8_t& p_color,const uint8_t& n_color,const std::string& ip,bool b);
	LIGHT_SHAPE get_light_sharp(const op::LIGHT_COLOUR& color);

	// 获取json串
	string get_json_login(); // websocket登录接口
	string get_json_logout(); // websocket退出接口
	bool   need_display_verification(std::shared_ptr<Card> card); //是否需要推送 false 不需要 true 继续执行
	string get_json_down_and_up(std::shared_ptr<Card> card); // 升入井接口,当有升井、入井数据时发送
	string get_json_special_area_process(std::shared_ptr<Card> card); // 进入特殊区域接口，当车辆标识卡信号丢失，根据特殊区域业务，判断车辆进入相应特殊区域时发送
	string get_json_all_special_area_data(); // 所有在特殊区域的车辆，用于前端登录时，发送全部数据
	string get_json_drivingface_card_position(std::shared_ptr<Card> card); // 掘进机状态接口，发送给web端
	int insert_data(int index, int key, StatisticDataStr** header); // 用来分组计数，给前端实时数据时使用
	void delete_memory(StatisticDataStr *header); // 释放局部变量
	//int get_json_statistic_vehicle_data(Json::Value& vehicle_data);

	Json::Value get_json_statistic_vehicle_data(Json::Value& vehicle_data);
	Json::Value get_json_statistic_staff_data(Json::Value& staff_data);
	Json::Value get_json_statistic_data(StatisticDataStr* header); // 每秒发送统计数据，里面包含了所有卡的位置信息，包括人员、车辆  == 处理链表中的数据成json
	int get_json_node_position(std::shared_ptr<Card> card,Json::Value& detailNode);
	string get_json_card_statistic();//所有实时位置信息 handle get_json_statistic_vehicle_data  get_json_statistic_staff_data
	string get_json_all_data(); // 前端有用户登录时，发送
	string get_json_device_state(); // 分站状态信息
	string get_json_help();			//求救json
	string get_json_event(bool bAll = false);
	string get_json_all_traffic_lights();//lemon 2018/05/15
	void get_json_all_traffic_lights(std::shared_ptr<op::TrafficLightGroup>);//lemon 2018/05/15

	string get_json_call_list(); // 呼叫列表 not handle
	string get_json_new_device_state(); // 分站状态信息
	string get_json_count_area();	//统计区域人数 not handle
	string get_json_leader_arrange(); // 领导带班情况

	Json::Value get_section_json_alarm(); // 路段告警
	Json::Value get_light_json_alarm(); // 红绿灯告警
	Json::Value get_red_light_json_alarm(); // 闯红灯告警

	void send_json_data(string cmd, string data, bool is_login = false); // 向web端发送json数据
	// 业务处理
	void deal_readers();  // 统计分站连接状态信息 
	void deal_readers_event(EVENT_TYPE et,bool falg,const std::shared_ptr<Reader> &r);
	void deal_lamp_light_event(EVENT_TYPE et,bool flag,const std::shared_ptr<op::TrafficLight>& ptl);
	void deal_areas(); // 统计区域状态信息，如超员
	void set_card_pos_state(std::shared_ptr<Card> card); //设置标识卡考勤状态
	void deal_card_msg(std::shared_ptr<Card> card, bool is_hist = false); // 根据标识卡位置，处理相关业务
	int store_data_run_red_light(std::shared_ptr<Card> card,std::shared_ptr<RunRedLight> runredlight);
	void deal_run_red_light_alarm(std::shared_ptr<RunRedLight> runredlight, bool is_red_light);
	void deal_run_red_light_alarm(std::shared_ptr<Card> card,std::shared_ptr<RunRedLight> runredlight);
	void Calc_CoalMining_RegularCycleRate(std::shared_ptr<Card> card);//计算挖煤机的正规循环率
	int store_data_coalmining_Pos(int workface_id, std::string dis_record);//间隔60s上报挖煤机的位置
	void cal_card_position_by_msg(std::shared_ptr<Card> card); // 根据接收到的底层数据计算标识卡位置
	void deal_hist_card_postion(); // 根据加载历史标识卡位置，设置标识卡所在区域等信息
	void deal_his_card_list(std::shared_ptr<Card> card); // 设置加载历史标识卡的状态

	void card_enter_mine(std::shared_ptr<Card> card); // 升入井判断，根据井上井下状态判断升入井
	void card_enter_mine(std::shared_ptr<Card> card, POS_DEVICE_TYPE pdt); // 升入井操作，根据pdt区域升井、入井
	void card_down_mine(std::shared_ptr<Card> card); // 入井业务处理，1、通知前端，2、入库，3
	void card_up_mine(std::shared_ptr<Card> card); // 标识卡升井后的处理，1、通知前端，2、入库，3、结束相关告警，4、重置列表与状态
	void card_enter_map(std::shared_ptr<Card> card); // 标识卡位置切换地图，根据分站所在地图判断
	void card_enter_area(std::shared_ptr<Card> card); // 标识卡切换区域，
	//lemon monkey car
	void handle_reverse_alarm(std::shared_ptr<Card> card,int16_t antid,uint32_t ct,double d);
	//lemon 2017/11/20
	void card_deal_other_business(std::shared_ptr<Card> card);
	bool determine_Save_Point_Or_Not(std::shared_ptr<Card> card);
	void deal_alarm_card_motionless(std::shared_ptr<NAMESPACE_POINT::card_interface> ci,bool flag);
	void iksdk_db(const std::shared_ptr<Card> card);

	void card_enter_special_area(std::shared_ptr<Card> card, int area_id); // 标识卡进入特殊区域
	void card_leave_area(std::shared_ptr<Card> card, std::shared_ptr<Area> area); // 标识卡离开区域处理，包括补全离开时间、结束相关告警
	void deal_card_state(std::shared_ptr<Card> card); // 标识卡状态处理，主要为低电量和呼救状态
	void deal_card_drivingface_permission(std::shared_ptr<Card> card); // 根据工种类型判断，靠近掘进机告警业务
	void deal_card_drivingface_permission(std::shared_ptr<Card> card,int id); // 根据距离判断，靠近掘进机告警业务，已弃用
	void deal_alarm_card(std::shared_ptr<Card> card, std::shared_ptr<CardMap> dest_card_list, bool is_alarm, ALARM_FLAG tag); // 处理标识卡报警信息，包括超时、超速等
	void deal_drivingface_alarm(std::shared_ptr<Card> card, bool is_alarm, ALARM_FLAG tag);// 掘进机告警记录存储到数据库
	void deal_drivingface_alarm_all(std::shared_ptr<Card> card,std::shared_ptr<DrivingfaceCard> drivingface_card); // 掘进面告警，主要为危险点告警
	void deal_alarm_area(std::shared_ptr<Area> area, std::shared_ptr<AreaMap> dest_area_list, bool is_alarm, ALARM_FLAG tag,int tyep); // 区域告警业务逻辑
	void deal_warning_point_alarm(uint64_t key,const std::shared_ptr<Card>&card);
	void deal_card_lost_state(); // 标识卡信号丢失业务判断
	int get_special_area_id(shared_ptr<Card> card); // 车辆丢失信号后，通过车辆所在位置，判断车辆进入的盲区
	int  deal_traffic_lights(std::shared_ptr<Card> card); // 根据卡位置、车辆级别控制交通灯
	void deal_alarm_vehicle(const std::string & cid,std::shared_ptr<Card> c1=nullptr);
	int get_drivingface_area_id(const std::string& card_id);	//根据id去获得区域信息


	int  deal_over_speed(std::shared_ptr<Card> card);		//处理超速
	int  deal_area_over_speed(std::shared_ptr<Card> card);		//处理区域超速
	int  deal_relationship_between_person_and_vehicle(std::shared_ptr<MovingReader> pReader); // 人上车业务判断
	int  deal_relationship_between_person_and_vehicle(std::shared_ptr<Card> card); // 人上车业务判断
	int  card_enter_chamber(std::shared_ptr<Card> card,std::shared_ptr<Section> section); // 车辆进入避车硐室，未启用
	int  select_pos_output(std::shared_ptr<Card> card); // 通过车辆行驶方向选择偏移后的位置坐标，暂未启用
	void cal_distance_of_card(); // 循环遍历，比较车辆两两之间的距离，更新车辆会车状态
	void reset_vehicle_meeting_state(); // 设置车辆会车状态
	void reset_map_card(); // 清除地图中缓存的标识卡列表, 暂未使用
	bool is_in_rectangle(_point p, double dblleft, double dbltop, double dblright, double dblbottom); // 判断点是否在矩形空间内
	bool is_in_circle(_point p1, _point p2, double r, double scale); // 判断点是否在圆内
	// save to database
	void execute_sql(const char* sql); // 执行sql语句，保存到数据库

	void deal_card_drivingface_real(std::shared_ptr<Card> card,std::shared_ptr<DrivingfaceCard> drivingface_card); // 处理掘进机实时数据
	void calculate_card_postion_by_tof(std::shared_ptr<Card> card); // 保存卡位置
	void process_driving_face_start_service(std::shared_ptr<Card> card); // 处理采掘面
	void send_drivingface_card_position_json(bool approve = false); // 向前端发送掘进机进度及状态信息
	void write_drivingface_shift_start_data(std::shared_ptr<Card> card); // 添加新的掘进机开关机记录
	void driving_face_shift_start(); // 判断新的掘进机班次进度记录
	void process_driving_face_end_service(std::shared_ptr<Card> card); // 掘进机停机后补全掘进机开关机记录
	void store_driving_face_data(std::shared_ptr<Card> card);  // 添加新的掘进机班次进度
	void update_driving_face_data(std::shared_ptr<Card> card);// 更新掘进机班次进度
	void write_his_drivingface_real(std::shared_ptr<Card> card); // 保存掘进机实时位置信息，只保存距离最大的数据
	void save_card_postion(std::shared_ptr<Card> card); // 保存卡历史位置
	void save_raw_data_card_tof(std::shared_ptr<Card> card); // 保存tof实时数据信息，用来保存掘进机数据信息
	void save_card_postion_ex(std::shared_ptr<Card> card); // 补录卡数据
	bool IsInLine(_point p1, _point p2, _point p3); // 判断三点是否在同一直线上

	void store_data_card(std::shared_ptr<Card> card, int tag); // 根据tag保存与卡相关的数据，主要为位置、考勤、区域记录
	void store_data_event(std::shared_ptr<YaEvent> ev); // 保存告警事件记录
	void save_patrol_data(std::shared_ptr<PatrolTask> pTask, std::shared_ptr<PatrolPoint> pPoint); // 保存巡检任务状态记录

	int  store_data_light(std::shared_ptr<Light> light,int tag);  // 存储交通灯状态信息
	int  store_data_traffic_red_light(std::shared_ptr<Light> light,std::shared_ptr<Card> card);	//存储闯红灯数据
	int  store_data_section(std::shared_ptr<Section> section,time_t cur_time,int tag); // 存储路段状态

	// 打包数据
	void package_data(); // 打包位置数据json发送给前端
	// 通用方法
	int API_TimeToString(string &strDateStr,const time_t &timeData); // 时间转字符串
	int API_StringToTime(const string &strDateStr,time_t &timeData); // 字符串转时间
	//void formatByteArray(CString &strBuf, BYTE * buf, int nLen);
	time_t formatByteArray(std::string &strBuf, BYTE * buf, int nLen); // 将接收到的字节数组，格式化为16进制字符串
	time_t formatByteArray_s(std::string &strBuf, std::string ip,BYTE * buf, int nLen); // 将接收到的字节数组，格式化为16进制字符串
	void show_log( LPCTSTR szlog, BOOL bSave = true); // 显示信息到主窗体
	void AddItem(CString strvalue, int readerid, BOOL is_closed, DEVICE_TYPE rt); // 在主窗体中显示已连接的分站列表
	void AddItem(std::shared_ptr<_SOCK> &s);
	// 响应web接口
	void parse_json_data_set_limit_value(const char* sz);  // 响应web端发送的系统设置指令
	int parse_json_data_hand_up(string card_id); // 响应web端发送的移动静止的车辆图标指令

	void parse_json_data_call_card_cancel(sio::message::ptr const& data); // 响应web端发送的取消呼叫指令
	void parse_json_data_call_card(sio::message::ptr const& data); // 响应web端发送的呼叫指令
	void parse_json_data_clear_card(sio::message::ptr const& data); // 响应web端发送的清除盲区卡指令
	void parse_json_data_deal_help(sio::message::ptr const& data); // 响应web端发送的处理呼救指令
	int  parse_json_data_set_light_color(sio::message::ptr const& data); // 响应web端发送的控制交通灯指令
	int  parse_json_data_request_counts_info(sio::message::ptr const& data); // 响应web端发送的请求统计计数指令
	int  parse_json_data_reader_pos_change(sio::message::ptr const& data); // 响应web端发送的分站位置改变指令
	string  parse_json_data_person_on_car(sio::message::ptr const& data); // 响应web端发送的根据用户请求人上车状态指令

	void deal_call_edit_map(int id, EDIT_TYPE_ID edit_type_id); // 前端编辑地图后，通知采集，采集重新载入
	void deal_call_edit_area(int id, EDIT_TYPE_ID edit_type_id); // 前端编辑区域后，通知采集，采集重新载入
	void deal_call_edit_reader(int id, EDIT_TYPE_ID edit_type_id); // 前端编辑分站后，通知采集，采集重新载入
	void deal_call_edit_card(string id, EDIT_TYPE_ID edit_type_id); // 前端编辑标识卡后，通知采集，采集重新载入
	void deal_call_edit_staff(string id, EDIT_TYPE_ID edit_type_id); // 前端编辑人员后，通知采集，采集重新载入
	void deal_call_edit_vehicle(string id, EDIT_TYPE_ID edit_type_id); // 前端编辑车辆后，通知采集，采集重新载入
	void deal_call_edit_adhoc(string id, EDIT_TYPE_ID edit_type_id); // 前端编辑自组网卡后，通知采集，采集重新载入
	int  deal_call_edit_section(int id,EDIT_TYPE_ID edit_type_id);		//web端编辑路段信息
	int  deal_call_edit_light(int id,EDIT_TYPE_ID edit_type_id);		//web端编辑灯信息
	int  deal_call_edit_light_group(int id,EDIT_TYPE_ID edit_type_id);	//web端编辑红绿灯组信息
	int  deal_call_edit_chamber(int id,EDIT_TYPE_ID edit_type_id);		//web端编辑硐室信息
	void deal_call_edit_rules(int id,EDIT_TYPE_ID edit_type_id);//lemon 2017/08/01
	int  get_ins_cal_list();			//获得惯导校准数据列表
	std::string  get_json_person_on_car();		//生成人上车json数据map<string,OnVehicleData> real_on_card_data;
	std::string  get_json_person_on_car(map<string,OnVehicleData>& real_on_card_data);		//生成人上车json数据;
	std::string  get_json_all_person_on_car(std::string val);	//生成所有人是否在车上的状态列表
	Json::Value  get_json_all_person_on_car();	//生成所有人是否在车上的状态列表

	void deal_call_edit_patrol_task(string id, EDIT_TYPE_ID edit_type_id); // 前端编辑巡检任务时，通知采集重新载入
	void remove_card(string card_id); // 从列表中删除标识卡记录，主要用在前端编辑卡信息，执行删除操作
	void clear_card_from_list(std::shared_ptr<Card> card); // 从缓存列表中删除标识卡，升井时使用

	void add_event(std::shared_ptr<YaEvent> ev); // 将报警事件添加到全局缓存列表，一是产生新的告警，而是更新告警信息
	void remove_event(std::shared_ptr<YaEvent> ev); // 从报警事件缓存列表删除，结束报警时使用

	void check_patrol(); // 巡检状态判断，系统定时检测巡检状态
	void send_call_info(); // 向分站下发呼叫命令，分站收到后，把指令发送给标识卡
	void send_call_his_data(); // 向分站下发请求历史数据命令，分站接收到后，发送缓存的历史数据，历史数据最大包4M
	void send_sync_reader(); // 向分站下发校时命令，用来校准分站时间，精确到秒 
	int send_heart_package(); // 与控制分站之间发送心跳数据包，控制分站会给响应，用来检测是否连接正常
	void clear_call_info(); // 根据呼叫状态、呼叫时长清除呼叫列表，即清除呼叫成功的卡、清除达到呼叫时长的卡
	void clear_call_card_by_user(std::string user_name); // 根据用户名清除呼叫列表
	int get_card_id_len(int card_type); // 通过卡类型获取卡号长度，自组网卡卡号只有一个字节
	int modify_card_speed(int val); // 校正标识卡运行速度
	int send_ins_data();			//发送惯导校准数据
	int send_change_reader_to_card();	//向大分站下发，请求小分站切换为卡工作模式
	void set_reader_simulate_status(const int& reader_id,bool status);
	void check_reader_simulate_status();		//检查分站模拟卡的状态，如果超过5分钟，则允许其切卡
	void send_light_auto_control_param(const uint32_t& id,const uint16_t& value,const std::string& ip);	//给红绿灯下发断网后自动控制的间隔时间
	void deal_light_auto_control_param(const uint32_t& id,CONNID dwConnID);								//处理设置红绿灯自动控制的间隔时间

	void deal_simulate_card(std::shared_ptr<Card> pCard);		//处理模拟卡
	bool need_drivingface_algo(std::shared_ptr<Card> pCard);	//此卡是否需要调用掘进机算法
	void deal_drivingface_regular_cycle(std::shared_ptr<Card> pCard,const op::point& p);	//处理正规循环率
	void deal_drivingface_regular_cycle();	//超时处理正规循环率
	void deal_drivingface_services(std::shared_ptr<Card> pCard);		//处理掘进面的业务：1.正规循环率；2.每天当中每一时刻的掘进距离
	void deal_drivingface_real_distance(std::shared_ptr<Card> pCard);	//处理掘进面每一时刻的掘进距离；
	void deal_drivingface_real_distance();		//超时处理掘进距离；
	void init_drivingface_recently_info(std::shared_ptr<Card> pCard);	//初始化掘进机最新位置和距离信息
	void save_drivingface_regular_cycle_data(std::shared_ptr<Card> pCard,std::shared_ptr<DrivingfaceCard> pDrivingfaceCard,const op::point& p);	//计算并保存正规循环率数据
	op::point get_drivingface_base_point(std::shared_ptr<Card> pCard);	//获得掘进面的基准点位置信息
	void smooth_row_spacing(double& value,const double& sv);								//平滑排距信息
	int get_forbidden_area_id(const _point& p);		//获得区域id
	int auto_call_person(std::shared_ptr<CardMap>& person_list);			//呼叫人员
	int cancel_call(const std::string& card_id);							//取消指定卡的呼叫

	bool is_has_chamber(int section_id);	//路段内存在可用的硐室
	bool isInMainTunel(std::shared_ptr<Card> pCard);		//此卡是否在主巷道
	int getTunelProperty(std::shared_ptr<Card> pCard);		//获得卡的巷道值
	void AnalysisAlgoFailedData(int interval = 60000 /*std::shared_ptr<Card> pCard*/);
	int GetLandmarkID(std::shared_ptr<Card> card); // 获取与当前位置最近的地标信息
	double GetDistance(_point p1, _point p2); // 获取两点间的距离，用来计算位置与地标间的距离
	time_t GetCurShiftStartTime(int& shift_id); // 获取当前班次开始时间
	time_t GetCurShiftEndTime();  // 获取当前班次结束时间
	time_t GetLastShiftStartTime(int& shift_id); // 获取掘进机最后一次开机所在班次开始时间
	int GetCurShiftId(struct tm* current_time, int shift_type = 1); // 获取当前班次编号
	void GetLandmarkInfo(std::shared_ptr<Card> card); // 通过标识卡的地标信息，用来描述标识卡位置

	DIRECTION_TYPE GetDirectionType(_point card_point, _point landmark_point, int map_id); // 获取坐标点在地标的哪个方向
	POS_DEVICE_TYPE GetPosDownAndUp(int vehicle_type_id, int area_id); // 根据车辆类型和区域编号，通过考勤区域设置规则，获取当前区域是否为考勤区域
	int get_parent_anchor_id(const int& id);	//查找anchor_id所属带ip的大分站
	int get_parent_anchor_id(const std::string& id);
	uint64_t get_drivingface_schedule_value(const uint64_t& id,const uint8_t& type);	//根据掘进面或综采面id和类型查询其指定的掘进计划数

	void reader_power_battery_alarm(const uint64_t& id,const uint8_t& status);	//电池供电需要发送告警
	void deal_lamp_light_alarm();

	void deal_vehicle_driver_alarm(std::shared_ptr<Card> card);//检查工作面司机与车卡告警距离

	int get_vehicle_driverlist(int dept_id, int worktype_id, std::vector<int>& driverList);//获取挖煤机或掘进机对应的司机列表
	void Init_data_vehicle_meanpos(std::shared_ptr<Card> card);//初始化采煤机和挖掘机与司机的对应关系,初始化平均坐标
	void remove_vehicle_meanpos(std::shared_ptr<Card> card);//去除某个车相关的工作面司机与车卡告警信息
	void remove_person_meanpos(std::shared_ptr<Card> card);//去除某个人相关的工作面司机与车卡告警信息
	void add_person_meanpos(std::shared_ptr<Card> card);//增加某个人相关的工作面司机与车卡告警信息
	
	void deal_vehicle_driver_changed(std::shared_ptr<Card> card,bool isCalc=false);//处理工作面车和司机告警发生变化（车的开关机和到了检查告警时间）
	void start_end_vehicle_driver_alarm(std::shared_ptr<Card> card,bool isStart,double limitdis=0.0,double realdis=0.0);//开始或结束工作面司机与车卡告警
	bool calc_vehicle_driver_distance( double mean_vx,double mean_vy,double& distance, std::shared_ptr<VehicleDriverPos> driverPos);//计算司机与车的距离
	void reset_vehicle_driver_pos(std::shared_ptr<VehicleDriverPos> Pos);//重置某个平均坐标
public:
	int init_workingface_area(int area_id = 0);
public:
	//测试函数
	void ReadTdoaDistFile(); // 从dist文件中读取信息，计算坐标
	int  ReadTofDistFile();			// 从TOF数据文件中读取数据，计算坐标
	int  TestGenerateAllDataJson(); // 测试登录请求所有数据接口
	int  TestPersonOnCardJson();	// 测试人上车接口
	void TestLandmarkRequirement(); // 测试地标信息
	void TestCallCard(); // 测试呼叫接口，向分站发送
	void TestParseCallCard(); // 测试呼叫接口，接收前端指令
	void TestFitData(); // 测试拟合数据
	void TestMultSql(); // 测试向多个库写入数据
	void TestCardPosition(); // 测试卡靠右行驶
	void TestClock();			//测试高精度时钟
	string get_json_call_test(); // 组装呼叫测试json
	void package_data_test(); // 组装位置数据json
public:
	std::unique_ptr<sio::client> _io;
	CListBox m_list_log;
	CReportCtrl m_listctrl_reader;

	// websocket相关
	void OnPushMessage(); // 向前端发送数据
	// 接收前端发送的json消息
	void OnCallMessage(string const& name, sio::message::ptr const& data, bool isAck,sio::message::list &ack_resp); 
	// 响应登录操作
	void OnLogin(string const& name, sio::message::ptr const& data, bool isAck, sio::message::list &ack_resp);
	// websocket 连接成功触发的事件
	void OnConnected();
	// websocket 连接关闭触发的事件
	void OnClosed(sio::client::close_reason const& reason);
	// websocket 连接失败触发的时间
	void OnFailed();

	// 向多个Web服务器发送数据
	std::unique_ptr<sio::client> _io_ex;
	void OnLoginEx(string const& name, sio::message::ptr const& data, bool isAck, sio::message::list &ack_resp);
	void OnConnectedEx();
	void OnClosedEx(sio::client::close_reason const& reason);
	void OnFailedEx();
	std::string time_t2string_date(const time_t& t);//由time_t获取日期
	// 向指定socket连接发送校准时间 add by zhuyf
	int send_sync_reader(CONNID dwConnID);
protected:
	
	afx_msg LRESULT OnRemoveSocket(WPARAM wParam, LPARAM lParam);
	afx_msg LRESULT OnMsgRefreshIpList(WPARAM wParam, LPARAM lParam);
public:
	UINT m_reader_id_hist;
	afx_msg void OnEnUpdateEditReaderid();
	afx_msg void OnAbout();
	afx_msg void OnBnTest();
public:
	/*
	*@brief
	出区域时间合理性判断
	*param [in] enter_time 进区域时间
	*param [in] cur_time 当前出区域时间
	*param [in] area_id 当前区域id
	*param [in] tag 出区域标识
	*param [in] staff_id 员工ID
	*param [out] current_leave_time 出区域时间
	*/
	void GetCurrentLeaveAreaTime(const char* enter_time,const char* cur_time,int area_id,string &current_leave_time,int staff_id,int tag = HIS_AREA_LOCATION_LEAVE);
	//工时利用率
	void store_worktime_detail(std::shared_ptr<Card> card,int tag,const char* cur_time);
	bool GetStartWorkTime(int id, char* start_work_time);
	//启动时加载未进出区域的卡
	int Init_worktime_detail();
};

typedef struct {
	CYAServerDlg* handle;
	int len;
	CONNID dwConnID;
	BYTE buf[LENGTH_MSG_4K];
}ParseData;

typedef struct 
{
	CYAServerDlg* handle;
	bool useTime;
	char* path;
	char* strLog;
}LogInfo;