const net = require('net');
const iconv = require('iconv-lite');
const xml2js = require('xml2js');
const fs = require('fs');
const path = require('path');
const {
    extractFramesFromUtf16leBuffer,
    extractFramesFromText,
    guessTextEncodingFromBuffer,
} = require('./framing');

// ============================================================================
// 解析主流程（index.js）
// A) 在线模式：TCP 收包 -> buffer 拼接 -> framing 分帧 -> parseAndPrintData 解析
// B) 离线模式：读取文件(--decode-file) -> 判定输入编码/形态 -> 分帧 -> 解析
// C) 解析结果：控制台打印 + 可选 onFrame 回调（供 gateway.js 做缓存与转发）
// ============================================================================

// ================= 配置区域 =================
const CONFIG = {
    host: '127.0.0.1', // 【重要】请修改为您的透析机 IP 地址
    port: 3021,            // 3021: 自动推送模式
    reconnectInterval: 5000 // 断线重连间隔 (毫秒)
};

// 允许命令行覆盖连接目标：node .\index.js --host 127.0.0.1 --port 3021
const hostIdx = process.argv.indexOf('--host');
if (hostIdx !== -1 && process.argv[hostIdx + 1]) {
    CONFIG.host = process.argv[hostIdx + 1];
}
const portIdx = process.argv.indexOf('--port');
if (portIdx !== -1 && process.argv[portIdx + 1]) {
    const p = Number(process.argv[portIdx + 1]);
    if (!Number.isNaN(p) && p > 0) CONFIG.port = p;
}

// 参数映射表 (基于百特 Artis 协议文档)
// 如果文档中有新参数，请在此处添加
const PARAM_MAP = {
    '0': '治疗阶段 (Phase)', 
    '1': '剩余时间 (Time Rem)', 
    '2': '超滤量 (UF Vol)', 
    '3': '超滤率 (UF Rate)',
    '4': '电导率 (Cond)', 
    '5': '碳酸氢盐电导率 (Bic Cond)', 
    '6': '血流速 (Blood Flow)', 
    '7': '温度 (Temp)',
    '8': '透析液流速 (Dialysate Flow)', 
    '9': '在线置换率 (OnLine Sub Rate)',
    '10': '累计血容量 (Cum Blood Vol)',
    '12': '跨膜压 (TMP Actual)',
    '13': '静脉压 (Venous Pressure)',
    '14': '动脉压 (Arterial Pressure)',
    '32': '设定血流速 (Set Blood Flow)', 
    '34': '设定超滤量 (Set UF Vol)',
    '100': '动脉压 (Art Pressure)', // 示例补充，需核对文档
    '101': '静脉压 (Ven Pressure)'  // 示例补充，需核对文档
};

let bufferCache = Buffer.alloc(0);
let client = null;
let reconnectTimer = null;
let reconnectScheduledAt = null;

const DEBUG = process.argv.includes('--debug');
const PRINT_RX = process.argv.includes('--print-rx');
const printRxMaxIdx = process.argv.indexOf('--print-rx-max');
const PRINT_RX_MAX = (printRxMaxIdx !== -1 && process.argv[printRxMaxIdx + 1])
    ? Math.max(0, Number(process.argv[printRxMaxIdx + 1]) || 0)
    : 256;

const decodeFileIdx = process.argv.indexOf('--decode-file');
const DECODE_FILE = (decodeFileIdx !== -1 && process.argv[decodeFileIdx + 1])
    ? path.resolve(process.cwd(), process.argv[decodeFileIdx + 1])
    : null;

function toHexPreview(buf, maxBytes = 32) {
    if (!buf || buf.length === 0) return '';
    const slice = buf.slice(0, Math.min(buf.length, maxBytes));
    return slice.toString('hex').match(/../g).join(' ');
}

