export class CustomType {
  withFields(fields) {
    let properties = Object.keys(this).map((label) =>
      label in fields ? fields[label] : this[label],
    );
    return new this.constructor(...properties);
  }
}

export class List {
  static fromArray(array, tail) {
    let t = tail || new Empty();
    for (let i = array.length - 1; i >= 0; --i) {
      t = new NonEmpty(array[i], t);
    }
    return t;
  }

  [Symbol.iterator]() {
    return new ListIterator(this);
  }

  toArray() {
    return [...this];
  }

  atLeastLength(desired) {
    let current = this;
    while (desired-- > 0 && current) current = current.tail;
    return current !== undefined;
  }

  hasLength(desired) {
    let current = this;
    while (desired-- > 0 && current) current = current.tail;
    return desired === -1 && current instanceof Empty;
  }

  countLength() {
    let current = this;
    let length = 0;
    while (current) {
      current = current.tail;
      length++;
    }
    return length - 1;
  }
}

export function prepend(element, tail) {
  return new NonEmpty(element, tail);
}

export function toList(elements, tail) {
  return List.fromArray(elements, tail);
}

class ListIterator {
  #current;

  constructor(current) {
    this.#current = current;
  }

  next() {
    if (this.#current instanceof Empty) {
      return { done: true };
    } else {
      let { head, tail } = this.#current;
      this.#current = tail;
      return { value: head, done: false };
    }
  }
}

export class Empty extends List {}
export const List$Empty = () => new Empty();
export const List$isEmpty = (value) => value instanceof Empty;

export class NonEmpty extends List {
  constructor(head, tail) {
    super();
    this.head = head;
    this.tail = tail;
  }
}
export const List$NonEmpty = (head, tail) => new NonEmpty(head, tail);
export const List$isNonEmpty = (value) => value instanceof NonEmpty;

export const List$NonEmpty$first = (value) => value.head;
export const List$NonEmpty$rest = (value) => value.tail;

/**
 * A bit array is a contiguous sequence of bits similar to Erlang's Binary type.
 */
export class BitArray {
  /**
   * The size in bits of this bit array's data.
   *
   * @type {number}
   */
  bitSize;

  /**
   * The size in bytes of this bit array's data. If this bit array doesn't store
   * a whole number of bytes then this value is rounded up.
   *
   * @type {number}
   */
  byteSize;

  /**
   * The number of unused high bits in the first byte of this bit array's
   * buffer prior to the start of its data. The value of any unused high bits is
   * undefined.
   *
   * The bit offset will be in the range 0-7.
   *
   * @type {number}
   */
  bitOffset;

  /**
   * The raw bytes that hold this bit array's data.
   *
   * If `bitOffset` is not zero then there are unused high bits in the first
   * byte of this buffer.
   *
   * If `bitOffset + bitSize` is not a multiple of 8 then there are unused low
   * bits in the last byte of this buffer.
   *
   * @type {Uint8Array}
   */
  rawBuffer;

  /**
   * Constructs a new bit array from a `Uint8Array`, an optional size in
   * bits, and an optional bit offset.
   *
   * If no bit size is specified it is taken as `buffer.length * 8`, i.e. all
   * bytes in the buffer make up the new bit array's data.
   *
   * If no bit offset is specified it defaults to zero, i.e. there are no unused
   * high bits in the first byte of the buffer.
   *
   * @param {Uint8Array} buffer
   * @param {number} [bitSize]
   * @param {number} [bitOffset]
   */
  constructor(buffer, bitSize, bitOffset) {
    if (!(buffer instanceof Uint8Array)) {
      throw globalThis.Error(
        "BitArray can only be constructed from a Uint8Array",
      );
    }

    this.bitSize = bitSize ?? buffer.length * 8;
    this.byteSize = Math.trunc((this.bitSize + 7) / 8);
    this.bitOffset = bitOffset ?? 0;

    // Validate the bit size
    if (this.bitSize < 0) {
      throw globalThis.Error(`BitArray bit size is invalid: ${this.bitSize}`);
    }

    // Validate the bit offset
    if (this.bitOffset < 0 || this.bitOffset > 7) {
      throw globalThis.Error(
        `BitArray bit offset is invalid: ${this.bitOffset}`,
      );
    }

    // Validate the length of the buffer
    if (buffer.length !== Math.trunc((this.bitOffset + this.bitSize + 7) / 8)) {
      throw globalThis.Error("BitArray buffer length is invalid");
    }

    this.rawBuffer = buffer;
  }

  /**
   * Returns a specific byte in this bit array. If the byte index is out of
   * range then `undefined` is returned.
   *
   * When returning the final byte of a bit array with a bit size that's not a
   * multiple of 8, the content of the unused low bits are undefined.
   *
   * @param {number} index
   * @returns {number | undefined}
   */
  byteAt(index) {
    if (index < 0 || index >= this.byteSize) {
      return undefined;
    }

    return bitArrayByteAt(this.rawBuffer, this.bitOffset, index);
  }

