/**
 * 门禁通行服务模块
 * 处理门禁通行相关的业务逻辑，包括人脸/密码白名单校验、权限判断、通行记录保存等
 */
import logger from "../../dxmodules/dxLogger.js"
import std from "../../dxmodules/dxStd.js"
import config from "../../dxmodules/dxConfig.js"
import common from "../../dxmodules/dxCommon.js"
import map from '../../dxmodules/dxMap.js'
import bus from '../../dxmodules/dxEventBus.js'
import driver from "../driver.js"
import mqttService from "./mqttService.js"
import sqliteService from "./sqliteService.js"
import utils from '../common/utils/utils.js'
import http from "../../dxmodules/dxHttp.js"
import grainService from './grainService.js'
const accessService = {}

/**
 * 将十进制数转换为小端序十六进制字符串
 * @param {number} decimalNumber - 十进制数
 * @param {number} byteSize - 字节大小
 * @returns {string} 小端序十六进制字符串
 */
function decimalToLittleEndianHex(decimalNumber, byteSize) {
    const littleEndianBytes = [];
    for (let i = 0; i < byteSize; i++) {
        littleEndianBytes.push(decimalNumber & 0xFF);
        decimalNumber >>= 8; // 相当于除以256
    }
    const littleEndianHex = littleEndianBytes
        .map((byte) => byte.toString(16).padStart(2, '0'))
        .join('');
    return littleEndianHex;
}

/**
 * 将数据包转换为字符串格式
 * @param {object} pack - 数据包对象
 * @returns {string} 转换后的字符串
 */
function pack2str(pack) {
    pack.data = (!pack.data) ? [] : pack.data.match(/.{2}/g)
    let len = decimalToLittleEndianHex(pack.data.length, 2)
    let str = "55aa" + pack.cmd + pack.result + len + pack.data.join('')
    let crc = common.calculateBcc([0x55, 0xaa, parseInt(pack.cmd, 16), parseInt(pack.result, 16), pack.data.length % 256, pack.data.length / 256].concat(pack.data.map(v => parseInt(v, 16))))
    return str + crc.toString(16).padStart(2, '0')
}

/**
 * 人脸/密码白名单校验
 * @param {object} data - 通行数据，包含type（码制）和code（码内容）
 * @param {string} fileName - 通行图片文件路径
 * @param {boolean|undefined} similarity - 相似度验证结果，false表示验证失败
 * @returns {number|string|boolean} -1（参数错误），0（通行成功），1（在线验证），string（校验失败的原因），false（通行加锁）
 */