function printReceivedChunk(data) {
    // 调试辅助：打印原始 chunk 的 hex + UTF16LE 视图，用于排查乱码/截断/粘包。
    if (!PRINT_RX || !data || data.length === 0) return;

    const max = PRINT_RX_MAX;
    const showAll = max === 0;
    const shown = showAll ? data : data.slice(0, Math.min(data.length, max));
    const truncated = shown.length < data.length;

    const hex = shown.toString('hex');
    const hexPretty = hex ? hex.match(/../g).join(' ') : '';

    let utf16Text = '';
    try {
        const evenLen = shown.length % 2 === 0 ? shown.length : shown.length - 1;
        const utf16Buf = shown.slice(0, Math.max(0, evenLen));
        utf16Text = iconv.decode(utf16Buf, 'utf16le').replace(/^\uFEFF/, '');
    } catch (_) {
        utf16Text = '[UTF-16LE 解码失败]';
    }

    console.log(`\n🧩 收包 chunk: ${data.length} bytes${truncated ? ` (仅显示前 ${shown.length} bytes)` : ''}`);
    console.log(`HEX: ${hexPretty}`);
    console.log('UTF16LE:');
    console.log(utf16Text);
}

function extractLikelyHexBytesFromText(text) {
    // Prefer long runs like: "3C 00 3F 00 ..." to avoid RTF/header noise.
    const candidates = text.match(/[0-9A-Fa-f]{2}(?:\s+[0-9A-Fa-f]{2}){40,}/g);
    if (candidates && candidates.length) {
        let best = candidates[0];
        for (const c of candidates) {
            if (c.length > best.length) best = c;
        }
        const hex = best.split(/\s+/g).filter(Boolean).join('');
        return hex;
    }

    // Fallback: strip anything not hex.
    return text
        .replace(/0x/gi, '')
        .replace(/\\x/gi, '')
        .replace(/[^0-9a-fA-F]/g, '');
}

function decodeHexTextToBytes(text) {
    let cleaned = extractLikelyHexBytesFromText(text);
    if (!cleaned || cleaned.length < 40) {
        throw new Error('未在文件中提取到足够的 hex 字节（可能不是 hex 文本/或格式不支持）');
    }
    if (cleaned.length % 2 !== 0) {
        console.warn('⚠️ hex 长度不是偶数（可能复制/截断），已丢弃最后 1 个半字节继续尝试解析');
        cleaned = cleaned.slice(0, -1);
    }
    return Buffer.from(cleaned, 'hex');
}

