/*
文件名:Json_Class.nut
路径:Base/_Tool/Json_Class.nut
创建日期:2024-09-27	23:54
文件用途:Json类
*/

class JSONParser {


    static version = "1.0.1";


    state = "";
    stack = null;
    container = null;
    key = "";
    value = "";
    converter = null;

    constructor() {
        stack = [];
        container = {};
    }

    function parse(str, ...) {
        if (vargc > 0) converter = vargc[0];


        // actions for string tokens
        local string = {
            go = function() {
                state = "ok";
            }.bindenv(this),
            firstokey = function() {
                key = value;
                state = "colon";
            }.bindenv(this),
            okey = function() {
                key = value;
                state = "colon";
            }.bindenv(this),
            ovalue = function() {
                value = this._convert(value, "string", converter);
                state = "ocomma";
            }.bindenv(this),
            firstavalue = function() {
                value = this._convert(value, "string", converter);
                state = "acomma";
            }.bindenv(this),
            avalue = function() {
                value = value;
                this._convert(value, "string", converter);
                state = "acomma";
            }.bindenv(this)
        };

        // the actions for number tokens
        local number = {
            go = function() {
                state = "ok";
            }.bindenv(this),
            ovalue = function() {
                value = this._convert(value, "number", converter);
                state = "ocomma";
            }.bindenv(this),
            firstavalue = function() {
                value = this._convert(value, "number", converter);
                state = "acomma";
            }.bindenv(this),
            avalue = function() {
                value = this._convert(value, "number", converter);
                state = "acomma";
            }.bindenv(this)
        };


        // action table
        // describes where the state machine will go from each given state
        local action = {};


        action["{"] <- {
                go = function() {
                    stack.push({
                        state = "ok"
                    });
                    container = {};
                    state = "firstokey";
                }.bindenv(this),
                ovalue = function() {
                    stack.push({
                        container = container,
                        state = "ocomma",
                        key = key
                    });
                    container = {};
                    state = "firstokey";
                }.bindenv(this),
                firstavalue = function() {
                    stack.push({
                        container = container,
                        state = "acomma"
                    });
                    container = {};
                    state = "firstokey";
                }.bindenv(this),
                avalue = function() {
                    stack.push({
                        container = container,
                        state = "acomma"
                    });
                    container = {};
                    state = "firstokey";
                }.bindenv(this)
            },

            action["}"] <- {
                firstokey = function() {
                    local pop = stack.pop();
                    value = container;
                    container = ("container" in pop) ? pop.container : null;
                    key = ("key" in pop) ? pop.key : null;
                    state = pop.state;
                }.bindenv(this),
                ocomma = function() {
                    local pop = stack.pop();
                    container[key] <- value;
                    value = container;
                    container = ("container" in pop) ? pop.container : null;
                    key = ("key" in pop) ? pop.key : null;
                    state = pop.state;
                }.bindenv(this)
            },

            action["["] <- {
                go = function() {
                    stack.push({
                        state = "ok"
                    });
                    container = [];
                    state = "firstavalue";
                }.bindenv(this),
                ovalue = function() {
                    stack.push({
                        container = container,
                        state = "ocomma",
                        key = key
                    });
                    container = [];
                    state = "firstavalue";
                }.bindenv(this),
                firstavalue = function() {
                    stack.push({
                        container = container,
                        state = "acomma"
                    });
                    container = [];
                    state = "firstavalue";
                }.bindenv(this),
                avalue = function() {
                    stack.push({
                        container = container,
                        state = "acomma"
                    });
                    container = [];
                    state = "firstavalue";
                }.bindenv(this)
            },

            action["]"] <- {
                firstavalue = function() {
                    local pop = stack.pop();
                    value = container;
                    container = ("container" in pop) ? pop.container : null;
                    key = ("key" in pop) ? pop.key : null;
                    state = pop.state;
                }.bindenv(this),
                acomma = function() {
                    local pop = stack.pop();
                    container.push(value);
                    value = container;
                    container = ("container" in pop) ? pop.container : null;
                    key = ("key" in pop) ? pop.key : null;
                    state = pop.state;
                }.bindenv(this)
            },

            action[":"] <- {
                colon = function() {
                    // Check if the key already exists
                    // NOTE previous code used 'if (key in container)...'
                    //      but this finds table ('container') member methods too
                    local err = false;
                    foreach(akey, avalue in container) {
                        if (akey == key) err = true;
                        break
                    }
                    if (err) throw "Duplicate key \"" + key + "\"";
                    state = "ovalue";
                }.bindenv(this)
            },

            action[","] <- {
                ocomma = function() {
                    container[key] <- value;
                    state = "okey";
                }.bindenv(this),
                acomma = function() {
                    container.push(value);
                    state = "avalue";
                }.bindenv(this)
            },

            action["true"] <- {
                go = function() {
                    value = true;
                    state = "ok";
                }.bindenv(this),
                ovalue = function() {
                    value = true;
                    state = "ocomma";
                }.bindenv(this),
                firstavalue = function() {
                    value = true;
                    state = "acomma";
                }.bindenv(this),
                avalue = function() {
                    value = true;
                    state = "acomma";
                }.bindenv(this)
            },

            action["false"] <- {
                go = function() {
                    value = false;
                    state = "ok";
                }.bindenv(this),
                ovalue = function() {
                    value = false;
                    state = "ocomma";
                }.bindenv(this),
                firstavalue = function() {
                    value = false;
                    state = "acomma";
                }.bindenv(this),
                avalue = function() {
                    value = false;
                    state = "acomma";
                }.bindenv(this)
            },

            action["null"] <- {
                go = function() {
                    value = null;
                    state = "ok";
                }.bindenv(this),
                ovalue = function() {
                    value = null;
                    state = "ocomma";
                }.bindenv(this),
                firstavalue = function() {
                    value = null;
                    state = "acomma";
                }.bindenv(this),
                avalue = function() {
                    value = null;
                    state = "acomma";
                }.bindenv(this)
            }



        //
        state = "go";
        stack = [];

        // current tokenizeing position
        local start = 0;

        try {

            local result, token, tokenizer = _JSONTokenizer();

            while (token = tokenizer.nextToken(str, start)) {

                if ("ptfn" == token.type) {
                    // punctuation/true/false/null
                    action[token.value][state]();
                } else if ("number" == token.type) {
                    // number
                    value = token.value;
                    number[state]();
                } else if ("string" == token.type) {
                    // string
                    value = tokenizer.unescape(token.value);
                    string[state]();
                }

                start += token.length;
            }

        } catch (e) {
            state = e;
        }


        if (state != "ok" || regexp("[^\\s]").capture(str, start)) {
            local near = str.slice(start, GetMin(str.len(), start + 10));
            throw "JSON Syntax Error near `" + near + "`";
        }


        return value;
    }

