package com.netsdk.demo.customize;

import java.io.File;
import java.util.Arrays;
import java.util.Vector;

import com.netsdk.demo.util.CaseMenu;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.NetSDKLib.*;
import com.sun.jna.Memory;
import com.sun.jna.NativeLong;
import com.sun.jna.Pointer;

import com.sun.jna.ptr.IntByReference;

public class SCADA {
	static NetSDKLib netsdkApi 	= NetSDKLib.NETSDK_INSTANCE;
	static NetSDKLib configApi 	= NetSDKLib.CONFIG_INSTANCE;
    
	// 设备信息
	private NetSDKLib.NET_DEVICEINFO_Ex deviceinfo = new NetSDKLib.NET_DEVICEINFO_Ex();
	
	//登陆句柄
	private LLong m_hLoginHandle = new LLong(0);  
    
	// 报警监听标识
    private boolean bListening = false;
    
	private LLong m_hAttachHandle = new LLong(0);
	
	private LLong m_hAlarmAttachHandle = new LLong(0);
    
	Vector<String> m_lstDeviceID = new Vector<String>();
	
    /**
     * 通用服务
     */
    static class SDKGeneralService {
    	
    	// 网络断线回调
    	// 调用 CLIENT_Init设置此回调, 当设备断线时会自动调用.
    	public static class DisConnect implements NetSDKLib.fDisConnect{
    		
    		private DisConnect() {}
    		
    		private static class CallBackHolder {
    			private static final DisConnect cb = new DisConnect();
    		}
    		
    		public static final DisConnect getInstance() {
    			return CallBackHolder.cb;
    		}
    		
    		public void invoke(LLong lLoginID, String pchDVRIP, int nDVRPort, Pointer dwUser) {
    			System.out.printf("Device[%s] Port[%d] Disconnect!\n" , pchDVRIP , nDVRPort);
    		}	
        }
    		
    	// 网络连接恢复回调
    	// 调用 CLIENT_SetAutoReconnect设置此回调, 当设备重连时会自动调用.
    	public static class HaveReConnect implements NetSDKLib.fHaveReConnect{
    		
    		private HaveReConnect() {}
    		
    		private static class CallBackHolder {
    			private static final HaveReConnect cb = new HaveReConnect();
    		}
    		
    		public static final HaveReConnect getInstance() {
    			return CallBackHolder.cb;
    		}
    		
    		public void invoke(LLong loginHandle, String pchDVRIP, int nDVRPort, Pointer dwUser) {
    			System.out.printf("ReConnect Device[%s] Port[%d]\n", pchDVRIP, nDVRPort);
    		}	
        }
    	
    	/**
    	 * SDK初始化
    	 */
    	public static void init()
    	{		
    		// SDK资源初始化
    		netsdkApi.CLIENT_Init(DisConnect.getInstance(), null);
        	
    		// 设置断线重连回调，当设备断线后会自动重连并在重连后自动调用HaveReConnect(可选)
    		netsdkApi.CLIENT_SetAutoReconnect(HaveReConnect.getInstance(), null); 
    		
    		// 打开SDK日志（可选）
    		LOG_SET_PRINT_INFO setLog = new LOG_SET_PRINT_INFO();
    		
    		File path = new File(".");			
    		String logPath = path.getAbsoluteFile().getParent() + "\\sdk_log\\" + System.currentTimeMillis() + ".log";
    			
    		setLog.bSetFilePath = 1;
    		System.arraycopy(logPath.getBytes(), 0, setLog.szLogFilePath, 0, logPath.getBytes().length);
    	
    		setLog.bSetPrintStrategy = 1;
    		setLog.nPrintStrategy = 0;
    		boolean bLogopen = netsdkApi.CLIENT_LogOpen(setLog);
    		if (!bLogopen) {
    			System.err.println("Failed to open NetSDK log !!!");
    		}
    		
    		// 设置报警监听回调
    		netsdkApi.CLIENT_SetDVRMessCallBack(MessCallback.getInstance(), null);
    	}
    	
    	/**
    	 * SDK反初始化——释放资源
    	 */
    	public static void cleanup()
    	{
    		netsdkApi.CLIENT_Cleanup();
    		System.exit(0);
    	}
    }
    
    public void InitTest() {
    	
    	SDKGeneralService.init(); // SDK初始化
    	if (!loginDevice()) { // 登陆设备
			EndTest();
		}
	}

	public void EndTest() {
		detach();	// 取消订阅
		logoutDevice(); //	登出设备
		System.out.println("See You...");
		SDKGeneralService.cleanup(); // 反初始化
		System.exit(0);
	}
    
