package com.netsdk.demo.customize;

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

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

import static com.netsdk.lib.Utils.getOsPrefix;

public class SCADA_New {

    static NetSDKLib netsdkApi = NetSDKLib.NETSDK_INSTANCE;
    static NetSDKLib configApi = NetSDKLib.CONFIG_INSTANCE;

    public static String encode;  // 系统编码

    static {
        String osPrefix = getOsPrefix();
        if (osPrefix.toLowerCase().startsWith("win32")) {
            encode = "GBK";
        } else if (osPrefix.toLowerCase().startsWith("linux")) {
            encode = "UTF-8";
        } else if (osPrefix.toLowerCase().startsWith("mac")) {
            encode = "UTF-8";
        }
    }

    // 设备信息
    private NET_DEVICEINFO_Ex deviceinfo = new 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 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 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 boolean loginDevice() {

        NetSDKLib.NET_IN_LOGIN_WITH_HIGHLEVEL_SECURITY pstlnParam =
                new NetSDKLib.NET_IN_LOGIN_WITH_HIGHLEVEL_SECURITY() {{
                    szIP = m_strIp.getBytes();
                    nPort = m_nPort;
                    szUserName = m_strUser.getBytes();
                    szPassword = m_strPassword.getBytes();
                }};   // 输入结构体参数
        NetSDKLib.NET_OUT_LOGIN_WITH_HIGHLEVEL_SECURITY pstOutParam =
                new NetSDKLib.NET_OUT_LOGIN_WITH_HIGHLEVEL_SECURITY();  // 输结构体参数

        // 写入sdk
        m_hLoginHandle = netsdkApi.CLIENT_LoginWithHighLevelSecurity(pstlnParam, pstOutParam);

        if (m_hLoginHandle.longValue() == 0) {
            System.err.printf("Login Device[%s] Port[%d]Failed. %s\n", m_strIp, m_nPort, ToolKits.getErrorCode());
        } else {
            deviceinfo = pstOutParam.stuDeviceInfo;   // 获取设备信息
            System.out.println("Login Succeed");
            System.out.println("Device Address：" + m_strIp);
            System.out.println("设备包含：" + deviceinfo.byChanNum + "个通道");
        }

        return m_hLoginHandle.longValue() != 0;
    }

    /**
     * 登出设备
     */
    public void logoutDevice() {
        if (m_hLoginHandle.longValue() != 0) {
            netsdkApi.CLIENT_Logout(m_hLoginHandle);
        }
    }

    //////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////订阅回调 (必须写成静态单例模式，回调是子线程)//////////////////////
    //////////////////////////////////////////////////////////////////////////////////////

    /**
     * 普通报警监听回调
     */
    private static class MessCallback implements fMessCallBack {

        private MessCallback() {
        }

        private static class CallBackHolder {
            private static final SCADA_New.MessCallback cb = new SCADA_New.MessCallback();
        }