  equals(other) {
    if (this.bitSize !== other.bitSize) {
      return false;
    }

    const wholeByteCount = Math.trunc(this.bitSize / 8);

    // If both bit offsets are zero do a byte-aligned equality check which is
    // faster
    if (this.bitOffset === 0 && other.bitOffset === 0) {
      // Compare any whole bytes
      for (let i = 0; i < wholeByteCount; i++) {
        if (this.rawBuffer[i] !== other.rawBuffer[i]) {
          return false;
        }
      }

      // Compare any trailing bits, excluding unused low bits
      const trailingBitsCount = this.bitSize % 8;
      if (trailingBitsCount) {
        const unusedLowBitCount = 8 - trailingBitsCount;
        if (
          this.rawBuffer[wholeByteCount] >> unusedLowBitCount !==
          other.rawBuffer[wholeByteCount] >> unusedLowBitCount
        ) {
          return false;
        }
      }
    } else {
      // Compare any whole bytes
      for (let i = 0; i < wholeByteCount; i++) {
        const a = bitArrayByteAt(this.rawBuffer, this.bitOffset, i);
        const b = bitArrayByteAt(other.rawBuffer, other.bitOffset, i);

        if (a !== b) {
          return false;
        }
      }

      // Compare any trailing bits
      const trailingBitsCount = this.bitSize % 8;
      if (trailingBitsCount) {
        const a = bitArrayByteAt(
          this.rawBuffer,
          this.bitOffset,
          wholeByteCount,
        );
        const b = bitArrayByteAt(
          other.rawBuffer,
          other.bitOffset,
          wholeByteCount,
        );

        const unusedLowBitCount = 8 - trailingBitsCount;
        if (a >> unusedLowBitCount !== b >> unusedLowBitCount) {
          return false;
        }
      }
    }

    return true;
  }

  /**
   * Returns this bit array's internal buffer.
   *
   * @deprecated Use `BitArray.byteAt()` or `BitArray.rawBuffer` instead.
   *
   * @returns {Uint8Array}
   */
  get buffer() {
    bitArrayPrintDeprecationWarning(
      "buffer",
      "Use BitArray.byteAt() or BitArray.rawBuffer instead",
    );

    if (this.bitOffset !== 0 || this.bitSize % 8 !== 0) {
      throw new globalThis.Error(
        "BitArray.buffer does not support unaligned bit arrays",
      );
    }

    return this.rawBuffer;
  }

  /**
   * Returns the length in bytes of this bit array's internal buffer.
   *
   * @deprecated Use `BitArray.bitSize` or `BitArray.byteSize` instead.
   *
   * @returns {number}
   */
  get length() {
    bitArrayPrintDeprecationWarning(
      "length",
      "Use BitArray.bitSize or BitArray.byteSize instead",
    );

    if (this.bitOffset !== 0 || this.bitSize % 8 !== 0) {
      throw new globalThis.Error(
        "BitArray.length does not support unaligned bit arrays",
      );
    }

    return this.rawBuffer.length;
  }
}

export const BitArray$BitArray = (buffer, bitSize, bitOffset) =>
  new BitArray(buffer, bitSize, bitOffset);

/**
 * Returns the nth byte in the given buffer, after applying the specified bit
 * offset. If the index is out of bounds then zero is returned.
 *
 * @param {Uint8Array} buffer
 * @param {number} bitOffset
 * @param {number} index
 * @returns {number}
 */
function bitArrayByteAt(buffer, bitOffset, index) {
  if (bitOffset === 0) {
    return buffer[index] ?? 0;
  } else {
    const a = (buffer[index] << bitOffset) & 0xff;
    const b = buffer[index + 1] >> (8 - bitOffset);

    return a | b;
  }
}

export class UtfCodepoint {
  constructor(value) {
    this.value = value;
  }
}

const isBitArrayDeprecationMessagePrinted = {};
function bitArrayPrintDeprecationWarning(name, message) {
  if (isBitArrayDeprecationMessagePrinted[name]) {
    return;
  }

  console.warn(
    `Deprecated BitArray.${name} property used in JavaScript FFI code. ${message}.`,
  );

  isBitArrayDeprecationMessagePrinted[name] = true;
}

/**
 * Slices a bit array to produce a new bit array. If `end` is not supplied then
 * all bits from `start` onward are returned.
 *
 * If the slice is out of bounds then an exception is thrown.
 *
 * @param {BitArray} bitArray
 * @param {number} start
 * @param {number} [end]
 * @returns {BitArray}
 */
export function bitArraySlice(bitArray, start, end) {
  end ??= bitArray.bitSize;

  bitArrayValidateRange(bitArray, start, end);

  // Handle zero-length slices
  if (start === end) {
    return new BitArray(new Uint8Array());
  }

  // Early return for slices that cover the whole bit array
  if (start === 0 && end === bitArray.bitSize) {
    return bitArray;
  }

  start += bitArray.bitOffset;
  end += bitArray.bitOffset;

  const startByteIndex = Math.trunc(start / 8);
  const endByteIndex = Math.trunc((end + 7) / 8);
  const byteLength = endByteIndex - startByteIndex;

  // Avoid creating a new Uint8Array if the view of the underlying ArrayBuffer
  // is the same. This can occur when slicing off just the first or last bit of
  // a bit array, i.e. when only the bit offset or bit size need to be updated.
  let buffer;
  if (startByteIndex === 0 && byteLength === bitArray.rawBuffer.byteLength) {
    buffer = bitArray.rawBuffer;
  } else {
    buffer = new Uint8Array(
      bitArray.rawBuffer.buffer,
      bitArray.rawBuffer.byteOffset + startByteIndex,
      byteLength,
    );
  }

  return new BitArray(buffer, end - start, start % 8);
}