	/*************************************************************************************
	*									 设备通用功能							 		 	 * 
	*************************************************************************************/
    /**
	 * 登陆设备
	 */
	public boolean loginDevice() {
		
		int nSpecCap = 0;
    	Pointer pCapParam = null;
    	IntByReference nError = new IntByReference(0);
    	m_hLoginHandle = netsdkApi.CLIENT_LoginEx2(m_strIp, m_nPort, m_strUser, 
    			m_strPassword, nSpecCap, pCapParam, SCADA.this.deviceinfo, nError);
		
		if(m_hLoginHandle.longValue() != 0) {
    		System.out.printf("Login Device[%s] Port[%d] Success!\n" , m_strIp , m_nPort);
    	} else {	
    		System.out.printf("Login Device[%s] Port[%d] Failed. %s\n" , m_strIp , m_nPort , ToolKits.getErrorCode());
    	}
		
		return m_hLoginHandle.longValue() != 0;
	}
	
	/**
	 * 登出设备
	 */
	public void logoutDevice() {
		if(m_hLoginHandle.longValue() != 0){
			netsdkApi.CLIENT_Logout(m_hLoginHandle);
		}
	}
	
	/**
	 * 订阅报警信息
	 */
	public boolean startListen() {		
		if (bListening) {
			return true;
		}
		
		// 订阅报警 （报警回调函数已经在在initSdk中设置）
		bListening = netsdkApi.CLIENT_StartListenEx(m_hLoginHandle);
		if (!bListening) {
			System.err.println("订阅报警失败! LastError = 0x%x\n" + netsdkApi.CLIENT_GetLastError());
		}else {
			System.out.println("订阅报警成功.");
		}
		return bListening;
	}
	
	/**
	 * 取消订阅报警信息
	 */
	public void stopListen() {
		if (bListening) {
			System.out.println("取消订阅报警信息.");
			netsdkApi.CLIENT_StopListen(m_hLoginHandle);
			bListening = false;
		}
	}
    
	/*************************************************************************************
	*						订阅回调 (建议写成单例模式，回调是子线程)							     * 
	*************************************************************************************/
    /**
     * 报警监听回调
     */
    private static class MessCallback implements NetSDKLib.fMessCallBack {
		
		private MessCallback() {}
		
		private static class CallBackHolder {
			private static final MessCallback cb = new MessCallback();
		}
		
		public static final MessCallback getInstance() {
			return CallBackHolder.cb;
		}

		@Override
		public boolean invoke(int lCommand, LLong lLoginID, Pointer pStuEvent,
				int dwBufLen, String strDeviceIP, NativeLong nDevicePort,
				Pointer dwUser) {
			switch (lCommand) {
    	  		case NetSDKLib.NET_ALARM_SCADA_DEV_ALARM :  // 检测采集设备报警事件   "SCADADevAlarm"
    	  		{
    	  			NetSDKLib.ALARM_SCADA_DEV_INFO msg = new NetSDKLib.ALARM_SCADA_DEV_INFO();
    	  			ToolKits.GetPointerData(pStuEvent, msg);
    	  			System.out.println("[检测采集设备报警事件] nChannel :" + msg.nChannel + " nAction :" + msg.nAction + 
    	  					" nAlarmFlag :" + msg.nAlarmFlag);
    	  			break;
    	  		}
	            default:
	            	break;
	            	
	        }
				
			return true;
		}
    }
    
    /**
     * 订阅监测点位信息回调
     */
    private static class SCADAAttachInfoCallBack implements NetSDKLib.fSCADAAttachInfoCallBack {
 		private SCADAAttachInfoCallBack() {}
		
		private static class CallBackHolder {
			private static final SCADAAttachInfoCallBack cb = new SCADAAttachInfoCallBack();
		}
		
		public static final SCADAAttachInfoCallBack getInstance() {
			return CallBackHolder.cb;
		}
 		
 		@Override
 		public void invoke(LLong lLoginID, LLong lAttachHandle,
 				NetSDKLib.NET_SCADA_NOTIFY_POINT_INFO_LIST pInfo, int nBufLen, Pointer dwUser) {
 			System.out.println("————————————————————【订阅监测点位信息回调】————————————————————");
 			for(int i = 0; i < pInfo.nList; i++) {
 				System.out.print("设备名称:" + new String(pInfo.stuList[i].szDevName).trim());
 				System.out.print(" 点位名(与点位表的取值一致):" + new String(pInfo.stuList[i].szPointName).trim());
 				System.out.print(" 现场监控单元ID:" + new String(pInfo.stuList[i].szFSUID).trim());
 				System.out.print(" 点位ID:" + new String(pInfo.stuList[i].szID).trim());
 				System.out.print(" 探测器ID:" + new String(pInfo.stuList[i].szSensorID).trim());
 				System.out.print(" 点位类型:" + pInfo.stuList[i].emPointType);
 				System.out.println(" 采集时间 : " + pInfo.stuList[i].stuCollectTime.toStringTime());
 			}
 			System.out.println("————————————————————【订阅监测点位信息回调】————————————————————");

 		}	
 	}
    
