cdef enum:
    NO_EXTRA_DATA = 0x0011_0000


cdef void _skip_single_line(ReaderRef reader):
    cdef uint32_t c0
    while _reader_good(reader):
        c0 = _reader_get(reader)
        if _is_line_terminator(c0):
            break


cdef boolean _skip_multiline_comment(ReaderRef reader) except False:
    cdef uint32_t c0
    cdef boolean seen_asterisk = False
    cdef Py_ssize_t comment_start = _reader_tell(reader)

    comment_start = _reader_tell(reader)

    seen_asterisk = False
    while True:
        if expect(not _reader_good(reader), False):
            break

        c0 = _reader_get(reader)
        if c0 == b'*':
            seen_asterisk = True
        elif seen_asterisk:
            if c0 == b'/':
                return True
            seen_asterisk = False

    _raise_unclosed(b'comment', comment_start)
    return False


#     data found
# -1: exhausted
# -2: exception
cdef int32_t _skip_to_data_sub(ReaderRef reader, uint32_t c0) except -2:
    cdef int32_t c1
    cdef boolean seen_slash

    seen_slash = False
    while True:
        if c0 == b'/':
            if seen_slash:
                _skip_single_line(reader)
                seen_slash = False
            else:
                seen_slash = True
        elif c0 == b'*':
            if expect(not seen_slash, False):
                _raise_stray_character('asterisk', _reader_tell(reader))

            _skip_multiline_comment(reader)
            seen_slash = False
        elif not _is_ws_zs(c0):
            c1 = cast_to_int32(c0)
            break
        elif expect(seen_slash, False):
            _raise_stray_character('slash', _reader_tell(reader))

        if not _reader_good(reader):
            c1 = -1
            break

        c0 = _reader_get(reader)

    if expect(seen_slash, False):
        _raise_stray_character('slash', _reader_tell(reader))

    return c1


#    data found
# -1 exhausted
# -2 exception
cdef int32_t _skip_to_data(ReaderRef reader) except -2:
    cdef uint32_t c0
    cdef int32_t c1
    if _reader_good(reader):
        c0 = _reader_get(reader)
        c1 = _skip_to_data_sub(reader, c0)
    else:
        c1 = -1
    return c1


cdef int32_t _get_hex_character(ReaderRef reader, Py_ssize_t length) except -1:
    cdef Py_ssize_t start
    cdef uint32_t c0
    cdef uint32_t result
    cdef Py_ssize_t index

    start = _reader_tell(reader)
    result = 0
    for index in range(length):
        result <<= 4
        if expect(not _reader_good(reader), False):
            _raise_unclosed(b'escape sequence', start)

        c0 = _reader_get(reader)
        if b'0' <= c0 <= b'9':
            result |= c0 - <uint32_t> b'0'
        elif b'a' <= c0 <= b'f':
            result |= c0 - <uint32_t> b'a' + 10
        elif b'A' <= c0 <= b'F':
            result |= c0 - <uint32_t> b'A' + 10
        else:
            _raise_expected_s('hexadecimal character', start, c0)

    if expect(result > 0x10ffff, False):
        _raise_expected_s('Unicode code point', start, result)

    return cast_to_int32(result)


# >=  0: character to append
cdef int32_t _get_escaped_unicode_maybe_surrogate(ReaderRef reader, Py_ssize_t start) except -1:
    cdef uint32_t c0
    cdef uint32_t c1

    c0 = cast_to_uint32(_get_hex_character(reader, 4))
    if expect(Py_UNICODE_IS_LOW_SURROGATE(c0), False):
        _raise_expected_s('high surrogate before low surrogate', start, c0)
    elif not Py_UNICODE_IS_HIGH_SURROGATE(c0):
        return c0

    _accept_string(reader, b'\\u')

    c1 = cast_to_uint32(_get_hex_character(reader, 4))
    if expect(not Py_UNICODE_IS_LOW_SURROGATE(c1), False):
        _raise_expected_s('low surrogate', start, c1)

    return Py_UNICODE_JOIN_SURROGATES(c0, c1)