/**
 * Interprets a slice of this bit array as a floating point number, either
 * 32-bit or 64-bit, with the specified endianness.
 *
 * The value of `end - start` must be exactly 32 or 64, otherwise an exception
 * will be thrown.
 *
 * @param {BitArray} bitArray
 * @param {number} start
 * @param {number} end
 * @param {boolean} isBigEndian
 * @returns {number}
 */
export function bitArraySliceToFloat(bitArray, start, end, isBigEndian) {
  bitArrayValidateRange(bitArray, start, end);

  const floatSize = end - start;

  // Check size is valid
  if (floatSize !== 16 && floatSize !== 32 && floatSize !== 64) {
    const msg =
      `Sized floats must be 16-bit, 32-bit or 64-bit, got size of ` +
      `${floatSize} bits`;
    throw new globalThis.Error(msg);
  }

  start += bitArray.bitOffset;

  const isStartByteAligned = start % 8 === 0;

  // If the bit range is byte aligned then the float can be read directly out
  // of the existing buffer
  if (isStartByteAligned) {
    const view = new DataView(
      bitArray.rawBuffer.buffer,
      bitArray.rawBuffer.byteOffset + start / 8,
    );

    if (floatSize === 64) {
      return view.getFloat64(0, !isBigEndian);
    } else if (floatSize === 32) {
      return view.getFloat32(0, !isBigEndian);
    } else if (floatSize === 16) {
      return fp16UintToNumber(view.getUint16(0, !isBigEndian));
    }
  }

  // Copy the unaligned bytes into an aligned array so a DataView can be used
  const alignedBytes = new Uint8Array(floatSize / 8);
  const byteOffset = Math.trunc(start / 8);
  for (let i = 0; i < alignedBytes.length; i++) {
    alignedBytes[i] = bitArrayByteAt(
      bitArray.rawBuffer,
      start % 8,
      byteOffset + i,
    );
  }

  // Read the float out of the aligned buffer
  const view = new DataView(alignedBytes.buffer);
  if (floatSize === 64) {
    return view.getFloat64(0, !isBigEndian);
  } else if (floatSize === 32) {
    return view.getFloat32(0, !isBigEndian);
  } else {
    return fp16UintToNumber(view.getUint16(0, !isBigEndian));
  }
}

/**
 * Interprets a slice of this bit array as a signed or unsigned integer with the
 * specified endianness.
 *
 * @param {BitArray} bitArray
 * @param {number} start
 * @param {number} end
 * @param {boolean} isBigEndian
 * @param {boolean} isSigned
 * @returns {number}
 */
export function bitArraySliceToInt(
  bitArray,
  start,
  end,
  isBigEndian,
  isSigned,
) {
  bitArrayValidateRange(bitArray, start, end);

  if (start === end) {
    return 0;
  }

  start += bitArray.bitOffset;
  end += bitArray.bitOffset;

  const isStartByteAligned = start % 8 === 0;
  const isEndByteAligned = end % 8 === 0;

  // If the slice is byte-aligned then there is no need to handle unaligned
  // slices, meaning a simpler and faster implementation can be used instead
  if (isStartByteAligned && isEndByteAligned) {
    return intFromAlignedSlice(
      bitArray,
      start / 8,
      end / 8,
      isBigEndian,
      isSigned,
    );
  }

  const size = end - start;

  const startByteIndex = Math.trunc(start / 8);
  const endByteIndex = Math.trunc((end - 1) / 8);

  // Handle the case of the slice being completely contained in a single byte
  if (startByteIndex == endByteIndex) {
    const mask = 0xff >> start % 8;
    const unusedLowBitCount = (8 - (end % 8)) % 8;

    let value =
      (bitArray.rawBuffer[startByteIndex] & mask) >> unusedLowBitCount;

    // For signed integers, if the high bit is set reinterpret as two's
    // complement
    if (isSigned) {
      const highBit = 2 ** (size - 1);
      if (value >= highBit) {
        value -= highBit * 2;
      }
    }

    return value;
  }

  // The integer value to be read is not aligned and crosses at least one byte
  // boundary in the input array

  if (size <= 53) {
    return intFromUnalignedSliceUsingNumber(
      bitArray.rawBuffer,
      start,
      end,
      isBigEndian,
      isSigned,
    );
  } else {
    return intFromUnalignedSliceUsingBigInt(
      bitArray.rawBuffer,
      start,
      end,
      isBigEndian,
      isSigned,
    );
  }
}

/**
 * Joins the given segments into a new bit array, tightly packing them together.
 * Each segment must be one of the following types:
 *
 * - A `number`: A single byte value in the range 0-255. Values outside this
 *   range will be wrapped.
 * - A `Uint8Array`: A sequence of byte values of any length.
 * - A `BitArray`: A sequence of bits of any length, which may not be byte
 *   aligned.
 *
 * The bit size of the returned bit array will be the sum of the size in bits
 * of the input segments.
 *
 * @param {(number | Uint8Array | BitArray)[]} segments
 * @returns {BitArray}
 */
