module json2

import strconv
import time

const null_in_string = 'null'

const true_in_string = 'true'

const false_in_string = 'false'

const float_zero_in_string = '0.0'

const whitespace_chars = [` `, `\t`, `\n`, `\r`]!

// Node represents a node in a linked list to store ValueInfo.
struct Node[T] {
mut:
    value T
    next  &Node[T] = unsafe { nil } // next is the next node in the linked list.
}

// ValueInfo represents the position and length of a value, such as string, number, array, object key, and object value in a JSON string.
struct ValueInfo {
    position   int       // The position of the value in the JSON string.
    value_kind ValueKind // The kind of the value.
mut:
    length int // The length of the value in the JSON string.
}

struct DecoderFieldInfo {
    key_name string

    is_omitempty bool
    is_skip      bool
    is_required  bool
    is_raw       bool
}

@[markused]
struct StructFieldInfo {
    json_name_ptr voidptr
    json_name_len int
    is_omitempty  bool
    is_skip       bool
    is_required   bool
    is_raw        bool
}

struct StructKeyDecodeResult[T] {
    matched bool
    value   T
}

// DecoderOptions provides options for JSON decoding.
// By default, decoding is lenient. Use `strict: true` for strict JSON spec compliance.
@[markused; params]
pub struct DecoderOptions {
pub:
    // In strict mode, quoted strings are not accepted as numbers.
    // For example, '"123"' will fail to decode as int in strict mode,
    // but will succeed in default mode.
    strict bool
}

// Decoder is the internal decoding state.
@[markused]
struct Decoder {
    json   string // json is the JSON data to be decoded.
    strict bool   // strict mode rejects quoted strings as numbers
mut:
    values_info  LinkedList[ValueInfo] // A linked list to store ValueInfo.
    checker_idx  int                   // checker_idx is the current index of the decoder.
    current_node &Node[ValueInfo] = unsafe { nil } // The current node in the linked list.
}

// LinkedList represents a linked list to store ValueInfo.
struct LinkedList[T] {
mut:
    head &Node[T] = unsafe { nil } // head is the first node in the linked list.
    tail &Node[T] = unsafe { nil } // tail is the last node in the linked list.
    len  int // len is the length of the linked list.
}

// push adds a new element to the linked list.
fn (mut list LinkedList[T]) push(value T) {
    new_node := &Node[T]{
        value: value
    }
    if list.head == unsafe { nil } {
        list.head = new_node
        list.tail = new_node
    } else {
        list.tail.next = new_node
        list.tail = new_node
    }
    list.len++
}

// last returns the last element added to the linked list.
fn (list &LinkedList[T]) last() &T {
    return &list.tail.value
}

// str returns a string representation of the linked list.
fn (list &LinkedList[ValueInfo]) str() string {
    mut result_buffer := []u8{}
    mut current := list.head
    for current != unsafe { nil } {
        value_kind_as_string := current.value.value_kind.str()
        unsafe { result_buffer.push_many(value_kind_as_string.str, value_kind_as_string.len) }
        result_buffer << u8(` `)

        current = current.next
    }
    return result_buffer.bytestr()
}

@[unsafe]
fn (list &LinkedList[T]) free() {
    mut current := list.head
    for current != unsafe { nil } {
        mut next := current.next
        current.next = unsafe { nil }
        unsafe { free(current) }
        current = next
    }
    list.head = unsafe { nil }
    list.tail = unsafe { nil }
    list.len = 0
}

const max_context_length = 50
const max_extra_characters = 5
const tab_width = 8

pub struct JsonDecodeError {
    Error
    context string
pub:
    message string

    line      int
    character int
}

fn (e JsonDecodeError) msg() string {
    return '\n${e.line}:${e.character}: Invalid json: ${e.message}\n${e.context}'
}

// checker_error generates a checker error message showing the position in the json string
@[markused]
fn (mut checker Decoder) checker_error(message string) ! {
    position := checker.checker_idx

    mut line_number := 0
    mut character_number := 0
    mut last_newline := 0

    for i := position - 1; i >= 0; i-- {
        if last_newline == 0 {
            if checker.json[i] == `\n` {
                last_newline = i + 1
            } else if checker.json[i] == `\t` {
                character_number += tab_width
            } else {
                character_number++
            }
        }
        if checker.json[i] == `\n` {
            line_number++
        }
    }

    cutoff := character_number > max_context_length

    // either start of string, last newline or a limited amount of characters
    context_start := if cutoff { position - max_context_length } else { last_newline }

    // print some extra characters
    mut context_end := int_min(checker.json.len, position + max_extra_characters)
    context_end_newline := checker.json[position..context_end].index_u8(`\n`)

    if context_end_newline != -1 {
        context_end = position + context_end_newline
    }

    mut context := ''

    if cutoff {
        context += '...'
    }
    context += checker.json[context_start..position]
    context += '\e[31m${checker.json[position].ascii_str()}\e[0m'
    context += checker.json[position + 1..context_end]
    context += '\n'

    if cutoff {
        context += ' '.repeat(max_context_length + 3)
    } else {
        context += ' '.repeat(character_number)
    }
    context += '\e[31m^\e[0m'

    return JsonDecodeError{
        context:   context
        message:   'Syntax: ${message}'
        line:      line_number + 1
        character: character_number + 1
    }
}