# >=  0: character to append
#    -1: skip
# <  -1: -(next character + 1)
cdef int32_t _get_escape_sequence(ReaderRef reader,
                                  Py_ssize_t start) except 0x7ffffff:
    cdef uint32_t c0
    cdef uint32_t c1

    c0 = _reader_get(reader)
    if expect(not _reader_good(reader), False):
        _raise_unclosed(b'string', start)

    if c0 == b'b':
        return 0x0008
    elif c0 == b'f':
        return 0x000c
    elif c0 == b'n':
        return 0x000a
    elif c0 == b'r':
        return 0x000d
    elif c0 == b't':
        return 0x0009
    elif c0 == b'v':
        return 0x000b
    elif c0 == b'0':
        return 0x0000
    elif c0 == b'x':
        return _get_hex_character(reader, 2)
    elif c0 == b'u':
        return _get_escaped_unicode_maybe_surrogate(reader, start)
    elif c0 == b'U':
        return _get_hex_character(reader, 8)
    elif expect(b'1' <= c0 <= b'9', False):
        _raise_expected_s('escape sequence', start, c0)
        return -2
    elif _is_line_terminator(c0):
        if c0 != 0x000D:
            return -1

        c0 = _reader_get(reader)
        if c0 == 0x000A:
            return -1

        return -cast_to_int32(c0 + 1)
    else:
        return cast_to_int32(c0)


cdef object _decode_string_sub(ReaderRef reader, uint32_t delim,
                               Py_ssize_t start, uint32_t c0):
    cdef int32_t c1
    cdef StackHeapString[uint32_t] buf

    while True:
        if c0 == delim:
            break

        if expect(not _reader_good(reader), False):
            _raise_unclosed(b'string', start)

        if c0 != b'\\':
            buf.push_back(c0)
            c0 = _reader_get(reader)
            continue

        c1 = _get_escape_sequence(reader, start)
        if c1 >= -1:
            if expect(not _reader_good(reader), False):
                _raise_unclosed(b'string', start)

            if c1 >= 0:
                c0 = cast_to_uint32(c1)
                buf.push_back(c0)

            c0 = _reader_get(reader)
        else:
            c0 = cast_to_uint32(-(c1 + 1))

    return PyUnicode_FromKindAndData(
        PyUnicode_4BYTE_KIND, buf.data(), buf.size(),
    )


cdef object _decode_string(ReaderRef reader, int32_t *c_in_out):
    cdef uint32_t delim
    cdef uint32_t c0
    cdef int32_t c1
    cdef Py_ssize_t start
    cdef object result

    c1 = c_in_out[0]
    delim = cast_to_uint32(c1)
    start = _reader_tell(reader)

    if expect(not _reader_good(reader), False):
        _raise_unclosed(b'string', start)

    c0 = _reader_get(reader)
    result = _decode_string_sub(reader, delim, start, c0)

    c_in_out[0] = NO_EXTRA_DATA
    return result


