package com.netsdk.demo.customize;

import com.netsdk.demo.util.CaseMenu;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.callback.impl.DefaultHaveReconnectCallBack;
import com.netsdk.lib.enumeration.ENUMERROR;
import com.netsdk.lib.structure.*;
import com.sun.jna.Memory;
import com.sun.jna.Pointer;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.text.SimpleDateFormat;
import java.util.Date;

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

public class LocalAnalyseTaskDemo {

    // SDk对象初始化
    public static final NetSDKLib netsdk = NetSDKLib.NETSDK_INSTANCE;
    public static final NetSDKLib configsdk = NetSDKLib.CONFIG_INSTANCE;
    //通道号
    private static int nChannel = 0;
    // 判断是否初始化
    private static boolean bInit = false;
    // 判断log是否打开
    private static boolean bLogOpen = false;
    // 任务ID
    private int nTaskID = 0;
    // 长任务ID
    private int longNTaskID = 0;
    // 设备信息
    private NetSDKLib.NET_DEVICEINFO_Ex deviceInfo = new NetSDKLib.NET_DEVICEINFO_Ex();
    // 登录句柄
    private NetSDKLib.LLong loginHandle = new NetSDKLib.LLong(0);

    //实现断线重连静态单例
    public static class DefaultDisconnectCallback implements NetSDKLib.fDisConnect {
        private static volatile DefaultDisconnectCallback INSTANCE;

        private DefaultDisconnectCallback() {}

        public static DefaultDisconnectCallback getINSTANCE() {
            if (INSTANCE == null) {
                synchronized (DefaultDisconnectCallback.class){
                    if (INSTANCE == null){
                        INSTANCE = new DefaultDisconnectCallback();
                    }
                }
            }
            return INSTANCE;
        }

        @Override
        public void invoke(NetSDKLib.LLong lLoginID, String pchDVRIP, int nDVRPort, Pointer dwUser) {
            System.out.printf("Device[%s] Port[%d] DisConnected!\n", pchDVRIP, nDVRPort);
        }
    }

    // 回调函数需要是静态的，防止被系统回收
    // 断线回调
    private static NetSDKLib.fDisConnect disConnectCB = MultiTalkDevDemo.DefaultDisconnectCallback.getINSTANCE();
    // 重连回调
    private static NetSDKLib.fHaveReConnect haveReConnectCB = DefaultHaveReconnectCallBack.getINSTANCE();

    // 编码格式
    public static String encode;

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

    /**
     * 按照指定格式，获取当前时间
     */
    public static String getDate() {
        SimpleDateFormat simpleDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return simpleDate.format(new Date()).replaceAll("[^0-9]", "-");
    }

    /**
     * 初始化SDK库
     */
    public static boolean initSdk() {
        bInit = netsdk.CLIENT_Init(disConnectCB, null);// 进程启动时，初始化一次
        if (!bInit) {
            System.out.println("Initialize SDK failed");
            return false;
        }
        // 配置日志
        enableLog();
        // 设置断线重连回调接口, 此操作为可选操作，但建议用户进行设置
        netsdk.CLIENT_SetAutoReconnect(haveReConnectCB, null);
        // 设置登录超时时间和尝试次数，可选
        // 登录请求响应超时时间设置为3S
        int waitTime = 3000; //单位为ms
        // 登录时尝试建立链接 1 次
        int tryTimes = 1;
        // 设置连接设备超时时间和尝试次数
        netsdk.CLIENT_SetConnectTime(waitTime, tryTimes);
        // 设置更多网络参数， NET_PARAM 的nWaittime ， nConnectTryNum 成员与 CLIENT_SetConnectTime
        // 接口设置的登录设备超时时间和尝试次数意义相同,可选
        NetSDKLib.NET_PARAM netParam = new NetSDKLib.NET_PARAM();
        // 登录时尝试建立链接的超时时间
        netParam.nConnectTime = 10000;
        // 设置子连接的超时时间
        netParam.nGetConnInfoTime = 3000;
        //设置登陆网络环境
        netsdk.CLIENT_SetNetworkParam(netParam);
        return true;
    }

