/**
 * 屏幕管理模块
 * 负责屏幕显示、UI控制、用户界面管理等功能
 */
import dxui from '../dxmodules/dxUi.js'
import dxMap from '../dxmodules/dxMap.js'
import log from '../dxmodules/dxLogger.js'
import net from '../dxmodules/dxNet.js'
import viewUtils from './view/viewUtils.js'
import i18n from './view/i18n.js'
import grainService from './service/grainService.js'
import sqliteService from './service/sqliteService.js'
import pinyin from './view/pinyin/pinyin.js'
import mainView from './view/mainView.js'
import idleView from './view/idleView.js'
import topView from './view/topView.js'
import appView from './view/appView.js'
import pwdView from './view/pwdView.js'
import emergencyPwdView from './view/emergencyPwdView.js'
import newPwdView from './view/config/newPwdView.js'
import identityVerificationView from './view/config/identityVerificationView.js'
import configView from './view/config/configView.js'
import cloudCertView from './view/config/menu/cloudCertView.js'
import doorControlView from './view/config/menu/doorControlView.js'
import helpView from './view/config/menu/helpView.js'
import networkSettingView from './view/config/menu/networkSettingView.js'
import systemSettingView from './view/config/menu/systemSettingView.js'
import deviceInfoView from './view/config/menu/deviceInfoView.js'
import factoryTestView from './view/config/menu/factoryTestView.js'
import localUserView from './view/config/menu/localUserView.js'
import recordQueryView from './view/config/menu/recordQueryView.js'
import voiceBroadcastView from './view/config/menu/voiceBroadcastView.js'
import dockingSettingView from './view/config/menu/dockingSetting.js'
import localUserAddView from './view/config/menu/localUser/localUserAddView.js'
import faceEnterView from './view/config/menu/localUser/faceEnterView.js'
import displaySettingView from './view/config/menu/systemSetting/displaySettingView.js'
import faceRecognitionSettingView from './view/config/menu/systemSetting/faceRecognitionSettingView.js'
import swipeCardRecognitionSettingView from './view/config/menu/systemSetting/swipeCardRecognitionSettingView.js'
import passLogSettingView from './view/config/menu/systemSetting/passLogSettingView.js'
import passwordOpenDoorSettingView from './view/config/menu/systemSetting/passwordOpenDoorSettingView.js'
import passwordManagementView from './view/config/menu/systemSetting/passwordManagementView.js'
import timeSettingView from './view/config/menu/systemSetting/timeSettingView.js'
import systemInfoView from './view/config/menu/deviceInfo/systemInfoView.js'
import dataCapacityInfoView from './view/config/menu/deviceInfo/dataCapacityInfoView.js'
import recordQueryDetailView from './view/config/menu/recordQuery/recordQueryDetailView.js'
import std from '../dxmodules/dxStd.js'
import bus from '../dxmodules/dxEventBus.js'
import driver from './driver.js'
import config from '../dxmodules/dxConfig.js'
import common from '../dxmodules/dxCommon.js'
import configService from './service/configService.js'
import codeService from './service/codeService.js'
import face from '../dxmodules/dxFace.js'
import faceService from './service/faceService.js'

/**
 * 屏幕管理对象
 */
const screen = {}

/**
 * 屏幕尺寸配置
 */
screen.screenSize = {
    width: 800,
    height: 1280
}

/**
 * UI上下文
 */
const context = {}

/**
 * 初始化屏幕管理模块
 * 初始化所有UI组件、设置语言、启动屏保计时器等
 * 注意：在main.js中调用，只允许调用一次
 */
screen.init = function () {
    const loadMethod = dxui.loadMain
    dxui.loadMain = function (view) {
        if (screen.screenNow && screen.screenNow.id == view.id) {
            return
        }
        screen.screenNow = view
        pinyin.hide(true)
        loadMethod.call(dxui, view)
    }

    dxui.init({ orientation: 0 }, context);
    // 初始化所有组件
    pinyin.init(800, 400)

    viewUtils.confirmInit()

    mainView.init()
    idleView.init()
    topView.init()
    appView.init()
    pwdView.init()
    emergencyPwdView.init()
    newPwdView.init()
    identityVerificationView.init()
    configView.init()

    cloudCertView.init()
    doorControlView.init()
    helpView.init()
    networkSettingView.init()
    systemSettingView.init()
    deviceInfoView.init()
    factoryTestView.init()
    localUserView.init()
    recordQueryView.init()
    voiceBroadcastView.init()
    dockingSettingView.init()

    localUserAddView.init()
    faceEnterView.init()

    displaySettingView.init()
    faceRecognitionSettingView.init()
    swipeCardRecognitionSettingView.init()
    passLogSettingView.init()


    passwordOpenDoorSettingView.init()
    passwordManagementView.init()
    timeSettingView.init()

    systemInfoView.init()
    dataCapacityInfoView.init()
    recordQueryDetailView.init()

    // 设置语言
    // i18n.setLanguage("en-US")
    i18n.setLanguage(config.get("base.language"))

    dxui.loadMain(mainView.screenMain)
    // dxui.loadMain(networkSettingView.screenMain)

    // 启动屏保计时器
    idleTimerStart()

    // bus事件
    busEvents()

    // 实时获取点击坐标
    getClickPoint()

    // 隐藏键盘
    hidePinyin()

    // 人脸跟踪框
    faceTrackingBox()
}

/**
 * 人脸跟踪框处理
 * 定期获取人脸跟踪数据并更新跟踪框显示
 */