// decode_error generates a decoding error from the decoding stage
@[markused]
fn (mut decoder Decoder) decode_error(message string) ! {
    mut error_info := ValueInfo{}
    if decoder.current_node != unsafe { nil } {
        error_info = decoder.current_node.value
    } else {
        error_info = decoder.values_info.tail.value
    }

    start := error_info.position
    end := start + int_min(error_info.length, max_context_length)

    mut line_number := 0
    mut character_number := 0
    mut last_newline := 0

    for i := start - 1; i >= 0; i-- {
        if last_newline == 0 {
            if decoder.json[i] == `\n` {
                last_newline = i + 1
            } else if decoder.json[i] == `\t` {
                character_number += tab_width
            } else {
                character_number++
            }
        }
        if decoder.json[i] == `\n` {
            line_number++
        }
    }

    cutoff := character_number > max_context_length

    // either start of string, last newline or a limited amount of characters
    context_start := if cutoff { start - max_context_length } else { last_newline }

    // print some extra characters
    mut context_end := int_min(decoder.json.len, end + max_extra_characters)
    context_end_newline := decoder.json[end..context_end].index_u8(`\n`)

    if context_end_newline != -1 {
        context_end = end + context_end_newline
    }

    mut context := ''

    if cutoff {
        context += '...'
    }
    context += decoder.json[context_start..start]
    context += '\e[31m${decoder.json[start..end]}\e[0m'
    context += decoder.json[end..context_end]
    context += '\n'

    if cutoff {
        context += ' '.repeat(max_context_length + 3)
    } else {
        context += ' '.repeat(character_number)
    }
    context += '\e[31m${'~'.repeat(error_info.length)}\e[0m'

    return JsonDecodeError{
        context:   context
        message:   'Data: ${message}'
        line:      line_number + 1
        character: character_number + 1
    }
}

// decode decodes a JSON string into a specified type.
// By default, decoding is lenient. Use `strict: true` for strict JSON spec compliance.
@[manualfree]
pub fn decode[T](val string, params DecoderOptions) !T {
    if val == '' {
        return JsonDecodeError{
            message:   'empty string'
            line:      1
            character: 1
        }
    }
    mut decoder := Decoder{
        json:   val
        strict: params.strict
    }

    decoder.check_json_format()!

    mut result := T{}
    decoder.current_node = decoder.values_info.head
    $if T.unaliased_typ is $array_dynamic {
        result.clear()
        decoder.decode_array(mut result)!
    } $else $if T.unaliased_typ is $map {
        decoder.decode_map(mut result)!
    } $else $if T.indirections == 1 {
        if decoder.current_node.value.value_kind == .null {
            if decoder.current_node != unsafe { nil } {
                decoder.current_node = decoder.current_node.next
            }
        } else {
            mut decoded_ptr := create_decoded_ptr(result)
            decoder.decode_value(mut decoded_ptr)!
            result = decoded_ptr
        }
    } $else {
        decoder.decode_value(mut result)!
    }
    return result
}

fn get_dynamic_from_element[T](_t T) []T {
    return []T{}
}

fn create_decoded_ptr[T](_ &T) &T {
    $if T is $interface {
        return unsafe { nil }
    } $else $if T.unaliased_typ is voidptr {
        return unsafe { nil }
    } $else {
        return unsafe { &T(vcalloc(sizeof(T))) }
    }
}

fn create_decoded_option_ptr[U](_ ?&U) &U {
    return &U{}
}

fn decoder_field_infos[T]() []DecoderFieldInfo {
    mut field_infos := []DecoderFieldInfo{}
    $for field in T.fields {
        mut key_name := field.name
        mut is_json_skip := false
        for attr in field.attrs {
            if start, end := json_attr_value_range(attr) {
                if end <= start {
                    continue
                }
                if end == start + 1 && attr[start] == `-` {
                    is_json_skip = true
                    break
                }
                key_name = attr[start..end]
                break
            }
        }
        field_infos << DecoderFieldInfo{
            key_name:     key_name
            is_omitempty: field.attrs.contains('omitempty')
            is_skip:      field.attrs.contains('skip') || is_json_skip
            is_required:  field.attrs.contains('required')
            is_raw:       field.attrs.contains('raw')
        }
    }
    return field_infos
}

@[manualfree; unsafe]
fn (mut decoder Decoder) cached_struct_field_infos[T]() []StructFieldInfo {
    static field_infos := &[]StructFieldInfo(nil)
    if field_infos == nil {
        field_infos = &[]StructFieldInfo{}
        $for field in T.fields {
            mut json_name_str := field.name.str
            mut json_name_len := field.name.len
            mut is_json_skip := false
            for attr in field.attrs {
                if start, end := json_attr_value_range(attr) {
                    if end <= start {
                        continue
                    }
                    if end == start + 1 && attr[start] == `-` {
                        is_json_skip = true
                        break
                    }
                    json_name_str = unsafe { attr.str + start }
                    json_name_len = end - start
                    break
                }
            }
            field_infos << StructFieldInfo{
                json_name_ptr: voidptr(json_name_str)
                json_name_len: json_name_len
                is_omitempty:  field.attrs.contains('omitempty')
                is_skip:       field.attrs.contains('skip') || is_json_skip
                is_required:   field.attrs.contains('required')
                is_raw:        field.attrs.contains('raw')
            }
        }
    }
    return *field_infos
}

@[inline; markused]
fn struct_field_is_decoded(decoded_mask u64, decoded_fields []bool, field_idx int) bool {
    if field_idx < 64 {
        return (decoded_mask & (u64(1) << u64(field_idx))) != 0
    }
    return decoded_fields[field_idx]
}

@[inline; markused]
fn mark_struct_field_decoded(decoded_mask u64, mut decoded_fields []bool, field_idx int) u64 {
    if field_idx < 64 {
        return decoded_mask | (u64(1) << u64(field_idx))
    }
    decoded_fields[field_idx] = true
    return decoded_mask
}

@[inline]
fn (decoder &Decoder) json_key_matches(key_info ValueInfo, key_name string) bool {
    if key_info.length - 2 != key_name.len {
        return false
    }
    return unsafe {
        vmemcmp(decoder.json.str + key_info.position + 1, key_name.str, key_name.len) == 0
    }
}

