// 透析机协议解析模块
// 按《山外山血透机远程通讯协议（V1.11）》实现：
// - 帧头：0x55555555（4 字节）
// - 公共头：机器类型(1) + 机器编号(5) + 运行模式(1) + 数据帧类型(1) + 协议版本(1) + 保留(7)
// - 数据区长度：运行参数帧(0x1F)≈220B，报警帧(0x26)≈150B，血压帧(0x29)≈150B

const logger = require("./logger");

class ProtocolParser {
  constructor() {
    this.headerBytes = Buffer.from([0x55, 0x55, 0x55, 0x55]);
    // 公共头总长度：4(帧头) + 1 + 5 + 1 + 1 + 1 + 7 = 20
    this.baseHeaderLength = 20;
  }

  /**
   * 根据帧类型返回数据区长度
   * @param {number} frameType
   * @returns {number|null}
   */
  getDataLength(frameType) {
    switch (frameType) {
      case 0x1f: // 运行参数帧
        // 文档标注“数据长度 220 字节”，结合实际抓包：整帧长度就是 220，
        // 即 20 字节公共头 + 200 字节数据区，这里返回的数据区长度应为 200。
        return 200;
      case 0x26: // 报警信息帧
        // 文档标注“数据长度 150 字节”，实际抓包显示 **整帧长度就是 150**，
        // 即 20 字节公共头 + 130 字节数据区，这里返回的数据区长度应为 130。
        return 130;
      case 0x29: // 血压测量数据帧
        // 同报警帧，整帧 150 字节 => 数据区 130 字节。
        return 130;
      default:
        return null;
    }
  }

  /**
   * 从设备 buffer 中尽可能提取完整报文
   * @param {Buffer} buffer 当前累计 buffer
   * @returns {{ frames: Buffer[], remaining: Buffer }}
   */
  extractFrames(buffer) {
    const frames = [];
    let offset = 0;

    while (buffer.length - offset >= this.baseHeaderLength) {
      const start = buffer.indexOf(this.headerBytes, offset);
      if (start === -1) {
        // 没找到帧头：仅保留最后 3 字节，兼容下一次 data 事件和帧头跨包拼接
        const keepTail = this.headerBytes.length - 1;
        const remaining =
          buffer.length > keepTail ? buffer.slice(buffer.length - keepTail) : buffer;
        return { frames, remaining };
      }

      // 头部不完整，等待更多数据
      if (buffer.length - start < this.baseHeaderLength) {
        break;
      }

      const frameType = buffer[start + 11]; // 帧头后第 11 字节为数据帧类型
      const dataLen = this.getDataLength(frameType);
      if (!dataLen) {
        logger.warn("Unknown frame type, skip header", { frameType });
        // 跳过这 4 字节帧头，继续往后找，避免卡死
        offset = start + 4;
        continue;
      }

      const totalLen = this.baseHeaderLength + dataLen;
      if (buffer.length - start < totalLen) {
        // 不够一整帧，等待下次数据
        break;
      }

      const frame = buffer.slice(start, start + totalLen);
      frames.push(frame);
      offset = start + totalLen;
    }

    const remaining = buffer.slice(offset);
    return { frames, remaining };
  }

  /**
   * 工具：按字节长度读取无符号整数（运行参数帧使用小端）
   * @param {Buffer} buf
   * @param {number} offset
   * @param {number} length 1/2/4
   */
  readUInt(buf, offset, length) {
    if (offset + length > buf.length) return null;
    if (length === 1) return buf.readUInt8(offset);
    if (length === 2) return buf.readUInt16LE(offset);
    if (length === 4) return buf.readUInt32LE(offset);
    return null;
  }

  mapMachineType(type) {
    switch (type) {
      case 0x01:
        return "SWS-4000";
      case 0x02:
        return "SWS-4000A";
      case 0x31:
        return "SWS-6000";
      case 0x32:
        return "SWS-6000A";
      default:
        return "unknown";
    }
  }

