import log from '../dxmodules/dxLogger.js'
import std from '../dxmodules/dxStd.js'
import dxCommon from '../dxmodules/dxCommon.js'
import bus from '../dxmodules/dxEventBus.js'
import driver from './driver.js'
import pool from '../dxmodules/dxWorkerPool.js'
import config from '../dxmodules/dxConfig.js'
import * as os from "os"
import dxDriver from '../dxmodules/dxDriver.js'
import sqliteService from './service/sqliteService.js'

let topics = [
    "recognition",
    "bleCallback",
    driver.gpiokey.RECEIVE_MSG,
    "access",
    "setConfig",
    driver.nfc.NFC_CARD_RECEIVE,
    driver.nfc.EID_RECEIVE,
    driver.mqtt.CONNECTED_CHANGED,
    driver.mqtt.RECEIVE_MSG,
    driver.uartCode.RECEIVE_MSG,
    "code",
    driver.finger.RECEIVE_MSG
]

function initController() {
    driver.config.init()
    driver.gpio.init()
    driver.watchdog.init()
    driver.audio.init()
    driver.gpiokey.init()
    if (dxDriver.DRIVER.MODEL == "vf202") {
        driver.uartBle.init()
    }
    if (!driver.device.finger && (dxDriver.DRIVER.MODEL == "vf105" || dxDriver.DRIVER.MODEL == "vf114")) {
        driver.uartCode.init()
    }
    driver.net.init()
    driver.sqlite.init()
    if (dxDriver.DRIVER.MODEL != "vf105" || std.loadFile('/etc/app/nfc.conf')) {
        driver.nfc.init()
        driver.nfc.eidInit()
    } 
    driver.pwm.init()
    driver.mqtt.init()
    driver.ntp.init()
    if(driver.device.finger){
        driver.finger.init()
    }
}

// 清理未绑定的凭证信息
function cleanupUnboundVouchers() {
    try {
        log.info("[cleanup]: 开始清理未绑定的凭证信息")
        // 查询所有凭证
        const vouchers = sqliteService.d1_voucher.findAll()
        if (vouchers && vouchers.length > 0) {
            let deletedCount = 0
            // 用于记录需要删除人脸特征的用户ID
            const userIdsToDeleteFace = new Set()
            // 用于记录有效的指纹ID
            const validFingerIds = new Set()
            
            for (const voucher of vouchers) {
                // 检查userId是否存在于d1_person表中
                const person = sqliteService.d1_person.findByUserId(voucher.userId)
                if (!person || person.length === 0) {
                    // 删除未绑定的凭证
                    const result = sqliteService.d1_voucher.deleteByKeyId(voucher.keyId)
                    if (result === 0) {
                        deletedCount++
                        log.info(`[cleanup]: 删除未绑定的凭证，keyId: ${voucher.keyId}, userId: ${voucher.userId}, type: ${voucher.type}`)
                        
                        // 根据凭证类型进行相应的设备清理
                        if (voucher.type === "500" && driver.device.finger) {
                            // 指纹凭证，从设备中删除指纹
                            try {
                                const fingerId = parseInt(voucher.code)
                                if (!isNaN(fingerId)) {
                                    const deleteResult = driver.finger.delete(fingerId)
                                    log.info(`[cleanup]: 从设备中删除指纹，fingerId: ${fingerId}, result: ${deleteResult}`)
                                }
                            } catch (error) {
                                log.error(`[cleanup]: 删除指纹时发生错误:`, error)
                            }
                        } else if (voucher.type === "300") {
                            // 人脸凭证，记录用户ID以便后续删除人脸特征
                            userIdsToDeleteFace.add(voucher.userId)
                        } else if (voucher.type === "200") {
                            // 卡片凭证，记录删除信息
                            log.info(`[cleanup]: 删除未绑定的卡片凭证，code: ${voucher.code}`)
                        } else if (voucher.type === "400") {
                            // 密码凭证，记录删除信息
                            log.info(`[cleanup]: 删除未绑定的密码凭证`)
                        }
                    }
                } else if (voucher.type === "500") {
                    // 记录有效的指纹ID
                    try {
                        const fingerId = parseInt(voucher.code)
                        if (!isNaN(fingerId)) {
                            validFingerIds.add(fingerId)
                        }
                    } catch (error) {
                        log.error(`[cleanup]: 解析指纹ID时发生错误:`, error)
                    }
                }
            }
            
            // 删除未绑定用户的人脸特征
            for (const userId of userIdsToDeleteFace) {
                try {
                    const deleteResult = driver.face.deleteFea(userId)
                    log.info(`[cleanup]: 从设备中删除人脸特征，userId: ${userId}, result: ${deleteResult}`)
                    // 清理用户目录
                    dxos.systemBrief(`rm -rf /data/user/${userId}`)
                } catch (error) {
                    log.error(`[cleanup]: 删除人脸特征时发生错误:`, error)
                }
            }
            
            // 删除系统中非凭证的指纹信息
            if (driver.device.finger) {
                try {
                    log.info("[cleanup]: 开始清理系统中非凭证的指纹信息")
                    
                    // 记录需要保留的指纹ID
                    const validFingerArray = Array.from(validFingerIds);
                    log.info(`[cleanup]: 需要保留的指纹ID: ${validFingerArray.join(', ')}`)
                    
                    // 对于指纹清理，我们采用更高效的策略：
                    // 1. 如果没有需要保留的指纹，直接清理所有指纹
                    // 2. 如果有需要保留的指纹，只清理非凭证指纹
                    if (validFingerArray.length === 0) {
                        // 没有需要保留的指纹，直接清理所有指纹
                        log.info("[cleanup]: 没有需要保留的指纹，清理所有指纹")
                        const clearResult = driver.finger.clear()
                        log.info(`[cleanup]: 清理所有指纹结果: ${clearResult}`)
                    } else {
                        // 有需要保留的指纹，只清理非凭证指纹
                        // 注意：由于ZAZ指纹模块的限制，我们只能尝试删除非凭证指纹
                        // 但会捕获错误以避免日志污染
                        log.info("[cleanup]: 执行指纹清理，只保留有效的指纹凭证")
                        
                        // 对于ZAZ指纹模块，我们可以使用更智能的方式
                        // 由于我们已经知道有效的指纹ID，我们可以只关注这些ID
                        // 这里我们不遍历所有可能的指纹ID，而是只处理可能存在的指纹
                        // 假设指纹ID是连续分配的，我们只检查到最大的有效指纹ID
                        const maxFingerId = Math.max(...validFingerArray);
                        log.info(`[cleanup]: 最大的有效指纹ID: ${maxFingerId}`)
                        
                        let deletedNonValidCount = 0;
                        // 只检查到最大有效指纹ID的范围，减少不必要的操作
                        for (let i = 1; i <= Math.min(maxFingerId + 10, 1024); i++) {
                            // 检查指纹ID是否在有效的指纹ID集合中
                            if (!validFingerIds.has(i)) {
                                try {
                                    // 尝试删除非凭证的指纹
                                    const deleteResult = driver.finger.delete(i)
                                    if (deleteResult === 0) {
                                        deletedNonValidCount++
                                        log.info(`[cleanup]: 从设备中删除非凭证指纹，fingerId: ${i}`)
                                    }
                                } catch (error) {
                                    // 忽略删除不存在指纹的错误
                                }
                            }
                        }
                        log.info(`[cleanup]: 系统中非凭证的指纹信息清理完成，共删除 ${deletedNonValidCount} 个非凭证指纹`)
                    }
                } catch (error) {
                    log.error(`[cleanup]: 清理系统中非凭证的指纹信息时发生错误:`, error)
                }
            }
            
            log.info(`[cleanup]: 清理完成，共删除 ${deletedCount} 个未绑定的凭证`)
        } else {
            log.info("[cleanup]: 没有凭证需要清理")
            
            // 如果没有凭证，清理所有指纹
            if (driver.device.finger) {
                try {
                    log.info("[cleanup]: 没有凭证，清理所有指纹")
                    const clearResult = driver.finger.clear()
                    log.info(`[cleanup]: 清理所有指纹结果: ${clearResult}`)
                } catch (error) {
                    log.error(`[cleanup]: 清理所有指纹时发生错误:`, error)
                }
            }
        }
    } catch (error) {
        log.error("[cleanup]: 清理未绑定凭证时发生错误:", error)
    }
}