@[inline; markused]
fn (decoder &Decoder) is_empty_value(value_info ValueInfo) bool {
    match value_info.value_kind {
        .null {
            return true
        }
        .string {
            return value_info.length == 2
        }
        .number {
            if decoder.json[value_info.position] == `0` {
                if value_info.length == 1 {
                    return true
                }
                if value_info.length == 3 {
                    return unsafe {
                        vmemcmp(decoder.json.str + value_info.position, float_zero_in_string.str,
                            float_zero_in_string.len) == 0
                    }
                }
            }
        }
        else {}
    }

    return false
}

@[markused]
fn (mut decoder Decoder) skip_current_value() {
    if decoder.current_node == unsafe { nil } {
        return
    }
    value_end := decoder.current_node.value.position + decoder.current_node.value.length
    for decoder.current_node != unsafe { nil } && decoder.current_node.value.position < value_end {
        decoder.current_node = decoder.current_node.next
    }
}

@[manualfree]
fn decode_struct_key[T](mut decoder Decoder, val T, key_info ValueInfo, prefix string, mut seen_required []string) !StructKeyDecodeResult[T] {
    field_infos := decoder_field_infos[T]()
    mut new_val := val
    mut i := 0
    $for field in T.fields {
        field_info := field_infos[i]
        $if !field.is_embed {
            if decoder.json_key_matches(key_info, field_info.key_name)
                || (prefix != ''
                && decoder.json_key_matches(key_info, prefix + field_info.key_name)) {
                decoder.current_node = decoder.current_node.next

                if field_info.is_skip {
                    if field_info.is_required {
                        seen_required << prefix + field.name
                    }
                    decoder.skip_current_value()
                    return StructKeyDecodeResult[T]{
                        matched: true
                        value:   new_val
                    }
                }

                if field_info.is_omitempty && decoder.current_node != unsafe { nil }
                    && decoder.is_empty_value(decoder.current_node.value) {
                    decoder.skip_current_value()
                    return StructKeyDecodeResult[T]{
                        matched: true
                        value:   new_val
                    }
                }

                if field_info.is_required {
                    seen_required << prefix + field.name
                }

                if field_info.is_raw {
                    $if field.unaliased_typ is $enum {
                        decoder.decode_error('`raw` attribute cannot be used with enum fields')!
                    } $else $if field.typ is ?string {
                        position := decoder.current_node.value.position
                        end := position + decoder.current_node.value.length

                        new_val.$(field.name) = decoder.json[position..end]
                        decoder.current_node = decoder.current_node.next

                        for {
                            if decoder.current_node == unsafe { nil }
                                || decoder.current_node.value.position + decoder.current_node.value.length >= end {
                                break
                            }
                            decoder.current_node = decoder.current_node.next
                        }
                    } $else $if field.typ is string {
                        position := decoder.current_node.value.position
                        end := position + decoder.current_node.value.length

                        new_val.$(field.name) = decoder.json[position..end]
                        decoder.current_node = decoder.current_node.next

                        for {
                            if decoder.current_node == unsafe { nil }
                                || decoder.current_node.value.position + decoder.current_node.value.length >= end {
                                break
                            }
                            decoder.current_node = decoder.current_node.next
                        }
                    } $else {
                        decoder.decode_error('`raw` attribute can only be used with string fields')!
                    }
                } else {
                    $if field.typ is $option {
                        if decoder.current_node.value.value_kind == .null {
                            new_val.$(field.name) = none

                            if decoder.current_node != unsafe { nil } {
                                decoder.current_node = decoder.current_node.next
                            }
                        } else {
                            $if field.indirections == 1 {
                                mut decoded_ptr := create_decoded_option_ptr(new_val.$(field.name))
                                decoder.decode_value(mut decoded_ptr)!
                                new_val.$(field.name) = decoded_ptr
                            } $else {
                                mut unwrapped_val := create_value_from_optional(new_val.$(field.name)) or {
                                    return StructKeyDecodeResult[T]{
                                        matched: false
                                        value:   val
                                    }
                                }
                                decoder.decode_value(mut unwrapped_val)!
                                new_val.$(field.name) = unwrapped_val
                            }
                        }
                    } $else $if field.unaliased_typ is $array_dynamic {
                        new_val.$(field.name).clear()
                        decoder.decode_array(mut new_val.$(field.name))!
                    } $else $if field.unaliased_typ is $map {
                        decoder.decode_map(mut new_val.$(field.name))!
                    } $else $if field.indirections == 1 {
                        if decoder.current_node.value.value_kind == .null {
                            new_val.$(field.name) = unsafe { nil }

                            if decoder.current_node != unsafe { nil } {
                                decoder.current_node = decoder.current_node.next
                            }
                        } else {
                            mut decoded_ptr := create_decoded_ptr(new_val.$(field.name))
                            decoder.decode_value(mut decoded_ptr)!
                            new_val.$(field.name) = decoded_ptr
                        }
                    } $else {
                        decoder.decode_value(mut new_val.$(field.name))!
                    }
                }
                return StructKeyDecodeResult[T]{
                    matched: true
                    value:   new_val
                }
            }
        }
        i++
    }
    i = 0
    $for field in T.fields {
        field_info := field_infos[i]
        $if field.is_embed {
            if decoder.json_key_matches(key_info, field_info.key_name)
                && decoder.current_node.next != unsafe { nil }
                && decoder.current_node.next.value.value_kind == .object {
                if field_info.is_required {
                    seen_required << prefix + field.name
                }
                decoder.current_node = decoder.current_node.next
                decoder.decode_value(mut new_val.$(field.name))!
                return StructKeyDecodeResult[T]{
                    matched: true
                    value:   new_val
                }
            }
            {
                embed_result := decode_struct_key(mut decoder, new_val.$(field.name), key_info,

                    prefix + field.name + '.', mut seen_required)!
                if embed_result.matched {
                    new_val.$(field.name) = embed_result.value
                    return StructKeyDecodeResult[T]{
                        matched: true
                        value:   new_val
                    }
                }
            }
        }
        i++
    }
    return StructKeyDecodeResult[T]{
        matched: false
        value:   val
    }
}