accessService.access = function (data, fileName, similarity) {
    // 通行加锁，防止重复验证
    let lockMap = map.get("access_lock")
    if (lockMap.get("access_lock")) {
        logger.error("[access]: 通行加锁，请稍后再试")
        return false
    }
    lockMap.put("access_lock", true)

    try {
        // 记录通行时间戳
        data.time = Math.floor(Date.parse(new Date()) / 1000)
        
        // 根据code查询凭证
        let res
        if (data.type == "300") {
            // 人脸类型，使用userId查询
            res = sqliteService.d1_voucher.findByUserIdAndType(data.code, data.type)
        } else {
            // 其他类型，使用code查询
            res = sqliteService.d1_voucher.findByCodeAndType(data.code, data.type)
        }
        
        // 权限认证结果
        let ret = true
        // 是否是陌生人
        let isStranger = false

        if (similarity === false) {
            // 如果相似度验证失败，则不进行认证
            ret = false
            isStranger = true
        } else {
            // 验证凭证是否存在
            if (res.length == 0) {
                logger.error("[access]: 通行失败，没查询到凭证！")
                ret = false
                isStranger = true
            } else {
                // 凭证存在，获取用户信息
                data.userId = res[0].userId
                data.keyId = res[0].id
                
                // 根据userId查询人员信息
                res = sqliteService.d1_person.findByUserId(data.userId)
                if (res.length == 0) {
                    logger.error("[access]: 通行失败，没查询到人员！")
                    ret = false
                    isStranger = true
                } else {
                    // 获取人员姓名、身份证号和身份类型
                    let idCard
                    let userType = 0
                    try {
                        idCard = JSON.parse(res[0].extra).idCard
                        userType = JSON.parse(res[0].extra).type || 0
                    } catch (error) {
                        logger.error("无身份证号或类型")
                    }
                    data.extra = { name: res[0].name, idCard: idCard, type: userType }
                }
                
                // 处理双人认证信息
                if (data.dualAuthInfo) {
                    logger.info("[access]: 处理双人认证信息: " + JSON.stringify(data.dualAuthInfo))
                    // 存储第一用户信息
                    let firstUserId = data.dualAuthInfo.firstUserId
                    // 查询第一用户的详细信息
                    let res1 = sqliteService.d1_person.findByUserId(firstUserId)
                    if (res1.length > 0) {
                        // 获取第一用户的姓名、身份证号和身份类型
                        let idCard1
                        let firstUserType = 0
                        try {
                            idCard1 = JSON.parse(res1[0].extra).idCard
                            firstUserType = JSON.parse(res1[0].extra).type || 0
                        } catch (error) {
                            logger.error("无第一用户身份证号或类型")
                        }
                        data.userId = firstUserId
                        data.extra = { name: res1[0].name, idCard: idCard1, type: firstUserType }
                    } else {
                        // 如果没有查询到第一用户信息，使用默认值
                        data.userId = firstUserId
                        data.extra = { name: data.dualAuthInfo.firstUserName, idCard: "", type: 0 }
                    }
                    // 存储第二用户信息
                    data.userId2 = data.dualAuthInfo.secondUserId
                    // 查询第二用户的详细信息
                    let res2 = sqliteService.d1_person.findByUserId(data.dualAuthInfo.secondUserId)
                    if (res2.length > 0) {
                        // 获取第二用户的姓名和身份证号
                        let idCard2
                        let secondUserType = 0
                        try {
                            idCard2 = JSON.parse(res2[0].extra).idCard
                            secondUserType = JSON.parse(res2[0].extra).type || 0
                        } catch (error) {
                            logger.error("无第二用户身份证号或类型")
                        }
                        data.extra2 = { name: res2[0].name, idCard: idCard2 }
                        // 存储第二用户的权限ID（身份类型）
                        data.permissionId2 = secondUserType.toString()
                    } else {
                        // 如果没有查询到第二用户信息，使用默认值
                        data.extra2 = { name: data.dualAuthInfo.secondUserName, idCard: "" }
                        data.permissionId2 = ""
                    }
                    // 处理第一用户的人脸图片
                    if (data.firstUserFileName) {
                        let firstUserSrc = `/app/data/passRecord/${firstUserId}_${data.time}_1.jpg`
                        std.ensurePathExists(firstUserSrc) // 确保目录存在
                        if (std.exist(data.firstUserFileName)) {
                            // 移动图片到指定目录
                            common.systemBrief(`mv ${data.firstUserFileName} ${firstUserSrc}`)
                            // 更新data中的code为第一用户的图片路径
                            data.code = firstUserSrc
                        }
                    }
                    // 处理第二用户的人脸图片
                    if (fileName) {
                        let secondUserSrc = `/app/data/passRecord/${data.userId2}_${data.time}_2.jpg`
                        std.ensurePathExists(secondUserSrc) // 确保目录存在
                        if (std.exist(fileName)) {
                            // 移动图片到指定目录
                            common.systemBrief(`mv ${fileName} ${secondUserSrc}`)
                            // 更新data中的code2为第二用户的图片路径
                            data.code2 = secondUserSrc
                        }
                    }
                }
            }

            // 验证权限
            if (ret) {
                // 根据userId查询权限
                res = sqliteService.d1_permission.findByUserId(data.userId)
                if (res && res.length > 0 && judgmentPermission(res)) {
                    logger.info("[access]: 权限认证通过")
                    ret = true
                    // 存储用户身份类型作为权限ID（本系统中身份即权限）
                    let userType = 0
                    try {
                        if (data.extra) {
                            userType = data.extra.type || 0
                        } else {
                            // 从数据库查询用户信息获取身份类型
                            let userRes = sqliteService.d1_person.findByUserId(data.userId)
                            if (userRes && userRes.length > 0) {
                                userType = JSON.parse(userRes[0].extra).type || 0
                            }
                        }
                    } catch (error) {
                        logger.error("解析用户类型失败")
                    }
                    data.permissionId = userType.toString()
                    // 暂停人脸认证功能
                    driver.face.status(false)
                    logger.info("[access]: 暂停人脸认证功能")
                } else {
                    logger.info("[access]: 无权限")
                    ret = false
                }
            }

            // 无权限时，尝试在线验证
            if (!ret && config.get('mqtt.onlinecheck') == 1 && driver.mqtt.getStatus()) {
                logger.info("[access]: 无权限，走在线验证")
                let serialNo = std.genRandomStr(10)
                driver.mqtt.send("access_device/v2/event/access_online", JSON.stringify(mqttService.mqttReply(serialNo, data, mqttService.CODE.S_000)))
                driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/verify.wav`)
                
                // 等待在线验证结果
                let payload = driver.mqtt.getOnlinecheck()
                if (payload && payload.serialNo == serialNo && payload.code == '000000') {
                    ret = true
                    // 暂停人脸认证功能
                    driver.face.status(false)
                    logger.info("[access]: 暂停人脸认证功能")
                } else {
                    logger.info("[access]: 在线验证失败")
                    ret = false
                }
            }
        }

        // 确定语音文件名称
        let alsaFile = (data.type).toString().startsWith("10") ? '10x' : data.type
        
        //暂停人脸认证功能
        

        if (ret == true) {
            // 验证气体浓度
            grainService.checkGasConcentration(function() {
                // 从存储的气体数据中获取验证结果
                const gasData = grainService.getGasData()
                
                if(gasData && gasData.data && gasData.data.status === "0") {
                    logger.info("[access]: 气体浓度验证合格")
                    // 通行成功处理
                    driver.screen.accessSuccess()
                    logger.info("[access]: 通行成功")
                    
                    // 显示通行成功结果
                    bus.fire("showAccessResult", {
                        faceAuth: true,
                        gasConcentration: true,
                        accessAllowed: true,
                        message: "*仓内气体浓度合格，允许通行*"
                    })
                    
                    // 触发通行成功事件，通知UI更新
                    bus.fire("accessSuccess", { data: data, fileName: fileName })
                    driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/access_s.wav`)
                    driver.gpio.open() // 开门
                    savePassPic(data, fileName) // 保存通行图片
                    reply(data, true) // 上报通行记录
                } else {
                    logger.info("[access]: 气体浓度验证不合格")
                    // 通行失败处理
                    driver.screen.accessFail()
                    logger.error("[access]: 通行失败")
                    // 触发失败弹窗
                    bus.fire("showAccessResult", {
                        faceAuth: true,
                        gasConcentration: false,
                        accessAllowed: false,
                        message: "*仓内气体浓度不合格，禁止通行*"
                    })
                    if (utils.isEmpty(similarity)) {
                        driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/access_f.wav`)
                    }
                    // if (isStranger && !config.get("sys.strangerImage")) {
                    //     // 陌生人不保存照片
                    // } else {
                    //     savePassPic(data, fileName)
                    // }
                    savePassPic(data, fileName)
                    // 添加气体浓度失败信息
                    data.message = "气体浓度不合格"
                    reply(data, false) // 上报通行记录
                }
            })

        } else {
            // 通行失败处理
            driver.screen.accessFail()
            logger.error("[access]: 通行失败")
            // 触发失败弹窗
            bus.fire("showAccessResult", {
                faceAuth: true,
                gasConcentration: false,
                accessAllowed: false,
                message: "*权限认证失败，禁止通行*"
            })
            if (utils.isEmpty(similarity)) {
                driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/recg_f.wav`)
            }
            // if (isStranger && !config.get("sys.strangerImage")) {
            //     // 陌生人不保存照片
            // } else {
            //     savePassPic(data, fileName)
            // }
            savePassPic(data, fileName)

            reply(data, false) // 上报通行记录
        }
    } catch (error) {
        logger.error(error)
    }
    
    // 语音播报需要时间，所以延迟1秒解锁
    std.sleep(1000)
    lockMap.put("access_lock", false)
    logger.error("[access]: 解锁成功")
    // 触发通行解锁完成事件，通知UI重置
    // bus.fire("accessUnlockComplete")
}