export function toBitArray(segments) {
  if (segments.length === 0) {
    return new BitArray(new Uint8Array());
  }

  if (segments.length === 1) {
    const segment = segments[0];

    // When there is a single BitArray segment it can be returned as-is
    if (segment instanceof BitArray) {
      return segment;
    }

    // When there is a single Uint8Array segment, pass it directly to the bit
    // array constructor to avoid a copy
    if (segment instanceof Uint8Array) {
      return new BitArray(segment);
    }

    return new BitArray(new Uint8Array(/** @type {number[]} */ (segments)));
  }

  // Count the total number of bits and check if all segments are numbers, i.e.
  // single bytes
  let bitSize = 0;
  let areAllSegmentsNumbers = true;
  for (const segment of segments) {
    if (segment instanceof BitArray) {
      bitSize += segment.bitSize;
      areAllSegmentsNumbers = false;
    } else if (segment instanceof Uint8Array) {
      bitSize += segment.byteLength * 8;
      areAllSegmentsNumbers = false;
    } else {
      bitSize += 8;
    }
  }

  // If all segments are numbers then pass the segments array directly to the
  // Uint8Array constructor
  if (areAllSegmentsNumbers) {
    return new BitArray(new Uint8Array(/** @type {number[]} */ (segments)));
  }

  // Pack the segments into a Uint8Array
  const buffer = new Uint8Array(Math.trunc((bitSize + 7) / 8));

  // The current write position in bits into the above array. Byte-aligned
  // segments, i.e. when the cursor is a multiple of 8, are able to be processed
  // faster due to being able to copy bytes directly.
  let cursor = 0;

  for (let segment of segments) {
    const isCursorByteAligned = cursor % 8 === 0;

    if (segment instanceof BitArray) {
      if (isCursorByteAligned && segment.bitOffset === 0) {
        buffer.set(segment.rawBuffer, cursor / 8);
        cursor += segment.bitSize;

        // Zero any unused bits in the last byte of the buffer. Their content is
        // undefined and shouldn't be included in the output.
        const trailingBitsCount = segment.bitSize % 8;
        if (trailingBitsCount !== 0) {
          const lastByteIndex = Math.trunc(cursor / 8);
          buffer[lastByteIndex] >>= 8 - trailingBitsCount;
          buffer[lastByteIndex] <<= 8 - trailingBitsCount;
        }
      } else {
        appendUnalignedBits(
          segment.rawBuffer,
          segment.bitSize,
          segment.bitOffset,
        );
      }
    } else if (segment instanceof Uint8Array) {
      if (isCursorByteAligned) {
        buffer.set(segment, cursor / 8);
        cursor += segment.byteLength * 8;
      } else {
        appendUnalignedBits(segment, segment.byteLength * 8, 0);
      }
    } else {
      if (isCursorByteAligned) {
        buffer[cursor / 8] = segment;
        cursor += 8;
      } else {
        appendUnalignedBits(new Uint8Array([segment]), 8, 0);
      }
    }
  }

  function appendUnalignedBits(unalignedBits, size, offset) {
    if (size === 0) {
      return;
    }

    const byteSize = Math.trunc(size + 7 / 8);

    const highBitsCount = cursor % 8;
    const lowBitsCount = 8 - highBitsCount;

    let byteIndex = Math.trunc(cursor / 8);

    for (let i = 0; i < byteSize; i++) {
      let byte = bitArrayByteAt(unalignedBits, offset, i);

      // If this is a partial byte then zero out the trailing bits as their
      // content is undefined and shouldn't be included in the output
      if (size < 8) {
        byte >>= 8 - size;
        byte <<= 8 - size;
      }

      // Copy the high bits of the input byte to the low bits of the current
      // output byte
      buffer[byteIndex] |= byte >> highBitsCount;

      let appendedBitsCount = size - Math.max(0, size - lowBitsCount);
      size -= appendedBitsCount;
      cursor += appendedBitsCount;

      if (size === 0) {
        break;
      }

      // Copy the low bits of the input byte to the high bits of the next output
      // byte
      buffer[++byteIndex] = byte << lowBitsCount;
      appendedBitsCount = size - Math.max(0, size - highBitsCount);
      size -= appendedBitsCount;
      cursor += appendedBitsCount;
    }
  }

  return new BitArray(buffer, bitSize);
}

/**
 * Encodes a floating point value into a `Uint8Array`. This is used to create
 * float segments that are part of bit array expressions.
 *
 * @param {number} value
 * @param {number} size
 * @param {boolean} isBigEndian
 * @returns {Uint8Array}
 */
export function sizedFloat(value, size, isBigEndian) {
  if (size !== 16 && size !== 32 && size !== 64) {
    const msg = `Sized floats must be 16-bit, 32-bit or 64-bit, got size of ${size} bits`;
    throw new globalThis.Error(msg);
  }

  if (size === 16) {
    return numberToFp16Uint(value, isBigEndian);
  }

  const buffer = new Uint8Array(size / 8);

  const view = new DataView(buffer.buffer);

  if (size == 64) {
    view.setFloat64(0, value, !isBigEndian);
  } else {
    view.setFloat32(0, value, !isBigEndian);
  }

  return buffer;
}

/**
 * Encodes an integer value into a `Uint8Array`, or a `BitArray` if the size in
 * bits is not a multiple of 8. This is used to create integer segments used in
 * bit array expressions.
 *
 * @param {number} value
 * @param {number} size
 * @param {boolean} isBigEndian
 * @returns {Uint8Array | BitArray}
 */