fn check_required_struct_fields[T](mut decoder Decoder, val T, seen_required []string, prefix string) ! {
    field_infos := decoder_field_infos[T]()
    mut i := 0
    $for field in T.fields {
        field_info := field_infos[i]
        if field_info.is_required && prefix + field.name !in seen_required {
            decoder.decode_error('missing required field `${field.name}`')!
        }
        $if field.is_embed {
            check_required_struct_fields(mut decoder, val.$(field.name), seen_required, prefix +
                field.name + '.')!
        }
        i++
    }
}

// decode_value decodes a value from the JSON nodes.
@[manualfree]
fn (mut decoder Decoder) decode_value[T](mut val T) ! {
    $if T.unaliased_typ is voidptr {
        // skip voidptr fields - they cannot be decoded from JSON
        if decoder.current_node != unsafe { nil } {
            decoder.current_node = decoder.current_node.next
        }
        return
    } $else $if T is $interface {
        // skip interface fields - they cannot be decoded from JSON
        if decoder.current_node != unsafe { nil } {
            decoder.current_node = decoder.current_node.next
        }
        return
    } $else {
        // Custom Decoders
        $if val is StringDecoder {
            struct_info := decoder.current_node.value

            if struct_info.value_kind == .string {
                val.from_json_string(decoder.json[struct_info.position + 1..struct_info.position +
                    struct_info.length - 1]) or {
                    decoder.decode_error('${typeof(val).name}: ${err.msg()}')!
                }
                if decoder.current_node != unsafe { nil } {
                    decoder.current_node = decoder.current_node.next
                }

                return
            }
        }
        $if val is NumberDecoder {
            struct_info := decoder.current_node.value

            if struct_info.value_kind == .number {
                val.from_json_number(decoder.json[struct_info.position..struct_info.position +
                    struct_info.length]) or {
                    decoder.decode_error('${typeof(val).name}: ${err.msg()}')!
                }
                if decoder.current_node != unsafe { nil } {
                    decoder.current_node = decoder.current_node.next
                }

                return
            }
        }
        $if val is BooleanDecoder {
            struct_info := decoder.current_node.value

            if struct_info.value_kind == .boolean {
                val.from_json_boolean(decoder.json[struct_info.position] == `t`)
                if decoder.current_node != unsafe { nil } {
                    decoder.current_node = decoder.current_node.next
                }

                return
            }
        }
        $if val is NullDecoder {
            struct_info := decoder.current_node.value

            if struct_info.value_kind == .null {
                val.from_json_null()
                if decoder.current_node != unsafe { nil } {
                    decoder.current_node = decoder.current_node.next
                }

                return
            }
        }
        $if T.unaliased_typ is voidptr {
            // skip voidptr fields - they cannot be decoded from JSON
            if decoder.current_node != unsafe { nil } {
                decoder.current_node = decoder.current_node.next
            }
            return
        } $else $if T.unaliased_typ is string {
            decoder.decode_string(mut val)!
        } $else $if T.unaliased_typ is time.Time {
            value_info := decoder.current_node.value
            mut decoded_time := time.Time{}
            if value_info.value_kind == .string {
                decoded_time.from_json_string(decoder.json[value_info.position + 1..
                    value_info.position + value_info.length - 1]) or {
                    decoder.decode_error('${typeof(val).name}: ${err.msg()}')!
                }
            } else if value_info.value_kind == .number {
                decoded_time.from_json_number(decoder.json[value_info.position..
                    value_info.position + value_info.length]) or {
                    decoder.decode_error('${typeof(val).name}: ${err.msg()}')!
                }
            } else {
                decoder.decode_error('Expected string or number, but got ${value_info.value_kind}')!
            }
            val = T(decoded_time)
        } $else $if T.unaliased_typ is $sumtype {
            decoder.decode_sumtype(mut val)!
            return
        } $else $if T.unaliased_typ is $map {
            decoder.decode_map(mut val)!
            return
        } $else $if T.unaliased_typ is $array_dynamic {
            val.clear()
            decoder.decode_array(mut val)!
            // return to avoid the next increment of the current node
            // this is because the current node is already incremented in the decode_array function
            // remove this line will cause the current node to be incremented twice
            // and bug recursive array decoding like `[][]int{}`
            return
        } $else $if T.unaliased_typ is $array_fixed {
            mut dynamic_val := get_dynamic_from_element(val[0])

            // avoid copying by pointing dynamic_val to val
            unsafe {
                dynamic_val.len = 0
                dynamic_val.cap = val.len // ensures data wont reallocate
                dynamic_val.data = &val
            }
            decoder.decode_array(mut dynamic_val)!

            if dynamic_val.len != val.len {
                decoder.decode_error('Fixed size array expected ${val.len} elements but got ${dynamic_val.len} elements')!
            }
            return
        } $else $if T.unaliased_typ is $struct {
            struct_info := decoder.current_node.value

            if struct_info.value_kind == .object {
                struct_position := struct_info.position
                struct_end := struct_position + struct_info.length
                mut has_embeds := false
                $for field in T.fields {
                    $if field.is_embed {
                        has_embeds = true
                    }
                }
                decoder.current_node = decoder.current_node.next
                if has_embeds {
                    mut seen_required := []string{}

                    // json object loop
                    for {
                        if decoder.current_node == unsafe { nil } {
                            break
                        }

                        key_info := decoder.current_node.value

                        if key_info.position >= struct_end {
                            break
                        }

                        decode_result := decode_struct_key(mut decoder, val, key_info, '', mut
                            seen_required)!
                        if decode_result.matched {
                            val = decode_result.value
                        } else {
                            // The key doesn't match any field in the struct, skip the entire value
                            // including all nested objects/arrays.
                            decoder.current_node = decoder.current_node.next
                            decoder.skip_current_value()
                        }
                    }

                    check_required_struct_fields(mut decoder, val, seen_required, '')!
                } else {
                    field_infos := unsafe { decoder.cached_struct_field_infos[T]() }
                    mut decoded_mask := u64(0)
                    mut decoded_fields := []bool{}
                    if field_infos.len > 64 {
                        decoded_fields = []bool{len: field_infos.len}
                    }

                    mut field_idx := 0
                    // json object loop
                    for {
                        if decoder.current_node == unsafe { nil } {
                            break
                        }

                        key_info := decoder.current_node.value

                        if key_info.position >= struct_end {
                            break
                        }

                        mut matched := false
                        field_idx = 0
                        $for field in T.fields {
                            if !matched {
                                field_info := field_infos[field_idx]
                                field_can_match := (!field_info.is_skip || field_info.is_required)
                                    && !(field_info.is_omitempty
                                    && decoder.is_empty_value(decoder.current_node.next.value))
                                field_name_matches := key_info.length - 2 == field_info.json_name_len && unsafe {
                                    vmemcmp(decoder.json.str + key_info.position + 1, field_info.json_name_ptr, field_info.json_name_len) == 0
                                }
                                if field_can_match && field_name_matches {
                                    // value node
                                    decoder.current_node = decoder.current_node.next

                                    if field_info.is_skip {
                                        // Preserve the existing inline decode behavior for `skip`+`required`.
                                        decoded_mask = mark_struct_field_decoded(decoded_mask, mut
                                            decoded_fields, field_idx)
                                        if decoder.current_node != unsafe { nil } {
                                            decoder.current_node = decoder.current_node.next
                                        }
                                    } else if field_info.is_raw {
                                        $if field.unaliased_typ is $enum {
                                            // workaround to avoid the error: enums can only be assigned `int` values
                                            decoder.decode_error('`raw` attribute cannot be used with enum fields')!
                                        } $else $if field.typ is ?string {
                                            position := decoder.current_node.value.position
                                            end := position + decoder.current_node.value.length

                                            val.$(field.name) = decoder.json[position..end]
                                            decoder.current_node = decoder.current_node.next

                                            for {
                                                if decoder.current_node == unsafe { nil }
                                                    || decoder.current_node.value.position + decoder.current_node.value.length >= end {
                                                    break
                                                }
                                                decoder.current_node = decoder.current_node.next
                                            }
                                        } $else $if field.typ is string {
                                            position := decoder.current_node.value.position
                                            end := position + decoder.current_node.value.length

                                            val.$(field.name) = decoder.json[position..end]
                                            decoder.current_node = decoder.current_node.next

                                            for {
                                                if decoder.current_node == unsafe { nil }
                                                    || decoder.current_node.value.position + decoder.current_node.value.length >= end {
                                                    break
                                                }
                                                decoder.current_node = decoder.current_node.next
                                            }
                                        } $else {
                                            decoder.decode_error('`raw` attribute can only be used with string fields')!
                                        }
                                    } else {
                                        $if field.typ is $option {
                                            // it would be nicer to do this at the start of the function
                                            // but options cant be passed to generic functions
                                            if decoder.current_node.value.value_kind == .null {
                                                val.$(field.name) = none

                                                if decoder.current_node != unsafe { nil } {
                                                    decoder.current_node = decoder.current_node.next
                                                }
                                            } else {
                                                $if field.indirections == 1 {
                                                    mut decoded_ptr :=
                                                        create_decoded_option_ptr(val.$(field.name))
                                                    decoder.decode_value(mut decoded_ptr)!
                                                    val.$(field.name) = decoded_ptr
                                                } $else {
                                                    mut unwrapped_val := create_value_from_optional(val.$(field.name)) or {
                                                        return
                                                    }
                                                    decoder.decode_value(mut unwrapped_val)!
                                                    val.$(field.name) = unwrapped_val
                                                }
                                            }
                                        } $else $if field.unaliased_typ is $array_dynamic {
                                            val.$(field.name).clear()
                                            decoder.decode_array(mut val.$(field.name))!
                                        } $else $if field.unaliased_typ is $map {
                                            decoder.decode_map(mut val.$(field.name))!
                                        } $else $if field.indirections == 1 {
                                            if decoder.current_node.value.value_kind == .null {
                                                val.$(field.name) = unsafe { nil }

                                                if decoder.current_node != unsafe { nil } {
                                                    decoder.current_node = decoder.current_node.next
                                                }
                                            } else {
                                                mut decoded_ptr :=
                                                    create_decoded_ptr(val.$(field.name))
                                                decoder.decode_value(mut decoded_ptr)!
                                                val.$(field.name) = decoded_ptr
                                            }
                                        } $else {
                                            mut decoded_field_value := val.$(field.name)
                                            decoder.decode_value(mut decoded_field_value)!
                                            $if field.unaliased_typ is $map {
                                                val.$(field.name) = decoded_field_value.move()
                                            } $else {
                                                val.$(field.name) = decoded_field_value
                                            }
                                        }
                                    }

                                    decoded_mask = mark_struct_field_decoded(decoded_mask, mut
                                        decoded_fields, field_idx)
                                    matched = true
                                }
                            }
                            field_idx++
                        }
                        if !matched {
                            // The key doesn't match any field in the struct, skip the entire value
                            // including all nested objects/arrays.
                            decoder.current_node = decoder.current_node.next
                            decoder.skip_current_value()
                        }
                    }

                    // check if all required fields are present
                    field_idx = 0
                    $for field in T.fields {
                        field_info := field_infos[field_idx]
                        if field_info.is_required
                            && !struct_field_is_decoded(decoded_mask, decoded_fields, field_idx) {
                            decoder.decode_error('missing required field `${field.name}`')!
                        }
                        field_idx++
                    }
                }
            } else {
                decoder.decode_error('Expected object, but got ${struct_info.value_kind}')!
            }
            return
        } $else $if T.unaliased_typ is bool {
            value_info := decoder.current_node.value

            if value_info.value_kind != .boolean {
                decoder.decode_error('Expected boolean, but got ${value_info.value_kind}')!
            }

            unsafe {
                val = vmemcmp(decoder.json.str + value_info.position, c'true', 'true'.len) == 0
            }
        } $else $if T.unaliased_typ is $float || T.unaliased_typ is $int {
            value_info := decoder.current_node.value

            if value_info.value_kind == .number {
                unsafe { decoder.decode_number(&val)! }
            } else if value_info.value_kind == .string && !decoder.strict {
                // In default mode, try to parse quoted strings as numbers
                val = decoder.decode_number_from_string[T]()!
            } else {
                decoder.decode_error('Expected number, but got ${value_info.value_kind}')!
            }
        } $else $if T.unaliased_typ is $enum {
            decoder.decode_enum(mut val)!
        } $else {
            decoder.decode_error('cannot decode value with ${typeof(val).name} type')!
        }

        if decoder.current_node != unsafe { nil } {
            decoder.current_node = decoder.current_node.next
        }
    } // $else (not voidptr / interface)
}