cdef object _decode_number_leading_zero(ReaderRef reader, StackHeapString[char] &buf,
                                        int32_t *c_in_out):
    cdef uint32_t c0
    cdef int32_t c1
    cdef object pybuf

    if not _reader_good(reader):
        c_in_out[0] = -1
        return 0

    c0 = _reader_get(reader)
    if _is_x(c0):
        while True:
            if not _reader_good(reader):
                c1 = -1
                break

            c0 = _reader_get(reader)
            if _is_hexadecimal(c0):
                buf.push_back(<char> <unsigned char> c0)
            elif c0 != b'_':
                c1 = cast_to_int32(c0)
                break

        c_in_out[0] = c1
        pybuf = PyBytes_FromStringAndSize(buf.data(), buf.size())
        return int(pybuf, 16)
    elif c0 == b'.':
        buf.push_back(b'.')

        while True:
            if not _reader_good(reader):
                c1 = -1
                break

            c0 = _reader_get(reader)
            if _is_in_float_representation(c0):
                buf.push_back(<char> <unsigned char> c0)
            elif c0 != b'_':
                c1 = cast_to_int32(c0)
                break

        c_in_out[0] = c1
        pybuf = PyBytes_FromStringAndSize(buf.data(), buf.size())
        return float(pybuf)
    elif _is_e(c0):
        while True:
            if not _reader_good(reader):
                c1 = -1
                break

            c0 = _reader_get(reader)
            if _is_in_float_representation(c0):
                pass
            elif c0 == b'_':
                pass
            else:
                c1 = cast_to_int32(c0)
                break

        c_in_out[0] = c1
        return 0.0
    else:
        c1 = cast_to_int32(c0)
        c_in_out[0] = c1
        return 0


cdef object _decode_number_any(ReaderRef reader, StackHeapString[char] &buf,
                               int32_t *c_in_out):
    cdef uint32_t c0
    cdef int32_t c1
    cdef boolean is_float
    cdef object pybuf

    c1 = c_in_out[0]
    c0 = cast_to_uint32(c1)

    is_float = False
    while True:
        if _is_decimal(c0):
            pass
        elif _is_in_float_representation(c0):
            is_float = True
        elif c0 != b'_':
            c1 = cast_to_int32(c0)
            break

        if c0 != b'_':
            buf.push_back(<char> <unsigned char> c0)

        if not _reader_good(reader):
            c1 = -1
            break

        c0 = _reader_get(reader)

    c_in_out[0] = c1

    pybuf = PyBytes_FromStringAndSize(buf.data(), buf.size())
    if is_float:
        return float(pybuf)
    else:
        return int(pybuf, 10)


cdef object _decode_number(ReaderRef reader, int32_t *c_in_out):
    cdef uint32_t c0
    cdef int32_t c1
    cdef Py_ssize_t start
    cdef StackHeapString[char] buf

    c1 = c_in_out[0]
    c0 = cast_to_uint32(c1)

    if c0 == b'+':
        start = _reader_tell(reader)
        if expect(not _reader_good(reader), False):
            _raise_unclosed(b'number', start)

        c0 = _reader_get(reader)
        if c0 == b'I':
            _accept_string(reader, b'nfinity')
            c_in_out[0] = NO_EXTRA_DATA
            return CONST_POS_INF
        elif c0 == b'N':
            _accept_string(reader, b'aN')
            c_in_out[0] = NO_EXTRA_DATA
            return CONST_POS_NAN
    elif c0 == b'-':
        start = _reader_tell(reader)
        if expect(not _reader_good(reader), False):
            _raise_unclosed(b'number', start)

        c0 = _reader_get(reader)
        if c0 == b'I':
            _accept_string(reader, b'nfinity')
            c_in_out[0] = NO_EXTRA_DATA
            return CONST_NEG_INF
        elif c0 == b'N':
            _accept_string(reader, b'aN')
            c_in_out[0] = NO_EXTRA_DATA
            return CONST_NEG_NAN

        buf.push_back(b'-')

    if c0 == b'0':
        return _decode_number_leading_zero(reader, buf, c_in_out)
    else:
        c1 = cast_to_int32(c0)
        c_in_out[0] = c1
        return _decode_number_any(reader, buf, c_in_out)