export function sizedInt(value, size, isBigEndian) {
  if (size <= 0) {
    return new Uint8Array();
  }

  // Fast path when size is 8 bits. This relies on the rounding behavior of the
  // Uint8Array constructor.
  if (size === 8) {
    return new Uint8Array([value]);
  }

  // Fast path when size is less than 8 bits: shift the value up to the high
  // bits
  if (size < 8) {
    value <<= 8 - size;
    return new BitArray(new Uint8Array([value]), size);
  }

  // Allocate output buffer
  const buffer = new Uint8Array(Math.trunc((size + 7) / 8));

  // The number of trailing bits in the final byte. Will be zero if the size is
  // an exact number of bytes.
  const trailingBitsCount = size % 8;

  // The number of unused bits in the final byte of the buffer
  const unusedBitsCount = 8 - trailingBitsCount;

  // For output sizes not exceeding 32 bits the number type is used. For larger
  // output sizes the BigInt type is needed.
  //
  // The code in each of these two paths must be kept in sync.
  if (size <= 32) {
    if (isBigEndian) {
      let i = buffer.length - 1;

      // Set the trailing bits at the end of the output buffer
      if (trailingBitsCount) {
        buffer[i--] = (value << unusedBitsCount) & 0xff;
        value >>= trailingBitsCount;
      }

      for (; i >= 0; i--) {
        buffer[i] = value;
        value >>= 8;
      }
    } else {
      let i = 0;

      const wholeByteCount = Math.trunc(size / 8);
      for (; i < wholeByteCount; i++) {
        buffer[i] = value;
        value >>= 8;
      }

      // Set the trailing bits at the end of the output buffer
      if (trailingBitsCount) {
        buffer[i] = value << unusedBitsCount;
      }
    }
  } else {
    const bigTrailingBitsCount = BigInt(trailingBitsCount);
    const bigUnusedBitsCount = BigInt(unusedBitsCount);

    let bigValue = BigInt(value);

    if (isBigEndian) {
      let i = buffer.length - 1;

      // Set the trailing bits at the end of the output buffer
      if (trailingBitsCount) {
        buffer[i--] = Number(bigValue << bigUnusedBitsCount);
        bigValue >>= bigTrailingBitsCount;
      }

      for (; i >= 0; i--) {
        buffer[i] = Number(bigValue);
        bigValue >>= 8n;
      }
    } else {
      let i = 0;

      const wholeByteCount = Math.trunc(size / 8);
      for (; i < wholeByteCount; i++) {
        buffer[i] = Number(bigValue);
        bigValue >>= 8n;
      }

      // Set the trailing bits at the end of the output buffer
      if (trailingBitsCount) {
        buffer[i] = Number(bigValue << bigUnusedBitsCount);
      }
    }
  }

  // Integers that aren't a whole number of bytes are returned as a BitArray so
  // their size in bits is tracked
  if (trailingBitsCount) {
    return new BitArray(buffer, size);
  }

  return buffer;
}

/**
 * Reads an aligned slice of any size as an integer.
 *
 * @param {BitArray} bitArray
 * @param {number} start
 * @param {number} end
 * @param {boolean} isBigEndian
 * @param {boolean} isSigned
 * @returns {number}
 */
function intFromAlignedSlice(bitArray, start, end, isBigEndian, isSigned) {
  const byteSize = end - start;

  if (byteSize <= 6) {
    return intFromAlignedSliceUsingNumber(
      bitArray.rawBuffer,
      start,
      end,
      isBigEndian,
      isSigned,
    );
  } else {
    return intFromAlignedSliceUsingBigInt(
      bitArray.rawBuffer,
      start,
      end,
      isBigEndian,
      isSigned,
    );
  }
}

/**
 * Reads an aligned slice up to 48 bits in size as an integer. Uses the
 * JavaScript `number` type internally.
 *
 * @param {Uint8Array} buffer
 * @param {number} start
 * @param {number} end
 * @param {boolean} isBigEndian
 * @param {boolean} isSigned
 * @returns {number}
 */
function intFromAlignedSliceUsingNumber(
  buffer,
  start,
  end,
  isBigEndian,
  isSigned,
) {
  const byteSize = end - start;

  let value = 0;

  // Read bytes as an unsigned integer
  if (isBigEndian) {
    for (let i = start; i < end; i++) {
      value *= 256;
      value += buffer[i];
    }
  } else {
    for (let i = end - 1; i >= start; i--) {
      value *= 256;
      value += buffer[i];
    }
  }

  // For signed integers, if the high bit is set reinterpret as two's
  // complement
  if (isSigned) {
    const highBit = 2 ** (byteSize * 8 - 1);
    if (value >= highBit) {
      value -= highBit * 2;
    }
  }

  return value;
}

/**
 * Reads an aligned slice of any size as an integer. Uses the JavaScript
 * `BigInt` type internally.
 *
 * @param {Uint8Array} buffer
 * @param {number} start
 * @param {number} end
 * @param {boolean} isBigEndian
 * @param {boolean} isSigned
 * @returns {number}
 */