fn (mut decoder Decoder) decode_string[T](mut val T) ! {
    _ = val
    string_info := decoder.current_node.value

    if string_info.value_kind == .string {
        string_start := string_info.position + 1
        string_end := string_info.position + string_info.length - 1
        string_body := decoder.json[string_start..string_end]
        if string_body.index_u8(`\\`) == -1 {
            val = string_body
            return
        }

        mut string_buffer := []u8{cap: string_info.length} // might be too long but most json strings don't contain many escape characters anyways

        mut buffer_index := 1
        mut string_index := 1

        for string_index < string_info.length - 1 {
            current_byte := decoder.json[string_info.position + string_index]

            if current_byte == `\\` {
                // push all characters up to this point
                unsafe {
                    string_buffer.push_many(decoder.json.str + string_info.position + buffer_index,
                        string_index - buffer_index)
                }

                string_index++

                escaped_char := decoder.json[string_info.position + string_index]

                string_index++

                match escaped_char {
                    `/`, `"`, `\\` {
                        string_buffer << escaped_char
                    }
                    `b` {
                        string_buffer << `\b`
                    }
                    `f` {
                        string_buffer << `\f`
                    }
                    `n` {
                        string_buffer << `\n`
                    }
                    `r` {
                        string_buffer << `\r`
                    }
                    `t` {
                        string_buffer << `\t`
                    }
                    `u` {
                        unicode_point := rune(strconv.parse_uint(decoder.json[
                            string_info.position + string_index..string_info.position +
                            string_index + 4], 16, 32)!)

                        string_index += 4

                        if unicode_point < 0xD800 || unicode_point > 0xDFFF { // normal utf-8
                            string_buffer << unicode_point.bytes()
                        } else if unicode_point >= 0xDC00 { // trail surrogate -> invalid
                            decoder.decode_error('Got trail surrogate: ${u32(unicode_point):04X} before head surrogate.')!
                        } else { // head surrogate -> treat as utf-16
                            if string_index > string_info.length - 6 {
                                decoder.decode_error('Expected a trail surrogate after a head surrogate, but got no valid escape sequence.')!
                            }
                            if decoder.json[string_info.position + string_index..
                                string_info.position + string_index + 2] != '\\u' {
                                decoder.decode_error('Expected a trail surrogate after a head surrogate, but got no valid escape sequence.')!
                            }

                            string_index += 2

                            unicode_point2 := rune(strconv.parse_uint(decoder.json[
                                string_info.position + string_index..string_info.position +
                                string_index + 4], 16, 32)!)

                            string_index += 4

                            if unicode_point2 < 0xDC00 {
                                decoder.decode_error('Expected a trail surrogate after a head surrogate, but got ${u32(unicode_point):04X}.')!
                            }

                            final_unicode_point := (unicode_point2 & 0x3FF) +
                                ((unicode_point & 0x3FF) << 10) + 0x10000
                            string_buffer << final_unicode_point.bytes()
                        }
                    }
                    else {} // has already been checked
                }

                buffer_index = string_index
            } else {
                string_index++
            }
        }

        // push the rest
        unsafe {
            string_buffer.push_many(decoder.json.str + string_info.position + buffer_index,
                string_index - buffer_index)
        }

        val = string_buffer.bytestr()
    } else {
        decoder.decode_error('Expected string, but got ${string_info.value_kind}')!
    }
}

