// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module json

import math
import strconv
import time

#flag -I @VEXEROOT/thirdparty/cJSON
#flag @VEXEROOT/thirdparty/cJSON/cJSON.o
#include "cJSON.h"
#define js_get(object, key) cJSON_GetObjectItemCaseSensitive((object), (key))

// As cJSON use `libm`, we need to link it.
$if windows {
    $if tinyc {
        #flag @VEXEROOT/thirdparty/tcc/lib/openlibm.o
    }
} $else {
    #flag -lm
}

pub struct C.cJSON {
    next        &C.cJSON
    prev        &C.cJSON
    child       &C.cJSON
    type        int
    valuestring &char
    valueint    int
    valuedouble f64
}

fn C.cJSON_IsTrue(&C.cJSON) bool
fn C.cJSON_IsFalse(&C.cJSON) bool
fn C.cJSON_IsNull(&C.cJSON) bool
fn C.cJSON_IsNumber(&C.cJSON) bool
fn C.cJSON_IsString(&C.cJSON) bool
fn C.cJSON_IsObject(&C.cJSON) bool
fn C.cJSON_IsArray(&C.cJSON) bool

fn C.cJSON_CreateNumber(f64) &C.cJSON
fn C.cJSON_CreateRaw(&char) &C.cJSON

fn C.cJSON_CreateBool(bool) &C.cJSON

fn C.cJSON_CreateString(&char) &C.cJSON

fn C.cJSON_CreateRaw(&char) &C.cJSON

fn C.cJSON_Parse(&char) &C.cJSON

fn C.cJSON_PrintUnformatted(&C.cJSON) &char

fn C.cJSON_Print(&C.cJSON) &char

fn C.cJSON_free(voidptr)
fn C.malloc(usize) voidptr
fn C.memcpy(voidptr, voidptr, usize) voidptr

// decode tries to decode the provided JSON string, into a V structure.
// If it can not do that, it returns an error describing the reason for
// the parsing failure.
pub fn decode(typ voidptr, s string) !voidptr {
    // compiler implementation
    return 0
}

// encode serialises the provided V value as a JSON string, optimised for shortness.
pub fn encode(x voidptr) string {
    // compiler implementation
    return ''
}

// encode_pretty serialises the provided V value as a JSON string, in a formatted way, optimised for viewing by humans.
pub fn encode_pretty(x voidptr) string {
    // compiler implementation
    return ''
}

@[markused]
fn decode_int(root &C.cJSON) int {
    if isnil(root) {
        return 0
    }
    return root.valueint
}

@[markused]
fn decode_i8(root &C.cJSON) i8 {
    if isnil(root) {
        return i8(0)
    }
    return i8(root.valueint)
}

@[markused]
fn decode_i16(root &C.cJSON) i16 {
    if isnil(root) {
        return i16(0)
    }
    return i16(root.valueint)
}

@[markused]
fn decode_i64(root &C.cJSON) i64 {
    if isnil(root) {
        return i64(0)
    }
    if value := decode_exact_i64(root) {
        return value
    }
    return i64(root.valuedouble) // i64 is double in C
}

// TODO: remove when `byte` is removed
@[markused]
fn decode_byte(root &C.cJSON) u8 {
    return decode_u8(root)
}

@[markused]
fn decode_u8(root &C.cJSON) u8 {
    if isnil(root) {
        return u8(0)
    }
    return u8(root.valueint)
}

@[markused]
fn decode_u16(root &C.cJSON) u16 {
    if isnil(root) {
        return u16(0)
    }
    return u16(root.valueint)
}

@[markused]
fn decode_u32(root &C.cJSON) u32 {
    if isnil(root) {
        return u32(0)
    }
    return u32(root.valueint)
}

@[markused]
fn decode_u64(root &C.cJSON) u64 {
    if isnil(root) {
        return u64(0)
    }
    if value := decode_exact_u64(root) {
        return value
    }
    return u64(root.valuedouble)
}

@[markused]
fn decode_f32(root &C.cJSON) f32 {
    if isnil(root) {
        return f32(0)
    }
    return f32(root.valuedouble)
}

