'use strict'

/**
 * @typedef ReadEscapeSequenceResult
 * @property {number} endPos The position in the buffer that marks the end of
 * the escape sequence.
 * @property {Buffer} parsed The parsed escape sequence as a buffer of bytes.
 */

/**
 * Read an escape sequence from a buffer. It reads until no escape sequences
 * are found. Thus, a sequence of escape sequences will all be parsed at once
 * and returned as a single result.
 *
 * @example A Single ASCII Sequence
 * const toParse = Buffer.from('foo\\#bar', 'utf8')
 * const {parsed, endPos} = readEscapeSequence({
 *   searchBuffer: toParse,
 *   startPos: 3
 * })
 * // => parsed = '#', endPos = 5
 *
 * @example Multiple ASCII Sequences In Succession
 * const toParse = Buffer.from('foo\\#\\!bar', 'utf8')
 * const {parsed, endPos} = readEscapeSequence({
 *   searchBuffer: toParse,
 *   startPos: 3
 * })
 * // => parsed = '#!', endPos = 7
 *
 * @param searchBuffer
 * @param startPos
 *
 * @returns {ReadEscapeSequenceResult}
 *
 * @throws When an escaped sequence is not a valid hexadecimal value.
 */
module.exports = function readEscapeSequence ({ searchBuffer, startPos }) {
  // This is very similar to the `readEscapedCharacters` algorithm in
  // the `utils/escape-filter-value` in `@ldapjs/filter`. The difference being
  // that here we want to interpret the escape sequence instead of return it
  // as a string to be embedded in an "escaped" string.
  // https://github.com/ldapjs/filter/blob/1423612/lib/utils/escape-filter-value.js

  let pos = startPos
  const buf = []

  while (pos < searchBuffer.byteLength) {
    const char = searchBuffer[pos]
    const nextChar = searchBuffer[pos + 1]

    if (char !== 0x5c) {
      // End of sequence reached.
      break
    }

    const strHexCode = String.fromCharCode(nextChar) +
      String.fromCharCode(searchBuffer[pos + 2])
    const hexCode = parseInt(strHexCode, 16)
    if (Number.isNaN(hexCode) === true) {
      if (nextChar >= 0x00 && nextChar <= 0x7f) {
        // Sequence is a single escaped ASCII character
        buf.push(nextChar)
        pos += 2
        continue
      } else {
        throw Error('invalid hex code in escape sequence')
      }
    }

    if (hexCode >= 0xc0 && hexCode <= 0xdf) {
      // Sequence is a 2-byte utf-8 character.
      const secondByte = parseInt(
        String.fromCharCode(searchBuffer[pos + 4]) +
        String.fromCharCode(searchBuffer[pos + 5]),
        16
      )
      buf.push(hexCode)
      buf.push(secondByte)
      pos += 6
      continue
    }

    if (hexCode >= 0xe0 && hexCode <= 0xef) {
      // Sequence is a 3-byte utf-8 character.
      const secondByte = parseInt(
        String.fromCharCode(searchBuffer[pos + 4]) +
        String.fromCharCode(searchBuffer[pos + 5]),
        16
      )
      const thirdByte = parseInt(
        String.fromCharCode(searchBuffer[pos + 7]) +
        String.fromCharCode(searchBuffer[pos + 8]),
        16
      )
      buf.push(hexCode)
      buf.push(secondByte)
      buf.push(thirdByte)
      pos += 9
      continue
    }

    if (hexCode >= 0xf0 && hexCode <= 0xf7) {
      // Sequence is a 4-byte utf-8 character.
      const secondByte = parseInt(
        String.fromCharCode(searchBuffer[pos + 4]) +
        String.fromCharCode(searchBuffer[pos + 5]),
        16
      )
      const thirdByte = parseInt(
        String.fromCharCode(searchBuffer[pos + 7]) +
        String.fromCharCode(searchBuffer[pos + 8]),
        16
      )
      const fourthByte = parseInt(
        String.fromCharCode(searchBuffer[pos + 10]) +
        String.fromCharCode(searchBuffer[pos + 11]),
        16
      )
      buf.push(hexCode)
      buf.push(secondByte)
      buf.push(thirdByte)
      buf.push(fourthByte)
      pos += 12
      continue
    }

    // The escaped character should be a single hex value.
    buf.push(hexCode)
    pos += 3
  }

  return {
    endPos: pos,
    parsed: Buffer.from(buf)
  }
}