fn (mut decoder Decoder) decode_array[T](mut val []T) ! {
    $if T is $interface {
        decoder.skip_current_value()
        return
    } $else $if T.unaliased_typ is voidptr {
        decoder.skip_current_value()
        return
    } $else {
        array_info := decoder.current_node.value

        if array_info.value_kind == .array {
            decoder.current_node = decoder.current_node.next

            array_position := array_info.position
            array_end := array_position + array_info.length

            for {
                if decoder.current_node == unsafe { nil }
                    || decoder.current_node.value.position >= array_end {
                    break
                }

                mut array_element := T{}

                $if T.indirections == 1 {
                    if decoder.current_node.value.value_kind == .null {
                        if decoder.current_node != unsafe { nil } {
                            decoder.current_node = decoder.current_node.next
                        }
                    } else {
                        mut decoded_ptr := create_decoded_ptr(array_element)
                        decoder.decode_value(mut decoded_ptr)!
                        array_element = decoded_ptr
                    }
                } $else {
                    decoder.decode_value(mut array_element)!
                }

                val << array_element
            }
        } else {
            decoder.decode_error('Expected array, but got ${array_info.value_kind}')!
        }
    }
}

fn (mut decoder Decoder) decode_map[V](mut val map[string]V) ! {
    $if V is $interface {
        decoder.skip_current_value()
        return
    } $else $if V.unaliased_typ is voidptr {
        decoder.skip_current_value()
        return
    } $else {
        map_info := decoder.current_node.value

        if map_info.value_kind == .object {
            map_position := map_info.position
            map_end := map_position + map_info.length

            decoder.current_node = decoder.current_node.next
            for {
                if decoder.current_node == unsafe { nil }
                    || decoder.current_node.value.position >= map_end {
                    break
                }

                key_info := decoder.current_node.value

                if key_info.position >= map_end {
                    break
                }

                key_str := decoder.json[key_info.position + 1..key_info.position + key_info.length -
                    1]

                decoder.current_node = decoder.current_node.next

                value_info := decoder.current_node.value

                if value_info.position + value_info.length > map_end {
                    break
                }

                mut map_value := V{}

                $if V.indirections == 1 {
                    if decoder.current_node.value.value_kind == .null {
                        if decoder.current_node != unsafe { nil } {
                            decoder.current_node = decoder.current_node.next
                        }
                    } else {
                        mut decoded_ptr := create_decoded_ptr(map_value)
                        decoder.decode_value(mut decoded_ptr)!
                        map_value = decoded_ptr
                    }
                } $else {
                    decoder.decode_value(mut map_value)!
                }

                $if V is $alias && V.unaliased_typ is $map {
                    // V is a map alias (e.g. `type SyntaxStyle = map[string]X`).
                    // V's checker reports `val[key]` as the unaliased element type
                    // while `map_value` keeps the alias type, so direct assignment
                    // fails to type-check. Skip to keep generic instantiations
                    // compilable; decoding into map-alias map values is unsupported.
                } $else $if K is string {
                    $if V is $map {
                        val[key_str] = map_value.move()
                    } $else {
                        val[key_str] = map_value
                    }
                } $else $if K is rune {
                    $if V is $map {
                        val[rune(key_str.int())] = map_value.move()
                    } $else {
                        val[rune(key_str.int())] = map_value
                    }
                } $else $if K is $int {
                    $if V is $map {
                        val[K(key_str.int())] = map_value.move()
                    } $else {
                        val[K(key_str.int())] = map_value
                    }
                } $else {
                    $if V is $map {
                        val[key_str] = map_value.move()
                    } $else {
                        val[key_str] = map_value
                    }
                }
            }
        } else {
            decoder.decode_error('Expected object, but got ${map_info.value_kind}')!
        }
    }
}