#  1: done
#  0: data found
# -1: exception (exhausted)
cdef uint32_t _skip_comma(ReaderRef reader, Py_ssize_t start,
                          uint32_t terminator, const char *what,
                          int32_t *c_in_out) except -1:
    cdef int32_t c0
    cdef uint32_t c1
    cdef boolean needs_comma
    cdef uint32_t done

    c0 = c_in_out[0]
    c1 = cast_to_uint32(c0)

    needs_comma = True
    while True:
        c0 = _skip_to_data_sub(reader, c1)
        if c0 < 0:
            break

        c1 = cast_to_uint32(c0)
        if c1 == terminator:
            c_in_out[0] = NO_EXTRA_DATA
            return 1

        if c1 != b',':
            if expect(needs_comma, False):
                _raise_expected_sc(
                    'comma', terminator, _reader_tell(reader), c1,
                )
            c_in_out[0] = c0
            return 0

        if expect(not needs_comma, False):
            _raise_stray_character('comma', _reader_tell(reader))

        if expect(not _reader_good(reader), False):
            break

        c1 = _reader_get(reader)
        needs_comma = False

    _raise_unclosed(what, start)
    return -1


cdef unicode _decode_identifier_name(ReaderRef reader, int32_t *c_in_out):
    cdef int32_t c0
    cdef uint32_t c1
    cdef Py_ssize_t start
    cdef StackHeapString[uint32_t] buf

    start = _reader_tell(reader)

    c0 = c_in_out[0]
    c1 = cast_to_uint32(c0)
    if expect(not _is_identifier_start(c1), False):
        _raise_expected_s('IdentifierStart', _reader_tell(reader), c1)

    while True:
        if expect(c1 == b'\\', False):
            if not _reader_good(reader):
                _raise_unclosed('IdentifierName', start)
                break

            c1 = _reader_get(reader)
            if c1 == b'u':
                c1 = cast_to_uint32(_get_escaped_unicode_maybe_surrogate(reader, _reader_tell(reader)))
            elif c1 == b'U':
                c1 = cast_to_uint32(_get_hex_character(reader, 8))
            else:
                _raise_expected_s('UnicodeEscapeSequence', _reader_tell(reader), c1)

        buf.push_back(c1)

        if not _reader_good(reader):
            c0 = -1
            break

        c1 = _reader_get(reader)
        if not _is_identifier_part(c1):
            c0 = cast_to_int32(c1)
            break

    c_in_out[0] = c0
    return PyUnicode_FromKindAndData(
        PyUnicode_4BYTE_KIND, buf.data(), buf.size(),
    )


cdef boolean _decode_object(ReaderRef reader, dict result) except False:
    cdef int32_t c0
    cdef uint32_t c1
    cdef Py_ssize_t start
    cdef boolean done
    cdef object key
    cdef object value

    start = _reader_tell(reader)

    c0 = _skip_to_data(reader)
    if expect(c0 >= 0, True):
        c1 = cast_to_uint32(c0)
        if c1 == b'}':
            return True

        while True:
            if c1 in b'"\'':
                key = _decode_string(reader, &c0)
            else:
                key = _decode_identifier_name(reader, &c0)
            if expect(c0 < 0, False):
                break

            c1 = cast_to_uint32(c0)
            c0 = _skip_to_data_sub(reader, c1)
            if expect(c0 < 0, False):
                break

            c1 = cast_to_uint32(c0)
            if expect(c1 != b':', False):
                _raise_expected_s('colon', _reader_tell(reader), c1)

            if expect(not _reader_good(reader), False):
                break

            c0 = _skip_to_data(reader)
            if expect(c0 < 0, False):
                break

            try:
                value = _decode_recursive(reader, &c0)
            except _DecoderException as ex:
                PyDict_SetItem(result, key, (<_DecoderException> ex).result)
                raise

            if expect(c0 < 0, False):
                break

            PyDict_SetItem(result, key, value)

            done = _skip_comma(
                reader, start, <unsigned char>b'}', b'object', &c0,
            )
            if done:
                return True

            c1 = cast_to_uint32(c0)

    _raise_unclosed(b'object', start)
    return False