function faceTrackingBox() {
    std.setInterval(() => {
        let data = driver.face.getTrackingBox()
        try {
            if (data && typeof data === 'string') {
                // 检查数据是否是有效的JSON字符串
                try {
                    data = JSON.parse(data)
                    // 最大10个人
                    if (data.type == "track" && data.faces && data.faces.length <= 10) {
                        for (let i = 0; i < data.faces.length; i++) {
                            let item = data.faces[i]
                            if (item && item.rect_render && item.rect_render.length === 4) {
                                screen.trackUpdate({ w: item.rect_render[2] - item.rect_render[0], h: item.rect_render[3] - item.rect_render[1], x: item.rect_render[0], y: item.rect_render[1] }, item.id, item.is_living)
                            }
                        }
                    }
                } catch (parseError) {
                    log.info('screen.faceTrackingBox: 无效的JSON数据:', data);
                    log.error("screen.faceTrackingBox: JSON解析错误:", parseError)
                }
            }
        } catch (error) {
            log.info('screen.faceTrackingBox:', data);
            log.error("screen.faceTrackingBox:", error)
        }
    }, 110)
}

/**
 * 点击坐标变化标记
 */
let changedClickPoint

/**
 * 上次点击坐标
 */
let lastClickPoint = { x: 0, y: 0 }

/**
 * 当前点击坐标
 */
let clickPoint

/**
 * 实时获取点击坐标
 * 定期获取用户触摸屏幕的坐标位置
 */
function getClickPoint() {
    const indev = NativeObject.APP.NativeComponents.NativeIndev
    std.setInterval(() => {
        clickPoint = {
            x: Math.abs(800 - indev.lvIndevGetPointVg().x),
            y: indev.lvIndevGetPointVg().y
        }

        if (lastClickPoint.x != clickPoint.x || lastClickPoint.y != clickPoint.y) {
            changedClickPoint = clickPoint
        } else {
            changedClickPoint = null
        }

        lastClickPoint = clickPoint
    }, 5)
}

/**
 * 隐藏拼音键盘
 * 处理拼音键盘的显示和隐藏逻辑，当用户点击屏幕其他区域时自动隐藏键盘
 */
function hidePinyin() {
    /**
     * 键盘显示时的点击坐标
     */
    let showPoint
    
    /**
     * 原始的隐藏方法
     */
    const hideMethod = pinyin.hide
    
    /**
     * 原始的显示方法
     */
    const showMethod = pinyin.show
    
    /**
     * 锁定标志，防止重复操作
     */
    let lock = false
    
    // 重写隐藏方法
    pinyin.hide = function (isForce) {
        if (isForce) {
            hideMethod.call(pinyin)
            lock = false
            return
        }
        if (lock) {
            return
        }
        lock = true
        hideMethod.call(pinyin)
        lock = false
    }
    
    // 重写显示方法
    pinyin.show = function (...args) {
        if (lock) {
            return
        }
        lock = true
        showMethod.call(pinyin, ...args)
        showPoint = clickPoint
        lock = false
    }
    
    // 定期检查是否需要隐藏键盘
    std.setInterval(() => {
        if (showPoint && (Math.abs(showPoint.x - clickPoint.x) > 5 && Math.abs(showPoint.y - clickPoint.y) > 5)) {
            if (clickPoint.y < (1280 - (pinyin.getMode() == 1 ? 400 + 70 : 400))) {
                let defocus = dxMap.get("INPUT_KEYBOARD").get("defocus")
                if (defocus == "defocus") {
                    dxMap.get("INPUT_KEYBOARD").del("defocus")
                    showPoint = null
                    pinyin.hide()
                }
            }
        }
    }, 5)
}

/**
 * 屏幕管理器类
 * 负责屏幕状态管理，包括屏保和熄屏功能
 */
class ScreenManager {
    /**
     * 构造函数
     * @param {object} callbacks - 回调函数对象
     */
    constructor(callbacks = {}) {
        /**
         * 定时器对象
         */
        this.timers = {
            screenSaver: null, // 屏保定时器
            screenOff: null    // 熄屏定时器
        };

        /**
         * 配置对象
         */
        this.config = {
            screenSaverDelay: 0, // 屏保延迟（毫秒）
            screenOffDelay: 0    // 熄屏延迟（毫秒）
        };

        /**
         * 回调函数
         */
        this.callbacks = {
            onScreenSaverStart: callbacks.onScreenSaverStart || (() => { }),
            onScreenSaverEnd: callbacks.onScreenSaverEnd || (() => { }),
            onScreenOff: callbacks.onScreenOff || (() => { }),
            onScreenOn: callbacks.onScreenOn || (() => { })
        };

        this.resetTimers = this.resetTimers.bind(this);
    }

    /**
     * 配置时间
     * @param {number} screenSaverDelay - 屏保延迟（毫秒）
     * @param {number} screenOffDelay - 熄屏延迟（毫秒）
     */
    configure({ screenSaverDelay = 0, screenOffDelay = 0 }) {
        this.config.screenSaverDelay = screenSaverDelay;
        this.config.screenOffDelay = screenOffDelay;
        this.resetTimers();
    }

    /**
     * 重置定时器
     * 清除现有定时器并设置新的定时器
     */
    resetTimers() {
        // 清除现有定时器
        if (this.timers.screenSaver) {
            std.clearTimeout(this.timers.screenSaver);
        }
        if (this.timers.screenOff) {
            std.clearTimeout(this.timers.screenOff);
        }

        // 退出当前状态
        this.exitScreenStates();

        // 设置新的定时器
        if (this.config.screenOffDelay > 0) {
            this.timers.screenOff = std.setTimeout(() => {
                this.enterScreenOff();
            }, this.config.screenOffDelay);
        }

        // 只有当熄屏时间大于屏保时间时才设置屏保定时器
        if (this.config.screenSaverDelay > 0 &&
            (this.config.screenSaverDelay < this.config.screenOffDelay || this.config.screenOffDelay == 0)) {
            this.timers.screenSaver = std.setTimeout(() => {
                this.enterScreenSaver();
            }, this.config.screenSaverDelay);
        }
    }