@[markused]
fn decode_f64(root &C.cJSON) f64 {
    if isnil(root) {
        return f64(0)
    }
    return root.valuedouble
}

@[markused]
fn decode_rune(root &C.cJSON) rune {
    if isnil(root) {
        return rune(0)
    }
    if isnil(root.valuestring) || !C.cJSON_IsString(root) {
        return rune(0)
    }

    // TODO: Parse as runes, bypassing string casting...?
    return unsafe { tos_clone(&u8(root.valuestring)).runes().first() }
}

@[markused]
fn decode_string(root &C.cJSON) string {
    if isnil(root) {
        return ''
    }
    if !isnil(root.valuestring) && C.cJSON_IsString(root) {
        return unsafe { tos_clone(&u8(root.valuestring)) } // , _strlen(root.valuestring))
    }
    // Object/array values can be stringified JSON payloads (e.g. `{}` from JSON.stringify()).
    if C.cJSON_IsObject(root) || C.cJSON_IsArray(root) {
        return json_print(root)
    }
    return ''
}

@[markused]
fn decode_bool(root &C.cJSON) bool {
    if isnil(root) {
        return false
    }
    return C.cJSON_IsTrue(root)
}

@[markused]
fn decode_time(root &C.cJSON) !time.Time {
    if isnil(root) || C.cJSON_IsNull(root) {
        return time.Time{}
    }
    mut decoded_time := time.Time{}
    if C.cJSON_IsString(root) {
        decoded_time.from_json_string(decode_string(root))!
        return decoded_time
    }
    if C.cJSON_IsNumber(root) {
        decoded_time.from_json_number(json_print(root))!
        return decoded_time
    }
    return error('expected time.Time to decode from a JSON string or number, got: ${json_print(root)}')
}

// ///////////////////

@[markused]
fn encode_int(val int) &C.cJSON {
    return C.cJSON_CreateNumber(val)
}

@[markused]
fn encode_i8(val i8) &C.cJSON {
    return C.cJSON_CreateNumber(val)
}

@[markused]
fn encode_i16(val i16) &C.cJSON {
    return C.cJSON_CreateNumber(val)
}

@[markused]
fn encode_i64(val i64) &C.cJSON {
    lit := val.str()
    return C.cJSON_CreateRaw(&char(lit.str))
}

// TODO: remove when `byte` is removed
@[markused]
fn encode_byte(root u8) &C.cJSON {
    return encode_u8(root)
}

@[markused]
fn encode_u8(val u8) &C.cJSON {
    return C.cJSON_CreateNumber(val)
}

@[markused]
fn encode_u16(val u16) &C.cJSON {
    return C.cJSON_CreateNumber(val)
}

@[markused]
fn encode_u32(val u32) &C.cJSON {
    return C.cJSON_CreateNumber(val)
}

@[markused]
fn encode_u64(val u64) &C.cJSON {
    lit := val.str()
    return C.cJSON_CreateRaw(&char(lit.str))
}

@[markused]
fn encode_f32(val f32) &C.cJSON {
    return C.cJSON_CreateRaw(&char(json_float_to_raw_string(val).str))
}

@[markused]
fn encode_f64(val f64) &C.cJSON {
    return C.cJSON_CreateRaw(&char(json_float_to_raw_string(val).str))
}

@[markused]
fn encode_bool(val bool) &C.cJSON {
    return C.cJSON_CreateBool(val)
}

@[markused]
fn encode_rune(val rune) &C.cJSON {
    return C.cJSON_CreateRaw(&char(json_ascii_string(val.str()).str))
}

@[markused]
fn encode_string(val string) &C.cJSON {
    return C.cJSON_CreateRaw(&char(json_ascii_string(val).str))
}