cdef boolean _decode_array(ReaderRef reader, list result) except False:
    cdef int32_t c0
    cdef uint32_t c1
    cdef Py_ssize_t start
    cdef boolean done
    cdef object value

    start = _reader_tell(reader)

    c0 = _skip_to_data(reader)
    if expect(c0 >= 0, True):
        c1 = cast_to_uint32(c0)
        if c1 == b']':
            return True

        while True:
            try:
                value = _decode_recursive(reader, &c0)
            except _DecoderException as ex:
                PyList_Append(result, (<_DecoderException> ex).result)
                raise

            if expect(c0 < 0, False):
                break

            PyList_Append(result, value)

            done = _skip_comma(
                reader, start, <unsigned char>b']', b'array', &c0,
            )
            if done:
                return True

    _raise_unclosed(b'array', start)


cdef boolean _accept_string(ReaderRef reader, const char *string) except False:
    cdef uint32_t c0
    cdef uint32_t c1
    cdef Py_ssize_t start

    start = _reader_tell(reader)
    while True:
        c0 = string[0]
        string += 1
        if not c0:
            break

        if expect(not _reader_good(reader), False):
            _raise_unclosed(b'literal', start)

        c1 = _reader_get(reader)
        if expect(c0 != c1, False):
            _raise_expected_c(c0, start, c1)

    return True


cdef object _decode_literal(ReaderRef reader, int32_t *c_in_out):
    cdef const char *tail
    cdef object result
    cdef uint32_t c0
    cdef int32_t c1

    c0 = cast_to_uint32(c_in_out[0])
    if c0 == b'n':
        tail = b'ull'
        result = None
    elif c0 == b't':
        tail = b'rue'
        result = True
    elif c0 == b'f':
        tail = b'alse'
        result = False
    elif c0 == b'I':
        tail = b'nfinity'
        result = CONST_POS_INF
    else:  # elif c0 == b'N':
        tail = b'aN'
        result = CONST_POS_NAN

    _accept_string(reader, tail)

    c_in_out[0] = NO_EXTRA_DATA
    return result


cdef object _decode_recursive_enter(ReaderRef reader, int32_t *c_in_out):
    cdef object result
    cdef int32_t c0
    cdef uint32_t c1

    c0 = c_in_out[0]
    c1 = cast_to_uint32(c0)

    _reader_enter(reader)
    try:
        if c1 == b'{':
            result = {}
            _decode_object(reader, result)
        else:
            result = []
            _decode_array(reader, result)
    except RecursionError:
        _raise_nesting(_reader_tell(reader), result)
    except _DecoderException as ex:
        (<_DecoderException> ex).result = result
        raise ex
    finally:
        _reader_leave(reader)

    c_in_out[0] = NO_EXTRA_DATA
    return result


cdef object _decoder_unknown(ReaderRef reader, int32_t *c_in_out):
    cdef int32_t c0
    cdef uint32_t c1
    cdef Py_ssize_t start

    c0 = c_in_out[0]
    c1 = cast_to_uint32(c0)
    start = _reader_tell(reader)

    _raise_expected_s('JSON5Value', start, c1)


cdef object _decode_recursive(ReaderRef reader, int32_t *c_in_out):
    cdef object (*decoder)(ReaderRef, int32_t*)
    cdef int32_t c0
    cdef uint32_t c1

    c0 = c_in_out[0]
    c1 = cast_to_uint32(c0)

    decoder = _decoder_unknown
    if c1 in b'ntfIN':
        decoder = _decode_literal
    elif c1 in b'\'"':
        decoder = _decode_string
    elif c1 in b'+-.0123456789':
        decoder = _decode_number
    elif c1 in b'{[':
        decoder = _decode_recursive_enter

    return decoder(reader, c_in_out)