	/**
	 * 订阅监测点报警信息回调
	 */
	private static class SCADAAlarmAttachInfoCallBack implements fSCADAAlarmAttachInfoCallBack {
		private SCADAAlarmAttachInfoCallBack() {}
		
		private static class CallBackHolder {
			private static final SCADAAlarmAttachInfoCallBack cb = new SCADAAlarmAttachInfoCallBack();
		}
		
		public static final SCADAAlarmAttachInfoCallBack getInstance() {
			return CallBackHolder.cb;
		}

		@Override
		public void invoke(LLong lAttachHandle,
						  NET_SCADA_NOTIFY_POINT_ALARM_INFO_LIST pInfo, int nBufLen,
						  Pointer dwUser) {
			
 			System.out.println("————————————————————【订阅监测点报警信息回调】————————————————————");
			for(int i = 0; i < pInfo.nList; i++) {
				System.out.print("设备ID:" + new String(pInfo.stuList[i].szDevID).trim());
				System.out.print(" 点位ID:" + new String(pInfo.stuList[i].szPointID).trim());
				System.out.print(" 报警描述:" + new String(pInfo.stuList[i].szAlarmDesc).trim());
				System.out.print(" 报警标志:" + String.valueOf(pInfo.stuList[i].bAlarmFlag == 1? true:false));
				System.out.print(" 报警时间:" + pInfo.stuList[i].stuAlarmTime.toStringTime());
				System.out.print(" 报警级别(0~6):" + pInfo.stuList[i].nAlarmLevel);
				System.out.println(" 报警编号(同一个告警的开始和结束的编号是相同的):" + pInfo.stuList[i].nSerialNo);
			}
 			System.out.println("————————————————————【订阅监测点报警信息回调】————————————————————");
		}
	}
	
	/*************************************************************************************
	*									 	SCADA 功能							 		 * 
	*************************************************************************************/
 	
    /**
     * 查询设备能力
     */
    public boolean queryDevCaps() {
    	
    	NET_SCADA_CAPS stuCaps = new NET_SCADA_CAPS();
		stuCaps.stuIn.emType = EM_NET_SCADA_CAPS_TYPE.EM_NET_SCADA_CAPS_TYPE_ALL; // 所有类型
    	if (!queryDevState(NetSDKLib.NET_DEVSTATE_SCADA_CAPS, stuCaps)) {
    		System.err.println("获取SCADA能力集信息失败" + ToolKits.getErrorCode());
    		return false;
    	}
    	System.out.println("有效设备类型个数：" + stuCaps.stuOut.nValidType);
		for (int i = 0; i < stuCaps.stuOut.nValidType; ++i) {
			NET_OUT_SCADA_CAPS_ITEM stuItem = stuCaps.stuOut.stuItems[i];
			System.out.printf("设备[%d] 设备类型[%s] 有效设备名称个数[%d] 设备名称(取第一个)[%s]\n", 
					i, new String(stuItem.szDevType).trim(), stuItem.nValidName, 
					new String(stuItem.stuScadaDevNames[0].szDevName).trim());	
		}
    	
    	return true;
    }
    
    /**
     * 获取点位表路径信息
     */
    public boolean querySpotChartPath() {
    	
    	NET_SCADA_POINT_LIST_INFO stuPointList = new NET_SCADA_POINT_LIST_INFO();
    	String  deviceType = "All";   // 设备类型  All 表示全部
    	System.arraycopy(deviceType.getBytes(), 0, stuPointList.stuIn.szDevType, 0, deviceType.getBytes().length); 
    	if (!queryDevState(NetSDKLib.NET_DEVSTATE_SCADA_POINT_LIST, stuPointList)) {
    		System.err.println("获取点位表路径信息失败" + ToolKits.getErrorCode());
    		return false;
    	}
    	
		System.out.println("获取有效点位表路径信息个数：" + stuPointList.stuOut.nList);
		for (int i = 0; i < stuPointList.stuOut.nList; ++i) {
			NET_SCADA_POINT_LIST stuList = stuPointList.stuOut.stuList[i];
			System.out.printf("点表[%d] 有效的配置下标个数[%d] 下标[%s] 点表的完整路径[%s]\n", 
					i, stuList.nIndexValidNum, 
					Arrays.toString(Arrays.copyOf(stuList.nIndex, stuList.nIndexValidNum)), 
					new String(stuList.szPath).trim());	
		}
		
		return true;
    }
    