/**
 * 保存通行图片
 * @param {object} data - 通行数据
 * @param {string} fileName - 图片文件路径
 */
function savePassPic(data, fileName) {
    if (data.type == "300") { // 仅处理人脸类型
        // 如果是双人认证，已经在处理双人认证信息时保存了图片，这里跳过
        if (data.dualAuthInfo) {
            return
        }
        let src = `/app/data/passRecord/${data.userId}_${data.time}.jpg`
        std.ensurePathExists(src) // 确保目录存在
        if (std.exist(fileName)) {
            // 移动图片到指定目录
            common.systemBrief(`mv ${fileName} ${src}`)
            // 只清理原始临时图片文件（以时间戳命名的文件），保留调整后的图片文件
            common.systemBrief(`rm -rf /app/data/user/temp/[0-9]*.jpg`)
            // 更新data中的code为图片路径
            data.code = src
        } else {
            logger.error("[access]: 通行失败，图片不存在！！！！！！！！！！！！！！！" + fileName)
        }
    }
}

/**
 * 校验权限时间是否可以通行
 * @param {array} permissions - 权限记录数组
 * @returns {boolean} true表示有权限，false表示无权限
 */
function judgmentPermission(permissions) {
    let currentTime = Math.floor(Date.now() / 1000)
    for (let permission of permissions) {
        if (permission.timeType == 0) {
            // 永久权限
            return true
        } else if (permission.beginTime <= currentTime && currentTime <= permission.endTime) {
            if (permission.timeType == 1) {
                // 时间段权限
                return true
            }
            if (permission.timeType == 2) {
                // 每日权限
                let seconds = Math.floor((new Date() - new Date().setHours(0, 0, 0, 0)) / 1000);
                if (permission.repeatBeginTime <= seconds && seconds <= permission.repeatEndTime) {
                    return true
                }
            }
            if (permission.timeType == 3 && permission.period) {
                // 周重复权限
                let dayTimes = JSON.parse(permission.period)[new Date().getDay() + 1]
                if (dayTimes && dayTimes.split("|").some((dayTime) => isCurrentTimeInTimeRange(dayTime))) {
                    return true
                }
            }
        }
    }
    return false
}