// json_ascii_string returns a quoted JSON string with non-ASCII runes escaped as `\uXXXX`.
fn json_ascii_string(val string) string {
    mut output := []u8{cap: val.len + 2}
    output << `"`
    for character in val.runes() {
        match character {
            `"` {
                output << `\\`
                output << `"`
            }
            `\\` {
                output << `\\`
                output << `\\`
            }
            `\b` {
                output << `\\`
                output << `b`
            }
            `\f` {
                output << `\\`
                output << `f`
            }
            `\n` {
                output << `\\`
                output << `n`
            }
            `\r` {
                output << `\\`
                output << `r`
            }
            `\t` {
                output << `\\`
                output << `t`
            }
            else {
                if character < 0x20 || character > 0x7f {
                    if character <= 0xffff {
                        output << `\\`
                        output << `u`
                        hex_string := '${u32(character):04x}'
                        unsafe { output.push_many(hex_string.str, 4) }
                    } else {
                        unicode_point_low := u32(character) - 0x10000
                        surrogate_pair := '\\u${0xD800 + ((unicode_point_low >> 10) & 0x3FF):04X}\\u${
                            0xDC00 + (unicode_point_low & 0x3FF):04x}'
                        unsafe { output.push_many(surrogate_pair.str, surrogate_pair.len) }
                    }
                } else {
                    output << u8(character)
                }
            }
        }
    }
    output << `"`
    return output.bytestr()
}

// json_float_to_raw_string uses V's float formatter so json.encode keeps exact float round-trips.
fn json_float_to_raw_string[T](val T) string {
    if val == 0 {
        return '0'
    }
    if math.is_nan(f64(val)) || math.is_inf(f64(val), 0) {
        return 'null'
    }
    mut raw := val.str()
    if raw.len > 2 && raw[raw.len - 2] == `.` && raw[raw.len - 1] == `0` {
        raw = raw[..raw.len - 2]
    }
    return raw
}

fn decode_exact_i64(root &C.cJSON) ?i64 {
    if isnil(root) || isnil(root.valuestring) {
        return none
    }
    lit := unsafe { tos_clone(&u8(root.valuestring)) }
    value := strconv.parse_int(lit, 10, 64) or { return none }
    return value
}

fn decode_exact_u64(root &C.cJSON) ?u64 {
    if isnil(root) || isnil(root.valuestring) {
        return none
    }
    lit := unsafe { tos_clone(&u8(root.valuestring)) }
    value := strconv.parse_uint(lit, 10, 64) or { return none }
    return value
}

fn clone_cstring(s string) &char {
    buf := C.malloc(usize(s.len + 1))
    if buf == unsafe { nil } {
        return unsafe { nil }
    }
    unsafe {
        if s.len > 0 {
            C.memcpy(buf, s.str, usize(s.len))
        }
        (&u8(buf))[s.len] = 0
    }
    return &char(buf)
}

@[inline]
fn is_json_whitespace(ch u8) bool {
    return ch == ` ` || ch == `\n` || ch == `\r` || ch == `\t`
}

fn skip_json_whitespace(src string, idx int) int {
    mut pos := idx
    for pos < src.len && is_json_whitespace(src[pos]) {
        pos++
    }
    return pos
}

fn skip_json_string(src string, idx int) int {
    mut pos := idx
    if pos >= src.len || src[pos] != `"` {
        return -1
    }
    pos++
    for pos < src.len {
        match src[pos] {
            `"` {
                return pos + 1
            }
            `\\` {
                pos++
                if pos >= src.len {
                    return -1
                }
                if src[pos] == `u` {
                    pos += 5
                } else {
                    pos++
                }
            }
            else {
                pos++
            }
        }
    }
    return -1
}

fn skip_json_literal(src string, lit string, idx int) int {
    if idx + lit.len > src.len || src[idx..idx + lit.len] != lit {
        return -1
    }
    return idx + lit.len
}

fn skip_json_number(src string, idx int) (string, int) {
    mut pos := idx
    start := pos
    if pos < src.len && src[pos] == `-` {
        pos++
    }
    if pos >= src.len {
        return '', -1
    }
    if src[pos] == `0` {
        pos++
    } else {
        if !src[pos].is_digit() {
            return '', -1
        }
        for pos < src.len && src[pos].is_digit() {
            pos++
        }
    }
    if pos < src.len && src[pos] == `.` {
        pos++
        if pos >= src.len || !src[pos].is_digit() {
            return '', -1
        }
        for pos < src.len && src[pos].is_digit() {
            pos++
        }
    }
    if pos < src.len && (src[pos] == `e` || src[pos] == `E`) {
        pos++
        if pos < src.len && (src[pos] == `+` || src[pos] == `-`) {
            pos++
        }
        if pos >= src.len || !src[pos].is_digit() {
            return '', -1
        }
        for pos < src.len && src[pos].is_digit() {
            pos++
        }
    }
    return src[start..pos], pos
}