        public static 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"
                {
                    ALARM_SCADA_DEV_INFO msg = new 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 fSCADAAttachInfoCallBack {
        private SCADAAttachInfoCallBack() {
        }

        private static class CallBackHolder {
            private static final SCADA_New.SCADAAttachInfoCallBack cb = new SCADA_New.SCADAAttachInfoCallBack();
        }

        public static final SCADAAttachInfoCallBack getInstance() {
            return CallBackHolder.cb;
        }

        @Override
        public void invoke(LLong lLoginID, LLong lAttachHandle,
                           NET_SCADA_NOTIFY_POINT_INFO_LIST pInfo, int nBufLen, Pointer dwUser) {
            System.out.println("————————————————————【订阅监测点位信息回调】————————————————————");
            for (int i = 0; i < pInfo.nList; i++) {
                System.out.println(" 设备名称:" + new String(pInfo.stuList[i].szDevName).trim());
                System.out.println(" 点位名(与点位表的取值一致):" + new String(pInfo.stuList[i].szPointName).trim());
                System.out.println(" 现场监控单元ID:" + new String(pInfo.stuList[i].szFSUID).trim());
                System.out.println(" 点位ID:" + new String(pInfo.stuList[i].szID).trim());
                System.out.println(" 探测器ID:" + new String(pInfo.stuList[i].szSensorID).trim());
                System.out.println(" 点位类型:" + 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 SCADA_New.SCADAAlarmAttachInfoCallBack cb = new SCADA_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.println(" 设备ID:" + new String(pInfo.stuList[i].szDevID).trim());
                System.out.println(" 点位ID:" + new String(pInfo.stuList[i].szPointID).trim());
                System.out.println(" 报警描述:" + new String(pInfo.stuList[i].szAlarmDesc).trim());
                System.out.println(" 报警标志:" + (pInfo.stuList[i].bAlarmFlag == 1));
                System.out.println(" 报警时间:" + pInfo.stuList[i].stuAlarmTime.toStringTime());
                System.out.println(" 报警级别(0~6):" + pInfo.stuList[i].nAlarmLevel);
                System.out.println(" 报警编号(同一个告警的开始和结束的编号是相同的):" + pInfo.stuList[i].nSerialNo);
            }
            System.out.println("————————————————————【订阅监测点报警信息回调】————————————————————");
        }
    }

    //////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////SCADA 功能////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////

    /**
     * 获取当前主机接入的外部设备ID
     */
    public boolean queryDeviceIdList() {
        m_lstDeviceID.clear(); // 清空外部设备ID列表

        int nCount = deviceinfo.byChanNum; // 设备的通道总数,依据实际通道情况设置

        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.");                        // 外部设备没有有效ID
            return false;
        }

        // 从 Pointer 提取数据
        ToolKits.GetPointerDataToStructArr(stuSCADADeviceInfo.pstuDeviceIDInfo, stuDeviceIDList);
        // 打印数据并更新设备ID
        System.out.println("获取当前主机接入的外部设备ID的有效个数：" + stuSCADADeviceInfo.nRet);
        for (int i = 0; i < stuSCADADeviceInfo.nRet; ++i) {
            String deviceID = "";
            try {
                System.out.printf("外部设备[%d] 设备id[%s] 设备名称[%s]\n", i,
                        new String(stuDeviceIDList[i].szDeviceID, encode).trim(),
                        new String(stuDeviceIDList[i].szDevName, encode).trim());
                deviceID = new String(stuDeviceIDList[i].szDeviceID, encode).trim();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            m_lstDeviceID.add(deviceID);  // 更新外部设备ID列表
        }
        return true;
    }

    /**
     * 通过设备ID获取监测点位信息
     */
    public void querySpotInfo(byte[] bDeviceId, NET_SCADA_POINT_BY_ID_INFO[] stuPointList) {

        int nCount = 20; // TODO 根据实际所需修改 33010011837001 支持 10个
        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(bDeviceId, 0, stuSCADAInfo.szSensorID, 0, bDeviceId.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;
        }

        if (stuSCADAInfo.nRetCount == 0) {   // 异常，获取不到信息
            System.out.println("通过设备ID获取监测点位信息返回个数为0.");
            return;
        }
        // 获取数据
        ToolKits.GetPointerDataToStructArr(stuSCADAInfo.pstuInfo, stuPointList);
        System.out.println("通过设备ID获取监测点位信息返回个数：" + stuSCADAInfo.nRetCount);
        int nPointCount = Math.min(stuSCADAInfo.nMaxCount, stuSCADAInfo.nRetCount);
        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);
        }

    }