function decodeFileAndParse(filePath) {
    // 离线解析入口：支持 hex/bin/base64 文本，自动识别 utf16le/utf8。
    if (!fs.existsSync(filePath)) {
        console.error(`文件不存在: ${filePath}`);
        process.exitCode = 1;
        return;
    }

    const args = process.argv;
    const forcedEncoding = args.includes('--utf16le') ? 'utf16le' : (args.includes('--utf8') ? 'utf8' : null);
    const modeHex = args.includes('--hex');
    const modeBin = args.includes('--bin');
    const modeB64 = args.includes('--b64');

    const raw = fs.readFileSync(filePath);
    let bytes = raw;
    let source = 'binary';

    if (modeHex || (!modeBin && !modeB64)) {
        // Default prefer hex for text-like inputs, especially RTF-wrapped hex dumps.
        try {
            const asText = raw.toString('utf8');
            bytes = decodeHexTextToBytes(asText);
            source = 'hex';
        } catch (e) {
            if (modeHex) throw e;
            // If not forced, fall back to treating as binary.
            bytes = raw;
            source = 'binary';
        }
    } else if (modeB64) {
        const asText = raw.toString('utf8').replace(/\s+/g, '');
        bytes = Buffer.from(asText, 'base64');
        source = 'base64';
    }

    const encoding = forcedEncoding || guessTextEncodingFromBuffer(bytes);
    console.log(`输入: ${filePath} (source=${source}, bytes=${bytes.length}, encoding=${encoding})`);

    if (encoding === 'utf16le') {
        const { frames, remainderBuffer } = extractFramesFromUtf16leBuffer(bytes);
        if (frames.length === 0) {
            // 兜底：常见“抓包/复制截断”，没拿到 </ORU_R31>，但前面可能已包含完整 OBX 段。
            let work = bytes;
            if (work.length % 2 === 1) work = work.slice(0, work.length - 1);
            const text = iconv.decode(work, 'utf16le').replace(/^\uFEFF/, '');
            const hasRoot = text.includes('<ORU_R31') || text.includes('<ORF_R04');
            const obxBlocks = text.match(/<OBX>[\s\S]*?<\/OBX>/g) || [];
            if (hasRoot && obxBlocks.length > 0) {
                console.log(`⚠️ 未找到完整帧（疑似截断），尝试从片段提取 ${obxBlocks.length} 个 OBX 解析`);
                const wrapped = `<?xml version="1.0" encoding="UTF-8"?>\n<ORU_R31>\n  <ORU_R31.OBSERVATION>\n${obxBlocks.join('\n')}\n  </ORU_R31.OBSERVATION>\n</ORU_R31>`;
                parseAndPrintData(wrapped);
                return;
            }

            console.log('未找到 ORU_R31/ORF_R04 XML 完整帧');
            if (DEBUG) console.log(`remainder=${remainderBuffer.length} bytes; head=${toHexPreview(bytes)}`);
            return;
        }
        console.log(`找到 ${frames.length} 条 XML 帧`);
        frames.forEach((xml, idx) => {
            console.log(`\n===== Frame #${idx + 1} =====`);
            parseAndPrintData(xml.replace(/^\uFEFF/, '').trim());
        });
        if (remainderBuffer && remainderBuffer.length) {
            console.warn(`⚠️ 末尾还有 ${remainderBuffer.length} bytes 未形成完整帧（可能抓包截断/拼接不完整）`);
        }
        return;
    }

    const text = bytes.toString('utf8');
    const { frames, remainderText } = extractFramesFromText(text);
    if (frames.length === 0) {
        const hasRoot = text.includes('<ORU_R31') || text.includes('<ORF_R04');
        const obxBlocks = text.match(/<OBX>[\s\S]*?<\/OBX>/g) || [];
        if (hasRoot && obxBlocks.length > 0) {
            console.log(`⚠️ 未找到完整帧（疑似截断），尝试从片段提取 ${obxBlocks.length} 个 OBX 解析`);
            const wrapped = `<?xml version="1.0" encoding="UTF-8"?>\n<ORU_R31>\n  <ORU_R31.OBSERVATION>\n${obxBlocks.join('\n')}\n  </ORU_R31.OBSERVATION>\n</ORU_R31>`;
            parseAndPrintData(wrapped);
            return;
        }

        console.log('未找到 ORU_R31/ORF_R04 XML 完整帧');
        if (DEBUG) console.log(`remainderChars=${remainderText.length}`);
        return;
    }
    console.log(`找到 ${frames.length} 条 XML 帧`);
    frames.forEach((xml, idx) => {
        console.log(`\n===== Frame #${idx + 1} =====`);
        parseAndPrintData(xml.replace(/^\uFEFF/, '').trim());
    });
    if (remainderText && remainderText.length) {
        console.warn(`⚠️ 末尾还有 ${remainderText.length} chars 未形成完整帧（可能抓包截断/拼接不完整）`);
    }
}

// ================= 数据收集（可选） =================
const COLLECT = {
    enabled: process.argv.includes('--collect'),
    outFile: path.resolve(__dirname, 'artis_frames.ndjson'),
};

const outIdx = process.argv.indexOf('--out');
if (outIdx !== -1 && process.argv[outIdx + 1]) {
    COLLECT.outFile = path.resolve(process.cwd(), process.argv[outIdx + 1]);
}

let collectStream = null;
function ensureCollector() {
    if (!COLLECT.enabled) return;
    if (collectStream) return;
    collectStream = fs.createWriteStream(COLLECT.outFile, { flags: 'a' });
    console.log(`🧾 收集已启用：${COLLECT.outFile}`);
}

function recordFrame(frameObj) {
    if (!COLLECT.enabled) return;
    ensureCollector();
    try {
        collectStream.write(`${JSON.stringify(frameObj)}\n`);
    } catch (e) {
        console.warn('⚠️ 写入收集文件失败:', e && e.message ? e.message : String(e));
    }
}

// ================= 主逻辑 =================