fn create_value_from_optional[T](_val ?T) ?T {
    return T{}
}

fn (mut decoder Decoder) decode_enum[T](mut val T) ! {
    enum_info := decoder.current_node.value

    if enum_info.value_kind == .number {
        mut result := 0
        unsafe { decoder.decode_number(&result)! }

        $for value in T.values {
            if int(value.value) == result {
                val = value.value
                return
            }
        }
        decoder.decode_error('Number value: `${result}` does not match any field in enum: ${typeof(val).name}')!
    } else if enum_info.value_kind == .string {
        mut result := ''
        decoder.decode_string(mut result)!

        $for value in T.values {
            for attr in value.attrs {
                if json_attr := json_attr_value(attr) {
                    if json_attr == result {
                        val = value.value
                        return
                    }
                }
            }
            if value.name == result {
                val = value.value
                return
            }
        }
        decoder.decode_error('String value: `${result}` does not match any field in enum: ${typeof(val).name}')!
    }

    decoder.decode_error('Expected number or string value for enum, got: ${enum_info.value_kind}')!
}

const max_integer_number_digits = 20

@[markused]
fn has_exponent_number_syntax(str string) bool {
    for c in str {
        if c == `e` || c == `E` {
            return true
        }
    }
    return false
}

@[markused]
fn scientific_number_to_integer_string(str string) !string {
    if !has_exponent_number_syntax(str) {
        // Handle plain decimal numbers with zero fractional part (e.g., "-123.0")
        dot_pos := str.index_u8(`.`)
        if dot_pos >= 0 {
            frac := str[dot_pos + 1..]
            mut all_zeros := frac.len > 0
            for c in frac {
                if c != `0` {
                    all_zeros = false
                    break
                }
            }
            if all_zeros {
                result := str[..dot_pos]
                if result.len == 0 || result == '-' || result == '+' {
                    return '0'
                }
                return result
            }
        }
        return str
    }
    if str.len == 0 {
        return error('invalid scientific notation number')
    }
    mut i := 0
    mut is_negative := false
    if str[i] == `+` || str[i] == `-` {
        is_negative = str[i] == `-`
        i++
    }
    if i >= str.len {
        return error('invalid scientific notation number')
    }
    mut digits := []u8{cap: str.len}
    mut fractional_digits := 0
    mut seen_digit := false
    mut seen_dot := false
    for i < str.len {
        c := str[i]
        if c >= `0` && c <= `9` {
            digits << c
            seen_digit = true
            if seen_dot {
                fractional_digits++
            }
            i++
            continue
        }
        if c == `.` && !seen_dot {
            seen_dot = true
            i++
            continue
        }
        break
    }
    if !seen_digit || i >= str.len || (str[i] != `e` && str[i] != `E`) {
        return error('invalid scientific notation number')
    }
    i++
    mut exponent_sign := 1
    if i < str.len && (str[i] == `+` || str[i] == `-`) {
        if str[i] == `-` {
            exponent_sign = -1
        }
        i++
    }
    if i >= str.len || str[i] < `0` || str[i] > `9` {
        return error('invalid scientific notation number')
    }
    mut exponent := 0
    exponent_cap := max_integer_number_digits + fractional_digits + 1
    for i < str.len && str[i] >= `0` && str[i] <= `9` {
        if exponent < exponent_cap {
            exponent = (exponent * 10) + int(str[i] - `0`)
        }
        i++
    }
    if i != str.len {
        return error('invalid scientific notation number')
    }
    if exponent_sign == -1 {
        exponent = -exponent
    }
    mut first_non_zero := 0
    for first_non_zero < digits.len && digits[first_non_zero] == `0` {
        first_non_zero++
    }
    if first_non_zero == digits.len {
        return '0'
    }
    digits = digits[first_non_zero..].clone()
    scale := exponent - fractional_digits
    if scale < 0 {
        truncated_digits := -scale
        if truncated_digits >= digits.len {
            return '0'
        }
        digits = digits[..digits.len - truncated_digits].clone()
    } else if scale > 0 {
        final_len := digits.len + scale
        if final_len > max_integer_number_digits {
            return error('number `${str}` exceeds 64-bit integer range')
        }
        mut out := []u8{cap: final_len + if is_negative { 1 } else { 0 }}
        if is_negative {
            out << `-`
        }
        out << digits
        for _ in 0 .. scale {
            out << `0`
        }
        return out.bytestr()
    }
    if digits.len == 0 {
        return '0'
    }
    mut out := []u8{cap: digits.len + if is_negative { 1 } else { 0 }}
    if is_negative {
        out << `-`
    }
    out << digits
    return out.bytestr()
}