/**
 * 判断当前时间是否在时间段内
 * @param {string} time - 时间段字符串，格式如"15:00-19:00"
 * @returns {boolean} true表示当前时间在时间段内，false表示不在
 */
function isCurrentTimeInTimeRange(time) {
    // 分割开始时间和结束时间
    let [startTime, endTime] = time.split('-');
    // 解析开始时间的小时和分钟
    let [startHour, startMinute] = startTime.split(':');
    // 解析结束时间的小时和分钟
    let [endHour, endMinute] = endTime.split(':');

    // 获取当前时间
    let currentTime = new Date();

    // 创建开始时间的日期对象
    let startDate = new Date();
    startDate.setHours(parseInt(startHour, 10));
    startDate.setMinutes(parseInt(startMinute, 10));
    // 创建结束时间的日期对象
    let endDate = new Date();
    endDate.setHours(parseInt(endHour, 10));
    endDate.setMinutes(parseInt(endMinute, 10));

    // 检查当前时间是否在时间范围内
    return currentTime >= startDate && currentTime <= endDate;
}

/**
 * 通行记录上报
 * @param {object} data - 通行数据
 * @param {boolean} result - 通行结果，true表示成功，false表示失败
 */
function reply(data, result) {
    // 使用线程处理整个reply函数，避免堵塞主进程
    std.setTimeout(() => {
        try {
            // 构建通行记录
            let record = {
                id: std.genRandomStr(16),
                result: result ? 0 : 1, // 0表示成功，1表示失败
            }
            
            // 复制data中的字段，排除extra和extra2
            for (const key in data) {
                if (key !== 'extra' && key !== 'extra2' && !(key in record)) {
                    record[key] = data[key]
                }
            }
            
            // 处理extra字段
            if (data.extra) {
                record.extra = JSON.stringify(data.extra)
            }
            
            // 处理extra2字段
            if (data.extra2) {
                record.extra2 = JSON.stringify(data.extra2)
            }
            
            // 存储通行记录，判断上限
            let count = sqliteService.d1_pass_record.count()
            let configNum = config.get("access.offlineAccessNum");
            configNum = configNum ? configNum : 2000;
            
            if (configNum > 0) {
                if (count >= configNum) {
                    // 达到最大存储数量，删除最旧的记录
                    let lastRecord = sqliteService.d1_pass_record.findAllOrderBytimeDesc({ page: 0, size: 1 })
                    if (lastRecord && lastRecord.length == 1) {
                        // 如果是人脸记录，删除对应的图片文件
                        if (lastRecord[0].type == 300) {
                            common.systemBrief(`rm -rf ${lastRecord[0].code}`)
                        }
                        sqliteService.d1_pass_record.deleteByid(lastRecord[0].id)
                    }
                }
                // 保存新记录
                sqliteService.d1_pass_record.save(record)
            }
            
            // // 生成序列号
            // let serialNo = std.genRandomStr(10)
            
            // // 处理人脸图片
            // if (record.type == 300) {
            //     let m = map.get("faceAccesss")
            //     m.del(serialNo)
            //     m.put(serialNo, record.code ? record.code : "")
            //     // 将图片转换为base64格式
            //     record.code = driver.face.fileToBase64(record.code)
            // }
            
            // // 构建MQTT消息并发送
            // let payload = mqttService.mqttReply(serialNo, [record], mqttService.CODE.S_000)
            // driver.mqtt.send("access_device/v2/event/access", JSON.stringify(payload))
        } catch (error) {
            logger.error(`[accessService]: 处理通行记录失败: ${error.message}`)
        }
    }, 0)
}

export default accessService