    /**
     * 进入屏保状态
     */
    enterScreenSaver() {
        const mapUI = dxMap.get("UI")
        if (!mapUI.get("isScreenOff")) {
            mapUI.put("isScreenSaver", true)
            this.callbacks.onScreenSaverStart();
        }
    }

    /**
     * 进入熄屏状态
     */
    enterScreenOff() {
        const mapUI = dxMap.get("UI")
        mapUI.put("isScreenOff", true)
        mapUI.put("isScreenSaver", false)
        this.callbacks.onScreenOff();
    }

    /**
     * 退出所有屏幕状态
     */
    exitScreenStates() {
        const mapUI = dxMap.get("UI")
        const previousState = { isScreenOff: mapUI.get("isScreenOff"), isScreenSaver: mapUI.get("isScreenSaver") };
        mapUI.put("isScreenOff", false)
        mapUI.put("isScreenSaver", false)
        // 如果状态发生改变，触发相应回调
        if (previousState.isScreenSaver) {
            this.callbacks.onScreenSaverEnd();
        }
        if (previousState.isScreenOff) {
            this.callbacks.onScreenOn();
        }
    }

    /**
     * 获取当前状态
     * @returns {object} 当前屏幕状态
     */
    getState() {
        const mapUI = dxMap.get("UI")
        return { isScreenOff: mapUI.get("isScreenOff"), isScreenSaver: mapUI.get("isScreenSaver") };
    }

    /**
     * 清理资源
     * 清除所有定时器
     */
    destroy() {
        if (this.timers.screenSaver) {
            std.clearTimeout(this.timers.screenSaver);
        }
        if (this.timers.screenOff) {
            std.clearTimeout(this.timers.screenOff);
        }
    }
}

/**
 * 屏幕管理器实例
 */
let screenManager

/**
 * 启动屏保计时器
 * 初始化屏幕管理器，设置屏保和熄屏时间，检测用户触摸
 */
function idleTimerStart() {
    // 创建实例，传入回调函数
    screenManager = new ScreenManager({
        /**
         * 屏保开始回调
         */
        onScreenSaverStart: () => {
            screen.enterIdle()
        },
        
        /**
         * 屏保结束回调
         */
        onScreenSaverEnd: () => {
            screen.exitIdle(true)
        },
        
        /**
         * 熄屏回调
         */
        onScreenOff: () => {
            dxMap.get("screenOff").put("status", 1)
            // 停止人脸识别
            driver.face.status(false)
            screen.screenNow.hide()
            topView.screenMain.hide()
        },
        
        /**
         * 亮屏回调
         */
        onScreenOn: () => {
            screen.exitIdle(true)
            dxMap.get("screenOff").put("status", 0)
            // 恢复人脸识别
            driver.face.status(true)
            screen.screenNow.show()
            topView.screenMain.show()
            
            // 退出熄屏时获取并更新气体浓度和状态信息
            try {
                log.info('[screen]: 退出熄屏，获取气体浓度和状态信息')
                grainService.checkGasConcentration()
                grainService.checkDevConcentration()
            } catch (error) {
                log.error(`[screen]: 获取气体浓度和状态信息错误: ${error.message}`)
            }
        }
    });

    // 配置时间（毫秒）
    screenManager.configure({
        // screenSaverDelay: 10000,  // 屏保
        // screenOffDelay: 5000     // 熄屏
        screenSaverDelay: config.get("base.screensaver") * 60 * 1000,  // 屏保
        screenOffDelay: config.get("base.screenOff") * 60 * 1000     // 熄屏
    });

    // 检测用户触摸
    let touchCount = 0
    std.setInterval(() => {
        let count = dxui.Utils.GG.NativeDisp.lvDispGetInactiveTime()
        if (count < touchCount) {
            screenManager.resetTimers();
        }
        touchCount = count
    }, 100);
}

/**
 * 刷新屏幕管理器配置
 * 更新屏保和熄屏时间配置
 */
screen.screenManagerRefresh = function () {
    screenManager.configure({
        screenSaverDelay: config.get("base.screensaver") * 60 * 1000,  // 屏保
        screenOffDelay: config.get("base.screenOff") * 60 * 1000     // 熄屏
    });
    screenManager.resetTimers();
}

/**
 * 进入屏保定时器
 */
let enterIdleTimer

/**
 * 进入屏保
 * 显示屏保界面
 */
screen.enterIdle = function () {
    // 延迟1秒，防止进入屏保和退出屏保同时触发，1秒内没有触发退出屏保，则认为进入屏保
    enterIdleTimer = std.setTimeout(() => {
        if (idleView.screenMain.isHide()) {
            viewUtils.confirmClose()
            dxui.loadMain(mainView.screenMain)
            idleView.screenMain.show()
            topView.changeTheme(false)
        }
    }, 1000)
}

/**
 * 退出屏保
 * 隐藏屏保界面
 * @param {boolean} isSelf - 是否由系统自身触发
 */
screen.exitIdle = function (isSelf) {
    if (enterIdleTimer) {
        std.clearTimeout(enterIdleTimer)
        enterIdleTimer = null
    }
    if (!isSelf) {
        screenManager.resetTimers();
    }
    if (!idleView.screenMain.isHide()) {
        idleView.screenMain.hide()
    }
}

