// MD5 (RFC 1321), written out because Web Crypto does not offer it. MD5 is broken for security
// (RFC 6151: collisions are practical) - it is here only to compare a file with a published MD5
// checksum, which detects accidental corruption, not tampering.
//
// Incremental: feed a large file in chunks with update() and call digest() once at the end.
import { toHex } from './encoding';

// Per-round left-rotation amounts (RFC 1321, section 3.4).
const SHIFTS = [
  7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14,
  20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15, 21, 6,
  10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
];

// T[i] = floor(2^32 * abs(sin(i + 1))), the table in RFC 1321 section 3.4 - written out rather
// than computed, so no engine's Math.sin rounding can change it.
const T = new Uint32Array([
  0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
  0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
  0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
  0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
  0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
  0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
  0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
  0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
]);

export type Md5 = {
  /** Adds bytes to the message. Can be called any number of times before digest(). */
  update(data: Uint8Array): Md5;
  /** The 16-byte digest. The hash cannot be updated afterwards. */
  digest(): Uint8Array;
};

export function createMd5(): Md5 {
  // Initial state: words A, B, C, D (RFC 1321, section 3.3).
  const state = new Uint32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476]);
  const block = new Uint8Array(64);
  const words = new Uint32Array(16);
  let buffered = 0;
  let total = 0; // message length in bytes
  let done = false;

  function compress() {
    for (let i = 0; i < 16; i += 1) {
      const j = i * 4;
      words[i] = block[j] | (block[j + 1] << 8) | (block[j + 2] << 16) | (block[j + 3] << 24);
    }
    let [a, b, c, d] = state;
    for (let i = 0; i < 64; i += 1) {
      let f: number;
      let g: number;
      if (i < 16) {
        f = (b & c) | (~b & d);
        g = i;
      } else if (i < 32) {
        f = (d & b) | (~d & c);
        g = (5 * i + 1) % 16;
      } else if (i < 48) {
        f = b ^ c ^ d;
        g = (3 * i + 5) % 16;
      } else {
        f = c ^ (b | ~d);
        g = (7 * i) % 16;
      }
      const sum = (a + f + T[i] + words[g]) | 0;
      a = d;
      d = c;
      c = b;
      b = (b + ((sum << SHIFTS[i]) | (sum >>> (32 - SHIFTS[i])))) | 0;
    }
    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;
  }

  const md5: Md5 = {
    update(data) {
      if (done) throw new Error('MD5: update() after digest()');
      total += data.length;
      let offset = 0;
      while (offset < data.length) {
        const take = Math.min(64 - buffered, data.length - offset);
        block.set(data.subarray(offset, offset + take), buffered);
        buffered += take;
        offset += take;
        if (buffered === 64) {
          compress();
          buffered = 0;
        }
      }
      return md5;
    },
    digest() {
      if (done) throw new Error('MD5: digest() called twice');
      done = true;
      // Padding: a 1 bit, zeros up to 56 bytes mod 64, then the bit length, little-endian.
      const bits = total * 8;
      block[buffered] = 0x80;
      block.fill(0, buffered + 1);
      if (buffered >= 56) {
        compress();
        block.fill(0);
      }
      const low = bits >>> 0;
      const high = Math.floor(bits / 2 ** 32) >>> 0;
      for (let i = 0; i < 4; i += 1) {
        block[56 + i] = (low >>> (8 * i)) & 0xff;
        block[60 + i] = (high >>> (8 * i)) & 0xff;
      }
      compress();
      const out = new Uint8Array(16);
      for (let i = 0; i < 16; i += 1) out[i] = (state[i >> 2] >>> (8 * (i & 3))) & 0xff;
      return out;
    },
  };
  return md5;
}

/** Lowercase hex MD5 of a UTF-8 string or of raw bytes. */
export function md5Hex(input: string | Uint8Array): string {
  const data = typeof input === 'string' ? new TextEncoder().encode(input) : input;
  return toHex(createMd5().update(data).digest());
}