  mapRunMode(mode) {
    switch (mode) {
      case 0x00:
        return "待机";
      case 0x01:
        return "透析";
      case 0x02:
        return "滤过";
      case 0x03:
        return "透析滤过";
      case 0x04:
        return "序贯-透析";
      case 0x05:
        return "单纯超滤";
      case 0x06:
        return "序贯-单超";
      case 0x07:
        return "预充";
      case 0x08:
        return "清洗";
      case 0x09:
        return "清洗消毒";
      case 0x14:
        return "透析结束";
      case 0x15:
        return "清洗结束";
      case 0x16:
        return "透析滤过结束";
      case 0x17:
        return "单纯超滤结束";
      default:
        return `MODE_${mode}`;
    }
  }

  buildTimeString(parts) {
    const [year, month, day, hour, minute, second] = parts;
    if (!year) return null;
    const y = year.toString().padStart(4, "0");
    const m = String(month || 0).padStart(2, "0");
    const d = String(day || 0).padStart(2, "0");
    const h = String(hour || 0).padStart(2, "0");
    const mi = String(minute || 0).padStart(2, "0");
    const s = String(second || 0).padStart(2, "0");
    return `${y}-${m}-${d} ${h}:${mi}:${s}`;
  }

  /**
   * 解析运行参数帧（0x1F），返回与 schema.json 对齐的字段对象
   *
   * 说明：
   * - 下表中的“偏移 / 长度”来自《运行参数帧》数据区定义；
   * - “协议含义”是 PDF 表格中的中文说明；
   * - "对应标识符" 是你 `schema.json` 里的 `identifier`，便于后续属性映射。
   *
   * 运行参数区字段对照（节选）：
   *
   * | 偏移 | 长度 | 协议含义                       | 对应标识符        |
   * |------|------|--------------------------------|-------------------|
   * | 0    | 4    | 设置治疗时间 (s)              | SetTreatmentTime  |
   * | 4    | 4    | 已治疗时间 (s)                | K                 |
   * | 8    | 2    | 血泵流量 (ml/min)            | D                 |
   * | 10   | 1    | 血泵运行标志 0/1 停止/运行   | xlyxbj            |
   * | 11   | 1    | 抗凝方式 0/1 无抗凝/肝素抗凝 | klfs              |
   * | 12   | 1    | 肝素泵运行标志 0/1 停止/运行 | z                 |
  * | 13   | 2    | 肝素泵流量 (ml/h×10)         | E（还原后保存）   |
  * | 15   | 2    | 肝素提前结束时间 (min)       | gstqjssj          |
  * | 17   | 4    | 超滤总量 (ml)                | A                 |
  * | 21   | 4    | 已超滤量 (ml)                | B                 |
  * | 25   | 4    | 超滤率 (ml/h)                | C                 |
  * | 29   | 1    | 超滤泵运行标志               | cllyxbj           |
  * | 30   | 1    | 旁路标志 0/1 关/开           | plbj              |
  * | 31   | 2    | 透析液流量 (ml/min)          | L                 |
  * | 33   | 2    | 透析液实际温度 (℃×10)       | F（还原后保存）   |
  * | 35   | 2    | 透析液电导值 (mS/cm×100)     | G（还原后保存）   |
  * | 37   | 4    | 补液总量 (ml)                | pyzl              |
  * | 41   | 4    | 已补入置换液量 (ml)         | ypyzhyl           |
   * | 45   | 1    | 补液补入模式 0/1 前/后稀释   | pyprfs            |
   * | 46   | 2    | 内毒素滤器1使用时间 (h)     | ldslq             |
   * | 48   | 2    | 内毒素滤器2使用时间 (h)     | ldslq2sysj        |
   * | 50   | 4    | 机器总运行时间 (min)        | jqzyxsj           |
   * | 54   | 2    | 动脉压 (mmHg)                | o                 |
   * | 56   | 2    | 静脉压 (mmHg)                | H                 |
   * | 58   | 2    | 跨膜压 (mmHg)                | J                 |
   * | 60   | 2    | 透析液压 (kPa×10)            | I（还原后保存）   |
   * | 62   | 1    | 尿素下降率 (%)               | lsxjl             |
   * | 64   | 2    | 实时清除率值 (×100)          | ssqclz（还原）    |
   * | 66   | 2    | 静脉血温 (℃×10)             | jmyxh（还原）     |
   * | 68   | 2    | 动脉血温 (℃×10)             | dmyxw（还原）     |
   * | 69   | 1    | 相对血容量 (%)               | xdxrl             |
   */
  parseRunParams(data) {
    const r = (off, len) => this.readUInt(data, off, len);
    const rInt16 = (off) =>
      off + 2 <= data.length ? data.readInt16LE(off) : null; // 带符号 16 位，小端
    const result = {};

    // 以下偏移和长度依据协议截图整理，必要时可结合抓包微调

    // 偏移 0，长度 4 字节
    // 协议字段：设置治疗时间(s)，这里转换为“分钟”保存
    // schema 标识符：SetTreatmentTime（按分钟上报）
    const SetTreatmentTimeSec = r(0, 4);
    if (SetTreatmentTimeSec != null) {
      // 结果四舍五入到整数分钟
      result.SetTreatmentTime = Math.round(SetTreatmentTimeSec / 60);
    }

    // 偏移 4，4 字节
    // 协议字段：已治疗时间(s)，这里同样按“分钟”保存
    // schema 标识符：K（按分钟上报）
    const Ksec = r(4, 4); // 已透析时间(s)
    if (Ksec != null) {
      result.K = Math.round(Ksec / 60);
    }

    // 偏移 8，2 字节
    // 协议字段：血泵流量(ml/min)
    // schema 标识符：D
    const D = r(8, 2); // 血泵流量 ml/min
    if (D != null) result.D = D;

    // 偏移 10，1 字节
    // 协议字段：血泵运行标志 0/1-停止/运行
    // schema 标识符：xlyxbj
    const xlyxbj = r(10, 1);
    if (xlyxbj != null) result.xlyxbj = xlyxbj;

    // 偏移 11，1 字节
    // 协议字段：抗凝方式 0/1-无抗凝/肝素抗凝
    // schema 标识符：klfs
    const klfs = r(11, 1);
    if (klfs != null) result.klfs = klfs;

    // 偏移 12，1 字节
    // 协议字段：肝素泵运行标志 0/1-停止/运行
    // schema 标识符：z
    const z = r(12, 1);
    if (z != null) result.z = z;

    // 偏移 13，2 字节
    // 协议字段：肝素泵流量(ml/h)，数值放大 10 倍
    // schema 标识符：E（在物模型中为 int，但这里解析时就做缩放）
    const Eraw = r(13, 2); // 肝素泵流量 ml/h，放大 10 倍
    if (Eraw != null) result.E = Eraw / 10;

    // 偏移 15，2 字节
    // 协议字段：肝素提前结束时间(min)
    // schema 标识符：gstqjssj
    const gstqjssj = r(15, 2);
    if (gstqjssj != null) result.gstqjssj = gstqjssj;

    // 偏移 17，4 字节
    // 协议字段：超滤总量(ml)，这里按 L 保存，保留 3 位小数
    // schema 标识符：A
    const Araw = r(17, 4); // 超滤总量 ml
    if (Araw != null) {
      result.A = (Araw / 1000).toFixed(3); // L
    }

    // 偏移 21，4 字节
    // 协议字段：已超滤量(ml)，这里按 L 保存，保留 3 位小数
    // schema 标识符：B
    const Braw = r(21, 4); // 已超滤量 ml
    if (Braw != null) {
      result.B = (Braw / 1000).toFixed(3); // L
    }

    // 偏移 29，1 字节
    // 协议字段：超滤泵运行标志 0/1-停止/运行
    // schema 标识符：cllyxbj
    const cllyxbj = r(29, 1);
    if (cllyxbj != null) result.cllyxbj = cllyxbj;

    // 偏移 30，1 字节
    // 协议字段：旁路标志 0/1-关闭/打开
    // schema 标识符：plbj
    const plbj = r(30, 1);
    if (plbj != null) result.plbj = plbj;

    // 偏移 31，2 字节
    // 协议字段：透析液流量(ml/min)
    // schema 标识符：L
    const L = r(31, 2); // 透析液流量 ml/min
    if (L != null) result.L = L;

    // 偏移 33，2 字节
    // 协议字段：透析液实际温度(℃)，数值放大 10 倍
    // schema 标识符：F
    const Fraw = r(33, 2); // 透析液温度，放大 10 倍
    if (Fraw != null) result.F = Fraw / 10;

    // 偏移 35，2 字节
    // 协议字段：透析液电导值(mS/cm)，数值放大 100 倍
    // schema 标识符：G
    const Graw = r(35, 2); // 透析液电导值，放大 100 倍
    if (Graw != null) result.G = Graw / 100;

    // 偏移 25，4 字节
    // 协议字段：超滤率(ml/h)，这里按 L/h 保存，保留 3 位小数
    // schema 标识符：C
    const Craw = r(25, 4);
    if (Craw != null) {
      result.C = (Craw / 1000).toFixed(3); // L/h
    }

    // 偏移 37，4 字节
    // 协议字段：补液总量(ml)
    // schema 标识符：pyzl
    const pyzl = r(37, 4);
    if (pyzl != null) result.pyzl = pyzl;

    // 偏移 41，4 字节
    // 协议字段：已补入置换液量(ml)
    // schema 标识符：ypyzhyl
    const ypyzhyl = r(41, 4);
    if (ypyzhyl != null) result.ypyzhyl = ypyzhyl;

    // 偏移 45，1 字节
    // 协议字段：补液补入模式 0/1-前稀释/后稀释
    // schema 标识符：pyprfs
    const pyprfs = r(45, 1);
    if (pyprfs != null) result.pyprfs = pyprfs;

    // 偏移 46，2 字节
    // 协议字段：内毒素滤器1使用时间(h)
    // schema 标识符：ldslq
    const ldslq = r(46, 2);
    if (ldslq != null) result.ldslq = ldslq;

    // 偏移 48，2 字节
    // 协议字段：内毒素滤器2使用时间(h)
    // schema 标识符：ldslq2sysj
    const ldslq2sysj = r(48, 2);
    if (ldslq2sysj != null) result.ldslq2sysj = ldslq2sysj;

    // 偏移 50，4 字节
    // 协议字段：机器总运行时间(min)
    // schema 标识符：jqzyxsj
    const jqzyxsj = r(50, 4);
    if (jqzyxsj != null) result.jqzyxsj = jqzyxsj;

    // 偏移 54，2 字节
    // 协议字段：动脉压(mmHg)，为带符号数，负值表示负压
    // schema 标识符：o
    const o = rInt16(54); // 动脉压
    if (o != null) result.o = o;

    // 偏移 56，2 字节
    // 协议字段：静脉压(mmHg)，一般为正值，这里同样按带符号解析以兼容异常情况
    // schema 标识符：H
    const H = rInt16(56); // 静脉压
    if (H != null) result.H = H;

    // 偏移 58，2 字节
    // 协议字段：跨膜压(mmHg)
    // schema 标识符：J
    const J = rInt16(58); // 跨膜压
    if (J != null) result.J = J;

    // 偏移 60，2 字节
    // 协议字段：透析液压(kPa)，数值放大 10 倍，可为负值
    // schema 标识符：I
    const Iraw = rInt16(60); // 透析液压 kPa，放大 10 倍
    if (Iraw != null) result.I = Iraw / 10;

    // 偏移 62，1 字节
    // 协议字段：尿素下降率(%)
    // schema 标识符：lsxjl
    const lsxjl = r(62, 1); // 尿素下降率 %
    if (lsxjl != null) result.lsxjl = lsxjl;

    // 偏移 64，2 字节
    // 协议字段：实时清除率值，数值放大 100 倍
    // schema 标识符：ssqclz
    const ssqclzRaw = r(64, 2); // 实时清除率，放大 100 倍
    if (ssqclzRaw != null) result.ssqclz = ssqclzRaw / 100;

    // 偏移 66，2 字节
    // 协议字段：静脉血温(℃)，数值放大 10 倍
    // schema 标识符：jmyxh
    const jmyxhRaw = r(66, 2); // 静脉血温，放大 10 倍
    if (jmyxhRaw != null) result.jmyxh = jmyxhRaw / 10;

    // 偏移 68，2 字节
    // 协议字段：动脉血温(℃)，数值放大 10 倍
    // schema 标识符：dmyxw
    const dmyxwRaw = r(68, 2); // 动脉血温，放大 10 倍
    if (dmyxwRaw != null) result.dmyxw = dmyxwRaw / 10;

    // 偏移 69，1 字节
    // 协议字段：相对血容量(%)
    // schema 标识符：xdxrl
    const xdxrl = r(69, 1); // 相对血容量 %
    if (xdxrl != null) result.xdxrl = xdxrl;

    return result;
  }