cdef object _decode_all_sub(ReaderRef reader, boolean some):
    cdef Py_ssize_t start
    cdef int32_t c0
    cdef uint32_t c1
    cdef object result

    start = _reader_tell(reader)
    c0 = _skip_to_data(reader)
    if expect(c0 < 0, False):
        _raise_no_data(start)

    result = _decode_recursive(reader, &c0)
    try:
        if c0 < 0:
            pass
        elif not some:
            start = _reader_tell(reader)
            c1 = cast_to_uint32(c0)
            c0 = _skip_to_data_sub(reader, c1)
            if expect(c0 >= 0, False):
                c1 = cast_to_uint32(c0)
                _raise_extra_data(c1, start)
        elif expect(not _is_ws_zs(c0), False):
            start = _reader_tell(reader)
            c1 = cast_to_uint32(c0)
            _raise_unframed_data(c1, start)
    except _DecoderException as ex:
        (<_DecoderException> ex).result = result
        raise ex

    return result


cdef object _decode_all(ReaderRef reader, boolean some):
    cdef Exception ex_result
    cdef _DecoderException ex
    try:
        return _decode_all_sub(reader, some)
    except _DecoderException as e:
        ex = <_DecoderException> e
        ex_result = ex.cls(ex.msg, ex.result, ex.extra)
    raise ex_result


cdef object _decode_ucs1(const void *string, Py_ssize_t length,
                         Py_ssize_t maxdepth, boolean some):
    cdef ReaderUCS1 reader = ReaderUCS1(
        ReaderUCS(length, 0, maxdepth),
        <const Py_UCS1*> string,
    )
    return _decode_all(reader, some)


cdef object _decode_ucs2(const void *string, Py_ssize_t length,
                         Py_ssize_t maxdepth, boolean some):
    cdef ReaderUCS2 reader = ReaderUCS2(
        ReaderUCS(length, 0, maxdepth),
        <const Py_UCS2*> string,
    )
    return _decode_all(reader, some)


cdef object _decode_ucs4(const void *string, Py_ssize_t length,
                         Py_ssize_t maxdepth, boolean some):
    cdef ReaderUCS4 reader = ReaderUCS4(
        ReaderUCS(length, 0, maxdepth),
        <const Py_UCS4*> string,
    )
    return _decode_all(reader, some)


cdef object _decode_unicode(object data, Py_ssize_t maxdepth, boolean some):
    cdef Py_ssize_t length
    cdef int kind

    PyUnicode_READY(data)

    length = PyUnicode_GET_LENGTH(data)
    kind = PyUnicode_KIND(data)

    if kind == PyUnicode_1BYTE_KIND:
        return _decode_ucs1(PyUnicode_1BYTE_DATA(data), length, maxdepth, some)
    elif kind == PyUnicode_2BYTE_KIND:
        return _decode_ucs2(PyUnicode_2BYTE_DATA(data), length, maxdepth, some)
    elif kind == PyUnicode_4BYTE_KIND:
        return _decode_ucs4(PyUnicode_4BYTE_DATA(data), length, maxdepth, some)
    else:
        __builtin_unreachable()


cdef object _decode_buffer(Py_buffer &view, int32_t wordlength,
                           Py_ssize_t maxdepth, boolean some):
    cdef object (*decoder)(const void*, Py_ssize_t, Py_ssize_t, boolean)
    cdef Py_ssize_t length

    if wordlength == 1:
        decoder = _decode_ucs1
        length = view.len // 1
    elif wordlength == 2:
        decoder = _decode_ucs2
        length = view.len // 2
    elif wordlength == 4:
        decoder = _decode_ucs4
        length = view.len // 4
    else:
        _raise_illegal_wordlength(wordlength)
        __builtin_unreachable()

    return decoder(view.buf, length, maxdepth, some)


cdef object _decode_callback(object cb, object args, Py_ssize_t maxdepth,
                             boolean some):
    cdef ReaderCallback reader = ReaderCallback(
        ReaderCallbackBase(0, maxdepth),
        <PyObject*> cb,
        <PyObject*> args,
        -1,
    )
    return _decode_all(reader, some)