// See file LICENSE for more information.

import 'dart:typed_data';

const _MASK_3 = 0x07;
const _MASK_5 = 0x1F;
const _MASK_6 = 0x3F;
const _MASK_8 = 0xFF;
const _MASK_16 = 0xFFFF;
const _MASK_32 = 0xFFFFFFFF;

// ignore: non_constant_identifier_names
final _MASK32_HI_BITS = [
  0xFFFFFFFF,
  0x7FFFFFFF,
  0x3FFFFFFF,
  0x1FFFFFFF,
  0x0FFFFFFF,
  0x07FFFFFF,
  0x03FFFFFF,
  0x01FFFFFF,
  0x00FFFFFF,
  0x007FFFFF,
  0x003FFFFF,
  0x001FFFFF,
  0x000FFFFF,
  0x0007FFFF,
  0x0003FFFF,
  0x0001FFFF,
  0x0000FFFF,
  0x00007FFF,
  0x00003FFF,
  0x00001FFF,
  0x00000FFF,
  0x000007FF,
  0x000003FF,
  0x000001FF,
  0x000000FF,
  0x0000007F,
  0x0000003F,
  0x0000001F,
  0x0000000F,
  0x00000007,
  0x00000003,
  0x00000001,
  0x00000000
];

////////////////////////////////////////////////////////////////////////////////////////////////////
// 8 bit operations
//
int clip8(int x) => x & _MASK_8;

int csum8(int x, int y) => sum8(clip8(x), clip8(y));
int sum8(int x, int y) {
  assert((x >= 0) && (x <= _MASK_8));
  assert((y >= 0) && (y <= _MASK_8));
  return (x + y) & _MASK_8;
}

int csub8(int x, int y) => sub8(clip8(x), clip8(y));
int sub8(int x, int y) {
  assert((x >= 0) && (x <= _MASK_8));
  assert((y >= 0) && (y <= _MASK_8));
  return (x - y) & _MASK_8;
}

int cshiftl8(int x, int n) => shiftl8(clip8(x), n);
int shiftl8(int x, int n) {
  assert((x >= 0) && (x <= _MASK_8));
  return (x << (n & _MASK_3)) & _MASK_8;
}

int cshiftr8(int x, int n) => shiftr8(clip8(x), n);
int shiftr8(int x, int n) {
  assert((x >= 0) && (x <= _MASK_8));
  return x >> (n & _MASK_3);
}

int cneg8(int x) => neg8(clip8(x));
int neg8(int x) {
  assert((x >= 0) && (x <= _MASK_8));
  return -x & _MASK_8;
}

int cnot8(int x) => not8(clip8(x));
int not8(int x) {
  assert((x >= 0) && (x <= _MASK_8));
  return ~x & _MASK_8;
}

int crotl8(int x, int n) => rotl8(clip8(x), n);
int rotl8(int x, int n) {
  assert(n >= 0);
  assert((x >= 0) && (x <= _MASK_8));
  n &= _MASK_3;
  return ((x << n) & _MASK_8) | (x >> (8 - n));
}