fn annotate_json_number_literal(root &C.cJSON, lit string) {
    if lit.len == 0 || !isnil(root.valuestring) {
        return
    }
    unsafe {
        root.valuestring = clone_cstring(lit)
    }
}

fn annotate_json_value(root &C.cJSON, src string, idx int) int {
    if isnil(root) {
        return -1
    }
    mut pos := skip_json_whitespace(src, idx)
    if C.cJSON_IsObject(root) {
        if pos >= src.len || src[pos] != `{` {
            return -1
        }
        pos++
        pos = skip_json_whitespace(src, pos)
        mut child := root.child
        if isnil(child) {
            if pos >= src.len || src[pos] != `}` {
                return -1
            }
            return pos + 1
        }
        for !isnil(child) {
            pos = skip_json_string(src, pos)
            if pos == -1 {
                return -1
            }
            pos = skip_json_whitespace(src, pos)
            if pos >= src.len || src[pos] != `:` {
                return -1
            }
            pos++
            pos = annotate_json_value(child, src, pos)
            if pos == -1 {
                return -1
            }
            pos = skip_json_whitespace(src, pos)
            if !isnil(child.next) {
                if pos >= src.len || src[pos] != `,` {
                    return -1
                }
                pos++
            }
            child = child.next
        }
        if pos >= src.len || src[pos] != `}` {
            return -1
        }
        return pos + 1
    }
    if C.cJSON_IsArray(root) {
        if pos >= src.len || src[pos] != `[` {
            return -1
        }
        pos++
        pos = skip_json_whitespace(src, pos)
        mut child := root.child
        if isnil(child) {
            if pos >= src.len || src[pos] != `]` {
                return -1
            }
            return pos + 1
        }
        for !isnil(child) {
            pos = annotate_json_value(child, src, pos)
            if pos == -1 {
                return -1
            }
            pos = skip_json_whitespace(src, pos)
            if !isnil(child.next) {
                if pos >= src.len || src[pos] != `,` {
                    return -1
                }
                pos++
            }
            child = child.next
        }
        if pos >= src.len || src[pos] != `]` {
            return -1
        }
        return pos + 1
    }
    if C.cJSON_IsString(root) {
        return skip_json_string(src, pos)
    }
    if C.cJSON_IsNumber(root) {
        lit, next_pos := skip_json_number(src, pos)
        if next_pos == -1 {
            return -1
        }
        annotate_json_number_literal(root, lit)
        return next_pos
    }
    if C.cJSON_IsTrue(root) {
        return skip_json_literal(src, 'true', pos)
    }
    if C.cJSON_IsFalse(root) {
        return skip_json_literal(src, 'false', pos)
    }
    if C.cJSON_IsNull(root) {
        return skip_json_literal(src, 'null', pos)
    }
    return -1
}

fn annotate_json_number_literals(root &C.cJSON, src string) {
    _ := annotate_json_value(root, src, 0)
}

// ///////////////////////
// user := decode_User(json_parse(js_string_var))
@[markused]
fn json_parse(s string) &C.cJSON {
    root := C.cJSON_Parse(&char(s.str))
    if !isnil(root) {
        annotate_json_number_literals(root, s)
    }
    return root
}

// json_string := json_print(encode_User(user))
@[markused]
fn json_print(data &C.cJSON) string {
    s := C.cJSON_PrintUnformatted(data)
    if s == unsafe { nil } {
        return ''
    }
    r := unsafe { tos_clone(&u8(s)) }
    C.cJSON_free(s)
    return r
}

@[markused]
fn json_print_pretty(data &C.cJSON) string {
    s := C.cJSON_Print(data)
    if s == unsafe { nil } {
        return ''
    }
    r := unsafe { tos_clone(&u8(s)) }
    C.cJSON_free(s)
    return r
}

// /  cjson wrappers
// fn json_array_for_each(val, root &C.cJSON) {
// #cJSON_ArrayForEach (val ,root)
// }