export type SourceMapSegment =
  | [number]
  | [number, number, number, number]
  | [number, number, number, number, number];
export type SourceMapLine = SourceMapSegment[];
export type SourceMapMappings = SourceMapLine[];

const comma = ','.charCodeAt(0);
const semicolon = ';'.charCodeAt(0);
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
const intToChar = new Uint8Array(64); // 64 possible chars.
const charToInt = new Uint8Array(128); // z is 122 in ASCII

for (let i = 0; i < chars.length; i++) {
  const c = chars.charCodeAt(i);
  intToChar[i] = c;
  charToInt[c] = i;
}

// Provide a fallback for older environments.
const td =
  typeof TextDecoder !== 'undefined'
    ? /* #__PURE__ */ new TextDecoder()
    : typeof Buffer !== 'undefined'
    ? {
        decode(buf: Uint8Array) {
          const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
          return out.toString();
        },
      }
    : {
        decode(buf: Uint8Array) {
          let out = '';
          for (let i = 0; i < buf.length; i++) {
            out += String.fromCharCode(buf[i]);
          }
          return out;
        },
      };

export function decode(mappings: string): SourceMapMappings {
  const state: [number, number, number, number, number] = new Int32Array(5) as any;
  const decoded: SourceMapMappings = [];

  let index = 0;
  do {
    const semi = indexOf(mappings, index);
    const line: SourceMapLine = [];
    let sorted = true;
    let lastCol = 0;
    state[0] = 0;

    for (let i = index; i < semi; i++) {
      let seg: SourceMapSegment;

      i = decodeInteger(mappings, i, state, 0); // genColumn
      const col = state[0];
      if (col < lastCol) sorted = false;
      lastCol = col;

      if (hasMoreVlq(mappings, i, semi)) {
        i = decodeInteger(mappings, i, state, 1); // sourcesIndex
        i = decodeInteger(mappings, i, state, 2); // sourceLine
        i = decodeInteger(mappings, i, state, 3); // sourceColumn

        if (hasMoreVlq(mappings, i, semi)) {
          i = decodeInteger(mappings, i, state, 4); // namesIndex
          seg = [col, state[1], state[2], state[3], state[4]];
        } else {
          seg = [col, state[1], state[2], state[3]];
        }
      } else {
        seg = [col];
      }

      line.push(seg);
    }

    if (!sorted) sort(line);
    decoded.push(line);
    index = semi + 1;
  } while (index <= mappings.length);

  return decoded;
}

function indexOf(mappings: string, index: number): number {
  const idx = mappings.indexOf(';', index);
  return idx === -1 ? mappings.length : idx;
}

function decodeInteger(mappings: string, pos: number, state: SourceMapSegment, j: number): number {
  let value = 0;
  let shift = 0;
  let integer = 0;

  do {
    const c = mappings.charCodeAt(pos++);
    integer = charToInt[c];
    value |= (integer & 31) << shift;
    shift += 5;
  } while (integer & 32);

  const shouldNegate = value & 1;
  value >>>= 1;

  if (shouldNegate) {
    value = -0x80000000 | -value;
  }

  state[j] += value;
  return pos;
}

function hasMoreVlq(mappings: string, i: number, length: number): boolean {
  if (i >= length) return false;
  return mappings.charCodeAt(i) !== comma;
}

function sort(line: SourceMapSegment[]) {
  line.sort(sortComparator);
}

function sortComparator(a: SourceMapSegment, b: SourceMapSegment): number {
  return a[0] - b[0];
}

export function encode(decoded: SourceMapMappings): string;
export function encode(decoded: Readonly<SourceMapMappings>): string;
export function encode(decoded: Readonly<SourceMapMappings>): string {
  const state: [number, number, number, number, number] = new Int32Array(5) as any;
  const bufLength = 1024 * 16;
  const subLength = bufLength - 36;
  const buf = new Uint8Array(bufLength);
  const sub = buf.subarray(0, subLength);
  let pos = 0;
  let out = '';

  for (let i = 0; i < decoded.length; i++) {
    const line = decoded[i];
    if (i > 0) {
      if (pos === bufLength) {
        out += td.decode(buf);
        pos = 0;
      }
      buf[pos++] = semicolon;
    }
    if (line.length === 0) continue;

    state[0] = 0;

    for (let j = 0; j < line.length; j++) {
      const segment = line[j];
      // We can push up to 5 ints, each int can take at most 7 chars, and we
      // may push a comma.
      if (pos > subLength) {
        out += td.decode(sub);
        buf.copyWithin(0, subLength, pos);
        pos -= subLength;
      }
      if (j > 0) buf[pos++] = comma;

      pos = encodeInteger(buf, pos, state, segment, 0); // genColumn

      if (segment.length === 1) continue;
      pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
      pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
      pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn

      if (segment.length === 4) continue;
      pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
    }
  }

  return out + td.decode(buf.subarray(0, pos));
}

function encodeInteger(
  buf: Uint8Array,
  pos: number,
  state: SourceMapSegment,
  segment: SourceMapSegment,
  j: number,
): number {
  const next = segment[j];
  let num = next - state[j];
  state[j] = next;

  num = num < 0 ? (-num << 1) | 1 : num << 1;
  do {
    let clamped = num & 0b011111;
    num >>>= 5;
    if (num > 0) clamped |= 0b100000;
    buf[pos++] = intToChar[clamped];
  } while (num > 0);

  return pos;
}