// dataCache.js - 透析机数据缓存管理
const logger = require('./logger');

class DataCache {
    constructor() {
        // 使用 Map 存储，key 是设备序号 (masData.n)，value 是最新数据
        this.cache = new Map();
        
        // 记录每个设备的更新时间，用于监控
        this.updateTimes = new Map();
    }

    /**
     * 存储或更新设备数据
     * @param {string} deviceNumber - 设备序号 (masData.n)
     * @param {object} data - 完整的设备数据对象
     */
    setDeviceData(deviceNumber, data) {
        if (!deviceNumber) {
            logger.warn('设备序号为空，无法缓存数据');
            return false;
        }

        try {
            this.cache.set(deviceNumber, {
                ...data,
                _cachedAt: new Date().toISOString()
            });
            this.updateTimes.set(deviceNumber, Date.now());
            logger.info(`✅ 数据缓存更新: 设备 ${deviceNumber}`);
            return true;
        } catch (err) {
            logger.error(`缓存数据失败 (${deviceNumber}):`, err.message);
            return false;
        }
    }

    /**
     * 获取指定设备的最新数据
     * @param {string} deviceNumber - 设备序号
     * @returns {object|null} 设备数据或 null
     */
    getDeviceData(deviceNumber) {
        const data = this.cache.get(deviceNumber);
        if (!data) {
            logger.warn(`未找到设备 ${deviceNumber} 的缓存数据`);
            return null;
        }
        logger.info(`📖 读取缓存数据: 设备 ${deviceNumber}`);
        return data;
    }

    /**
     * 获取所有设备的数据
     * @returns {object} 所有设备的数据字典
     */
    getAllDeviceData() {
        const result = {};
        for (const [key, value] of this.cache.entries()) {
            result[key] = value;
        }
        return result;
    }

    /**
     * 获取所有设备的列表（仅包含设备号和最后更新时间）
     * @returns {array} 设备列表
     */
    getDeviceList() {
        const list = [];
        for (const [deviceNumber, data] of this.cache.entries()) {
            list.push({
                deviceNumber: deviceNumber,
                lastUpdate: data._cachedAt,
            });
        }
        return list;
    }

    /**
     * 检查设备是否存在
     * @param {string} deviceNumber - 设备序号
     * @returns {boolean}
     */
    hasDevice(deviceNumber) {
        return this.cache.has(deviceNumber);
    }

    /**
     * 删除指定设备的缓存
     * @param {string} deviceNumber - 设备序号
     * @returns {boolean}
     */
    deleteDeviceData(deviceNumber) {
        const result = this.cache.delete(deviceNumber);
        this.updateTimes.delete(deviceNumber);
        if (result) {
            logger.info(`🗑️ 删除缓存数据: 设备 ${deviceNumber}`);
        }
        return result;
    }

    /**
     * 清空所有缓存
     */
    clearAll() {
        const count = this.cache.size;
        this.cache.clear();
        this.updateTimes.clear();
        logger.info(`🗑️ 已清空所有缓存数据 (共 ${count} 个设备)`);
    }

    /**
     * 获取缓存统计信息
     * @returns {object}
     */
    getStats() {
        const deviceCount = this.cache.size;
        const memoryUsage = JSON.stringify(this.getAllDeviceData()).length;
        
        return {
            deviceCount: deviceCount,
            memoryUsage: `${(memoryUsage / 1024).toFixed(2)} KB`,
            devices: this.getDeviceList()
        };
    }

    /**
     * 获取指定时间范围内未更新的设备列表
     * @param {number} timeoutMs - 超时时间（毫秒）
     * @returns {array} 超时的设备列表
     */
    getIdleDevices(timeoutMs = 300000) { // 默认 5 分钟
        const now = Date.now();
        const idleDevices = [];
        
        for (const [deviceNumber, updateTime] of this.updateTimes.entries()) {
            if (now - updateTime > timeoutMs) {
                idleDevices.push({
                    deviceNumber: deviceNumber,
                    idleTime: now - updateTime
                });
            }
        }
        
        return idleDevices;
    }
}

// 导出单例
module.exports = new DataCache();