/**
 * 屏幕循环处理
 * 处理UI事件
 * @returns {boolean} 处理结果
 */
screen.loop = function () {
    return dxui.handler()
}

/**
 * 云证激活
 * 激活电子身份证
 * @param {string} code - 激活码
 * @returns {number} 激活结果，0表示成功，非0表示失败
 */
screen.nfcIdentityCardActivation = function (code) {
    return driver.eid.active(config.get("sys.sn"), config.get("sys.appVersion"), config.get("sys.mac"), code);

}

/**
 * 删除人员
 * 删除用户信息、权限、凭证和人脸数据
 * @param {object} user - 用户对象
 * @returns {boolean} 删除结果
 */
screen.deleteUser = function (user) {
    // 删除人员信息
    sqliteService.d1_person.deleteByUserId(user.userId)
    // 删除权限信息
    sqliteService.d1_permission.deleteByUserId(user.userId)
    // 删除凭证信息
    sqliteService.d1_voucher.deleteByUserId(user.userId)
    // 删除人脸数据
    let res = driver.face.delete(user.userId)

    return true
}

/**
 * 更新人员信息
 * 更新用户信息、密码、卡片和人脸数据
 * @param {object} user - 用户对象
 * @returns {boolean|string} 更新结果，成功返回true，失败返回错误信息
 */
screen.updateUser = function (user) {
    //修改人员信息
    let res = sqliteService.d1_person.updatenameAndExtraByUserId(user.userId, user.name, JSON.stringify({ type: user.type, idCard: user.idCard }))
    if (res != 0) {
        return false
    }
    
    //处理凭证
    let ret
    
    //处理密码凭证
    if (user.pwd) {
        //判断库表是否存在这个凭证
        let pwdData = sqliteService.d1_voucher.findByCodeAndType(user.pwd, "400");
        if (pwdData.length > 0 && pwdData[0].userId != user.userId) {
            //存在不能添加返回失败
            log.info("密码重复");
            return "localUserAddView.failPwdRepeat"
        }
        //查询是否有密码凭证有更新没有新增
        let countByuserIdAndType = sqliteService.d1_voucher.findByuserIdAndType(user.userId, "400");
        if (countByuserIdAndType.length > 0) {
            ret = sqliteService.d1_voucher.updatecodeByuserIdAndtype(user.userId, "400", user.pwd)
            if (ret != 0) {
                return false
            }
        } else {
            //新增一个
            ret = sqliteService.d1_voucher.save({ keyId: std.genRandomStr(32), type: "400", code: user.pwd, userId: user.userId })
            if (ret != 0) {
                return false
            }
        }
    } else {
        //没有内容去数据库表删除一下
        sqliteService.d1_voucher.deleteByuserIdAndtype(user.userId, "400")
    }
    
    //处理卡片凭证
    if (user.card) {
        //判断库表是否存在这个凭证
        let cardData = sqliteService.d1_voucher.findByCodeAndType(user.card, "200");
        if (cardData.length > 0 && cardData[0].userId != user.userId) {
            //存在不能添加返回失败
            log.info("卡重复");
            return "localUserAddView.failCardRepeat"
        }
        //查询是否有密码凭证有更新没有新增
        let countByuserIdAndType = sqliteService.d1_voucher.countByuserIdAndType(user.userId, "200");
        if (countByuserIdAndType > 0) {
            ret = sqliteService.d1_voucher.updatecodeByuserIdAndtype(user.userId, "200", user.card)
            if (ret != 0) {
                return false
            }
        } else {
            //新增一个
            ret = sqliteService.d1_voucher.save({ keyId: std.genRandomStr(32), type: "200", code: user.card, userId: user.userId })

            if (ret != 0) {
                return false
            }
        }
    } else {
        //没有内容去数据库表删除一下
        sqliteService.d1_voucher.deleteByuserIdAndtype(user.userId, "200")
    }
    
    //处理人脸凭证
    if (user.face) {
        let findByuserIdAndType = sqliteService.d1_voucher.findByuserIdAndType(user.userId, "300");
        if (findByuserIdAndType.length <= 0) {
            let ret = driver.face.registerFaceByPicFile(user.userId, user.face)
            log.info("2注册人脸,ret:", ret)
            if (ret != 0) {
                return faceService.regErrorEnum.picture[ret + '']
            }
            //注册成功后需要吧原来图片移动到 user 对应目录下
            let src = "/app/data/user/" + user.userId + "/register.jpg"
            std.ensurePathExists(src)
            common.systemBrief('mv ' + user.face + " " + src)

            //新增一个
            ret = sqliteService.d1_voucher.save({ keyId: std.genRandomStr(32), type: "300", code: src, userId: user.userId })
            if (ret != 0) {
                return false
            }
        } else {
            //原来有又传入 先删除后新增
            if (findByuserIdAndType[0].code != user.face) {
                //删除老人脸
                driver.face.delete(user.userId)
                //注册新人脸
                let res = driver.face.registerFaceByPicFile(user.userId, user.face)
                log.info("3注册人脸,res:", res)
                if (res != 0) {
                    return faceService.regErrorEnum.picture[res + '']
                }
                let src = "/app/data/user/" + user.userId + "/register.jpg"
                std.ensurePathExists(src)
                //把临时目录人脸移动到 user 对应的文件夹中
                common.systemBrief('mv ' + user.face + " " + src)
                ret = sqliteService.d1_voucher.updatecodeAndExtraByuserIdAndtype(user.userId, "300", src, JSON.stringify({ faceType: 0 }))

            }
        }
    } else {
        //没有内容去数据库表删除一下
        sqliteService.d1_voucher.deleteByuserIdAndtype(user.userId, "300")
        driver.face.delete(user.userId)
        common.systemBrief("rm -rf /app/data/user/" + user.userId)
    }

    return true
}

