// Self-contained QR Code (model 2) encoder — byte mode, versions 1-40, all four
// ECC levels. We render our own QR locally so a join/admin link's secret
// #fragment never has to leave the browser for some third-party QR service.
//
// qrMatrix is pure (no DOM, no globals) so it can be unit-tested in Node; the
// only browser-only piece is qrCanvas. Tables and the placement/mask algorithm
// follow ISO/IEC 18004.

const ECL_INDEX = { L: 0, M: 1, Q: 2, H: 3 };

// The 2-bit EC indicator written into the format information is NOT in L/M/Q/H
// numeric order: L=01, M=00, Q=11, H=10 per the spec.
const ECL_FORMAT_BITS = { L: 1, M: 0, Q: 3, H: 2 };

// EC codewords per block, indexed [eclIndex][version]. Index 0 of each row is a
// placeholder so version can index directly. (Nayuki's tables — the part most
// worth copying verbatim rather than re-deriving.)
const ECC_CODEWORDS_PER_BLOCK = [
  [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
  [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
  [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
  [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
];

// Number of EC blocks, indexed [eclIndex][version].
const NUM_ERROR_CORRECTION_BLOCKS = [
  [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
  [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
  [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
  [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81],
];

const MIN_VERSION = 1;
const MAX_VERSION = 40;
const PENALTY_N1 = 3;
const PENALTY_N2 = 3;
const PENALTY_N3 = 40;
const PENALTY_N4 = 10;

// Number of data+EC modules available in a version, before subtracting function
// patterns' overhead — i.e. the bits the codeword stream is laid into.
function numRawDataModules(version) {
  let result = (16 * version + 128) * version + 64;
  if (version >= 2) {
    const numAlign = Math.floor(version / 7) + 2;
    result -= (25 * numAlign - 10) * numAlign - 55;
    if (version >= 7) result -= 36; // two version-information blocks
  }
  return result;
}

function numDataCodewords(version, eclIndex) {
  return (
    Math.floor(numRawDataModules(version) / 8) -
    ECC_CODEWORDS_PER_BLOCK[eclIndex][version] *
      NUM_ERROR_CORRECTION_BLOCKS[eclIndex][version]
  );
}

// Byte-mode character-count indicator width grows with version.
function charCountBits(version) {
  return version <= 9 ? 8 : 16;
}

// GF(256) multiply with primitive polynomial 0x11D, via Russian-peasant so we
// avoid log/antilog tables.
function gfMul(x, y) {
  let z = 0;
  for (let i = 7; i >= 0; i--) {
    z = (z << 1) ^ ((z >>> 7) * 0x11d);
    z ^= ((y >>> i) & 1) * x;
  }
  return z & 0xff;
}

// Generator polynomial coefficients (degree `ecLen`) for Reed–Solomon.
function rsDivisor(ecLen) {
  const result = new Uint8Array(ecLen);
  result[ecLen - 1] = 1; // start with the monomial x^0
  let root = 1;
  for (let i = 0; i < ecLen; i++) {
    // multiply the current product by (x - r^i)
    for (let j = 0; j < result.length; j++) {
      result[j] = gfMul(result[j], root);
      if (j + 1 < result.length) result[j] ^= result[j + 1];
    }
    root = gfMul(root, 0x02);
  }
  return result;
}

function rsRemainder(data, divisor) {
  const result = new Uint8Array(divisor.length);
  for (const b of data) {
    const factor = b ^ result[0];
    result.copyWithin(0, 1);
    result[result.length - 1] = 0;
    for (let i = 0; i < result.length; i++) {
      result[i] ^= gfMul(divisor[i], factor);
    }
  }
  return result;
}

// Build the bit-padded data codeword stream for the chosen version: mode,
// count, payload, terminator, byte-align, then the alternating EC/11 pad bytes.
function dataCodewords(bytes, version, eclIndex) {
  const capacityBits = numDataCodewords(version, eclIndex) * 8;
  const bits = [];
  const push = (value, len) => {
    for (let i = len - 1; i >= 0; i--) bits.push((value >>> i) & 1);
  };

  push(0b0100, 4); // byte mode
  push(bytes.length, charCountBits(version));
  for (const b of bytes) push(b, 8);

  push(0, Math.min(4, capacityBits - bits.length)); // terminator
  push(0, (8 - (bits.length % 8)) % 8); // align to byte boundary
  for (let pad = 0xec; bits.length < capacityBits; pad ^= 0xec ^ 0x11) {
    push(pad, 8);
  }

  const out = new Uint8Array(bits.length / 8);
  for (let i = 0; i < bits.length; i++) {
    out[i >> 3] |= bits[i] << (7 - (i & 7));
  }
  return out;
}

// Split data into blocks, append RS error correction to each, then interleave
// data-then-EC across blocks as the spec requires.
function addEccAndInterleave(data, version, eclIndex) {
  const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[eclIndex][version];
  const eccLen = ECC_CODEWORDS_PER_BLOCK[eclIndex][version];
  const rawCodewords = Math.floor(numRawDataModules(version) / 8);
  const numShort = numBlocks - (rawCodewords % numBlocks);
  const shortLen = Math.floor(rawCodewords / numBlocks);
  const divisor = rsDivisor(eccLen);

  const blocks = [];
  for (let i = 0, k = 0; i < numBlocks; i++) {
    const datLen = shortLen - eccLen + (i < numShort ? 0 : 1);
    const dat = data.slice(k, k + datLen);
    k += datLen;
    blocks.push({ dat, ecc: rsRemainder(dat, divisor) });
  }

  const result = new Uint8Array(rawCodewords);
  let idx = 0;
  const maxDatLen = shortLen - eccLen + 1;
  for (let i = 0; i < maxDatLen; i++) {
    for (const block of blocks) {
      // short blocks omit their final data codeword from the last column
      if (i < block.dat.length) result[idx++] = block.dat[i];
    }
  }
  for (let i = 0; i < eccLen; i++) {
    for (const block of blocks) result[idx++] = block.ecc[i];
  }
  return result;
}

// Alignment-pattern centre coordinates for a version (empty for version 1).
function alignmentPositions(version) {
  if (version === 1) return [];
  const size = version * 4 + 17;
  const numAlign = Math.floor(version / 7) + 2;
  const step =
    version === 32
      ? 26
      : Math.ceil((version * 4 + 4) / (numAlign * 2 - 2)) * 2;
  const result = [6];
  for (let pos = size - 7; result.length < numAlign; pos -= step) {
    result.splice(1, 0, pos);
  }
  return result;
}

// A QR symbol under construction: holds the module grid plus a parallel mask of
// which cells are immutable function patterns.
class QrSymbol {
  constructor(version, eclIndex) {
    this.version = version;
    this.eclIndex = eclIndex;
    this.ecl = ["L", "M", "Q", "H"][eclIndex];
    this.size = version * 4 + 17;
    this.modules = Array.from({ length: this.size }, () =>
      new Array(this.size).fill(false)
    );
    this.isFunction = Array.from({ length: this.size }, () =>
      new Array(this.size).fill(false)
    );
  }

  set(x, y, dark) {
    this.modules[y][x] = dark;
    this.isFunction[y][x] = true;
  }

  drawFinder(cx, cy) {
    for (let dy = -4; dy <= 4; dy++) {
      for (let dx = -4; dx <= 4; dx++) {
        const x = cx + dx;
        const y = cy + dy;
        if (x < 0 || x >= this.size || y < 0 || y >= this.size) continue;
        const dist = Math.max(Math.abs(dx), Math.abs(dy));
        this.set(x, y, dist !== 2 && dist !== 4); // ring + centre, with separator
      }
    }
  }

  drawAlignment(cx, cy) {
    for (let dy = -2; dy <= 2; dy++) {
      for (let dx = -2; dx <= 2; dx++) {
        this.set(cx + dx, cy + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
      }
    }
  }

  drawFunctionPatterns() {
    for (let i = 0; i < this.size; i++) {
      this.set(6, i, i % 2 === 0); // vertical timing
      this.set(i, 6, i % 2 === 0); // horizontal timing
    }

    this.drawFinder(3, 3);
    this.drawFinder(this.size - 4, 3);
    this.drawFinder(3, this.size - 4);

    const pos = alignmentPositions(this.version);
    const n = pos.length;
    for (let i = 0; i < n; i++) {
      for (let j = 0; j < n; j++) {
        // skip the three that collide with the finder patterns
        if (
          (i === 0 && j === 0) ||
          (i === 0 && j === n - 1) ||
          (i === n - 1 && j === 0)
        ) {
          continue;
        }
        this.drawAlignment(pos[i], pos[j]);
      }
    }

    // Reserve format/version areas (real bits drawn later); dummy mask is fine.
    this.drawFormatBits(0);
    this.drawVersion();
  }

  drawFormatBits(mask) {
    const data = (ECL_FORMAT_BITS[this.ecl] << 3) | mask; // 5 bits
    let rem = data;
    for (let i = 0; i < 10; i++) rem = (rem << 1) ^ ((rem >> 9) * 0x537);
    const bits = ((data << 10) | rem) ^ 0x5412; // 15 bits, masked per spec
    const bit = (i) => ((bits >> i) & 1) !== 0;

    for (let i = 0; i <= 5; i++) this.set(8, i, bit(i));
    this.set(8, 7, bit(6));
    this.set(8, 8, bit(7));
    this.set(7, 8, bit(8));
    for (let i = 9; i < 15; i++) this.set(14 - i, 8, bit(i));

    for (let i = 0; i < 8; i++) this.set(this.size - 1 - i, 8, bit(i));
    for (let i = 8; i < 15; i++) this.set(8, this.size - 15 + i, bit(i));
    this.set(8, this.size - 8, true); // always-dark module
  }

  drawVersion() {
    if (this.version < 7) return;
    let rem = this.version;
    for (let i = 0; i < 12; i++) rem = (rem << 1) ^ ((rem >> 11) * 0x1f25);
    const bits = (this.version << 12) | rem; // 18 bits

    for (let i = 0; i < 18; i++) {
      const dark = ((bits >> i) & 1) !== 0;
      const a = this.size - 11 + (i % 3);
      const b = Math.floor(i / 3);
      this.set(a, b, dark);
      this.set(b, a, dark);
    }
  }

  // Lay the interleaved codeword stream into the data region, zig-zagging up and
  // down pairs of columns from the right, skipping the vertical timing column.
  drawCodewords(data) {
    let i = 0;
    for (let right = this.size - 1; right >= 1; right -= 2) {
      if (right === 6) right = 5;
      for (let vert = 0; vert < this.size; vert++) {
        for (let j = 0; j < 2; j++) {
          const x = right - j;
          const upward = ((right + 1) & 2) === 0;
          const y = upward ? this.size - 1 - vert : vert;
          if (!this.isFunction[y][x] && i < data.length * 8) {
            this.modules[y][x] = ((data[i >> 3] >> (7 - (i & 7))) & 1) !== 0;
            i++;
          }
        }
      }
    }
  }

  maskBit(mask, x, y) {
    switch (mask) {
      case 0: return (x + y) % 2 === 0;
      case 1: return y % 2 === 0;
      case 2: return x % 3 === 0;
      case 3: return (x + y) % 3 === 0;
      case 4: return (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
      case 5: return ((x * y) % 2) + ((x * y) % 3) === 0;
      case 6: return (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
      case 7: return (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
      default: throw new Error("bad mask");
    }
  }

  applyMask(mask) {
    for (let y = 0; y < this.size; y++) {
      for (let x = 0; x < this.size; x++) {
        if (!this.isFunction[y][x] && this.maskBit(mask, x, y)) {
          this.modules[y][x] = !this.modules[y][x];
        }
      }
    }
  }

  penaltyScore() {
    let result = 0;
    const size = this.size;

    const addHistory = (runLen, history) => {
      if (history[0] === 0) runLen += size; // light border before a leading run
      history.pop();
      history.unshift(runLen);
    };
    // A 1:1:3:1:1 dark/light pattern flanked by 4+ light modules (the finder
    // look-alike) costs N3 each.
    const countPatterns = (h) => {
      const n = h[1];
      const core = n > 0 && h[2] === n && h[3] === n * 3 && h[4] === n && h[5] === n;
      return (
        (core && h[0] >= n * 4 && h[6] >= n ? 1 : 0) +
        (core && h[6] >= n * 4 && h[0] >= n ? 1 : 0)
      );
    };
    const terminateAndCount = (runColor, runLen, history) => {
      if (runColor) {
        addHistory(runLen, history);
        runLen = 0;
      }
      runLen += size; // trailing light border
      addHistory(runLen, history);
      return countPatterns(history);
    };

    // Rule 1 + Rule 3, scanned along rows then columns.
    for (let y = 0; y < size; y++) {
      let runColor = false;
      let runLen = 0;
      const history = [0, 0, 0, 0, 0, 0, 0];
      for (let x = 0; x < size; x++) {
        if (this.modules[y][x] === runColor) {
          runLen++;
          if (runLen === 5) result += PENALTY_N1;
          else if (runLen > 5) result++;
        } else {
          addHistory(runLen, history);
          if (!runColor) result += countPatterns(history) * PENALTY_N3;
          runColor = this.modules[y][x];
          runLen = 1;
        }
      }
      result += terminateAndCount(runColor, runLen, history) * PENALTY_N3;
    }
    for (let x = 0; x < size; x++) {
      let runColor = false;
      let runLen = 0;
      const history = [0, 0, 0, 0, 0, 0, 0];
      for (let y = 0; y < size; y++) {
        if (this.modules[y][x] === runColor) {
          runLen++;
          if (runLen === 5) result += PENALTY_N1;
          else if (runLen > 5) result++;
        } else {
          addHistory(runLen, history);
          if (!runColor) result += countPatterns(history) * PENALTY_N3;
          runColor = this.modules[y][x];
          runLen = 1;
        }
      }
      result += terminateAndCount(runColor, runLen, history) * PENALTY_N3;
    }

    // Rule 2: every 2x2 block of one colour costs N2.
    for (let y = 0; y < size - 1; y++) {
      for (let x = 0; x < size - 1; x++) {
        const c = this.modules[y][x];
        if (
          c === this.modules[y][x + 1] &&
          c === this.modules[y + 1][x] &&
          c === this.modules[y + 1][x + 1]
        ) {
          result += PENALTY_N2;
        }
      }
    }

    // Rule 4: deviation of dark-module proportion from 50%.
    let dark = 0;
    for (let y = 0; y < size; y++) {
      for (let x = 0; x < size; x++) if (this.modules[y][x]) dark++;
    }
    const total = size * size;
    const k = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
    result += k * PENALTY_N4;

    return result;
  }
}

// Pick the smallest version whose data capacity fits the byte payload at the
// requested ECC level.
function chooseVersion(byteLen, eclIndex) {
  for (let version = MIN_VERSION; version <= MAX_VERSION; version++) {
    const capacityBits = numDataCodewords(version, eclIndex) * 8;
    const neededBits = 4 + charCountBits(version) + 8 * byteLen;
    if (neededBits <= capacityBits) return version;
  }
  return -1;
}

// Returns { size, modules } where modules[y][x] is true for a dark module.
// Throws if the text is too long for version 40 at the given ECC level.
export function qrMatrix(text, ecl = "M") {
  const eclIndex = ECL_INDEX[ecl];
  if (eclIndex === undefined) throw new Error(`unknown ECC level: ${ecl}`);

  const bytes = new TextEncoder().encode(text);
  const version = chooseVersion(bytes.length, eclIndex);
  if (version < 0) {
    throw new Error(`data too long: ${bytes.length} bytes exceeds version 40 at level ${ecl}`);
  }

  const sym = new QrSymbol(version, eclIndex);
  sym.drawFunctionPatterns();
  sym.drawCodewords(
    addEccAndInterleave(dataCodewords(bytes, version, eclIndex), version, eclIndex)
  );

  // Try every mask, keep the lowest-penalty one. We apply, score, then undo by
  // re-applying (XOR masks are self-inverse).
  let bestMask = 0;
  let bestPenalty = Infinity;
  for (let mask = 0; mask < 8; mask++) {
    sym.applyMask(mask);
    sym.drawFormatBits(mask);
    const penalty = sym.penaltyScore();
    if (penalty < bestPenalty) {
      bestPenalty = penalty;
      bestMask = mask;
    }
    sym.applyMask(mask);
  }
  sym.applyMask(bestMask);
  sym.drawFormatBits(bestMask);

  return { size: sym.size, modules: sym.modules };
}

// Browser-only: render the matrix to a fresh <canvas> and return it.
export function qrCanvas(
  text,
  { ecl = "M", scale = 6, margin = 4, dark = "#000", light = "#fff" } = {}
) {
  const { size, modules } = qrMatrix(text, ecl);
  const dim = (size + margin * 2) * scale;
  const canvas = document.createElement("canvas");
  canvas.width = dim;
  canvas.height = dim;
  const ctx = canvas.getContext("2d");
  ctx.fillStyle = light;
  ctx.fillRect(0, 0, dim, dim);
  ctx.fillStyle = dark;
  for (let y = 0; y < size; y++) {
    for (let x = 0; x < size; x++) {
      if (modules[y][x]) {
        ctx.fillRect((x + margin) * scale, (y + margin) * scale, scale, scale);
      }
    }
  }
  return canvas;
}