    /**
     * 打开 sdk log
     */
    private static void enableLog() {
        // SDK全局日志打印信息
        NetSDKLib.LOG_SET_PRINT_INFO setLog = new NetSDKLib.LOG_SET_PRINT_INFO();
        //设置日志路径
        File path = new File("sdklog/");
        //判断日志路径是否存在，若不存在则创建
        if (!path.exists()){
            path.mkdir();
        }
        // 这里的log保存地址依据实际情况自己调整
        String logPath = path.getAbsoluteFile().getParent() + "\\sdklog\\" + "sdklog" + getDate() + ".log";
        //日志输出策略,0:输出到文件(默认); 1:输出到窗口,
        setLog.nPrintStrategy = 0;
        //是否重设日志路径, 取值0否 ,1是
        setLog.bSetFilePath = 1;
        //日志路径(默认"./sdk_log/sdk_log.log")
        byte[] szLogFilePath = setLog.szLogFilePath;
        //自定义log保存地址，将数据logPath数据copy到LOG_SET_PRINT_INFO-->szLogFilePath变量中
        System.arraycopy(logPath.getBytes(), 0, szLogFilePath, 0, logPath.getBytes().length);
        //是否重设日志打印输出策略 取值0否 ,1是
        setLog.bSetPrintStrategy = 1;
        // 打开日志功能
        bLogOpen = netsdk.CLIENT_LogOpen(setLog);
        if (!bLogOpen){
            System.err.println("Failed to open NetSDK log "+ ToolKits.getErrorCode());
        }else {
            System.out.println("Success to open NetSDK log ");
        }
    }