/**
 * 新增人员
 * 添加新用户信息、密码、卡片和人脸数据
 * @param {object} user - 用户对象
 * @returns {boolean|string} 添加结果，成功返回true，失败返回错误信息
 */
screen.insertUser = async function (user) {
    /**
     * 保存凭证
     * @param {string} type - 凭证类型
     * @param {string} code - 凭证代码
     * @returns {boolean|string} 保存结果
     */
    const saveVoucher = async (type, code) => {
        // 检查卡片凭证是否重复
        if (type == "200") {
            let cardData = sqliteService.d1_voucher.findByCodeAndType(code, "200");
            if (cardData.length > 0 && cardData[0].userId != user.userId) {
                //存在不能添加返回失败
                log.info("卡重复");
                return "localUserAddView.failCardRepeat"
            }
        }
        
        // 当 type 为 "300" 时，首先调用特定方法检查是否可以继续保存凭证
        if (type === "300") {
            let preCheckResult = await preSaveCheck(code); // 假设这是您提到的需要调用的方法
            if (preCheckResult !== true) { // 如果预检查不通过，则直接返回 false
                return preCheckResult;
            }
            code = "/app/data/user/" + user.userId + "/register.jpg"
        }

        // 检查密码凭证是否重复
        if (type == "400") {
            let pwdData = sqliteService.d1_voucher.findByCodeAndType(code, "400");
            if (pwdData.length > 0 && pwdData[0].userId != user.userId) {
                //存在不能添加返回失败
                log.info("密码重复");
                return "localUserAddView.failPwdRepeat"
            }
        }

        let keyId = std.genRandomStr(32);

        let extra = type == 300 ? JSON.stringify({ faceType: 0 }) : JSON.stringify({})
        let voucherRet = await sqliteService.d1_voucher.save({
            keyId: keyId,
            type: type,
            code: code,
            userId: user.userId,
            extra: extra
        });

        if (voucherRet != 0) {
            // 如果凭证保存失败，则删除已保存的用户信息及可能已保存的其他凭证
            await sqliteService.d1_person.deleteByUserId(user.userId);
            await sqliteService.d1_voucher.deleteByUserId(user.userId);
            return false;
        }
        return true;
    };
    
    /**
     * 保存前检查
     * @param {string} code - 人脸图片路径
     * @returns {boolean|string} 检查结果
     */
    async function preSaveCheck(code) {
        let ret = driver.face.registerFaceByPicFile(user.userId, code)
        log.info("1注册人脸,ret:", ret)
        if (ret != 0) {
            return faceService.regErrorEnum.picture[ret + '']
        }
        //注册成功后需要吧原来图片移动到 user 对应目录下
        let src = "/app/data/user/" + user.userId + "/register.jpg"
        std.ensurePathExists(src)
        common.systemBrief('mv ' + code + " " + src)
        return true;
    }

    let success = true;
    // 保存人脸凭证
    if (success === true && user.face && !(success = await saveVoucher("300", user.face)));
    // 保存密码凭证
    if (success === true && user.pwd && !(success = await saveVoucher("400", user.pwd)));
    // 保存卡片凭证
    if (success === true && user.card && !(success = await saveVoucher("200", user.card)));

    if (success === true) {
        //{"id":"423","userId":"423","name":"微光互联","idCard":"123","pwd":"251574","card":"123"}
        //保存人员信息
        let personRet = await sqliteService.d1_person.save({
            userId: user.userId,
            name: user.name,
            extra: JSON.stringify({ type: user.type == 1 ? 1 : 0, idCard: user.idCard })
        });
        if (personRet != 0) {
            sqliteService.d1_voucher.deleteByUserId(user.userId);
            return "localUserAddView.failRepeat"
        }
        //新增一条永久权限
        sqliteService.d1_permission.save({ permissionId: user.userId, userId: user.userId, timeType: 0 })
    } else {
        await sqliteService.d1_voucher.deleteByUserId(user.userId);
    }

    return success;

}

/**
 * 获取本地人员信息
 * 获取用户的凭证信息，包括身份证、卡片、密码和人脸数据
 * @param {string} userId - 用户ID
 * @returns {object} 用户凭证信息
 */
screen.getVoucher = function (userId) {
    // 获取用户信息
    let person = sqliteService.d1_person.find({ userId: userId });

    if (person.length < 0) {
        return
    }
    
    // 获取密码凭证
    let pwd_voucher = sqliteService.d1_voucher.find({ userId: userId, type: "400" })[0] || undefined
    
    // 获取卡片凭证
    let card_voucher = sqliteService.d1_voucher.find({ userId: userId, type: "200" })[0] || undefined
    
    // 获取人脸凭证
    let face_voucher = sqliteService.d1_voucher.find({ userId: userId, type: "300" })[0] || undefined
    
    // 获取身份证信息
    let idCard_voucher
    try {
        idCard_voucher = JSON.parse(person[0].extra).idCard
    } catch (error) {
    }

    return {
        id: userId,
        idCard: idCard_voucher ? idCard_voucher : undefined,
        card: card_voucher ? card_voucher.code : undefined,
        pwd: pwd_voucher ? pwd_voucher.code : undefined,
        face: face_voucher ? face_voucher.code : undefined,
        type: JSON.parse(person[0].extra).type || 0
    }

}