function intFromAlignedSliceUsingBigInt(
  buffer,
  start,
  end,
  isBigEndian,
  isSigned,
) {
  const byteSize = end - start;

  let value = 0n;

  // Read bytes as an unsigned integer value
  if (isBigEndian) {
    for (let i = start; i < end; i++) {
      value *= 256n;
      value += BigInt(buffer[i]);
    }
  } else {
    for (let i = end - 1; i >= start; i--) {
      value *= 256n;
      value += BigInt(buffer[i]);
    }
  }

  // For signed integers, if the high bit is set reinterpret as two's
  // complement
  if (isSigned) {
    const highBit = 1n << BigInt(byteSize * 8 - 1);
    if (value >= highBit) {
      value -= highBit * 2n;
    }
  }

  // Convert the result into a JS number. This may cause quantizing/error on
  // values outside JavaScript's safe integer range.
  return Number(value);
}

/**
 * Reads an unaligned slice up to 53 bits in size as an integer. Uses the
 * JavaScript `number` type internally.
 *
 * This function assumes that the slice crosses at least one byte boundary in
 * the input.
 *
 * @param {Uint8Array} buffer
 * @param {number} start
 * @param {number} end
 * @param {boolean} isBigEndian
 * @param {boolean} isSigned
 * @returns {number}
 */
function intFromUnalignedSliceUsingNumber(
  buffer,
  start,
  end,
  isBigEndian,
  isSigned,
) {
  const isStartByteAligned = start % 8 === 0;

  let size = end - start;
  let byteIndex = Math.trunc(start / 8);

  let value = 0;

  if (isBigEndian) {
    // Read any leading bits
    if (!isStartByteAligned) {
      const leadingBitsCount = 8 - (start % 8);
      value = buffer[byteIndex++] & ((1 << leadingBitsCount) - 1);
      size -= leadingBitsCount;
    }

    // Read any whole bytes
    while (size >= 8) {
      value *= 256;
      value += buffer[byteIndex++];
      size -= 8;
    }

    // Read any trailing bits
    if (size > 0) {
      value *= 2 ** size;
      value += buffer[byteIndex] >> (8 - size);
    }
  } else {
    // For little endian, if the start is aligned then whole bytes can be read
    // directly out of the input array, with the trailing bits handled at the
    // end
    if (isStartByteAligned) {
      let size = end - start;
      let scale = 1;

      // Read whole bytes
      while (size >= 8) {
        value += buffer[byteIndex++] * scale;
        scale *= 256;
        size -= 8;
      }

      // Read trailing bits
      value += (buffer[byteIndex] >> (8 - size)) * scale;
    } else {
      // Read little endian data where the start is not byte-aligned. This is
      // done by reading whole bytes that cross a byte boundary in the input
      // data, then reading any trailing bits.

      const highBitsCount = start % 8;
      const lowBitsCount = 8 - highBitsCount;

      let size = end - start;
      let scale = 1;

      // Extract whole bytes
      while (size >= 8) {
        const byte =
          (buffer[byteIndex] << highBitsCount) |
          (buffer[byteIndex + 1] >> lowBitsCount);

        value += (byte & 0xff) * scale;

        scale *= 256;
        size -= 8;
        byteIndex++;
      }

      // Read any trailing bits. These trailing bits may cross a byte boundary
      // in the input buffer.
      if (size > 0) {
        const lowBitsUsed = size - Math.max(0, size - lowBitsCount);

        let trailingByte =
          (buffer[byteIndex] & ((1 << lowBitsCount) - 1)) >>
          (lowBitsCount - lowBitsUsed);

        size -= lowBitsUsed;

        if (size > 0) {
          trailingByte *= 2 ** size;
          trailingByte += buffer[byteIndex + 1] >> (8 - size);
        }

        value += trailingByte * scale;
      }
    }
  }

  // For signed integers, if the high bit is set reinterpret as two's
  // complement
  if (isSigned) {
    const highBit = 2 ** (end - start - 1);
    if (value >= highBit) {
      value -= highBit * 2;
    }
  }

  return value;
}

/**
 * Reads an unaligned slice of any size as an integer. Uses the JavaScript
 * `BigInt` type internally.
 *
 * This function assumes that the slice crosses at least one byte boundary in
 * the input.
 *
 * @param {Uint8Array} buffer
 * @param {number} start
 * @param {number} end
 * @param {boolean} isBigEndian
 * @param {boolean} isSigned
 * @returns {number}
 */