    /**
     * 获取当前主机接入的外部设备ID
     */
    public boolean queryDeviceIdList() {
    	m_lstDeviceID.clear();

    	int nCount = deviceinfo.byChanNum; // TODO 根据实际所需修改
    	NET_SCADA_DEVICE_ID_INFO[] stuDeviceIDList = new NET_SCADA_DEVICE_ID_INFO[nCount];
    	for (int i = 0; i < stuDeviceIDList.length; ++i) {
    		stuDeviceIDList[i] = new NET_SCADA_DEVICE_ID_INFO();
    	}
    	NET_SCADA_DEVICE_LIST stuSCADADeviceInfo = new NET_SCADA_DEVICE_LIST();
    	stuSCADADeviceInfo.nMax = nCount;
    	int nSize = stuDeviceIDList[0].size() * nCount;
    	stuSCADADeviceInfo.pstuDeviceIDInfo = new Memory(nSize);   // 监测设备信息
    	stuSCADADeviceInfo.pstuDeviceIDInfo.clear(nSize); 
        ToolKits.SetStructArrToPointerData(stuDeviceIDList, stuSCADADeviceInfo.pstuDeviceIDInfo);    	
    	if (!queryDevState(NetSDKLib.NET_DEVSTATE_SCADA_DEVICE_LIST, stuSCADADeviceInfo)) {
    		System.err.println("获取当前主机接入的外部设备ID失败" + ToolKits.getErrorCode());
			return false;
    	}
    	
    	if (stuSCADADeviceInfo.nRet == 0) {
	    	System.out.println("当前主机接入的外部设备ID有效个数为0.");
			return false;
		}
		ToolKits.GetPointerDataToStructArr(stuSCADADeviceInfo.pstuDeviceIDInfo, stuDeviceIDList);
    	System.out.println("获取当前主机接入的外部设备ID的有效个数：" + stuSCADADeviceInfo.nRet);
		for (int i = 0; i < stuSCADADeviceInfo.nRet; ++i) {
			System.out.printf("外部设备[%d] 设备id[%s] 设备名称[%s]\n", 
					i, new String(stuDeviceIDList[i].szDeviceID).trim(), new String(stuDeviceIDList[i].szDevName).trim());
			m_lstDeviceID.add(new String(stuDeviceIDList[i].szDeviceID).trim());
		}
		
		return true;
	}
    
    /**
     * 按照监测点位类型获取监测点表信息
     */
    public boolean querySpotChart() {
    	NET_SCADA_INFO stuSCADAInfo = new NET_SCADA_INFO();
    	stuSCADAInfo.stuIn.emPointType = EM_NET_SCADA_POINT_TYPE.EM_NET_SCADA_POINT_TYPE_ALL; // 查询所有的点位类型
    	if (!queryDevState(NetSDKLib.NET_DEVSTATE_SCADA_INFO, stuSCADAInfo)) {
    		System.err.println("按照监测点位类型获取监测点位信息失败" + ToolKits.getErrorCode());
    		return false;
    	}
    	
    	System.out.println("获取有效点表个数：" + stuSCADAInfo.stuOut.nPointInfoNum);
		for (int i = 0; i < stuSCADAInfo.stuOut.nPointInfoNum; ++i) {
			NET_SCADA_POINT_INFO stuPointInfo = stuSCADAInfo.stuOut.stuPointInfo[i];
			System.out.printf("点表[%d] 设备名称[%s] 有效遥信个数[%d] 遥信信息[%s] 有效遥测个数[%d] 遥测信息[%s]\n", 
					i, new String(stuPointInfo.szDevName).trim(), 
					stuPointInfo.nYX, Arrays.toString(Arrays.copyOf(stuPointInfo.anYX, stuPointInfo.nYX)), 
					stuPointInfo.nYC, Arrays.toString(Arrays.copyOf(stuPointInfo.afYC, stuPointInfo.nYC)));
		}
		
		return true;
    }
    
    /**
     * 通过设备ID获取监测点位信息
     * @param deviceId
     */
    public int querySpotInfo(String deviceId, NET_SCADA_POINT_BY_ID_INFO[] stuPointList) {
    	
    	int nCount = 20; // TODO 根据实际所需修改
    	if (stuPointList != null) {
    		nCount = stuPointList.length;
    	}else {
        	stuPointList = new NET_SCADA_POINT_BY_ID_INFO[nCount];
        	for (int i = 0; i < stuPointList.length; ++i) {
        		stuPointList[i] = new NET_SCADA_POINT_BY_ID_INFO();
        	}
    	}
    	
    	NET_SCADA_INFO_BY_ID stuSCADAInfo = new NET_SCADA_INFO_BY_ID();
    	System.arraycopy(deviceId.getBytes(), 0, stuSCADAInfo.szSensorID, 0, deviceId.getBytes().length);
    	stuSCADAInfo.nMaxCount = nCount;
    	int nSize = stuPointList[0].size() * nCount;
    	stuSCADAInfo.pstuInfo = new Memory(nSize);   // 监测设备信息
    	stuSCADAInfo.pstuInfo.clear(nSize); 
        ToolKits.SetStructArrToPointerData(stuPointList, stuSCADAInfo.pstuInfo);    	
    	if (!queryDevState(NetSDKLib.NET_DEVSTATE_SCADA_INFO_BY_ID, stuSCADAInfo)) {
    		System.err.println("通过设备ID获取监测点位信息失败" + ToolKits.getErrorCode());
			return -1;
    	}
    	
    	if (stuSCADAInfo.nRetCount == 0) {
	    	System.out.println("通过设备ID获取监测点位信息返回个数为0.");
			return 0;
		}
		ToolKits.GetPointerDataToStructArr(stuSCADAInfo.pstuInfo, stuPointList);
    	System.out.println("通过设备ID获取监测点位信息返回个数：" + stuSCADAInfo.nRetCount);
    	int nPointCount = stuSCADAInfo.nMaxCount > stuSCADAInfo.nRetCount?stuSCADAInfo.nRetCount:stuSCADAInfo.nMaxCount;
		for (int i = 0; i < nPointCount; ++i) {
			System.out.printf("点位类型[%d] 监测点位ID[%s] 数据状态[%d]\n", 
					stuPointList[i].emType, new String(stuPointList[i].szID).trim(), stuPointList[i].nStatus);
		}

    	return stuSCADAInfo.nRetCount;
    }
    