/**
 * 获取用户列表
 * 根据条件查询用户列表，支持分页和搜索
 * @param {number} page - 页码，默认0
 * @param {number} size - 每页大小，默认6
 * @param {string} userId - 用户ID，用于精确搜索
 * @param {string} name - 用户姓名，用于模糊搜索
 * @returns {object} 用户列表数据，包含分页信息
 */
screen.getUsers = function (page = 0, size = 6, userId, name) {
    // 按用户ID或姓名搜索
    if (userId || name) {
        // 按用户ID搜索
        let user = sqliteService.d1_person.findByUserId(userId)[0]
        if (user) {
            user.id = user.userId
            return { data: [user], totalPage: 1, totalSize: 1, currentPage: 1 }
        }
        // 按用户姓名搜索
        let users = sqliteService.d1_person.findByName(name)
        if (users && users.length > 0) {
            users.map(v => {
                v.id = v.userId
            })
            
            /**
             * 数组分块
             * @param {array} arr - 源数组
             * @param {number} size - 块大小
             * @returns {array} 分块后的数组
             */
            function chunkArray(arr, size) {
                // 如果数组为空或者大小为零，返回空数组
                if (arr.length === 0 || size <= 0) {
                    return [];
                }
                const result = [];
                // 使用循环遍历数组，并按照大小切割
                for (let i = 0; i < arr.length; i += size) {
                    result.push(arr.slice(i, i + size));  // slice 截取指定范围的元素
                }
                return result;
            }
            
            const chunkedArray = chunkArray(users, size);
            return { data: chunkedArray[page], totalPage: Math.ceil(users.length / size), totalSize: users.length, currentPage: page + 1 }
        }
        return { data: [], totalPage: 0, totalSize: 0, currentPage: 1 }
    }
    
    // 获取所有用户
    let userCount = sqliteService.d1_person.count()
    let users = sqliteService.d1_person.findOrderByUserIdAsc({ page, size })
    if (users.length > 0) {
        users.forEach(element => { element.id = element.userId });
    }
    // 总页数
    let totalPage = Math.ceil(userCount / size)
    return { data: users, totalPage: totalPage, totalSize: userCount, currentPage: page + 1 }
}

/**
 * 获取通行记录
 * 获取用户通行记录，支持分页
 * @param {number} page - 页码，默认0
 * @param {number} size - 每页大小，默认6
 * @returns {object} 通行记录数据，包含分页信息
 */
screen.getPassRecord = function (page = 0, size = 6) {
    let passCount = sqliteService.d1_pass_record.count()
    let datas = sqliteService.d1_pass_record.findOrderByTimeDesc({ page, size })
    // 总页数
    let totalPage = Math.ceil(passCount / size)
    return { data: datas, totalPage: totalPage, totalSize: passCount, currentPage: page + 1 }
}

/**
 * 人脸录入开始
 * 开始人脸录入，UI控制
 * @param {string} userId - 用户ID
 */
screen.faceEnterStart = function (userId) {
    dxMap.get("UI").put("faceEnterStart", userId)
    driver.face.status(1)
    driver.face.mode(1)
}

/**
 * 人脸录入结束
 * 结束人脸录入，UI控制
 */
screen.faceEnterEnd = function () {
    dxMap.get("UI").del("faceEnterStart")
    driver.face.status(0)
    // driver.face.mode(0)
}

/**
 * 获取卡号开始
 * 开始获取卡号，UI控制
 */
screen.getCardStart = function () {
    dxMap.get("UI").put("getCardStart", true)
}

/**
 * 获取卡号结束
 * 结束获取卡号，UI控制
 */
screen.endCardEnd = function () {
    dxMap.get("UI").del("getCardStart")
}

/**
 * 开启人脸识别
 * 开始人脸识别功能
 */
screen.faceRecgStart = function () {
    driver.face.status(1)
    driver.face.mode(0)
}

/**
 * 人脸识别暂停
 * 暂停人脸识别功能
 */
screen.faceRecgPause = function () {
    driver.face.status(0)
}

/**
 * 人脸录入结果
 * 处理人脸录入结果
 * @param {string} facePic - 人脸图片路径
 */
screen.faceEnterResult = function (facePic) {
    if (facePic) {
        faceEnterView.successFlag = true
        // 成功，显示人脸照片
        localUserAddView.addFace(facePic)
        dxui.loadMain(localUserAddView.screenMain)
        faceEnterView.backCb()
    } else {
        // 失败，报错
        faceEnterView.timeout()
    }
}

/**
 * 非识别页面人脸认证开始
 * 开始人脸认证，UI控制
 */
screen.faceAuthStart = function () {
    dxMap.get("UI").put("faceAuthStart", "Y")
    driver.face.status(1)
    driver.face.mode(0)
}

/**
 * 非识别页面人脸认证结束
 * 结束人脸认证，UI控制
 */
screen.faceAuthEnd = function () {
    dxMap.get("UI").del("faceAuthStart")
    driver.face.status(0)
}

/**
 * 非识别页面人脸认证结果
 * 处理人脸认证结果
 * @param {boolean} bool - 认证结果，true表示成功，false表示失败
 */
screen.faceAuthResult = function (bool) {
    if (bool) {
        // 成功，进入设置菜单
        driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/recg_s.wav`)
        dxui.loadMain(configView.screenMain)
    } else {
        // 失败，报错
        driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/recg_f.wav`)
        identityVerificationView.statusPanel.fail()
    }
}

/**
 * 保存配置
 * 保存系统配置
 * @param {object} configAll - 配置对象
 * @returns {boolean} 保存结果
 */
screen.saveConfig = function (configAll) {
    // 直接调用配置验证和保存函数
    return configService.configVerifyAndSave(configAll)
}