function startClient() {
    // 在线 TCP 入口：连接透析机，接收实时推送并持续解析。
    if (reconnectTimer) {
        clearTimeout(reconnectTimer);
        reconnectTimer = null;
        reconnectScheduledAt = null;
    }

    if (client) {
        client.destroy();
    }

    client = new net.Socket();
    client.setKeepAlive(true, 10_000);

    console.log(`\n🔄 正在连接百特 Artis 透析机 (${CONFIG.host}:${CONFIG.port})...`);

    client.connect(CONFIG.port, CONFIG.host, () => {
        console.log('✅ 连接成功！等待数据推送...\n');

        // 可选：开启收集器
        ensureCollector();
    });

    client.on('end', () => {
        console.log('📴 远端已结束连接 (FIN)');
    });

    client.on('timeout', () => {
        console.log('⏱️ Socket 超时');
        try { client.destroy(); } catch (_) {}
    });

    // 接收数据
    client.on('data', (data) => {
        printReceivedChunk(data);

        // 1. 将新数据拼接到缓存区 (处理 TCP 分包/粘包)
        bufferCache = Buffer.concat([bufferCache, data]);

        // 2. 从原始字节流中提取出尽可能多的完整 XML 帧（处理粘包/半包/多帧连发）
        try {
            const { frames, remainderBuffer } = extractFramesFromUtf16leBuffer(bufferCache);
            bufferCache = remainderBuffer;

            if (DEBUG) {
                console.log(`📥 收到 ${data.length} bytes；本次提取 ${frames.length} 帧；缓存剩余 ${bufferCache.length} bytes；head=${toHexPreview(data)}`);
            }

            frames.forEach((xmlStr) => {
                const normalized = xmlStr.replace(/^\uFEFF/, '').trim();
                parseAndPrintData(normalized, { onFrame: recordFrame });
            });
        } catch (err) {
            if (DEBUG) {
                console.log(`📥 收到 ${data.length} bytes；当前缓存 ${bufferCache.length} bytes；尚未形成完整帧；head=${toHexPreview(data)}`);
            }
            // 保持缓存，等待后续数据补齐。
        }
    });

    client.on('error', (err) => {
        console.error(`❌ 连接错误: ${err.message}`);
        handleDisconnect();
    });

    client.on('close', (hadError) => {
        console.log(`🔌 连接已断开${hadError ? ' (伴随错误)' : ''}`);
        handleDisconnect();
    });
}

// 处理断开重连
function handleDisconnect() {
    if (reconnectTimer) return;
    reconnectScheduledAt = Date.now();
    console.log(`⏳ ${CONFIG.reconnectInterval/1000}秒后尝试重连...`);
    reconnectTimer = setTimeout(() => {
        reconnectTimer = null;
        reconnectScheduledAt = null;
        startClient();
    }, CONFIG.reconnectInterval);
}

