// Minimal LZ4 *block* compressor (no dependency, no frame header).
//
// Stock G2 firmware 2.2.6.10 added CompressMode=2, which feeds the payload straight to
// LZ4_decompress_safe(src, dst, srcLen, dstCapacity) at 0x0054f338 — i.e. it expects a
// raw LZ4 BLOCK, not an LZ4 frame. Most npm LZ4 packages emit frames (magic 0x184D2204),
// which that decoder rejects, so we produce the block format ourselves.
//
// Block format (one or more sequences, last one literals-only):
//   token   : 1 byte, high nibble = literal length, low nibble = match length - 4
//             a nibble of 15 means "read more": add 255-valued bytes until one is < 255
//   literals: literalLength raw bytes
//   offset  : 2 bytes little-endian, distance back to the match (1..65535)
//   matchlen: continuation bytes, if the low nibble was 15
//
// Two rules the reference decoder relies on, both enforced below:
//   * the last 5 bytes of a block are always literals (LASTLITERALS)
//   * no match may start within the last 12 bytes (MFLIMIT)
// Violating either makes LZ4_decompress_safe fail, which the firmware logs as
// "evenhub_ui: decompress failed, mode=%u raw_len=%u".

const MINMATCH = 4;
const MFLIMIT = 12;
const LASTLITERALS = 5;
const HASH_LOG = 16;
const MAX_DISTANCE = 65535;

/** Compress `src` to an LZ4 block. Output is always a valid block, worst case ~ src + src/255. */
export function lz4CompressBlock(src: Uint8Array): Uint8Array {
  const n = src.length;
  const out = new Uint8Array(lz4CompressBound(n));
  let op = 0;

  const emitLen = (len: number) => {
    while (len >= 255) { out[op++] = 255; len -= 255; }
    out[op++] = len;
  };
  const emitSeq = (anchor: number, litLen: number, offset: number, matchLen: number) => {
    // token
    out[op++] = (litLen >= 15 ? 15 << 4 : litLen << 4) | (matchLen >= 15 ? 15 : matchLen);
    if (litLen >= 15) emitLen(litLen - 15);
    out.set(src.subarray(anchor, anchor + litLen), op); op += litLen;
    if (offset > 0) {
      out[op++] = offset & 0xff;
      out[op++] = (offset >>> 8) & 0xff;
      if (matchLen >= 15) emitLen(matchLen - 15);
    }
  };

  // Too small to hold even one match: everything is literals.
  if (n < MFLIMIT + 1) {
    emitSeq(0, n, 0, 0);
    return out.subarray(0, op);
  }

  const hashTable = new Int32Array(1 << HASH_LOG).fill(-1);
  const read32 = (i: number) =>
    (src[i]! | (src[i + 1]! << 8) | (src[i + 2]! << 16) | (src[i + 3]! << 24)) >>> 0;
  const hash = (v: number) => (Math.imul(v, 2654435761) >>> (32 - HASH_LOG));

  const mflimit = n - MFLIMIT;        // no match may START at/after this
  const matchLimit = n - LASTLITERALS; // no match may EXTEND at/beyond this
  let anchor = 0;
  let ip = 0;

  hashTable[hash(read32(ip))] = ip;
  ip++;

  while (ip < mflimit) {
    const h = hash(read32(ip));
    const ref = hashTable[h]!;
    hashTable[h] = ip;

    if (ref < 0 || ip - ref > MAX_DISTANCE || read32(ref) !== read32(ip)) { ip++; continue; }

    // Extend the match backwards over bytes we would otherwise emit as literals.
    let s = ip, r = ref;
    while (s > anchor && r > 0 && src[s - 1] === src[r - 1]) { s--; r--; }

    // Extend forwards, never into the final LASTLITERALS bytes.
    let m = ip + MINMATCH, q = ref + MINMATCH;
    while (m < matchLimit && src[m] === src[q]) { m++; q++; }

    // The match now spans [s, m), NOT [ip, m) — the length must be measured from the
    // back-extended start or the decoder silently reproduces too few bytes.
    emitSeq(anchor, s - anchor, s - r, m - s - MINMATCH);
    ip = m;
    anchor = ip;
  }

  emitSeq(anchor, n - anchor, 0, 0);   // final sequence: literals only
  return out.subarray(0, op);
}

/** Worst-case compressed size for `n` input bytes (matches LZ4_compressBound). */
export function lz4CompressBound(n: number): number {
  return n + Math.ceil(n / 255) + 16;
}

/**
 * Reference LZ4 block decompressor — used to self-check the compressor before we put
 * bytes on the wire (a malformed block would just render garbage on the lens, since the
 * firmware treats an unknown/broken payload as raw rather than failing loudly).
 */
export function lz4DecompressBlock(src: Uint8Array, maxOut: number): Uint8Array {
  const out = new Uint8Array(maxOut);
  let ip = 0, op = 0;
  while (ip < src.length) {
    const token = src[ip++]!;
    let litLen = token >>> 4;
    if (litLen === 15) {
      let b = 255;
      while (b === 255 && ip < src.length) { b = src[ip++]!; litLen += b; }
    }
    out.set(src.subarray(ip, ip + litLen), op);
    ip += litLen; op += litLen;
    if (ip >= src.length) break;            // final literals-only sequence
    const offset = src[ip]! | (src[ip + 1]! << 8);
    ip += 2;
    let matchLen = token & 0x0f;
    if (matchLen === 15) {
      let b = 255;
      while (b === 255 && ip < src.length) { b = src[ip++]!; matchLen += b; }
    }
    matchLen += MINMATCH;
    if (offset === 0 || offset > op) throw new Error(`lz4: bad offset ${offset} at op=${op}`);
    let ref = op - offset;
    for (let i = 0; i < matchLen; i++) out[op++] = out[ref++]!;  // may overlap; byte-wise is correct
  }
  return out.subarray(0, op);
}