    /**
     * 查询设备状态
     */
    public 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)) {
            return true;
        }
        stuInfo.read();
        return false;
    }

    //////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////SCADA Demo 用例///////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////////

    /**
     * 查询当前主机接入的外部设备ID
     */
    public void case_scada_getdevicelist() {
        // 注意：获取SCADA能力集 获取点位表路径信息 按照监测点位类型获取监测点位信息 这三个功能设备现在不支持

        System.out.println("——————————————————获取当前主机接入的外部设备ID——————————————————");
        queryDeviceIdList();
    }

    /**
     * 获取阈值
     * 用例: 查询第一个ID设备的信息点阈值
     */
    public void case_scada_getThreshold() {

        System.out.println("——————————————————获取第一个ID外部设备的阈值——————————————————");

        if (m_lstDeviceID.isEmpty() && !queryDeviceIdList()) {
            return;
        }

        String deviceId = m_lstDeviceID.get(0);        // Demo 里取第一个设备的 ID
        int nPointCount = 20;                          // 点位阈值信息最大个数，假设是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());
        }
        // 读取数据
        ToolKits.GetPointerDataToStructArr(stuGetOut.pstuThresholdInfo, stuThresholdList);
        // 打印展示
        System.out.println("通过设备获取监测点位信息返回个数：" + stuGetOut.nRet);
        int nRetCount = Math.min(stuGetOut.nMax, stuGetOut.nRet);
        for (int i = 0; i < nRetCount; ++i) {
            try {
                System.out.printf("点位类型[%d] 监测点位ID[%s] 告警门限[%f] 绝对阈值[%f] 相对阈值[%f] 数据状态[%d]\n",
                        stuThresholdList[i].emPointType, new String(stuThresholdList[i].szID, encode).trim(),
                        stuThresholdList[i].fThreshold, stuThresholdList[i].fAbsoluteValue, stuThresholdList[i].fRelativeValue,
                        stuThresholdList[i].nStatus);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 设置阈值
     * 用例: 查询第一个ID设备的信息点阈值, 然后原封不动下发
     */
    public void case_scada_setThreshold() {

        System.out.println("——————————————————获取并设置第一个ID外部设备的阈值——————————————————");

        if (m_lstDeviceID.isEmpty() && !queryDeviceIdList()) {
            return;
        }

        //////////////////////////////////// 获取下发数据 /////////////////////////////////////////
        /////////////////////////////////////////////////////////////////////////////////////////

        String deviceId = m_lstDeviceID.get(0);        // Demo 里取第一个设备的 ID
        int nPointCount = 20;                          // 点位阈值信息最大个数，假设是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());
        }
        // 读取数据到 stuThresholdList
        ToolKits.GetPointerDataToStructArr(stuGetOut.pstuThresholdInfo, stuThresholdList);
        int nRetCount = Math.min(stuGetOut.nMax, stuGetOut.nRet);

        //////////////////////////////// 原封不动下发数据 /////////////////////////////////////////
        /////////////////////////////////////////////////////////////////////////////////////////

        // 现在 stuThresholdList 中共有 nRetCount 个有效数据
        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);

        // Todo 如果要修改，请自行在 stuThresholdList 内修改

        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);
    }

    /**
     * 查询监控点的实时值
     * 用例: 查询第一个ID设备 监控点的实时值
     */
    public void case_scada_get() {
        System.out.println("——————————————————获取第一个ID外部设备的实时监控值——————————————————");

        if (m_lstDeviceID.isEmpty() && !queryDeviceIdList()) {
            return;
        }

        try {
            byte[] deviceId = m_lstDeviceID.get(0).getBytes(encode);  // Demo 里取第一个设备的 ID
            int nMaxCount = 20;                                       // 监控值最大个数，假设是20个，33010011837001 支持10个
            NET_SCADA_POINT_BY_ID_INFO[] stuThresholdList = new NET_SCADA_POINT_BY_ID_INFO[nMaxCount];
            for (int i = 0; i < stuThresholdList.length; ++i) {
                stuThresholdList[i] = new NET_SCADA_POINT_BY_ID_INFO();
            }
            querySpotInfo(deviceId, stuThresholdList);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

    /**
     * 订阅报警信息
     */
    public boolean case_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 case_stopListen() {
        if (bListening) {
            System.out.println("取消订阅报警信息.");
            netsdkApi.CLIENT_StopListen(m_hLoginHandle);
            bListening = false;
        }
    }

    /**
     * 订阅监测点位报警信息
     */
    public void case_scada_alarm_attach() {
        // 入参
        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 case_scada_alarm_detach() {
        if (m_hAlarmAttachHandle.longValue() != 0) {
            netsdkApi.CLIENT_SCADAAlarmDetachInfo(m_hAlarmAttachHandle);
            m_hAlarmAttachHandle.setValue(0);
        }
    }

    /**
     * 订阅监测点位实时数据
     */
    public void case_scada_real_attach() {
        // 入参
        NET_IN_SCADA_ATTACH_INFO stIn = new NET_IN_SCADA_ATTACH_INFO();
        stIn.cbCallBack = SCADAAttachInfoCallBack.getInstance();
        stIn.emPointType = EM_NET_SCADA_POINT_TYPE.EM_NET_SCADA_POINT_TYPE_ALL;

        // 出参
        NET_OUT_SCADA_ATTACH_INFO stOut = new 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 case_scada_real_detach() {
        if (m_hAttachHandle.longValue() != 0) {
            netsdkApi.CLIENT_SCADADetachInfo(m_hAttachHandle);
            m_hAttachHandle.setValue(0);

        }
    }

    /**
     * 查询历史数据
     * 注意：查询的数据量测试发现是有上限，建议区间设置 1 小时
     * 用例：查询第一个ID外设的第一个监测点位 的历史数据(2020/10/14/11:0:0 - 2020/10/14/12:0:0)
     */
    public void case_scada_find_history() {
        if (m_lstDeviceID.isEmpty() && !queryDeviceIdList()) {
            return;
        }

        byte[] bDeviceId = new byte[0];
        byte[] bID = new byte[0];
        try {
            bDeviceId = m_lstDeviceID.get(0).getBytes(encode);        // 第一个ID外设
            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(bDeviceId, stuPointList);
            bID = new String(stuPointList[0].szID, encode).trim().getBytes(encode);   // 第一个监测点位
            if (bID.length > 32) return; // 长度超过32无效
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        NET_TIME startTime = new NET_TIME();
        startTime.setTime(2020, 11, 14, 11, 0, 0);

        NET_TIME endTime = new NET_TIME();
        endTime.setTime(2020, 11, 14, 12, 0, 0);

        ///////////////////////////// 开始查询 ////////////////////////////////////
        NET_IN_SCADA_START_FIND stuInFind = new NET_IN_SCADA_START_FIND();
        stuInFind.stuStartTime = startTime;    // 开始时间
        stuInFind.bEndTime = 1;                // 限制结束时间
        stuInFind.stuEndTime = endTime;        // 结束时间

        System.arraycopy(bDeviceId, 0, stuInFind.szDeviceID, 0, bDeviceId.length);     // DeviceID
        System.arraycopy(bID, 0, stuInFind.szID, 0, bID.length);                       // 监测点位ID

        NET_OUT_SCADA_START_FIND stuOutFind = new NET_OUT_SCADA_START_FIND();

        LLong lFindHandle = netsdkApi.CLIENT_StartFindSCADA(m_hLoginHandle, stuInFind, stuOutFind, 5000);
        if (lFindHandle.longValue() == 0) {
            System.err.println("开始查询SCADA点位历史数据失败！" + ToolKits.getErrorCode());
            return;
        }
        System.out.println("符合查询条件的总数:" + stuOutFind.dwTotalCount);

        if (stuOutFind.dwTotalCount == 0) {   // 没有查到任何数据
            System.err.println("没有查询到任何SCADA点位历史数据");
            netsdkApi.CLIENT_StopFindSCADA(lFindHandle);
            return;
        }

        int nFindCount = 50;   // 顺序从设备端取回数据，这个值请根据自己的带宽适当填写

        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 (stInDoFind.nStartNo + nFindCount >= stuOutFind.dwTotalCount) {  // 最后一批数据
                stInDoFind.nCount = stuOutFind.dwTotalCount - (stInDoFind.nStartNo);
            }

            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((stInDoFind.nStartNo + i + 1) + " 点位类型[%d] 监测点位ID[%s] 数据状态[%d] 记录时间[%s]\n",
                        stuFindResult[i].emType, new String(stuFindResult[i].szID).trim(),
                        stuFindResult[i].nStatus, stuFindResult[i].stuTime.toStringTimeEx());
            }

            stInDoFind.nStartNo += stOutDoFind.nRetNum;

            if (stInDoFind.nStartNo >= stuOutFind.dwTotalCount) {
                break;
            }

        }

        // 结束查询
        netsdkApi.CLIENT_StopFindSCADA(lFindHandle);
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////// 简易控制台 ///////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * 一键订阅
     */
    public void attach() {
        case_scada_real_attach();            // 订阅实时数据
        case_startListen();                  // 订阅报警事件
        case_scada_alarm_attach();           // 订阅报警数据
    }

    /**
     * 一键取消
     */
    public void detach() {
        case_scada_real_detach();        // 取消订阅实时数据
        case_stopListen();                    // 取消订阅报警事件
        case_scada_alarm_detach();       // 取消订阅报警数据
    }

    public void InitTest() {

        SDKGeneralService.init(); // SDK初始化
        if (!loginDevice()) { // 登陆设备
            EndTest();
        }
    }

    public void EndTest() {
        detach();    // 取消订阅
        logoutDevice(); //	登出设备
        System.out.println("See You...");
        SDKGeneralService.cleanup(); // 反初始化
        System.exit(0);
    }

    /**
     * case: SCADA.getDeviceList, 获取当前接入外部设备ID  {@link SCADA_New#case_scada_getdevicelist}
     * case: SCADA.getThreshold,  获取阈值              {@link SCADA_New#case_scada_getThreshold}
     * case: SCADA.SetThreshold,  设置阈值              {@link SCADA_New#case_scada_setThreshold}
     * case: SCADA.get            获取监控点的实时值     {@link SCADA_New#case_scada_get}
     * case: startListen          订阅普通报警          {@link SCADA_New#case_startListen}
     * case: stopListen           取消普通报警          {@link SCADA_New#case_stopListen}
     * case: SCADA.alarmAttach    订阅监测点位报警信息   {@link SCADA_New#case_scada_alarm_attach}
     * case: SCADA.alarmDetach    取消监测点位报警信息   {@link SCADA_New#case_scada_alarm_detach}
     * case: SCADA.attach         订阅监测点位实时信息   {@link SCADA_New#case_scada_real_attach}
     * case: SCADA.detach         取消监测点位实时信息   {@link SCADA_New#case_scada_real_detach}
     * case: SCADA.startFind.     查询历史数据          {@link SCADA_New#case_scada_find_history}
     */
    public void RunTest() {
        System.out.println("Run Test");
        CaseMenu menu = new CaseMenu();

        menu.addItem(new CaseMenu.Item(this, "case: SCADA.getDeviceList, 获取当前接入外部设备ID", "case_scada_getdevicelist"));
        menu.addItem(new CaseMenu.Item(this, "case: SCADA.getThreshold,  获取阈值", "case_scada_getThreshold"));
        menu.addItem(new CaseMenu.Item(this, "case: SCADA.setThreshold,  设置阈值", "case_scada_setThreshold"));
        menu.addItem(new CaseMenu.Item(this, "case: SCADA.get            获取监控点的实时值", "case_scada_get"));
        menu.addItem(new CaseMenu.Item(this, "case: startListen          订阅普通报警", "case_startListen"));
        menu.addItem(new CaseMenu.Item(this, "case: stopListen           取消普通报警", "case_stopListen"));
        menu.addItem(new CaseMenu.Item(this, "case: SCADA.alarmAttach    订阅监测点位报警信息", "case_scada_alarm_attach"));
        menu.addItem(new CaseMenu.Item(this, "case: SCADA.alarmDetach    取消监测点位报警信息", "case_scada_alarm_detach"));
        menu.addItem(new CaseMenu.Item(this, "case: SCADA.attach         订阅监测点位实时信息", "case_scada_real_attach"));
        menu.addItem(new CaseMenu.Item(this, "case: SCADA.detach         取消监测点位实时信息", "case_scada_real_detach"));
        menu.addItem(new CaseMenu.Item(this, "case: SCADA.startFind.     查询历史数据", "case_scada_find_history"));
        menu.run();
    }

    ////////////////////////////////////////////////////////////////
    private final String m_strIp = "172.3.3.174";
    private final int m_nPort = 37777;
    private final String m_strUser = "admin";
    private final String m_strPassword = "admin123";
    ////////////////////////////////////////////////////////////////

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