(function () {
    bus.newWorker('screen', '/app/code/src/worker/screenWorker.js')
    initController()
    // 通行记录上报独立线程（依赖 sqlite/mqtt 初始化完成）
    bus.newWorker('passRecord', '/app/code/src/worker/passRecordWorker.js')
    bus.newWorker('controller', '/app/code/src/controller.js')
    bus.newWorker('httpServer', '/app/code/src/service/httpService.js')
    pool.init('/app/code/src/services.js', bus, topics, 5, 100)

    // 清理未绑定的凭证信息
    cleanupUnboundVouchers()

    let appVersion
    let releaseTime
    if (dxDriver.DRIVER.MODEL == "vf202") {
        appVersion = 'vf202_v12_access_2.0.2'
        releaseTime = '2026-01-09 13:00:00'
    } else if (dxDriver.DRIVER.MODEL == "vf203") {
        appVersion = 'vf203_v14_access_2.0.2'
        releaseTime = '2026-02-04 14:30:00'
    } else if (dxDriver.DRIVER.MODEL == "vf114") {
        if(driver.device.finger) {
            appVersion = 'vf124_v12_access_2.0.2'
            releaseTime = '2026-03-19 13:00:00'
        } else {
            appVersion = 'vf114_v12_access_2.0.2'
            releaseTime = '2026-01-09 13:00:00'
        }
    } else if (dxDriver.DRIVER.MODEL == "vf105") {
        if(driver.device.finger) {
            appVersion = 'vf107_v12_access_2.0.2.1'
            releaseTime = '2026-03-19 13:00:00'
        } else {
            appVersion = 'vf105_v12_access_2.0.2'
            releaseTime = '2026-01-09 13:00:00'
        }
    }
    config.setAndSave('sys.version', appVersion)
    config.setAndSave('sys.appVersion', appVersion)
    config.setAndSave('sys.releaseTime', releaseTime)
    log.info("=================== version:" + appVersion + " ====================")
})();

std.setInterval(() => {
    try {
        driver.watchdog.restart(driver.watchdog.MAIN_WORKER)
    } catch (error) {
        log.error(error)
    }
}, 3000)

// std.setInterval(() => {
//     os.exec(["free", "-k"])
//     os.exec(["uptime"])
// }, 6000);