// 解析 XML 并打印
function parseAndPrintData(xmlStr, options = {}) {
    // 解析策略：
    // 1) 先走 xml2js 严格解析（结构化准确）
    // 2) 失败则走 OBX 片段兜底（容忍非严格/损坏 XML）
    // 3) 最终产出 params + latest，并可通过 onFrame 回调给上层网关
    const parser = new xml2js.Parser({ 
        explicitArray: false, // 如果只有一个节点，不强制转为数组
        mergeAttrs: false     // 属性单独处理
    });

    const unescapeXmlText = (s) => {
        if (s == null) return '';
        return String(s)
            .replace(/&lt;/g, '<')
            .replace(/&gt;/g, '>')
            .replace(/&amp;/g, '&')
            .replace(/&quot;/g, '"')
            .replace(/&apos;/g, "'");
    };

    const extractMetaFromXmlText = (text) => {
        const meta = {
            device: '',
            timestamp: '',
        };

        // MSH.4 is often SW version + SN, e.g. SW_8.60.02_SN_34856
        const msh4 = pickFirst(text, [
            /<MSH\.4>[\s\S]*?<HD\.1>([^<]*)<\/HD\.1>/i,
            /<MSH\.4>\s*([^<\s][^<]*)\s*<\/MSH\.4>/i,
        ]);
        const msh3 = pickFirst(text, [
            /<MSH\.3>[\s\S]*?<HD\.1>([^<]*)<\/HD\.1>/i,
            /<MSH\.3>\s*([^<\s][^<]*)\s*<\/MSH\.3>/i,
        ]);
        meta.device = msh4 || msh3;

        meta.timestamp = pickFirst(text, [
            /<MSH\.7>[\s\S]*?<TS\.1>([^<]*)<\/TS\.1>/i,
            /<MSH\.7>\s*([^<\s][^<]*)\s*<\/MSH\.7>/i,
        ]);

        return meta;
    };

    const pickFirst = (text, patterns) => {
        for (const re of patterns) {
            const m = text.match(re);
            if (m && m[1] != null) return unescapeXmlText(m[1]).trim();
        }
        return '';
    };

    const parseObxBlockLoosely = (obxXml) => {
        const paramId = pickFirst(obxXml, [
            /<OBX\.3>[\s\S]*?<CE\.1>([^<]*)<\/CE\.1>/i,
            /<OBX\.3>\s*([^<\s][^<]*)\s*<\/OBX\.3>/i,
        ]);
        if (!paramId) return null;

        const paramNameRaw = pickFirst(obxXml, [
            /<OBX\.3>[\s\S]*?<CE\.2>([^<]*)<\/CE\.2>/i,
        ]) || null;

        const value = pickFirst(obxXml, [
            /<OBX\.5>[\s\S]*?<FN\.1>([^<]*)<\/FN\.1>/i,
            /<OBX\.5>[\s\S]*?<ST>([^<]*)<\/ST>/i,
            /<OBX\.5>\s*([^<\s][^<]*)\s*<\/OBX\.5>/i,
        ]);

        const unit = pickFirst(obxXml, [
            /<OBX\.6>[\s\S]*?<CE\.1>([^<]*)<\/CE\.1>/i,
            /<OBX\.6>[\s\S]*?<CE\.2>([^<]*)<\/CE\.2>/i,
            /<OBX\.6>\s*([^<\s][^<]*)\s*<\/OBX\.6>/i,
        ]);

        const displayName = PARAM_MAP[String(paramId)] || paramNameRaw || `未知参数(${paramId})`;
        return {
            id: String(paramId),
            name: displayName,
            rawName: paramNameRaw || undefined,
            value: value,
            unit: unit,
        };
    };

    const salvageObxAndPrint = () => {
        // 非严格 XML 兜底解析：直接正则提取 <OBX>...</OBX>，尽可能保留业务数据。
        const obxBlocks = xmlStr.match(/<OBX>[\s\S]*?<\/OBX>/g) || [];
        if (obxBlocks.length === 0) return false;

        const meta = extractMetaFromXmlText(xmlStr);

        const receivedAt = new Date().toISOString();
        const messageType = xmlStr.includes('<ORF_R04') ? 'ORF_R04' : 'ORU_R31';
        const params = [];
        const latest = {};

        for (const block of obxBlocks) {
            const p = parseObxBlockLoosely(block);
            if (!p) continue;
            params.push(p);
            latest[p.id] = p;
        }

        if (params.length === 0) return false;

        console.warn(`⚠️ XML 非严格/损坏，已从片段提取 ${params.length}/${obxBlocks.length} 个 OBX 兜底解析`);
        console.log('--- 📊 收到新数据帧 ---');
        if (meta.device || meta.timestamp) {
            console.log(`  设备: ${meta.device || '--'} | 时间: ${meta.timestamp || '--'}`);
        }
        params.forEach(p => {
            const unitStr = (p.unit && p.unit !== '-' && p.unit !== 'NULL') ? ` ${p.unit}` : '';
            console.log(`  [${p.id}] ${p.name}: ${p.value}${unitStr}`);
        });

        if (typeof options.onFrame === 'function') {
            options.onFrame({
                receivedAt,
                messageType,
                device: meta.device || undefined,
                timestamp: meta.timestamp || undefined,
                params,
                latest,
            });
        }
        console.log('------------------------\n');
        return true;
    };

    const asArray = (val) => {
        if (!val) return [];
        return Array.isArray(val) ? val : [val];
    };

    const collectObxFromObservationGroup = (obsGroup, target) => {
        asArray(obsGroup).forEach(item => {
            if (!item) return;
            const obx = item.OBX;
            if (!obx) return;
            target.push(...asArray(obx));
        });
    };

    parser.parseString(xmlStr, (err, result) => {
        if (err) {
            // 兜底：部分设备/抓包数据存在重复/缺失标签，导致不是严格 XML。
            // 若帧内有完整 OBX 段，则仍可提取参数。
            if (!options.__salvaged && salvageObxAndPrint()) return;

            console.error('❌ XML 解析失败:', err.message);
            return;
        }

        console.log('--- 📊 收到新数据帧 ---');
        
        // 兼容 ORU (自动推送) 和 ORF (查询响应)
        const root = result.ORU_R31 || result.ORF_R04;
        
        if (!root) {
            console.log('⚠️ 无法识别根节点，可能是非标准消息');
            return;
        }

        // 提取 OBX 数据段
        // 结构路径通常是: MSH -> OBR -> [OBSERVATION] -> OBX
        // 注意：xml2js 的结构取决于具体 XML 层级，这里做通用提取
        
        let obxItems = [];

        // 优先：与你的协议文档示例一致（OBSERVATION 为根节点的直接子节点）
        collectObxFromObservationGroup(root['ORU_R31.OBSERVATION'], obxItems);
        collectObxFromObservationGroup(root['ORF_R04.OBSERVATION'], obxItems);
        
        // 尝试从 OBR 下的 OBSERVATION 组获取
        asArray(root.OBR).forEach(obr => {
            if (!obr) return;
            const obsGroup = obr['ORU_R31.OBSERVATION'] || obr['ORF_R04.OBSERVATION'];
            collectObxFromObservationGroup(obsGroup, obxItems);
        });
        
        // 如果没有找到，尝试直接在根节点下找 (某些简化结构)
        if (obxItems.length === 0 && root.OBX) {
            obxItems = asArray(root.OBX);
        }

        if (obxItems.length === 0) {
            console.log('ℹ️ 消息中未找到 OBX 数据段');
            return;
        }

        const receivedAt = new Date().toISOString();
        const messageType = result.ORU_R31 ? 'ORU_R31' : 'ORF_R04';
        const msh = root.MSH;
        const meta = {
            device: (msh && msh['MSH.4'] && msh['MSH.4']['HD.1']) ? msh['MSH.4']['HD.1']
                : ((msh && msh['MSH.3'] && msh['MSH.3']['HD.1']) ? msh['MSH.3']['HD.1'] : ''),
            timestamp: (msh && msh['MSH.7'] && msh['MSH.7']['TS.1']) ? msh['MSH.7']['TS.1'] : '',
        };

        if (meta.device || meta.timestamp) {
            console.log(`  设备: ${meta.device || '--'} | 时间: ${meta.timestamp || '--'}`);
        }
        const params = [];
        const latest = {};

        // 遍历并打印每个参数
        obxItems.forEach(obx => {
            // 1. 获取参数 ID (OBX.3)
            // 结构可能是 CE (CE.1=ID, CE.2=Name) 或直接是字符串
            const idObj = obx['OBX.3'];
            let paramId = null;
            let paramNameRaw = null;

            if (idObj && typeof idObj === 'object') {
                paramId = idObj['CE.1'];
                paramNameRaw = idObj['CE.2'];
            } else if (idObj) {
                paramId = idObj;
            }

            if (!paramId) return;

            // 2. 获取中文名称 (查表 或 使用原始名)
            const displayName = PARAM_MAP[paramId] || paramNameRaw || `未知参数(${paramId})`;

            // 3. 获取数值 (OBX.5)
            // 结构可能是 FN (FN.1=Value), ST, 或直接值
            const valObj = obx['OBX.5'];
            let value = '';
            if (valObj && typeof valObj === 'object') {
                value = valObj['FN.1'] || valObj['ST'] || JSON.stringify(valObj);
            } else if (valObj) {
                value = valObj;
            }

            // 4. 获取单位 (OBX.6)
            const unitObj = obx['OBX.6'];
            let unit = '';
            if (unitObj && typeof unitObj === 'object') {
                unit = unitObj['CE.1'] || unitObj['CE.2'];
            } else if (unitObj) {
                unit = unitObj;
            }

            // 格式化输出
            const unitStr = (unit && unit !== '-' && unit !== 'NULL') ? ` ${unit}` : '';
            console.log(`  [${paramId}] ${displayName}: ${value}${unitStr}`);

            const paramObj = {
                id: String(paramId),
                name: displayName,
                rawName: paramNameRaw || undefined,
                value: value,
                unit: unit,
            };
            params.push(paramObj);
            latest[String(paramId)] = paramObj;
        });

        if (typeof options.onFrame === 'function') {
            options.onFrame({
                receivedAt,
                messageType,
                device: meta.device || undefined,
                timestamp: meta.timestamp || undefined,
                params,
                latest,
            });
        }
        
        console.log('------------------------\n');
    });
}

// 启动
if (require.main === module) {
    if (DECODE_FILE) {
        try {
            decodeFileAndParse(DECODE_FILE);
        } catch (e) {
            console.error(`解码失败: ${e && e.message ? e.message : String(e)}`);
            process.exitCode = 1;
        }
    } else {
        startClient();
    }
}

module.exports = {
    parseAndPrintData,
};