  /**
    * 解析报警帧（0x26）
    *
    * 数据区字段对照：
    * - 偏移 0，长度 2：报警编号（小端）→ 这里记为 alarmCode
    * - 偏移 2，长度 1：报警类型 → 0/1=消除报警/产生报警，对应 schema 中的 `bjlx`
    * - 偏移 3~?: 年(2 字节小端)、月、日、时、分、秒 → 组合为 `bjsj`（报警时间，字符串格式 YYYY-MM-DD HH:MM:SS）
   */
  parseAlarm(data) {
    // 报警帧里的 16 位数值（报警编号、年份）使用小端序，
    // 与运行参数帧的大端序不同，这里单独处理。
    const r8 = (off) => (off < data.length ? data.readUInt8(off) : null);
    const r16le = (off) =>
      off + 2 <= data.length ? data.readUInt16LE(off) : null;

    const alarmCode = r16le(0);
    const alarmType = r8(2); // 0=解除,1=产生

    const year = r16le(3);
    const month = r8(5);
    const day = r8(6);
    const hour = r8(7);
    const minute = r8(8);
    const second = r8(9);

    const alarmTime = this.buildTimeString([year, month, day, hour, minute, second]);

    return {
      alarmCode,
      bjlx: alarmType,
      bjsj: alarmTime
    };
  }