/**
 * 获取配置
 * 获取系统配置
 * @returns {object} 配置对象
 */
screen.getConfig = function () {
    let config1 = config.getAll()
    return config1
}

/**
 * 密码通行
 * 使用密码进行通行验证
 * @param {string} pwd - 密码
 * @returns {boolean} 验证结果，true表示成功，false表示失败
 */
screen.pwdAccess = function (pwd) {
    // 检查数据库中的应急开仓密码
    try {
        const passwords = sqliteService.d1_emergency_password.findAll({ status: 1 })
        for (let i = 0; i < passwords.length; i++) {
            if (passwords[i].password === pwd) {
                return true
            }
        }
    } catch (error) {
        logger.error('检查应急开仓密码失败:', error)
    }
    
    // 其他密码验证逻辑
    bus.fire("access", { data: { type: "400", code: pwd } })
    return false
}

/**
 * 切换网络类型
 * 切换网络连接类型
 * @param {object} data - 网络类型数据
 */
screen.switchNetworkType = function (data) {
    bus.fire("switchNetworkType", data)
}

/**
 * 获取WiFi列表
 * 获取可用的WiFi网络列表
 */
screen.netGetWifiSsidList = function () {
    bus.fire("netGetWifiSsidList")
}

/**
 * WiFi列表数据
 * 处理WiFi列表数据
 * @param {array} data - WiFi列表数据
 */
screen.netWifiSsidList = function (data) {
    if (data.length == 0 && config.get("net.type") == 2) {
        //无线网
        std.setTimeout(() => {
            screen.netGetWifiSsidList()
        }, 1000)
        return
    }
    networkSettingView.wifiListData = data
    networkSettingView.wifiList.refresh()
}

/**
 * 连接WiFi
 * 连接到指定的WiFi网络
 * @param {string} ssid - WiFi名称
 * @param {string} psk - WiFi密码
 * @returns {boolean} 连接结果
 */
screen.netConnectWifiSsid = function (ssid, psk) {
    return driver.net.netConnectWifiSsid(ssid, psk)
}

/**
 * 获取卡号
 * 处理获取到的卡号
 * @param {string} card - 卡号
 */
screen.getCard = function (card) {
    localUserAddView.cardBoxInput.text(card)
}

/**
 * 事件总线事件处理
 * 注册和处理系统事件
 */
function busEvents() {
    // 网络状态
    bus.on('netStatus', (data) => {
        console.log(JSON.stringify(data));
        let type = config.get("net.type")
        if (data.connected) {
            let ip = net.getModeByCard(type).param.ip
            mainView.overlayIpLbl.text("IP:" + ip)
            config.setAndSave("net.ip", ip)
            config.setAndSave("net.mac", net.getMacaddr(type))
            topView.ethConnectState(true, type)
            networkSettingView.netInfo[10].label.dataI18n = "networkSettingView.networkConnected"
        } else {
            topView.ethConnectState(false, type)
            networkSettingView.netInfo[10].label.dataI18n = "networkSettingView.networkUnconnected"
        }
        i18n.refreshObj(networkSettingView.netInfo[10].label)
    })
    
    // mqtt连接状态
    bus.on('mqttStatus', (data) => {
        if (data == "connected") {
            topView.mqttConnectState(true)
        } else {
            topView.mqttConnectState(false)
        }
    })
    
    // 人脸录入开始
    bus.on("beginAddFace", screen.beginAddFace)
    
    // 人脸录入结果
    bus.on("faceEnterResult", screen.faceEnterResult)
    
    // 退出屏保
    bus.on("exitIdle", screen.exitIdle)
    
    // 获取WiFi列表 - 移除事件监听器，避免无限循环
    
    // 获取卡号
    bus.on("getCard", screen.getCard)
    
    // 人脸认证结果
    bus.on("faceAuthResult", screen.faceAuthResult)
    
    // 通行结果
    bus.on("accessRes", screen.accessRes)
    
    // 跟踪更新
    // bus.on("trackUpdate", screen.trackUpdate)
    
    // 隐藏SN
    bus.on("hideSn", screen.hideSn)
    
    // 切换语言
    bus.on("changeLanguage", screen.changeLanguage)
    
    // 隐藏IP
    bus.on("hideIp", screen.hideIp)
    
    // 刷新屏幕管理器
    bus.on("screenManagerRefresh", screen.screenManagerRefresh)
    
    // WiFi列表数据
    bus.on("netWifiSsidList", screen.netWifiSsidList)
    
    // APP模式
    bus.on("appMode", screen.appMode)
    
    // 升级
    bus.on("upgrade", screen.upgrade)
    
    // 卡片重置
    // bus.on("cardReset", screen.cardReset)
    
    // 跟踪结果
    bus.on("trackResult", screen.trackResult)
    bus.on("showAccessResult", screen.showAccessResult)
}

/**
 * 卡片重置定时器
 */
let setTimeout

/**
 * 卡片重置
 * 处理卡片重置逻辑
 * @param {object} msg - 消息对象
 */
screen.cardReset = function (msg) {
    if (msg.type == 2 && msg.status == 3) {
        setTimeout = std.setTimeout(() => {
            driver.net.cardReset()
        }, 30 * 1000);
    } else {
        if (setTimeout) {
            std.clearTimeout(setTimeout)
        }
    }
}

/**
 * 开始注册人脸
 * 处理人脸注册开始逻辑
 * @param {object} data - 人脸数据对象
 */