function intFromUnalignedSliceUsingBigInt(
  buffer,
  start,
  end,
  isBigEndian,
  isSigned,
) {
  const isStartByteAligned = start % 8 === 0;

  let size = end - start;
  let byteIndex = Math.trunc(start / 8);

  let value = 0n;

  if (isBigEndian) {
    // Read any leading bits
    if (!isStartByteAligned) {
      const leadingBitsCount = 8 - (start % 8);
      value = BigInt(buffer[byteIndex++] & ((1 << leadingBitsCount) - 1));
      size -= leadingBitsCount;
    }

    // Read any whole bytes
    while (size >= 8) {
      value *= 256n;
      value += BigInt(buffer[byteIndex++]);
      size -= 8;
    }

    // Read any trailing bits
    if (size > 0) {
      value <<= BigInt(size);
      value += BigInt(buffer[byteIndex] >> (8 - size));
    }
  } else {
    // For little endian, if the start is aligned then whole bytes can be read
    // directly out of the input array, with the trailing bits handled at the
    // end
    if (isStartByteAligned) {
      let size = end - start;
      let shift = 0n;

      // Read whole bytes
      while (size >= 8) {
        value += BigInt(buffer[byteIndex++]) << shift;
        shift += 8n;
        size -= 8;
      }

      // Read trailing bits
      value += BigInt(buffer[byteIndex] >> (8 - size)) << shift;
    } else {
      // Read little endian data where the start is not byte-aligned. This is
      // done by reading whole bytes that cross a byte boundary in the input
      // data, then reading any trailing bits.

      const highBitsCount = start % 8;
      const lowBitsCount = 8 - highBitsCount;

      let size = end - start;
      let shift = 0n;

      // Extract whole bytes
      while (size >= 8) {
        const byte =
          (buffer[byteIndex] << highBitsCount) |
          (buffer[byteIndex + 1] >> lowBitsCount);

        value += BigInt(byte & 0xff) << shift;

        shift += 8n;
        size -= 8;
        byteIndex++;
      }

      // Read any trailing bits. These trailing bits may cross a byte boundary
      // in the input buffer.
      if (size > 0) {
        const lowBitsUsed = size - Math.max(0, size - lowBitsCount);

        let trailingByte =
          (buffer[byteIndex] & ((1 << lowBitsCount) - 1)) >>
          (lowBitsCount - lowBitsUsed);

        size -= lowBitsUsed;

        if (size > 0) {
          trailingByte <<= size;
          trailingByte += buffer[byteIndex + 1] >> (8 - size);
        }

        value += BigInt(trailingByte) << shift;
      }
    }
  }

  // For signed integers, if the high bit is set reinterpret as two's
  // complement
  if (isSigned) {
    const highBit = 2n ** BigInt(end - start - 1);
    if (value >= highBit) {
      value -= highBit * 2n;
    }
  }

  // Convert the result into a JS number. This may cause quantizing/error on
  // values outside JavaScript's safe integer range.
  return Number(value);
}

/**
 * Interprets a 16-bit unsigned integer value as a 16-bit floating point value.
 *
 * @param {number} intValue
 * @returns {number}
 */
function fp16UintToNumber(intValue) {
  const sign = intValue >= 0x8000 ? -1 : 1;
  const exponent = (intValue & 0x7c00) >> 10;
  const fraction = intValue & 0x03ff;

  let value;
  if (exponent === 0) {
    value = 6.103515625e-5 * (fraction / 0x400);
  } else if (exponent === 0x1f) {
    value = fraction === 0 ? Infinity : NaN;
  } else {
    value = Math.pow(2, exponent - 15) * (1 + fraction / 0x400);
  }

  return sign * value;
}

/**
 * Converts a floating point number to bytes for a 16-bit floating point value.
 *
 * @param {number} intValue
 * @param {boolean} isBigEndian
 * @returns {Uint8Array}
 */
function numberToFp16Uint(value, isBigEndian) {
  const buffer = new Uint8Array(2);

  if (isNaN(value)) {
    buffer[1] = 0x7e;
  } else if (value === Infinity) {
    buffer[1] = 0x7c;
  } else if (value === -Infinity) {
    buffer[1] = 0xfc;
  } else if (value === 0) {
    // Both values are already zero
  } else {
    const sign = value < 0 ? 1 : 0;
    value = Math.abs(value);

    let exponent = Math.floor(Math.log2(value));
    let fraction = value / Math.pow(2, exponent) - 1;

    exponent += 15;

    if (exponent <= 0) {
      exponent = 0;
      fraction = value / Math.pow(2, -14);
    } else if (exponent >= 31) {
      exponent = 31;
      fraction = 0;
    }

    fraction = Math.round(fraction * 1024);

    buffer[1] =
      (sign << 7) | ((exponent & 0x1f) << 2) | ((fraction >> 8) & 0x03);
    buffer[0] = fraction & 0xff;
  }

  if (isBigEndian) {
    const a = buffer[0];
    buffer[0] = buffer[1];
    buffer[1] = a;
  }

  return buffer;
}

/**
 * Throws an exception if the given start and end values are out of bounds for
 * a bit array.
 *
 * @param {BitArray} bitArray
 * @param {number} start
 * @param {number} end
 */
function bitArrayValidateRange(bitArray, start, end) {
  if (
    start < 0 ||
    start > bitArray.bitSize ||
    end < start ||
    end > bitArray.bitSize
  ) {
    const msg =
      `Invalid bit array slice: start = ${start}, end = ${end}, ` +
      `bit size = ${bitArray.bitSize}`;
    throw new globalThis.Error(msg);
  }
}

/** @type {TextEncoder | undefined} */
let utf8Encoder;

/**
 * Returns the UTF-8 bytes for a string.
 *
 * @param {string} string
 * @returns {Uint8Array}
 */
export function stringBits(string) {
  utf8Encoder ??= new TextEncoder();
  return utf8Encoder.encode(string);
}

/**
 * Returns the UTF-8 bytes for a single UTF codepoint.
 *
 * @param {UtfCodepoint} codepoint
 * @returns {Uint8Array}
 */
export function codepointBits(codepoint) {
  return stringBits(String.fromCodePoint(codepoint.value));
}

/**
 * Returns the UTF-16 bytes for a string.
 *
 * @param {string} string
 * @param {boolean} isBigEndian
 * @returns {Uint8Array}
 */
export function stringToUtf16(string, isBigEndian) {
  const buffer = new ArrayBuffer(string.length * 2);
  const bufferView = new DataView(buffer);

  for (let i = 0; i < string.length; i++) {
    bufferView.setUint16(i * 2, string.charCodeAt(i), !isBigEndian);
  }

  return new Uint8Array(buffer);
}