    /**
	 * 查询设备状态
	 */
	private boolean queryDevState(int nType, SdkStructure stuInfo) {
    	
     	IntByReference intRetLen = new IntByReference();
     	stuInfo.write();
 		if (!netsdkApi.CLIENT_QueryDevState(m_hLoginHandle, nType, 
 				stuInfo.getPointer(), stuInfo.size(), intRetLen, 3000)) {
//     			System.err.println("type[" + nType + "] Query Device State failed!" + ToolKits.getErrorCode());
 			return false;
 		}
 		
 		stuInfo.read();
    		
    	return true;
	}
    
    
    /**
     * 查询设备状态
     * 获取SCADA能力集、获取点位表路径信息、获取当前主机接入的外部设备ID、按照监测点位类型获取监测点位信息
     */
    public void queryDevState() {
    	System.out.println("——————————————————获取SCADA能力集——————————————————");
    	queryDevCaps();
    	System.out.println("——————————————————获取点位表路径信息——————————————————");
    	querySpotChartPath(); 	// 可能设备未实现
    	System.out.println("——————————————————获取当前主机接入的外部设备ID——————————————————");
    	queryDeviceIdList();
    	System.out.println("——————————————————按照监测点位类型获取监测点位信息——————————————————");
    	querySpotChart(); // 可能设备未实现
    }
    
    /**
     * 获取/设置阈值
     */
    public void getAndSetThreshold() {
    	if (m_lstDeviceID.isEmpty()  && !queryDeviceIdList()) {
    		return;
    	}
    	
    	String deviceId = m_lstDeviceID.get(0);
    	int nPointCount = 20;
    	NET_SCADA_ID_THRESHOLD_INFO[] stuThresholdList = new NET_SCADA_ID_THRESHOLD_INFO[nPointCount];
    	for (int i = 0; i < stuThresholdList.length; ++i) {
    		stuThresholdList[i] = new NET_SCADA_ID_THRESHOLD_INFO();
    	}
    	    	
    	NET_IN_SCADA_GET_THRESHOLD stuGetIn = new NET_IN_SCADA_GET_THRESHOLD();
    	System.arraycopy(deviceId.getBytes(), 0, stuGetIn.szDeviceID, 0, deviceId.getBytes().length);
	   	NET_OUT_SCADA_GET_THRESHOLD stuGetOut = new NET_OUT_SCADA_GET_THRESHOLD();
	   	stuGetOut.nMax = nPointCount;
	   	int nSize = stuThresholdList[0].size() * nPointCount;
	   	stuGetOut.pstuThresholdInfo = new Memory(nSize);
	   	stuGetOut.pstuThresholdInfo.clear(nSize); 
        ToolKits.SetStructArrToPointerData(stuThresholdList, stuGetOut.pstuThresholdInfo);    	
 		if (!netsdkApi.CLIENT_SCADAGetThreshold(m_hLoginHandle, stuGetIn, stuGetOut, 3000)) {
 			System.err.println("获取阈值失败" + ToolKits.getErrorCode());
 			return;
 		}
 		
 		ToolKits.GetPointerDataToStructArr(stuGetOut.pstuThresholdInfo, stuThresholdList);
    	System.out.println("通过设备获取监测点位信息返回个数：" + stuGetOut.nRet);
    	int nRetCount = stuGetOut.nMax > stuGetOut.nRet?stuGetOut.nRet:stuGetOut.nMax;
		for (int i = 0; i < nRetCount; ++i) {
			System.out.printf("点位类型[%d] 监测点位ID[%s] 告警门限[%f] 绝对阈值[%f] 相对阈值[%f] 数据状态[%d]\n", 
					stuThresholdList[i].emPointType, new String(stuThresholdList[i].szID).trim(), 
					stuThresholdList[i].fThreshold, stuThresholdList[i].fAbsoluteValue, stuThresholdList[i].fRelativeValue, 
					stuThresholdList[i].nStatus);
		}
		
		NET_IN_SCADA_SET_THRESHOLD stuSetIn = new NET_IN_SCADA_SET_THRESHOLD();
    	System.arraycopy(deviceId.getBytes(), 0, stuSetIn.szDeviceID, 0, deviceId.getBytes().length);
    	stuSetIn.nMax = nRetCount;
	   	nSize = stuThresholdList[0].size() * nRetCount;
	   	stuSetIn.pstuThresholdInfo = new Memory(nSize);
	   	stuSetIn.pstuThresholdInfo.clear(nSize); 
	   	stuThresholdList[0].fThreshold += 1;
	   	stuThresholdList[0].fAbsoluteValue += 1;
	   	stuThresholdList[0].fRelativeValue += 1;
	   	long offset = 0;
		for (int i = 0; i < nRetCount; ++i) {
			ToolKits.SetStructDataToPointer(stuThresholdList[i], stuSetIn.pstuThresholdInfo, offset);
			offset += stuThresholdList[i].size();
		}
	
	   	NET_OUT_SCADA_SET_THRESHOLD stuSetOut = new NET_OUT_SCADA_SET_THRESHOLD();
 		if (!netsdkApi.CLIENT_SCADASetThreshold(m_hLoginHandle, stuSetIn, stuSetOut, 3000)) {
 			System.err.println("设置阈值失败" + ToolKits.getErrorCode());
 			return;
 		}
 		
 		System.out.printf(" 有效的存放设置阈值成功的id个数[%d] 设置阈值失败的id个数[%d]\n", stuSetOut.nSuccess, stuSetOut.nFail);		
    }
    