int crotr8(int x, int n) => rotr8(clip8(x), n);
int rotr8(int x, int n) {
  assert(n >= 0);
  assert((x >= 0) && (x <= _MASK_8));
  n &= _MASK_3;
  return ((x >> n) & _MASK_8) | ((x << (8 - n)) & _MASK_8);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
// 16 bit operations
//
int clip16(int x) => x & _MASK_16;

/// Packs a 16 bit integer into a byte buffer. The [out] parameter can be an [Uint8List] or a
/// [ByteData] if you will run it several times against the same buffer and want faster execution.
void pack16(int x, dynamic out, int offset, Endian endian) {
  assert((x >= 0) && (x <= _MASK_16));
  if (out is! ByteData) {
    out = ByteData.view(out.buffer, out.offsetInBytes, out.length);
  }
  out.setUint16(offset, x, endian);
}

/// Unpacks a 16 bit integer from a byte buffer. The [inp] parameter can be an [Uint8List] or a
/// [ByteData] if you will run it several times against the same buffer and want faster execution.
int unpack16(dynamic inp, int offset, Endian endian) {
  if (inp is! ByteData) {
    inp = ByteData.view(
        inp.buffer as ByteBuffer, inp.offsetInBytes as int, inp.length as int?);
  }
  return inp.getUint16(offset, endian);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
// 32 bit operations
//
int clip32(int x) => x & _MASK_32;

int csum32(int x, int y) => sum32(clip32(x), clip32(y));
int sum32(int x, int y) {
  assert((x >= 0) && (x <= _MASK_32));
  assert((y >= 0) && (y <= _MASK_32));
  return (x + y) & _MASK_32;
}

int csub32(int x, int y) => sub32(clip32(x), clip32(y));
int sub32(int x, int y) {
  assert((x >= 0) && (x <= _MASK_32));
  assert((y >= 0) && (y <= _MASK_32));
  return (x - y) & _MASK_32;
}

int cshiftl32(int x, int n) => shiftl32(clip32(x), n);
int shiftl32(int x, int n) {
  assert((x >= 0) && (x <= _MASK_32));
  n &= _MASK_5;
  x &= _MASK32_HI_BITS[n];
  return (x << n) & _MASK_32;
}

int cshiftr32(int x, int n) => shiftr32(clip32(x), n);
int shiftr32(int x, int n) {
  assert((x >= 0) && (x <= _MASK_32));
  n &= _MASK_5;
  return x >> n;
}

int cneg32(int x) => neg32(clip32(x));
int neg32(int x) {
  assert((x >= 0) && (x <= _MASK_32));
  return -x & _MASK_32;
}

int cnot32(int x) => not32(clip32(x));
int not32(int x) {
  assert((x >= 0) && (x <= _MASK_32));
  return ~x & _MASK_32;
}

int crotl32(int x, int n) => rotl32(clip32(x), n);
int rotl32(int x, int n) {
  assert(n >= 0);
  assert((x >= 0) && (x <= _MASK_32));
  n &= _MASK_5;
  return shiftl32(x, n) | (x >> (32 - n));
}

int crotr32(int x, int n) => rotr32(clip32(x), n);
int rotr32(int x, int n) {
  assert(n >= 0);
  assert((x >= 0) && (x <= _MASK_32));
  n &= _MASK_5;
  return (x >> n) | shiftl32(x, 32 - n);
}

/// Packs a 32 bit integer into a byte buffer. The [out] parameter can be an [Uint8List] or a
/// [ByteData] if you will run it several times against the same buffer and want faster execution.
void pack32(int x, dynamic out, int offset, Endian endian) {
  assert((x >= 0) && (x <= _MASK_32));
  if (out is! ByteData) {
    out =
        ByteData.view(out.buffer as ByteBuffer, out.offsetInBytes, out.length);
  }
  out.setUint32(offset, x, endian);
}

/// Unpacks a 32 bit integer from a byte buffer. The [inp] parameter can be an [Uint8List] or a
/// [ByteData] if you will run it several times against the same buffer and want faster execution.
int unpack32(dynamic inp, int offset, Endian endian) {
  if (inp is! ByteData) {
    inp = ByteData.view(inp.buffer, inp.offsetInBytes, inp.length);
  }
  return inp.getUint32(offset, endian);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
// 64 bit operations
//
class Register64 {
  late int _hi32;
  late int _lo32;

  Register64([Object hiOrLo32OrY = 0, int? lo32]) {
    set(hiOrLo32OrY, lo32);
  }

  int get lo32 => _lo32;
  int get hi32 => _hi32;

  @override
  bool operator ==(Object other) => other is Register64
      ? (((_hi32 == other._hi32) && (_lo32 == other._lo32)))
      : false;
  bool operator <(Register64 y) =>
      (_hi32 < y._hi32) || ((_hi32 == y._hi32) && (_lo32 < y._lo32));
  bool operator <=(Register64 y) => (this < y) || (this == y);
  bool operator >(Register64 y) =>
      (_hi32 > y._hi32) || ((_hi32 == y._hi32) && (_lo32 > y._lo32));
  bool operator >=(Register64 y) => (this > y) || (this == y);

  void set(dynamic hiOrLo32OrY, [int? lo32]) {
    if (lo32 == null) {
      if (hiOrLo32OrY is Register64) {
        _hi32 = hiOrLo32OrY._hi32;
        _lo32 = hiOrLo32OrY._lo32;
      } else {
        assert(hiOrLo32OrY as int <= _MASK_32);
        _hi32 = 0;
        _lo32 = hiOrLo32OrY as int;
      }
    } else {
      assert(hiOrLo32OrY as int <= _MASK_32);
      assert(lo32 <= _MASK_32);
      _hi32 = hiOrLo32OrY as int;
      _lo32 = lo32;
    }
  }

  void sum(dynamic y) {
    if (y is int) {
      y &= _MASK_32;
      var slo32 = _lo32 + y;
      _lo32 = slo32 & _MASK_32;
      if (slo32 != _lo32) {
        _hi32++;
        _hi32 &= _MASK_32;
      }
    } else {
      var slo32 = _lo32 + y._lo32 as int;
      _lo32 = slo32 & _MASK_32;
      var carry = ((slo32 != _lo32) ? 1 : 0);
      _hi32 = ((_hi32 + y._hi32 + carry) as int) & _MASK_32;
    }
  }

  void sumReg(Register64 y) {
    var slo32 = _lo32 + y._lo32;
    _lo32 = slo32 & _MASK_32;
    var carry = ((slo32 != _lo32) ? 1 : 0);
    _hi32 = (_hi32 + y._hi32 + carry) & _MASK_32;
  }

  void sub(dynamic y) {
    // TODO: optimize sub() ???
    sum(Register64(y)..neg());
  }

  void mul(dynamic y) {
    // Grab 16-bit chunks.
    final a0 = _lo32 & _MASK_16;
    final a1 = (_lo32 >> 16) & _MASK_16;
    final a2 = _hi32 & _MASK_16;
    final a3 = (_hi32 >> 16) & _MASK_16;
    late int b0, b1, b2, b3;
    if (y is int) {
      // Assume it is a 32-bit integer.
      y &= _MASK_32;
      b0 = y & _MASK_16;
      b1 = (y >> 16) & _MASK_16;
      b2 = b3 = 0;
    } else /* if (y is Register64) */ {
      b0 = (y as Register64)._lo32 & _MASK_16;
      b1 = (y._lo32 >> 16) & _MASK_16;
      b2 = y._hi32 & _MASK_16;
      b3 = (y._hi32 >> 16) & _MASK_16;
    }

    // Compute partial products.
    // Optimization: if b is small, avoid multiplying by parts that are 0.
    var p0 = a0 * b0; // << 0
    var p1 = a1 * b0; // << 16
    var p2 = a2 * b0; // << 32
    var p3 = a3 * b0; // << 48

    if (b1 != 0) {
      p1 += a0 * b1;
      p2 += a1 * b1;
      p3 += a2 * b1;
    }
    if (b2 != 0) {
      p2 += a0 * b2;
      p3 += a1 * b2;
    }
    if (b3 != 0) {
      p3 += a0 * b3;
    }

    // Accumulate into 32-bit chunks:
    // |................................|................................|
    // |................................|xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx| p0
    // |................................|................................|
    // |................................|................................|
    // |................xxxxxxxxxxxxxxxx|xxxxxxxxxxxxxxxx................| p1
    // |................................|................................|
    // |................................|................................|
    // |xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx|................................| p2
    // |................................|................................|
    // |................................|................................|
    // |xxxxxxxxxxxxxxxx................|................................| p3
    var slo32 = p0 + ((p1 & _MASK_16) << 16);
    _lo32 = slo32 & _MASK_32;
    var carry = ((slo32 != _lo32) ? 1 : 0);
    // p1 is a 33-bit integer, shiftr operation will ignore 33th-bit on js
    var carry2 = ((p1 & _MASK_32) != p1) ? 0x10000 : 0;
    var shi32 =
        ((p1 & _MASK_32) >> 16) + p2 + ((p3 & _MASK_16) << 16) + carry + carry2;
    _hi32 = shi32 & _MASK_32;
  }

  void neg() {
    not();
    sum(1);
  }

  void not() {
    _hi32 = ~_hi32 & _MASK_32;
    _lo32 = ~_lo32 & _MASK_32;
  }

  void and(Register64 y) {
    _hi32 &= y._hi32;
    _lo32 &= y._lo32;
  }

  void or(Register64 y) {
    _hi32 |= y._hi32;
    _lo32 |= y._lo32;
  }

  void xor(Register64 y) {
    _hi32 ^= y._hi32;
    _lo32 ^= y._lo32;
  }

  void shiftl(int n) {
    n &= _MASK_6;
    if (n == 0) {
      // do nothing
    } else if (n >= 32) {
      _hi32 = shiftl32(_lo32, n - 32);
      _lo32 = 0;
    } else {
      _hi32 = shiftl32(_hi32, n);
      _hi32 |= _lo32 >> (32 - n);
      _lo32 = shiftl32(_lo32, n);
    }
  }

  void shiftr(int n) {
    n &= _MASK_6;
    if (n == 0) {
      // do nothing
    } else if (n >= 32) {
      _lo32 = _hi32 >> (n - 32);
      _hi32 = 0;
    } else {
      _lo32 = _lo32 >> n;
      _lo32 |= shiftl32(_hi32, 32 - n);
      _hi32 = _hi32 >> n;
    }
  }

  void rotl(int n) {
    n &= _MASK_6;
    if (n == 0) {
      // do nothing
    } else {
      if (n >= 32) {
        var swap = _hi32;
        _hi32 = _lo32;
        _lo32 = swap;
        n -= 32;
      }
      if (n == 0) {
        // do nothing
      } else {
        var hi32 = _hi32;
        _hi32 = shiftl32(_hi32, n);
        _hi32 |= _lo32 >> (32 - n);
        _lo32 = shiftl32(_lo32, n);
        _lo32 |= hi32 >> (32 - n);
      }
    }
  }

  void rotr(int n) {
    n &= _MASK_6;
    if (n == 0) {
      // do nothing
    } else {
      if (n >= 32) {
        var swap = _hi32;
        _hi32 = _lo32;
        _lo32 = swap;
        n -= 32;
      }
      if (n == 0) {
        // do nothing
      } else {
        var hi32 = _hi32;
        _hi32 = _hi32 >> n;
        _hi32 |= shiftl32(_lo32, 32 - n);
        _lo32 = _lo32 >> n;
        _lo32 |= shiftl32(hi32, 32 - n);
      }
    }
  }

  void mod(int n) {
    if (_hi32 == 0) {
      // hi32 is zero, so just caculate lo32.
      _lo32 %= n;
    } else {
      // hi32 is not zero, use Horner's Method
      const b = 0x10000;
      final a0 = _lo32 & _MASK_16;
      final a1 = (_lo32 >> 16) & _MASK_16;
      final a2 = _hi32 & _MASK_16;
      final a3 = (_hi32 >> 16) & _MASK_16;
      _lo32 = ((((((a3 % n) * b + a2) % n) * b + a1) % n) * b + a0) % n;
      // Assume that n is a 32-bit integer, so hi32 will always be zero
      _hi32 = 0;
    }
  }

  /// Packs a 64 bit integer into a byte buffer. The [out] parameter can be an [Uint8List] or a
  /// [ByteData] if you will run it several times against the same buffer and want faster execution.
  void pack(dynamic out, int offset, Endian endian) {
    switch (endian) {
      case Endian.big:
        pack32(hi32, out, offset, endian);
        pack32(lo32, out, offset + 4, endian);
        break;

      case Endian.little:
        pack32(hi32, out, offset + 4, endian);
        pack32(lo32, out, offset, endian);
        break;

      default:
        throw UnsupportedError('Invalid endianness: $endian');
    }
  }

  /// Unpacks a 64 bit integer from a byte buffer. The [inp] parameter can be an [Uint8List] or a
  /// [ByteData] if you will run it several times against the same buffer and want faster execution.
  void unpack(dynamic inp, int offset, Endian endian) {
    switch (endian) {
      case Endian.big:
        _hi32 = unpack32(inp, offset, endian);
        _lo32 = unpack32(inp, offset + 4, endian);
        break;

      case Endian.little:
        _hi32 = unpack32(inp, offset + 4, endian);
        _lo32 = unpack32(inp, offset, endian);
        break;

      default:
        throw UnsupportedError('Invalid endianness: $endian');
    }
  }

  @override
  String toString() {
    var sb = StringBuffer();
    _padWrite(sb, _hi32);
    _padWrite(sb, _lo32);
    return sb.toString();
  }

  void _padWrite(StringBuffer sb, int value) {
    var str = value.toRadixString(16);
    for (var i = 8 - str.length; i > 0; i--) {
      sb.write('0');
    }
    sb.write(str);
  }

  @override
  int get hashCode => Object.hash(_hi32, _lo32);
}

class Register64List {
  final List<Register64> _list;

  Register64List.from(List<List<int>> values)
      : _list = List<Register64>.generate(
            values.length, (i) => Register64(values[i][0], values[i][1]));

  Register64List(int length)
      : _list = List<Register64>.generate(length, (_) => Register64());

  int get length => _list.length;

  Register64 operator [](int index) => _list[index];

  void fillRange(int start, int end, dynamic hiOrLo32OrY, [int? lo32]) {
    for (var i = start; i < end; i++) {
      _list[i].set(hiOrLo32OrY, lo32);
    }
  }

  void setRange(int start, int end, Register64List list, [int skipCount = 0]) {
    var length = end - start;
    for (var i = 0; i < length; i++) {
      _list[start + i].set(list[skipCount + i]);
    }
  }

  @override
  String toString() {
    var sb = StringBuffer('(');
    for (var i = 0; i < _list.length; i++) {
      if (i > 0) {
        sb.write(', ');
      }
      sb.write(_list[i].toString());
    }
    sb.write(')');
    return sb.toString();
  }
}