screen.beginAddFace = function (data) {
    log.info('screen.beginAddFace', JSON.stringify(data));

    if (!data.fileName) {
        return screen.faceEnterResult()
    }

    driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/recognition_s.wav`)
    faceEnterView.statusPanel.success("faceEnterView.recogSuccess")
    // 保存图片到本地   
    let src = `/app/data/user/register.jpg`
    common.systemBrief(`mv ${data.fileName} ${src}`)
    common.systemBrief(`rm -rf /app/data/user/temp/*`)

    screen.faceEnterResult(src)
}

/**
 * 通行结果
 * 处理通行成功或失败的结果
 * @param {boolean} bool - 通行结果，true表示成功，false表示失败
 */
screen.accessRes = function (bool) {
    if (bool) {
        if (mainView.smallStatusPanel && mainView.smallStatusPanel.success) {
            mainView.smallStatusPanel.success()
        }
    } else {
        if (mainView.smallStatusPanel && mainView.smallStatusPanel.fail) {
            mainView.smallStatusPanel.fail()
        }
    }
}

/**
 * 切换APP模式
 * 切换应用程序显示模式（标准模式或简洁模式）
 * @param {number} mode - 模式值，0表示标准模式，1表示简洁模式
 */
screen.appMode = function (mode) {
    if (mode == 0) {
        // 切换到标准模式
    } else if (mode == 1) {
        // 切换到简洁模式
    }
}

/**
 * 更新人脸跟踪框
 * 更新人脸跟踪框的位置和状态
 * @param {object} data - 坐标信息
 * @param {number} id - face_id，用于关联识别姓名用
 * @param {boolean} isLiving - 是否活体
 */
screen.trackUpdate = function (data, id, isLiving) {
    let item = mainView.trackFaces[0]
    for (let i = 0; i < 10; i++) {
        let ele = mainView.trackFaces[i]
        if (ele.face_id == id) {
            item = ele
            break
        }
    }
    item.face_id = id

    if (item && item.timer) {
        std.clearTimeout(item.timer)
        item.timer = null
    }

    item.timer = std.setTimeout(() => {
        item.trackFace.hide()
        // item.trackFaceName.hide()
        if (item.timer) {
            std.clearTimeout(item.timer)
            item.timer = null
        }
    }, 300)

    let edge = data.w > data.h ? data.w : data.h
    let offset = Math.abs(data.w - data.h) / 2
    item.trackFace.show()
    item.trackFace.setSize(edge, edge)
    item.trackFace.radius(edge / 2)
    if (data.w > data.h) {
        item.trackFace.setPos(data.x, data.y - offset)
    } else {
        item.trackFace.setPos(data.x - offset, data.y)
    }

    item.trackFaceName.text(" ")

    if (item.result && item.result.result === true && item.result.id == id) {
        item.trackFace.setBorderColor(viewUtils.color.success)
        let user = sqliteService.d1_person.findByUserId(item.result.userId)[0]
        item.trackFaceName.text(user ? user.name : "")
    } else if (item.result && item.result.result === false && item.result.id == id) {
        item.trackFace.setBorderColor(viewUtils.color.fail)
    } else if (isLiving) {
        item.trackFace.setBorderColor(0xf3e139)
    } else {
        item.trackFace.setBorderColor(0xffffff)
    }
}

/**
 * 认证结果
 * 处理人脸识别认证结果
 * @param {object} data - 认证结果数据
 */
screen.trackResult = function (data) {
    for (let i = 0; i < 10; i++) {
        let ele = mainView.trackFaces[i]
        if (ele.face_id == data.id) {
            ele.result = data
            return
        }
    }
}

/**
 * 隐藏SN按钮
 * 控制SN按钮的显示和隐藏
 * @param {boolean} bool - 是否显示，true表示显示，false表示隐藏
 */
screen.hideSn = function (bool) {
    if (bool) {
        mainView.bottomSnBtn.show()
    } else {
        mainView.bottomSnBtn.hide()
    }
}

/**
 * 隐藏IP标签
 * 控制IP标签的显示和隐藏
 * @param {boolean} bool - 是否显示，true表示显示，false表示隐藏
 */
screen.hideIp = function (bool) {
    // 不再需要此函数，因为IP信息现在显示在半透明覆盖图层中
}

/**
 * 隐藏底部框
 * 控制底部框的显示和隐藏
 * @param {boolean} bool - 是否显示，true表示显示，false表示隐藏
 */
screen.hideBottomBox = function (bool) {
    if (bool) {
        mainView.bottomBox.hide()
    } else {
        mainView.bottomBox.show()
    }
}

/**
 * 切换语言
 * 切换系统语言设置
 */
screen.changeLanguage = function () {
    i18n.setLanguage(screen.getConfig()['base.language'])
}

/**
 * 升级提示
 * 显示系统升级提示信息
 * @param {object} data - 升级信息对象，包含title和content
 */
screen.upgrade = function (data) {
    const { title, content } = data
    viewUtils.confirmOpen(title, content)
}

/**
 * 显示通行结果弹窗
 * @param {object} data - 通行结果数据
 * @param {boolean} data.faceAuth - 人脸识别是否通过
 * @param {boolean} data.gasConcentration - 气体浓度是否合格
 * @param {boolean} data.accessAllowed - 是否允许通行
 * @param {string} data.message - 弹窗消息
 */
screen.showAccessResult = function (data) {
    // // 显示状态面板，3秒后自动关闭
    // if (data.accessAllowed) {
    //     mainView.statusPanel.success(data.message)
    // } else {
    //     mainView.statusPanel.fail(data.message)
    // }

    
    // 显示小型状态面板，3秒后自动关闭
    if (data.accessAllowed) {
        mainView.smallStatusPanel.success(data.message)
    } else {
        mainView.smallStatusPanel.fail(data.message)
    }
}

export default screen