    /**
     * 获取/设置配置信息
     */
    public void getAndSetConfigure() {
    	
    	{ // 检测采集设备配置
			CFG_SCADA_DEV_INFO stuConfig = new CFG_SCADA_DEV_INFO(); 
			if (ToolKits.GetDevConfig(m_hLoginHandle, 0, NetSDKLib.CFG_CMD_SCADA_DEV, stuConfig)) {
				System.out.printf("检测采集设备配置是否启用:%d 设备类型:%s 设备名称:%s \n", stuConfig.bEnable, 
						new String(stuConfig.szDevType).trim(), new String(stuConfig.szDevName).trim());
				if (ToolKits.SetDevConfig(m_hLoginHandle, 0, NetSDKLib.CFG_CMD_SCADA_DEV, stuConfig)) {
					System.out.println("设置检测采集设备配置成功！");
				}else {
					System.err.println("设置检测采集设备配置失败！" + ToolKits.getErrorCode());
				}
			}else {
				System.err.println("获取检测采集设备配置失败" + ToolKits.getErrorCode());
			}
    	}
    	
    	{ // 告警屏蔽规则配置
    		CFG_ALARM_SHIELD_RULE_INFO stuConfig = new CFG_ALARM_SHIELD_RULE_INFO(); 
			if (ToolKits.GetDevConfig(m_hLoginHandle, -1, NetSDKLib.CFG_CMD_ALARM_SHIELD_RULE, stuConfig)) {
				System.out.printf("高频次报警 统计周期:%d 在对应统计周期内最大允许上报报警数:%d \n",  
						stuConfig.stuHighFreq.nPeriod, stuConfig.stuHighFreq.nMaxCount);
				if (ToolKits.SetDevConfig(m_hLoginHandle, -1, NetSDKLib.CFG_CMD_ALARM_SHIELD_RULE, stuConfig)) {
					System.out.println("设置告警屏蔽规则配置成功！");
				}else {
					System.err.println("设置告警屏蔽规则配置失败" + ToolKits.getErrorCode());
				}
			}else {
				System.err.println("获取告警屏蔽规则配置失败" + ToolKits.getErrorCode());
			}
    	}
    }
    
    /**
	 * 订阅监测点位信息
	 */
	public void scadaAttachInfo() {
		// 入参
		NetSDKLib.NET_IN_SCADA_ATTACH_INFO stIn = new NetSDKLib.NET_IN_SCADA_ATTACH_INFO();
		stIn.cbCallBack = SCADAAttachInfoCallBack.getInstance();
		stIn.emPointType = NetSDKLib.EM_NET_SCADA_POINT_TYPE.EM_NET_SCADA_POINT_TYPE_ALL;
		
		// 出参
		NetSDKLib.NET_OUT_SCADA_ATTACH_INFO stOut = new NetSDKLib.NET_OUT_SCADA_ATTACH_INFO();
		
		m_hAttachHandle = netsdkApi.CLIENT_SCADAAttachInfo(m_hLoginHandle, stIn, stOut, 3000);
		if(0 != m_hAttachHandle.longValue()) {
			System.out.println("订阅监测点位信息成功!");
		} else {
			System.err.println("订阅监测点位信息失败" + ToolKits.getErrorCode());
		}
	}
	