    function GetMin(a, b) {
        return a< b ? a : b;
    }


    function _convert(value, type, converter) {
        if ("function" == typeof converter) {

            // # of params for converter function

            local parametercCount = 2;

            // .getinfos() is missing on ei platform
            if ("getinfos" in converter) {
                parametercCount = converter.getinfos().parameters.len() -
                    1;
            }

            if (parametercCount == 1) {
                return converter(value);
            } else if (parametercCount == 2) {
                return converter(value, type);
            } else {
                throw "Error: converter function must take 1 or 2 parameters"
            }

        } else if ("number" == type) {
            local Ret = (value.find(".") == null && value.find("e") == null && value.find("E") == null) ? value.tointeger() : value.tofloat();
            return Ret;
        } else {
            return value;
        }

    }
}



class _JSONTokenizer {

    _ptfnRegex = null;
    _numberRegex = null;
    _stringRegex = null;
    _ltrimRegex = null;
    _unescapeRegex = null;

    constructor() {
        // punctuation/true/false/null
        this._ptfnRegex = regexp("^(?:\\,|\\:|\\[|\\]|\\{|\\}|true|false|null)");

        // numbers
        this._numberRegex = regexp("^(?:\\-?\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?)");

        // strings
        this._stringRegex = regexp("^(?:\\\"((?:[^\\r\\n\\t\\\\\\\"]|\\\\(?:[\"\\\\\\/trnfb]|u[0-9a-fA-F]{4}))*)\\\")");

        // ltrim pattern
        this._ltrimRegex = regexp("^[\\s\\t\\n\\r]*");

        // string unescaper tokenizer pattern
        this._unescapeRegex = regexp("\\\\(?:(?:u\\d{4})|[\\\"\\\\/bfnrt])");
    }


    function nextToken(str, ...) {
        local start = 0;
        if (vargc > 0) start = vargv[0];
        local
        m,
        type,
        token,
        value,
        length,
        whitespaces;

        // count # of left-side whitespace chars
        whitespaces = this._leadingWhitespaces(str, start);
        start += whitespaces;

        if (m = this._ptfnRegex.capture(str, start)) {
            // punctuation/true/false/null
            value = str.slice(m[0].begin, m[0].end);
            type = "ptfn";
        } else if (m = this._numberRegex.capture(str, start)) {
            // number
            value = str.slice(m[0].begin, m[0].end);
            type = "number";
        } else if (m = this._stringRegex.capture(str, start)) {
            // string
            value = str.slice(m[1].begin, m[1].end);
            type = "string";
        } else {
            return null;
        }

        token = {
            type = type,
            value = value,
            length = m[0].end - m[0].begin + whitespaces
        };

        return token;
    }


    function _leadingWhitespaces(str, start) {
        local r = this._ltrimRegex.capture(str, start);

        if (r) {
            return r[0].end - r[0].begin;
        } else {
            return 0;
        }
    }

    // unesacape() replacements table
    _unescapeReplacements = {
        b = "\b",
        f = "\f",
        n = "\n",
        r = "\r",
        t = "\t"
    };