/**
 * Returns the UTF-16 bytes for a single UTF codepoint.
 *
 * @param {UtfCodepoint} codepoint
 * @param {boolean} isBigEndian
 * @returns {Uint8Array}
 */
export function codepointToUtf16(codepoint, isBigEndian) {
  return stringToUtf16(String.fromCodePoint(codepoint.value), isBigEndian);
}

/**
 * Returns the UTF-32 bytes for a string.
 *
 * @param {string} string
 * @param {boolean} isBigEndian
 * @returns {Uint8Array}
 */
export function stringToUtf32(string, isBigEndian) {
  const buffer = new ArrayBuffer(string.length * 4);
  const bufferView = new DataView(buffer);
  let length = 0;

  for (let i = 0; i < string.length; i++) {
    const codepoint = string.codePointAt(i);

    bufferView.setUint32(length * 4, codepoint, !isBigEndian);
    length++;

    if (codepoint > 0xffff) {
      i++;
    }
  }

  return new Uint8Array(buffer.slice(0, length * 4));
}

/**
 * Returns the UTF-32 bytes for a single UTF codepoint.
 *
 * @param {UtfCodepoint} codepoint
 * @param {boolean} isBigEndian
 * @returns {Uint8Array}
 */
export function codepointToUtf32(codepoint, isBigEndian) {
  return stringToUtf32(String.fromCodePoint(codepoint.value), isBigEndian);
}

export class Result extends CustomType {
  static isResult(data) {
    return data instanceof Result;
  }
}

export class Ok extends Result {
  constructor(value) {
    super();
    this[0] = value;
  }

  isOk() {
    return true;
  }
}
export const Result$Ok = (value) => new Ok(value);
export const Result$isOk = (value) => value instanceof Ok;
export const Result$Ok$0 = (value) => value[0];

export class Error extends Result {
  constructor(detail) {
    super();
    this[0] = detail;
  }

  isOk() {
    return false;
  }
}
export const Result$Error = (detail) => new Error(detail);
export const Result$isError = (value) => value instanceof Error;
export const Result$Error$0 = (value) => value[0];

export function isEqual(x, y) {
  let values = [x, y];

  while (values.length) {
    let a = values.pop();
    let b = values.pop();
    if (a === b) continue;

    if (!isObject(a) || !isObject(b)) return false;
    let unequal =
      !structurallyCompatibleObjects(a, b) ||
      unequalDates(a, b) ||
      unequalBuffers(a, b) ||
      unequalArrays(a, b) ||
      unequalMaps(a, b) ||
      unequalSets(a, b) ||
      unequalRegExps(a, b);
    if (unequal) return false;

    const proto = Object.getPrototypeOf(a);
    if (proto !== null && typeof proto.equals === "function") {
      try {
        if (a.equals(b)) continue;
        else return false;
      } catch {}
    }

    let [keys, get] = getters(a);
    const ka = keys(a);
    const kb = keys(b);
    if (ka.length !== kb.length) return false;
    for (let k of ka) {
      values.push(get(a, k), get(b, k));
    }
  }

  return true;
}

function getters(object) {
  if (object instanceof Map) {
    return [(x) => x.keys(), (x, y) => x.get(y)];
  } else {
    let extra = object instanceof globalThis.Error ? ["message"] : [];
    return [(x) => [...extra, ...Object.keys(x)], (x, y) => x[y]];
  }
}

function unequalDates(a, b) {
  return a instanceof Date && (a > b || a < b);
}

function unequalBuffers(a, b) {
  return (
    !(a instanceof BitArray) &&
    a.buffer instanceof ArrayBuffer &&
    a.BYTES_PER_ELEMENT &&
    !(a.byteLength === b.byteLength && a.every((n, i) => n === b[i]))
  );
}

function unequalArrays(a, b) {
  return Array.isArray(a) && a.length !== b.length;
}

function unequalMaps(a, b) {
  return a instanceof Map && a.size !== b.size;
}

function unequalSets(a, b) {
  return (
    a instanceof Set && (a.size != b.size || [...a].some((e) => !b.has(e)))
  );
}

function unequalRegExps(a, b) {
  return a instanceof RegExp && (a.source !== b.source || a.flags !== b.flags);
}

function isObject(a) {
  return typeof a === "object" && a !== null;
}

function structurallyCompatibleObjects(a, b) {
  if (typeof a !== "object" && typeof b !== "object" && (!a || !b))
    return false;

  let nonstructural = [Promise, WeakSet, WeakMap, Function];
  if (nonstructural.some((c) => a instanceof c)) return false;

  return a.constructor === b.constructor;
}

export function remainderInt(a, b) {
  if (b === 0) {
    return 0;
  } else {
    return a % b;
  }
}

export function divideInt(a, b) {
  return Math.trunc(divideFloat(a, b));
}

export function divideFloat(a, b) {
  if (b === 0) {
    return 0;
  } else {
    return a / b;
  }
}

export function makeError(variant, file, module, line, fn, message, extra) {
  let error = new globalThis.Error(message);
  error.gleam_error = variant;
  error.file = file;
  error.module = module;
  error.line = line;
  error.function = fn;
  // TODO: Remove this with Gleam v2.0.0
  error.fn = fn;
  for (let k in extra) error[k] = extra[k];
  return error;
}