    /**
     * 高安全登录
     */
    public void loginWithHighLevel() {
        // 输入结构体参数
        NetSDKLib.NET_IN_LOGIN_WITH_HIGHLEVEL_SECURITY pstlnParam = new NetSDKLib.NET_IN_LOGIN_WITH_HIGHLEVEL_SECURITY() {
            {
                // IP
                szIP = m_strIpAddr.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();
        // 高安全级别登陆
        loginHandle = netsdk.CLIENT_LoginWithHighLevelSecurity(pstlnParam, pstOutParam);
        if (loginHandle.longValue() == 0) {  //登陆失败
            System.err.printf("Login Device[%s] Port[%d]Failed. %s\n", m_strIpAddr, m_nPort, ToolKits.getErrorCode());

        } else {
            //登陆成功
            // 获取设备信息
            deviceInfo = pstOutParam.stuDeviceInfo;
            System.out.printf("Login Success Device Address[%s] 设备包含[%d]个通道 \n",m_strIpAddr,deviceInfo.byChanNum);
        }
    }

    /**
     * 退出
     */
    public void logOut() {
        //判断是否已登录
        if (loginHandle.longValue() != 0) {
            netsdk.CLIENT_Logout(loginHandle);
            System.out.println("LogOut Success");
        }
    }

    /**
     * 清理sdk环境并退出
     */
    public static void cleanAndExit() {
        //判断log是否打开
        if (bLogOpen) {
            // 关闭sdk日志打印
            netsdk.CLIENT_LogClose();
        }
        // 进程关闭时，调用一次
        netsdk.CLIENT_Cleanup();
        System.exit(0);
    }

    /**
     * 初始化测试
     */
    public void initTest() {
        initSdk();

        this.loginWithHighLevel();
    }

    /**
     * 结束测试
     */
    public void endTest() {
        System.out.println("End Test");
        this.logOut(); // 登出设备
        System.out.println("See You...");
        cleanAndExit(); // 清理资源并退出
    }

    public void runTest()
    {
        System.out.println("Run Test");
        CaseMenu menu = new CaseMenu();
        menu.addItem(new CaseMenu.Item(this, "新增本地文件分析事件任务", "addLocalAnalyseTask"));
        menu.addItem(new CaseMenu.Item(this, "开启任务", "startAnalyseTask"));
        menu.addItem(new CaseMenu.Item(this, "暂停任务", "pauseAnalyseTask"));
        menu.addItem(new CaseMenu.Item(this, "删除任务", "removeAnalyseTask"));
        menu.addItem(new CaseMenu.Item(this, "查询任务", "findAnalyseTask"));
        menu.addItem((new CaseMenu.Item(this , "二次分析任务订阅" , "recordSecondaryAnalyseStartTask")));
        menu.addItem((new CaseMenu.Item(this , "二次分析任务退订" , "detachSecondaryAnalyseStartTask")));
        menu.run();
    }

    public void addLocalAnalyseTask(){
        try {
            int nRuleCount = 2;
            // 入参
            NET_IN_ADD_LOCAL_ANALYSE_TASK inPut = new NET_IN_ADD_LOCAL_ANALYSE_TASK();
            inPut.nChannel = nChannel;//通道号
            inPut.bCheck = 0;//是否检查重复分析
            inPut.szName = "人脸事件".getBytes(encode);//任务名称
            inPut.szSourceName = "人脸事件".getBytes(encode);//监控点
            inPut.nRuleCount = nRuleCount;//分析规则个数
            // 初始化
            NET_LOCAL_ANALYSE_TASK_RULE[] pstuRules = new NET_LOCAL_ANALYSE_TASK_RULE[nRuleCount];
            for(int i = 0;i < nRuleCount;i++){
                pstuRules[i] = new NET_LOCAL_ANALYSE_TASK_RULE();
            }
            inPut.pstuRule = new Memory(pstuRules[0].size() * nRuleCount);
            inPut.pstuRule.clear(pstuRules[0].size() * nRuleCount);

            pstuRules[0].dwRuleType = NetSDKLib.EVENT_IVS_HUMANTRAIT;
            pstuRules[0].emClassType = NetSDKLib.EM_SCENE_CLASS_TYPE.EM_SCENE_CLASS_OBJECTDETECT;
            pstuRules[0].nObjectTypesCount = 2;
            pstuRules[0].emObjectTypes[0] = NetSDKLib.EM_ANALYSE_OBJECT_TYPE.EM_ANALYSE_OBJECT_TYPE_HUMAN;
            pstuRules[0].emObjectTypes[1] = NetSDKLib.EM_ANALYSE_OBJECT_TYPE.EM_ANALYSE_OBJECT_TYPE_HUMANFACE;

            pstuRules[1].dwRuleType = NetSDKLib.EVENT_IVS_VEHICLEDETECT;
            pstuRules[1].emClassType = NetSDKLib.EM_SCENE_CLASS_TYPE.EM_SCENE_CLASS_OBJECTDETECT;
            pstuRules[1].nObjectTypesCount = 2;
            pstuRules[1].emObjectTypes[0] = NetSDKLib.EM_ANALYSE_OBJECT_TYPE.EM_ANALYSE_OBJECT_TYPE_VEHICLE;
            pstuRules[1].emObjectTypes[1] = NetSDKLib.EM_ANALYSE_OBJECT_TYPE.EM_ANALYSE_OBJECT_TYPE_HUMANFACE;


            ToolKits.SetStructArrToPointerData(pstuRules,inPut.pstuRule);

            inPut.stuStartTime.setTime(2023, 12, 25, 15, 10, 8);
            inPut.stuEndTime.setTime(2023, 12, 25, 19, 11, 25);
            inPut.write();

            // 出参
            NET_OUT_ADD_LOCAL_ANALYSE_TASK outPut = new NET_OUT_ADD_LOCAL_ANALYSE_TASK();
            outPut.write();

            boolean ret = netsdk.CLIENT_RecordSecondaryAnalyseAddLocalAnalyseTask(loginHandle , inPut.getPointer() , outPut.getPointer() , 3000);
            if(ret) {
                System.out.println("CLIENT_RecordSecondaryAnalyseAddLocalAnalyseTask Success \n");
            } else {
                System.out.println("CLIENT_RecordSecondaryAnalyseAddLocalAnalyseTask Failed \n" + ToolKits.getErrorCode());
                return;
            }
            inPut.read();
            outPut.read();
            if(outPut.nTaskID == 0){
                System.out.println("nErrorCode:" + outPut.nErrorCode);
            }
            nTaskID = outPut.nTaskID;
            System.out.println("nTaskID:" + outPut.nTaskID);
            for (int i = 0;i < outPut.nRepeatCount; i++){
                System.out.println("目标类型：" + outPut.stuRepeatInfo[i].emObjectType);
                System.out.println("重复开始时间：" + outPut.stuRepeatInfo[i].stuStartTime);
                System.out.println("重复结束时间：" + outPut.stuRepeatInfo[i].stuEndTime);
            }
        }catch (Exception e){
            System.out.println(e.toString());
        }
    }

    /**
     * 二次分析结果 句柄
     */
    private NetSDKLib.LLong secondaryAttachHandle = new NetSDKLib.LLong(0);

    /**
     * 查询智能分析任务
     */
    public void findAnalyseTask() {
        // 入参
        NetSDKLib.NET_IN_FIND_ANALYSE_TASK stuInParam = new NetSDKLib.NET_IN_FIND_ANALYSE_TASK();
        // 出参
        NetSDKLib.NET_OUT_FIND_ANALYSE_TASK stuOutParam = new NetSDKLib.NET_OUT_FIND_ANALYSE_TASK();

        if (netsdk.CLIENT_FindAnalyseTask(loginHandle, stuInParam, stuOutParam, 5000)) {
            System.out.println("FindAnalyseTask Succeed!" + "智能分析任务个数" + stuOutParam.nTaskNum);
            // ID和状态 可以从 stuTaskInfos 中获取
            for (int i = 0; i < stuOutParam.nTaskNum; i++) {   // 状态值参考 EM_ANALYSE_STATE

                longNTaskID=stuOutParam.stuTaskInfos[i].nTaskID;// 查出来的任务id用于订阅
                System.out.printf("任务%d: %d, 状态：%d\n", (i + 1), stuOutParam.stuTaskInfos[i].nTaskID, stuOutParam.stuTaskInfos[i].emAnalyseState);
            }
        } else {
            System.err.printf("FindAnalyseTask Failed!" + ToolKits.getErrorCode());
        }
    }

    // 开启任务
    public void startAnalyseTask() {
        // 入参
        NET_IN_SECONDARY_ANALYSE_STARTTASK pInParam = new NET_IN_SECONDARY_ANALYSE_STARTTASK();

        pInParam.nTaskIdNum = 1;
        pInParam.nTaskID[0] = nTaskID;//这个是CLIENT_RecordSecondaryAnalyseAddLocalAnalyseTask方法里面生成返回的output内的nTaskID

        // 出参
        NET_OUT_SECONDARY_ANALYSE_STARTTASK pOutParam = new NET_OUT_SECONDARY_ANALYSE_STARTTASK();
        pInParam.write();
        pOutParam.write();

        if (netsdk.CLIENT_RecordSecondaryAnalyseStartTask(loginHandle, pInParam.getPointer(), pOutParam.getPointer(), 5000)) {
            System.out.println("StartAnalyseTask Succeed! ");
        } else {
            System.err.println("StartAnalyseTask Failed!" + ToolKits.getErrorCode());
            return;
        }
    }

    // 停止任务
    public void pauseAnalyseTask() {
        // 入参
        NET_IN_SECONDARY_ANALYSE_PAUSETASK pInParam = new NET_IN_SECONDARY_ANALYSE_PAUSETASK();

        pInParam.nTaskIdNum = 1;
        pInParam.nTaskID[0] = nTaskID;//这个是CLIENT_RecordSecondaryAnalysePauseTask方法里面生成返回的output内的nTaskID

        // 出参
        NET_OUT_SECONDARY_ANALYSE_PAUSETASK pOutParam = new NET_OUT_SECONDARY_ANALYSE_PAUSETASK();
        pInParam.write();
        pOutParam.write();

        if (netsdk.CLIENT_RecordSecondaryAnalysePauseTask(loginHandle, pInParam.getPointer(), pOutParam.getPointer(), 5000)) {
            System.out.println("pauseAnalyseTask Succeed! ");
        } else {
            System.err.println("pauseAnalyseTask Failed!" + ToolKits.getErrorCode());
            return;
        }
    }

    // 删除任务
    public void removeAnalyseTask() {
        // 入参
        NET_IN_SECONDARY_ANALYSE_REMOVETASK pInParam = new NET_IN_SECONDARY_ANALYSE_REMOVETASK();

        pInParam.nTaskIdNum = 1;
        pInParam.nTaskID[0] = nTaskID;//这个是CLIENT_RecordSecondaryAnalyseRemoveTask方法里面生成返回的output内的nTaskID

        // 出参
        NET_OUT_SECONDARY_ANALYSE_REMOVETASK pOutParam = new NET_OUT_SECONDARY_ANALYSE_REMOVETASK();
        pInParam.write();
        pOutParam.write();

        if (netsdk.CLIENT_RecordSecondaryAnalyseRemoveTask(loginHandle, pInParam.getPointer(), pOutParam.getPointer(), 5000)) {
            System.out.println("removeAnalyseTask Succeed! ");
        } else {
            System.err.println("removeAnalyseTask Failed!" + ToolKits.getErrorCode());
            return;
        }
    }

    public void recordSecondaryAnalyseStartTask() {
        // 入参
        NET_IN_ATTACH_SECONDARY_ANALYSE_RESULT input = new NET_IN_ATTACH_SECONDARY_ANALYSE_RESULT();
        NET_OUT_ATTACH_SECONDARY_ANALYSE_RESULT output = new NET_OUT_ATTACH_SECONDARY_ANALYSE_RESULT();

        input.nTaskNum = 0;
        input.bNeedPicData = 1;
        input.nEventCount = 1;
        input.emEventType[0] = NetSDKLib.EM_ANALYSE_EVENT_TYPE.EM_ANALYSE_EVENT_ALL;
        input.cbAnalyseResult = CbfSecondaryAnalyseTaskResultCallBack.getInstance();
        input.write();
        output.write();

        secondaryAttachHandle = netsdk.CLIENT_AttachRecordSecondaryAnalyseResult(loginHandle, input.getPointer(), output.getPointer(), 5000);
        if (secondaryAttachHandle.longValue() != 0) {
            System.out.println("recordSecondaryAnalyseStartTask Succeed!"+secondaryAttachHandle.longValue());
        } else {
            System.err.printf("recordSecondaryAnalyseStartTask Failed!Last Error[0x%x]\n", netsdk.CLIENT_GetLastError());
            return;
        }
    }

    /**
     * 智能分析结果订阅函数原型
     */
    private static class CbfSecondaryAnalyseTaskResultCallBack implements NetSDKLib.fAnalyseResultCallBack {

        private final File picturePath2;

        private CbfSecondaryAnalyseTaskResultCallBack() {

            picturePath2 = new File("./AnalyzerPicture/result/");
            if (!picturePath2.exists()) {
                picturePath2.mkdirs();
            }

        }

        private static class CallBackHolder {
            private static CbfSecondaryAnalyseTaskResultCallBack instance = new CbfSecondaryAnalyseTaskResultCallBack();
        }

        public static CbfSecondaryAnalyseTaskResultCallBack getInstance() {
            return CbfSecondaryAnalyseTaskResultCallBack.CallBackHolder.instance;
        }

        @Override
        public int invoke(NetSDKLib.LLong lAttachHandle, Pointer pstAnalyseTaskResult, Pointer pBuf, int dwBufSize) {
            NET_CB_ANALYSE_RESULT_INFO task = new NET_CB_ANALYSE_RESULT_INFO();
            ToolKits.GetPointerData(pstAnalyseTaskResult, task);
            System.out.println("nTaskID:" + task.nTaskID);
            System.out.println("nRetEventCount:" + task.nRetEventCount);
            System.out.println(System.currentTimeMillis() + "进入回调-----------------------------------");

            for (int i = 0; i < task.nRetEventCount; i++) {
                System.out.println(i + " emEventType:" + task.stuEventInfo[i].emEventType);
                switch (task.stuEventInfo[i].emEventType) {
                    case NetSDKLib.EM_ANALYSE_EVENT_TYPE.EM_ANALYSE_EVENT_HUMANTRAIT: {// 人体特征事件, 对应结构体 DEV_EVENT_HUMANTRAIT_INFO

                        System.out.println("人体特征事件");

                        NetSDKLib.DEV_EVENT_HUMANTRAIT_INFO msg = new NetSDKLib.DEV_EVENT_HUMANTRAIT_INFO();
                        ToolKits.GetPointerData(task.stuEventInfo[i].pstEventInfo, msg);

                        byte[] szObjectUUID = msg.szObjectUUID;

                        try {
                            System.out.println("nChannelID:" + msg.nChannelID);
                            System.out.println("szName:" + new String(msg.szName,encode));
                            System.out.println("nEventID:" + msg.nEventID);
                            System.out.println("szObjectUUID:"+new String(szObjectUUID,encode));
                            System.out.println("nFaceAlignScore:" + msg.stuFaceAttributes.nFaceAlignScore);
                            System.out.println("nFaceDetectConf:" + msg.stuFaceAttributes.nFaceDetectConf);
                            System.out.println("nFaceClarity:" + msg.stuFaceAttributes.nFaceClarity);
                            System.out.println("nPitch:" + msg.stuFaceAttributes.stuFaceCaptureAngle.nPitch);
                            System.out.println("nFaceQuality:" + msg.stuFaceAttributes.nFaceQuality);
                        } catch (UnsupportedEncodingException e) {
                            e.printStackTrace();
                        }
                        break;
                    }
                    default:
                        System.out.println("其他事件--------------------" + task.stuEventInfo[i].emEventType);
                        break;
                }

            }

            return 0;
        }
    }

    public void detachSecondaryAnalyseStartTask() {
        System.out.println("detachSecondaryAnalyseStartTask:" + secondaryAttachHandle.longValue());

        boolean result = netsdk.CLIENT_DetachRecordSecondaryAnalyseResult(secondaryAttachHandle);
        if (!result) {
            System.out.println("detach secondary analyseTask result failed. error is " + ENUMERROR.getErrorMessage());
        } else {
            System.out.println("detachSecondaryAnalyseStartTask Succeed");

        }
    }

    // 配置登陆地址，端口，用户名，密码
    private String m_strIpAddr = "172.12.5.70";
    private int m_nPort = 37777;
    private String m_strUser = "admin";
    private String m_strPassword = "admin123";

    public static void main(String[] args) {
        LocalAnalyseTaskDemo demo=new LocalAnalyseTaskDemo();
        demo.initTest();
        demo.runTest();
        demo.endTest();
    }
}