    function unescape(str) {

        local start = 0;
        local res = "";

        while (start< str.len()) {
            local m = this._unescapeRegex.capture(str, start);

            if (m) {
                local token = str.slice(m[0].begin, m[0].end);

                // append chars before match
                local pre = str.slice(start, m[0].begin);
                res += pre;

                if (token.len() == 6) {
                    res += token;
                } else {
                    local char = token.slice(1);

                    if (char in this._unescapeReplacements) {
                        res += this._unescapeReplacements[char];
                    } else {
                        res += char;
                    }
                }

            } else {
                res += str.slice(start);
                break;
            }

            start = m[0].end;
        }

        return res;
    }
}


class JSONEncoder {

    static VERSION = "2.0.0";

    // max structure depth
    // anything above probably has a cyclic ref
    static _maxDepth = 32;


    function encode(value) {
        return this._encode(value);
    }


    function _encode(val, ...) {
        local depth = 0;
        if (vargc > 0) depth = vargv[0];
        // detect cyclic reference
        if (depth > this._maxDepth) {
            throw "Possible cyclic reference";
        }

        local
        r = "",
            s = "",
            i = 0;

        switch (typeof val) {

            case "table":
            case "class":
                s = "";

                // serialize properties, but not functions
                foreach(k, v in val) {
                    if (typeof v != "function") {
                        s += ",\"" + k + "\":" + this._encode(v, depth + 1);
                    }
                }

                s = s.len() > 0 ? s.slice(1) : s;
                r += "{" + s + "}";
                break;

            case "array":
                s = "";

                for (i = 0; i< val.len(); i++) {
                    s += "," + this._encode(val[i], depth + 1);
                }

                s = (i > 0) ? s.slice(1) : s;
                r += "[" + s + "]";
                break;

            case "integer":
            case "float":
            case "bool":
                r += val;
                break;

            case "null":
                r += "null";
                break;

            case "instance":

                if ("_serializeRaw" in val && typeof val._serializeRaw == "function") {

                    // include value produced by _serializeRaw()
                    r += val._serializeRaw().tostring();

                } else if ("_serialize" in val && typeof val._serialize == "function") {

                    // serialize instances by calling _serialize method
                    r += this._encode(val._serialize(), depth + 1);

                } else {

                    s = "";

                    try {

                        // iterate through instances which implement _nexti meta-method
                        foreach(k, v in val) {
                            s += ",\"" + k + "\":" + this._encode(v, depth + 1);
                        }

                    } catch (e) {

                        // iterate through instances w/o _nexti
                        // serialize properties, but not functions
                        foreach(k, v in val.getclass()) {
                            if (typeof v != "function") {
                                s += ",\"" + k + "\":" + this._encode(val[k], depth + 1);
                            }
                        }

                    }

                    s = s.len() > 0 ? s.slice(1) : s;
                    r += "{" + s + "}";
                }

                break;

            case "blob":
                // This is a workaround for a known bug:
                // on device side Blob.tostring() returns null
                // (instaead of an empty string)
                r += "\"" + (val.len() ? this._escape(val.tostring()) : "") + "\"";
                break;

                // strings and all other
            default:
                r += "\"" + this._escape(val.tostring()) + "\"";
                break;
        }

        return r;
    }

    function _escape(str) {
        local res = "";

        for (local i = 0; i< str.len(); i++) {

            local ch1 = (str[i] & 0xFF);

            if ((ch1 & 0x80) == 0x00) {
                // 7-bit Ascii

                ch1 = format("%c", ch1);

                if (ch1 == "\"") {
                    res += "\\\"";
                } else if (ch1 == "\\") {
                    res += "\\\\";
                } else if (ch1 == "/") {
                    res += "\\/";
                } else if (ch1 == "\b") {
                    res += "\\b";
                } else if (ch1 == "\f") {
                    res += "\\f";
                } else if (ch1 == "\n") {
                    res += "\\n";
                } else if (ch1 == "\r") {
                    res += "\\r";
                } else if (ch1 == "\t") {
                    res += "\\t";
                } else if (ch1 == "\0") {
                    res += "\\u0000";
                } else {
                    res += ch1;
                }

            } else {

                if ((ch1 & 0xE0) == 0xC0) {
                    // 110xxxxx = 2-byte unicode
                    local ch2 = (str[++i] & 0xFF);
                    res += format("%c%c", ch1, ch2);
                } else if ((ch1 & 0xF0) == 0xE0) {
                    // 1110xxxx = 3-byte unicode
                    local ch2 = (str[++i] & 0xFF);
                    local ch3 = (str[++i] & 0xFF);
                    res += format("%c%c%c", ch1, ch2, ch3);
                } else if ((ch1 & 0xF8) == 0xF0) {
                    // 11110xxx = 4 byte unicode
                    local ch2 = (str[++i] & 0xFF);
                    local ch3 = (str[++i] & 0xFF);
                    local ch4 = (str[++i] & 0xFF);
                    res += format("%c%c%c%c", ch1, ch2, ch3, ch4);
                }

            }
        }

        return res;
    }
}