  /**
    * 解析血压测量帧（0x29）
    *
    * 数据区字段对照（结合血压数据表与 schema）：
    * - 偏移 0，1 字节：测量模式 0/1=手动/自动 → 这里记为 `bpMode`
    * - 偏移 1，1 字节：测量结果 0/1=测量出错/测量成功 → `bpResult`
    * - 偏移 2 起：年/月/日/时/分/秒 → 组装为测量时间，挂到运行参数表字段 `M`（BPM监测时间）
    * - 偏移 13，2 字节：收缩压(mmHg) → schema 标识符 `N`
    * - 偏移 15，2 字节：舒张压(mmHg) → schema 标识符 `O`
    * - 偏移 17，2 字节：脉搏/心率 → schema 标识符 `P`
    * - 偏移 19，2 字节：平均动脉压 → schema 标识符 `BPMPJDMY`
   */
  parseBloodPressure(data) {
    // 血压帧的数据区里，多字节数值使用小端序（低字节在前），
    // 与运行参数帧/报警帧的大端序不同，这里单独按小端解析。

    const r8 = (off) => (off < data.length ? data.readUInt8(off) : null);
    const r16le = (off) =>
      off + 2 <= data.length ? data.readUInt16LE(off) : null;

    const bpMode = r8(0); // 测量模式：0/1 手动/自动
    const bpResult = r8(1); // 结果：0/1 出错/成功

    // 年：2 字节小端；月/日/时/分/秒：1 字节
    const year = r16le(2);
    const month = r8(4);
    const day = r8(5);
    const hour = r8(6);
    const minute = r8(7);
    const second = r8(8);

    const bpTime = this.buildTimeString([year, month, day, hour, minute, second]);

    // 根据抓包数据校正：
    // - 偏移  9，2 字节小端：收缩压 N（例如 0x81 0x00 => 129）
    // - 偏移 11，2 字节小端：舒张压 O（例如 0x5D 0x00 => 93）
    // - 偏移 13，2 字节小端：脉搏 P   （例如 0x56 0x00 => 86）
    // - 偏移 15，2 字节小端：平均动脉压 BPMPJDMY（例如 0x69 0x00 => 105）
    const systolic = r16le(9); // 收缩压 N
    const diastolic = r16le(11); // 舒张压 O
    const heartRate = r16le(13); // 脉搏 P
    const map = r16le(15); // 平均动脉压 BPMPJDMY

    return {
      bpMode,
      bpResult,
      M: bpTime,
      N: systolic,
      O: diastolic,
      P: heartRate,
      BPMPJDMY: map
    };
  }