fn parse_integer_number[T](str string) !T {
    int_str := scientific_number_to_integer_string(str)!
    $if T.unaliased_typ is i8 {
        return T(strconv.atoi8(int_str)!)
    } $else $if T.unaliased_typ is i16 {
        return T(strconv.atoi16(int_str)!)
    } $else $if T.unaliased_typ is i32 {
        return T(strconv.atoi32(int_str)!)
    } $else $if T.unaliased_typ is i64 {
        return T(strconv.atoi64(int_str)!)
    } $else $if T.unaliased_typ is u8 {
        return T(strconv.atou8(int_str)!)
    } $else $if T.unaliased_typ is u16 {
        return T(strconv.atou16(int_str)!)
    } $else $if T.unaliased_typ is u32 {
        return T(strconv.atou32(int_str)!)
    } $else $if T.unaliased_typ is u64 {
        return T(strconv.atou64(int_str)!)
    } $else $if T is int {
        return int(strconv.atoi64(int_str)!)
    } $else $if T.unaliased_typ is int {
        return T(int(strconv.atoi64(int_str)!))
    } $else $if T.unaliased_typ is isize {
        return T(isize(strconv.atoi64(int_str)!))
    } $else $if T.unaliased_typ is usize {
        return T(usize(strconv.atou64(int_str)!))
    } $else {
        return error('`parse_integer_number` cannot decode ${T.name} type')
    }
}

@[markused]
fn parse_int_number(str string) !int {
    int_str := scientific_number_to_integer_string(str)!
    return int(strconv.atoi64(int_str)!)
}

fn parse_float_number[T](str string) !T {
    $if js {
        $if T.unaliased_typ is f32 {
            return T(f32(strconv.atof64(str)!))
        } $else $if T.unaliased_typ is f64 {
            return T(strconv.atof64(str)!)
        } $else {
            return error('`parse_float_number` cannot decode ${T.name} type')
        }
    } $else {
        $if T.unaliased_typ is f32 {
            return T(f32(strconv.atof64(str, allow_extra_chars: false)!))
        } $else $if T.unaliased_typ is f64 {
            return T(strconv.atof64(str, allow_extra_chars: false)!)
        } $else {
            return error('`parse_float_number` cannot decode ${T.name} type')
        }
    }
}

// use pointer instead of mut so enum cast works
@[unsafe]
fn (mut decoder Decoder) decode_number[T](val &T) ! {
    _ = val
    number_info := decoder.current_node.value
    str := decoder.json[number_info.position..number_info.position + number_info.length]
    $match T.unaliased_typ {
        i8 { *val = parse_integer_number[T](str)! }
        i16 { *val = parse_integer_number[T](str)! }
        i32 { *val = parse_integer_number[T](str)! }
        i64 { *val = parse_integer_number[T](str)! }
        u8 { *val = parse_integer_number[T](str)! }
        u16 { *val = parse_integer_number[T](str)! }
        u32 { *val = parse_integer_number[T](str)! }
        u64 { *val = parse_integer_number[T](str)! }
        int { *val = parse_int_number(str)! }
        isize { *val = parse_integer_number[T](str)! }
        usize { *val = parse_integer_number[T](str)! }
        f32 { *val = parse_float_number[T](str)! }
        f64 { *val = parse_float_number[T](str)! }
        $else { return error('`decode_number` can not decode ${T.name} type') }
    }
}

// decode_number_from_string parses a number from a JSON string value (default mode).
// This extracts the content between quotes and parses it as a number.
fn (mut decoder Decoder) decode_number_from_string[T]() !T {
    string_info := decoder.current_node.value
    // Extract string content without quotes (position+1 to skip opening quote, length-2 to exclude both quotes)
    if string_info.length < 2 {
        return error('invalid string for number conversion')
    }
    str := decoder.json[string_info.position + 1..string_info.position + string_info.length - 1]
    $if T.unaliased_typ is i8 {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is i16 {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is i32 {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is i64 {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is u8 {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is u16 {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is u32 {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is u64 {
        return parse_integer_number[T](str)!
    } $else $if T is int {
        return parse_int_number(str)!
    } $else $if T.unaliased_typ is int {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is isize {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is usize {
        return parse_integer_number[T](str)!
    } $else $if T.unaliased_typ is f32 {
        return parse_float_number[T](str)!
    } $else $if T.unaliased_typ is f64 {
        return parse_float_number[T](str)!
    } $else {
        return error('`decode_number_from_string` cannot decode ${T.name} type')
    }
}