	/**
	 * 取消监测点位信息订阅
	 */
	public void scadaDetachInfo() {
		if(m_hAttachHandle.longValue() != 0) {
			netsdkApi.CLIENT_SCADADetachInfo(m_hAttachHandle);
			m_hAttachHandle.setValue(0);
			
		}
	}
	
	/**
	 * 订阅监测点位报警信息
	 */
	public void scadaAlarmAttachInfo() {
		// 入参
		NET_IN_SCADA_ALARM_ATTACH_INFO stIn = new NET_IN_SCADA_ALARM_ATTACH_INFO();
		stIn.cbCallBack = SCADAAlarmAttachInfoCallBack.getInstance();
		
		// 出参
		NET_OUT_SCADA_ALARM_ATTACH_INFO stOut = new NET_OUT_SCADA_ALARM_ATTACH_INFO();
		
		m_hAlarmAttachHandle = netsdkApi.CLIENT_SCADAAlarmAttachInfo(m_hLoginHandle, stIn, stOut, 3000);
		if(m_hAlarmAttachHandle.longValue() != 0) {
			System.out.println("订阅监测点位报警信息成功！");
		} else {
			System.err.println("订阅监测点位报警信息失败！" + ToolKits.getErrorCode());
		}
	}
	
	/**
	 * 取消订阅监测点位报警信息
	 */
	public void scadaAlarmDetachInfo() {
		if(m_hAlarmAttachHandle.longValue() != 0) {
			netsdkApi.CLIENT_SCADAAlarmDetachInfo(m_hAlarmAttachHandle);
			m_hAlarmAttachHandle.setValue(0);
		}
	}
	
	/**
	 * 订阅
	 */
	public void attach() {
		scadaAttachInfo();			// 订阅实时数据
		startListen();				// 订阅报警事件
		scadaAlarmAttachInfo();		// 订阅报警数据
	}
	
	/**
	 * 取消订阅
	 */
	public void detach() {
		scadaDetachInfo();		// 取消订阅实时数据
		stopListen();			// 取消订阅报警事件
		scadaAlarmDetachInfo(); // 取消订阅报警数据
	}
	
	/**
	 * 设置实时数据
	 */
	public void scadaSetInfo() {
		
		if (m_lstDeviceID.isEmpty() && !queryDeviceIdList()) {
    		return;
    	}
		
    	String deviceId = m_lstDeviceID.get(0);
		NET_IN_SCADA_POINT_SET_INFO_LIST stuIn = new NET_IN_SCADA_POINT_SET_INFO_LIST();
    	System.arraycopy(deviceId.getBytes(), 0, stuIn.szDevID, 0, deviceId.getBytes().length);
    	stuIn.nPointNum = 2;  // 监控点个数
    	stuIn.stuList[0].emType = EM_NET_SCADA_POINT_TYPE.EM_NET_SCADA_POINT_TYPE_YK; // 监控点位类型,取YK
    	String pointID = "10000000000001";	// 监控点位ID
    	System.arraycopy(pointID.getBytes(), 0, stuIn.stuList[0].szPointID, 0, pointID.getBytes().length);
    	stuIn.stuList[0].nSetupVal = 1;

    	stuIn.stuList[1].emType = EM_NET_SCADA_POINT_TYPE.EM_NET_SCADA_POINT_TYPE_YT; // 监控点位类型,取YT
    	pointID = "10000000000002";	// 监控点位ID
    	System.arraycopy(pointID.getBytes(), 0, stuIn.stuList[1].szPointID, 0, pointID.getBytes().length);
    	stuIn.stuList[1].fSetupVal = (float)2.0;
		NET_OUT_SCADA_POINT_SET_INFO_LIST stuOut = new NET_OUT_SCADA_POINT_SET_INFO_LIST();
		if (netsdkApi.CLIENT_SCADASetInfo(m_hLoginHandle, stuIn, stuOut, 3000)) {
			System.out.printf(" 有效的存放设置阈值成功的id个数[%d] 设置阈值失败的id个数[%d]\n", stuOut.nSuccess, stuOut.nFail);
		}else {
			System.err.println("设置实时数据失败！" + ToolKits.getErrorCode());
		}
		
		querySpotInfo(deviceId, null); // 查询
	}
	