  /**
   * 将一帧报文解析为结构化对象。
   * @param {Buffer} frame 完整帧（包含公共头 + 数据区）
   * @param {string} ip 设备 IP
   * @returns {{ deviceNumber: string, data: object }}
   */
  parseFrame(frame, ip) {
    const now = new Date();
    const suedtime = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(
      now.getDate()
    ).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(
      now.getMinutes()
    ).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`;

    const machineTypeByte = frame[4];
    const machineNumberBuf = frame.slice(5, 10); // 5 字节机器号

    // 按协议：机器编号为 5 字节无符号整数，小端在前。
    // 例如字节 E1 73 CB 72 01 => 十进制 6220903393。
    let deviceNumber = "";
    if (machineNumberBuf.length === 5) {
      let id = 0;
      for (let i = 0; i < 5; i++) {
        id += machineNumberBuf[i] * Math.pow(256, i); // 小端累加
      }
      deviceNumber = String(id);
    }
    if (!deviceNumber) {
      // 回退为十六进制字符串，避免完全丢失标识
      deviceNumber = Array.from(machineNumberBuf)
        .map((b) => b.toString(16).padStart(2, "0"))
        .join("");
    }

    const runModeByte = frame[10];
    const frameType = frame[11];
    const protocolVersion = frame[12];

    const dataBuf = frame.slice(this.baseHeaderLength);

    const baseData = {
      suedtime,
      deviceType: this.mapMachineType(machineTypeByte),
      IPAddress: ip,
      n: deviceNumber,
      jqyxms: this.mapRunMode(runModeByte),
      jqyxmsRaw: runModeByte,
      frameType,
      protocolVersion
    };

    if (frameType === 0x1f) {
      Object.assign(baseData, this.parseRunParams(dataBuf));
    } else if (frameType === 0x26) {
      Object.assign(baseData, this.parseAlarm(dataBuf));
    } else if (frameType === 0x29) {
      Object.assign(baseData, this.parseBloodPressure(dataBuf));
    } else {
      logger.warn("Unhandled frame type", { frameType });
    }

    const finalDeviceNumber = deviceNumber || ip || "unknown";

    logger.debug("Parsed frame", { ip, deviceNumber: finalDeviceNumber, frameType });

    return { deviceNumber: finalDeviceNumber, data: baseData };
  }
}

module.exports = ProtocolParser;