	/**
	 * 查询历史数据
	 */
	public void findHistory() {
		if (m_lstDeviceID.isEmpty()  && !queryDeviceIdList()) {
    		return;
    	}
    	
    	String deviceId = m_lstDeviceID.get(0);
    	NET_SCADA_POINT_BY_ID_INFO[] stuPointList = new NET_SCADA_POINT_BY_ID_INFO[10];
    	for (int i = 0; i < stuPointList.length; ++i) {
    		stuPointList[i] = new NET_SCADA_POINT_BY_ID_INFO();
    	}
    	
		querySpotInfo(deviceId, stuPointList); 	// (认为查询成功)

		// 开始查询
		NET_IN_SCADA_START_FIND stuInFind = new NET_IN_SCADA_START_FIND();
		stuInFind.stuStartTime.setTime(2019, 7, 1, 0, 0, 0);	// 开始时间
    	System.arraycopy(deviceId.getBytes(), 0, stuInFind.szDeviceID, 0, deviceId.getBytes().length);		// DeviceID
    	System.arraycopy(stuPointList[0].szID, 0, stuInFind.szID, 0, stuInFind.szID.length);				// 监测点位ID

		NET_OUT_SCADA_START_FIND stuOutFind = new NET_OUT_SCADA_START_FIND();
				
		LLong lFindHandle = netsdkApi.CLIENT_StartFindSCADA(m_hLoginHandle, stuInFind, stuOutFind, 3000);
		if (lFindHandle.longValue() == 0) {
			System.err.println("开始查询SCADA点位历史数据失败！" + ToolKits.getErrorCode());
			return;
		}
		System.out.println("符合查询条件的总数:" + stuOutFind.dwTotalCount);
		
		if (stuOutFind.dwTotalCount == 0) {
			netsdkApi.CLIENT_StopFindSCADA(lFindHandle);
			return;
		}
		
		int nFindCount = 20;
		
		
		NET_IN_SCADA_DO_FIND stInDoFind = new NET_IN_SCADA_DO_FIND();
		stInDoFind.nStartNo = 0;
		stInDoFind.nCount = nFindCount;
		
		NET_OUT_SCADA_DO_FIND stOutDoFind = new NET_OUT_SCADA_DO_FIND();
		stOutDoFind.nMaxNum = nFindCount;
		int nSize = new NET_SCADA_POINT_BY_ID_INFO().size() * nFindCount;
		stOutDoFind.pstuInfo = new Memory(nSize);
		while (true) {
			
			NET_SCADA_POINT_BY_ID_INFO[] stuFindResult = new NET_SCADA_POINT_BY_ID_INFO[nFindCount];
			for (int i = 0; i < stuFindResult.length; i++) {
				stuFindResult[i] = new NET_SCADA_POINT_BY_ID_INFO();
			}
			stOutDoFind.pstuInfo.clear(nSize);
	        ToolKits.SetStructArrToPointerData(stuFindResult, stOutDoFind.pstuInfo); 
			if (!netsdkApi.CLIENT_DoFindSCADA(lFindHandle, stInDoFind, stOutDoFind, 5000)) {
				System.err.println("获取SCADA点位历史数据失败！" + ToolKits.getErrorCode());
				break;
			}
			if (stOutDoFind.nRetNum <= 0) {
				System.err.println("获取SCADA点位历史数据个数:" + stOutDoFind.nRetNum);
				break;
			}
			
			ToolKits.GetPointerDataToStructArr(stOutDoFind.pstuInfo, stuFindResult);
			for (int i = 0; i < stOutDoFind.nRetNum; ++i) {
				System.out.printf("点位类型[%d] 监测点位ID[%s] 数据状态[%d] 记录时间[%s]\n",
						stuFindResult[i].emType, new String(stuFindResult[i].szID).trim(),
						stuFindResult[i].nStatus, stuFindResult[i].stuTime.toStringTimeEx());
			}
			
			if (stInDoFind.nCount > stuOutFind.dwTotalCount) {
				break;
			}
			stInDoFind.nStartNo += nFindCount;
			
		}
		
		// 结束查询
		netsdkApi.CLIENT_StopFindSCADA(lFindHandle);
	}
   
	////////////////////////////////////////////////////////////////
	private String m_strIp 				= "172.5.3.172";  
	private int    m_nPort 				= 37777;
	private String m_strUser 			= "admin";
	private String m_strPassword 		= "admin123";
	////////////////////////////////////////////////////////////////
	
	public void RunTest()
	{
		System.out.println("Run Test");		
		CaseMenu menu = new CaseMenu();
		menu.addItem(new CaseMenu.Item(this , "查询设备状态" , "queryDevState"));
		menu.addItem(new CaseMenu.Item(this , "获取/设置阈值" , "getAndSetThreshold"));
		menu.addItem(new CaseMenu.Item(this , "获取/设置配置信息" , "getAndSetConfigure"));
		menu.addItem(new CaseMenu.Item(this , "订阅" , "attach"));
		menu.addItem(new CaseMenu.Item(this , "取消订阅" , "detach"));
		menu.addItem(new CaseMenu.Item(this , "设置实时数据" , "scadaSetInfo"));
		menu.addItem(new CaseMenu.Item(this , "查询历史数据" , "findHistory"));
		
		menu.run(); 
	}	

	public static void main(String[]args)
	{		
		SCADA demo = new SCADA();
		demo.InitTest();
		demo.RunTest();
		demo.EndTest();
	}
}