//+------------------------------------------------------------------+
//|                                                     toyjson3.mqh |
//|                             Copyright 2022-2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+

#include "..\\..\\..\\MQL5Book\\Include\\MapArray.mqh"
#include "..\\..\\..\\MQL5Book\\Include\\AutoPtr.mqh"
#include "..\\..\\..\\MQL5Book\\Include\\Defines.mqh"
#include "..\\..\\..\\MQL5Book\\Include\\StringUtils.mqh"

enum JS_TYPE
{
   JS_OBJECT,
   JS_ARRAY,
   JS_PRIMITIVE,
   JS_NULL,        // singleton object stub for undefined props
   JS_ERROR
};

enum JS_AFFINITY  // for primitive type
{
   JS_NONE   = 0,
   JS_CONST  = 1, // true, false, null
   JS_INT    = 2,
   JS_FLOAT  = 4,
   JS_STRING = 8
};

#define JS_EOF 26 // Ctrl-Z
#ifndef JS_STACK_LIMIT
   #define JS_STACK_LIMIT 50
#endif

#ifndef ArrayContains

template<typename T>
int ArrayIndexOf(const T &a[], const T v)
{
   for(int i = 0; i < ArraySize(a); i++)
   {
      if(a[i] == v) return i;
   }
   return -1;
}

#define ArrayContains(A,V) (ArrayIndexOf(A,(V)) > -1)
#endif

//+------------------------------------------------------------------+
//| Main class to store single value (primitive, object, or array)   |
//+------------------------------------------------------------------+
class JsValue
{
   MapArray<string, int> properties;
   JsValue *objects[];
   
public:
   const static JsValue null;
   
   const string s;      // value is assigned once at construction
   const JS_TYPE t;     // type and
   const JS_AFFINITY a; //          affinity as detected
   JsValue(const string _s): s(_s), t(JS_PRIMITIVE), a(detect()) { }

   JsValue(const JS_TYPE _t = JS_OBJECT): t(_t), s(NULL), a(JS_NONE) { }
   
   JsValue(JsValue *that): s(that.s), t(that.t), a(that.a)
   {
      for(int i = 0; i < that.size(); i++)
      {
         if(that[i].t >= JS_PRIMITIVE)
         {
            this.put(t == JS_OBJECT ? that.props().getKey(i) : NULL, that[i].s);
         }
         else
         {
            this.put(t == JS_OBJECT ? that.props().getKey(i) : NULL, new JsValue(that[i]));
         }
      }
   }
   
   ~JsValue()
   {
      for(int i = 0; i < ArraySize(objects); i++)
      {
         FREE(objects[i]);
      }
   }
   
   bool merge(JsValue *that, const bool move = false)
   {
      if(this.t != that.t) return false;
      if(this.t >= JS_PRIMITIVE) return false;
      for(int i = 0; i < that.size(); i++)
      {
         if(that[i].t >= JS_PRIMITIVE)
         {
            if(move)
            {
               this.put(that.t == JS_OBJECT ? that.props().getKey(i) : NULL, that[i]);
            }
            else
            {
               this.put(that.t == JS_OBJECT ? that.props().getKey(i) : NULL, that[i].s);
            }
         }
         else
         {
            if(move)
            {
               this.put(that.t == JS_OBJECT ? that.props().getKey(i) : NULL, that[i]);
            }
            else
            {
               this.put(that.t == JS_OBJECT ? that.props().getKey(i) : NULL, move ? that[i] : new JsValue(that[i]));
            }
         }
         if(move) that.drop(i);
      }
      return true;
   }
   
   int length() const
   {
      return ArraySize(objects);
   }
   
   const MapArray<string, int> * const props() const
   {
      return &properties;
   }
   
   // simplistic state-machine approach
   static JS_AFFINITY isNumeric(const ushort c, const JS_AFFINITY state = 0)
   {
      if(c == '+' || c == '-')
      {
         if(state == JS_NONE || ((state & JS_FLOAT) == JS_FLOAT)) return state; // leading sign or in exponent
      }
      else if(c >= '0' && c <= '9') return JS_INT;
      else if(c == '.')
      {
         if(state < JS_FLOAT) return JS_FLOAT; // one point is a valid number
      }
      else if(c == 'e' || c == 'E') // PRB: multiple E's aren't catched as string
      {
         if(state >= JS_INT) return JS_FLOAT; // exponent is allowed provided digits exist
      }
      else if(c == ' ' || c == '\r' || c == '\n' || c == '\t') return JS_NONE;
      return JS_STRING; // also used for datetime, not existing in JSON
   }

   JS_AFFINITY detect() const
   {
      if(s == "true" || s == "false" || s == "null") return JS_CONST;
      if(s == "") return JS_STRING;
      JS_AFFINITY result = 0;
      for(int i = 0; i < StringLen(s) && result < JS_STRING; ++i)
      {
         result |= isNumeric(s[i], result);
      }
      return result;
   }
   
   string stringify(const uint allocate = 0, const int pretty = -1) const
   {
      if(t < JS_PRIMITIVE)
      {
         string buffer;
         if(allocate) StringReserve(buffer, allocate);
         stringify(buffer, pretty);
         return buffer;
      }
      if(a >= JS_STRING)
      {
         string ss = s;
         StringReplace(ss, "\"", "\\\"");
         return "\"" + ss + "\"";
      }
      if(a >= JS_FLOAT) return s; // FIXME: apply specific accuracy
      if(a >= JS_INT) return s;
      return s != NULL ? s : "null";
   }

   template<typename T>
   T get(const bool typechecks = true, T def = (T)NULL) const
   {
      if(typechecks)
      {
         if(t != JS_PRIMITIVE) return def;
         if(a >= JS_STRING && typename(T) != "string") return def;
         if(a == JS_CONST && typename(T) != "bool") return def;
      }
      // return (T)s;
      T r;
      cast(s, r);
      return r;
   }
   
   template<typename T>
   void cast(const string &in, T &out) const
   {
      out = (T)s;
   }

   void cast(const string &in, bool &out) const
   {
      out = !this.operator!();
   }

   bool operator!() const
   {
      if(t != JS_PRIMITIVE) return !(t < JS_PRIMITIVE); // NULL object is falsy
      if(a >= JS_STRING) return !(StringLen(s) > 0);
      if(a == JS_CONST) return !(s == "true");
      return !(double)(s);
   }
   
   template<typename T>
   bool operator==(const T value) const
   {
      if(t < JS_PRIMITIVE) return false;
      if(a >= JS_STRING && typename(T) != "string") return false;
      if(a == JS_CONST && typename(T) != "bool") return false;
      T temp = this.get<T>(false);
      return temp == value;
   }
   
   // check if 'that' is a subset of 'this',
   // 'fast' false means deep look for detailed changes and strict comparison
   bool match(const JsValue *that, const bool fast = true, JsValue *details = NULL)
   {
      bool result = true;

      if(this.t != that.t)
      {
         if(details)
         {
            details.put("(Type change)", StringFormat("(%s->%s)", EnumToString(this.t), EnumToString(that.t)));
         }
         return false;
      }
      if(this.t == JS_PRIMITIVE)
      {
         if(details && this.s != that.s)
         {
            details.put("(Value change)", StringFormat("(%s;%s->%s)", EnumToString(this.a), this.s, that.s));
         }
         return this.s == that.s;
      }
      
      if(this.t == JS_OBJECT)
      {
         if(fast && this.size() != that.size())
         {
            if(details)
            {
               details.put("(Object size change)", StringFormat("(%d->%d)", this.size(), that.size()));
            }
            return false;
         }
         
         static string keys1[], keys2[];
         that.getProperties(keys2);
         
         if(fast)
         {
            this.getProperties(keys1);
            if(ArrayCompare(keys1, keys2))
            {
               if(details)
               {
                  details.put("(Object keys differ)", StringFormat("`[[%s],[%s]]", SubArrayCombine(keys1, ","), SubArrayCombine(keys2, ",")));
               }
               return false;
            }
         }
         else
         {
            for(int i = 0; i < ArraySize(keys2); i++)
            {
               if(this[keys2[i]].t == JS_NULL)
               {
                  //if(details)
                  //{
                  //   details.put("Key is missing", keys2[i]); // will be logged below
                  //}
                  result = false;
               }
            }
         }
      }
      else
      {
         if(fast && this.length() != that.length())
         {
            if(details)
            {
               details.put("(Array length change)", StringFormat("(%d->%d)", this.length(), that.length()));
            }
            return false;
         }
      }
      
      if(fast)
      {
         for(int i = 0; i < ArraySize(objects); i++)
         {
            JsValue *sub = details ? new JsValue() : NULL;
            if(!objects[i].match(that[i], fast, sub))
            {
               if(details)
               {
                  if(sub.size()) details.put(this.t == JS_OBJECT ? properties.getKey(i) : StringFormat("%d", i), sub);
                  else delete sub;
               }
               result = false;
               if(!details) return false;
               // for details keep looping and comparing
            }
            
            if(sub && !sub.size()) delete sub;
         }
      }
      else
      {
         int matches = 0;
         int foundinthis[];
         int foundinthat[];
         
         // collect changes preliminary
         for(int i = 0; i < that.length() /*&& matches < that.length()*/; i++)
         {
            const JsValue *other = that[i];
            //if(ArrayContains(foundinthat, i)) continue; // fast but incomplete
            for(int j = 0; j < ArraySize(objects); j++)
            {
               //if(ArrayContains(foundinthis, j)) continue; // fast but incomplete
               if(objects[j].match(other, fast, NULL))
               {
                  //PUSH(foundinthis, j); // fast but incomplete
                  //PUSH(foundinthat, i); // fast but incomplete
                  
                  bool update = true;
                  int i1 = ArrayIndexOf(foundinthis, j);
                  int i2 = ArrayIndexOf(foundinthat, i);
                  
                  // look at corresponding counterparts
                  int ip = -1, jp = -1;
                  if(i1 > -1) jp = foundinthat[i1];
                  if(i2 > -1) ip = foundinthis[i2];
                  
                  if(jp > -1 && ip > -1 && fabs(ip - jp) <= fabs(i - j)) // speculation on closer changes
                  {
                     update = false;
                  }
                  if(update)
                  {
                     if(i1 > -1) foundinthis[i1] = -1;
                     PUSH(foundinthis, j);
                     if(i2 > -1) foundinthat[i2] = -1;
                     PUSH(foundinthat, i);
                  }
                  
                  matches++;
               }
            }
         }
         
         matches = 0; // that.length();
         for(int i = 0; i < ArraySize(foundinthat); i++)
         {
            if(foundinthat[i] != -1 && foundinthat[i] == foundinthis[i]) matches++;
         }
         
         if(matches < that.length())
         {
            if(details)
            {
               // collect details about differences
               for(int i = 0; i < that.length(); i++)
               {
                  const int p = ArrayIndexOf(foundinthis, i); // ArrayIndexOf(foundinthis, i);
                  if(p != -1 && foundinthat[p] == i) continue;
                  int k = ArrayIndexOf(foundinthat, i);
                  if(k > -1) k = foundinthis[k];
                  
                  if(k == -1 && i < this.length()) k = i; // speculation about change at the same i, modification
                  
                  if(k == -1)
                  {
                     details.put(that.t == JS_OBJECT ? that.props().getKey(i) : StringFormat("%d", i), "(new, missing in old)");
                     continue;
                  }
                  
                  // here we have 'that' element missing in 'this'
                  
                  JsValue *sub = new JsValue();
                  
                  objects[k].match(that[i], fast, sub);
                  
                  if(sub.size())
                  {
                     details.put(that.t == JS_OBJECT ? that.props().getKey(i) : StringFormat("%d", i), sub);
                  }
                  else
                  {
                     delete sub;
                     matches++;
                  }
               }
               
               #ifdef TOYJSON_SHOW_STATS
               if(matches < that.length())
                  details.put("(Incomplete pattern match)", StringFormat("(%d of %d)", matches, that.length()));
               #endif
            }
            if(matches < that.length())
            {
               result = false;
               if(!details) return false;
            }
         }

         // uncomment this to make comparison symmetrical between 'this' and 'that'
         #ifdef TOYJSON_MIRROR_MATCH
         matches = 0; // that.length();
         for(int i = 0; i < ArraySize(foundinthis); i++)
         {
            if(foundinthis[i] != -1 && foundinthat[i] == foundinthis[i]) matches++;
         }
         
         if(matches < this.length())
         {
            if(details)
            {
               for(int j = 0; j < ArraySize(objects); j++)
               {
                  const int p = ArrayIndexOf(foundinthis, j);
                  if(p != -1 && foundinthat[p] == j) continue;
                  int k = ArrayIndexOf(foundinthis, j);
                  if(k > -1) k = foundinthat[k];
                  
                  if(k == -1 && j < that.length()) k = j; // speculation about change at the same j, modification
                  
                  if(k == -1)
                  {
                     details.put(this.t == JS_OBJECT ? this.props().getKey(j) : StringFormat("%d", j), "(old, missing in new)");
                     continue;
                  }
                  
                  // here we have 'this' element missing in 'that' (which can be normal if 'that' is a subset, "search pattern")
                  
                  JsValue *sub = new JsValue();
                  
                  objects[j].match(that[k], fast, sub);
                  
                  if(sub.size())
                  {
                     details.put(this.t == JS_OBJECT ? properties.getKey(j) : StringFormat("%d", j), sub);
                  }
                  else
                  {
                     delete sub;
                     matches++;
                  }
               }
               
               #ifdef TOYJSON_SHOW_STATS
               if(matches < this.length())
                  details.put("(Coverage)", StringFormat("(%d of %d)", matches, this.length()));
               #endif
            }
            // we don't return false here, because 'that' is considered a search pattern (subset) for 'this',
            // hence some parts existing in 'this' but missing in 'that' does still mean that 'this' fulfills all props of 'that'
            // result = false;
         }
         #endif
      }
      
      return result;
   }
   
   int size() const
   {
      if(t == JS_OBJECT) return properties.getSize();
      else if(t == JS_ARRAY) return ArraySize(objects);
      return 0;
   }

   // object putters

   template<typename T>
   bool try_parse(const string key, const T value)
   {
      return false; // all except strings are non-parseable
   }

   bool try_parse(const string key, const string value)
   {
      if(value[0] == '`')
      {
         put(key, JsParser::jsonify(StringSubstr(value, 1)));
         return true;
      }
      return false;
   }
   
   template<typename T>
   void put(const string key, const T value)
   {
      if(try_parse(key, value)) return;
      
      put(key, new JsValue((string)value));
   }
   
   void put(const string key, const double value, const int digits = 8)
   {
      put(key, new JsValue(DoubleToString(value, digits)));
   }

   void put(const string key, JsValue *value)
   {
      if(t == JS_NULL) return; // show bulk errors?
      if(t != JS_OBJECT)
      {
         if(key != NULL)
         {
            PrintFormat("WARNING: Setting property '%s' for non-object", key);
         }
      }
      else if(key == NULL)
      {
         Print("WARNING: Setting NULL property for object");
      }
      int p = key == NULL ? -1 : properties.find(key);
      if(p == -1)
      {
         p = EXPAND(objects);
         if(key != NULL) properties.put(key, p);
      }
      else
      {
         FREE(objects[p]);
      }
      objects[p] = value;
   }
   
   // array putters
   
   template<typename T>
   void put(const T value)
   {
      put(NULL, value);
   }

   template<typename T>
   void replace(const int i, const T value)
   {
      if(t >= JS_PRIMITIVE) return;
      if(i < 0 || i >= ArraySize(objects)) return;
      FREE(objects[i]);
      objects[i] = new JsValue((string)value);
   }

   template<typename T>
   void put(const T &values[])
   {
      for(int i = 0; i < ArraySize(values); i++)
      {
         put(NULL, new JsValue((string)values[i]));
      }
   }

   void put(const double value, const int digits = 8)
   {
      put(NULL, new JsValue(DoubleToString(value, digits)));
   }

   void put(JsValue *value)
   {
      if(t != JS_ARRAY)
      {
         Print("WARNING: Setting indexed element for non-array: ", value.stringify());
      }
      put(NULL, value);
   }

   void replace(const int i, JsValue *value)
   {
      if(t >= JS_PRIMITIVE) return;
      /*
      if(t != JS_ARRAY)
      {
         PrintFormat("WARNING: Setting %d-th element for non-array (%s): %s", i, EnumToString(t), value.stringify());
      }
      */
      if(i < 0 || i >= ArraySize(objects)) return;
      FREE(objects[i]);
      objects[i] = value;
   }

   void drop(const int i)
   {
      if(t >= JS_PRIMITIVE) return;
      /*
      if(t != JS_ARRAY)
      {
         PrintFormat("WARNING: Dropping %d-th element of non-array (%s): %s", i, EnumToString(t), s);
      }
      */
      if(i < 0 || i >= ArraySize(objects)) return;
      objects[i] = (JsValue *)&null;
   }
   
   // indexed access
   
   JsValue *operator[](const string name) // const
   {
      const int p = properties.find(name);
      if(p == -1) return (JsValue *)&null;
      return objects[p];
   }

   JsValue *operator[](const int i) const
   {
      if(i >= ArraySize(objects)) return (JsValue *)&null;
      if(i < 0)
      {
         if(-i <= ArraySize(objects)) return objects[ArraySize(objects) + i];
         return (JsValue *)&null;
      }
      return objects[i];
   }
   
   bool getProperties(string &keys[]) const
   {
      if(t != JS_OBJECT) return false;
      ArrayResize(keys, properties.getSize());
      for(int i = 0; i < properties.getSize(); i++)
      {
         keys[i] = properties.getKey(i);
      }
      return true;
   }
   
   int indexOf(const string value)
   {
      if(t != JS_ARRAY) return -1;
      for(int i = 0; i < ArraySize(objects); i++)
      {
         if(objects[i].s == value) return i;
      }
      return -1;
   }
   
   // aux stuff
   
   void print(const int maxlevel = INT_MAX) const
   {
      int level = 0;
      print(level, maxlevel);
   }
   
   void print(int &level, const int maxlevel) const
   {
      const static string open[] = {"{", "[", "", "null", "ERROR: "};
      const static string close[] = {"}", "]", "", "", "!"};
      Print(StringFormat("%*s", level * 2, ""), open[t], s);
      ++level;
      if(level < maxlevel)
      {
         const string padding = StringFormat("%*s", level * 2, "");
         if(properties.getSize() >= ArraySize(objects))
         {
            for(int i = 0; i < properties.getSize(); ++i)
            {
               if(objects[i])
               {
                 if(objects[i].s != NULL)
                 {
                    Print(padding, properties.getKey(i), " = ", objects[i].s);
                 }
                 else
                 {
                    Print(padding, properties.getKey(i), " = ");
                    objects[i].print(level, maxlevel);
                 }
               }
               else Print(padding, "<N/A>");
            }
         }
         else // if(t == JS_ARRAY)
         {
            for(int i = 0; i < ArraySize(objects); ++i)
            {
               if(objects[i])
               {
                 if(objects[i].s != NULL)
                 {
                    Print(padding, objects[i].s);
                 }
                 else
                 {
                    objects[i].print(level, maxlevel);
                 }
               }
               else Print(padding, "<N/A>");
            }
         }
      }
      --level;
      if(t < JS_PRIMITIVE) Print(StringFormat("%*s", level * 2, ""), close[t]);
   }
   
   void stringify(string &buffer, const int pretty = 0) const
   {
      const static string open[] = {"{", "[", "", "null", "ERROR: "};
      const static string close[] = {"}", "]", "", "", "!"};
      const string padding = pretty && t <= JS_ARRAY ? StringFormat("\n%*s", fmax(pretty, 0) * 2, "") : "";
      const string inner = pretty && t <= JS_ARRAY ? "  " : "";
      const bool inprocess = StringLen(buffer);
      if(StringLen(buffer) << 1 > (int)StringBufferLen(buffer)) StringReserve(buffer, StringBufferLen(buffer) << 1);
      StringAdd(buffer, (inprocess && size() ? padding : "") + open[t]);
      for(int i = 0; i < ArraySize(objects); ++i)
      {
         if(i > 0) StringAdd(buffer, ", ");
         if(t != JS_ARRAY) StringAdd(buffer, padding + inner + "\"" + properties.getKey(i) + "\" : ");
         
         if(objects[i].s != NULL)
         {
            StringAdd(buffer, (!i && t == JS_ARRAY ? (padding + inner) : "") + objects[i].stringify());
         }
         else
         {
            objects[i].stringify(buffer, pretty ? fmax(pretty, 0) + 1 : pretty);
         }
      }
      // TODO: single value json produces empty output!
      if(s != NULL) StringAdd(buffer, padding + inner + s);
      StringAdd(buffer, (ArraySize(objects) ? padding : "") + close[t]);
   }

   string flatten(const bool compact = true, const string prefix = "@")
   {
      string buffer;
      flatten(&this, buffer, compact, prefix);
      return buffer;
   }
   
   static void flatten(JsValue *element, string &buffer, const bool compact = true, const string prefix = "@")
   {
     if(element.t == JS_OBJECT)
     {
        if(!compact)
           buffer += prefix + " = {..." + "};\n"; // 0x2026
     }
     else if(element.t == JS_ARRAY)
     {
        if(!compact)
           buffer += prefix + " = [..." + "];\n";
     }
     else
     {
        buffer += prefix + "=" + element.s + ";\n";
        return;
     }
     
     for(int i = 0; i < element.size(); i++)
     {
        string key = (element.t == JS_OBJECT) ? element.props().getKey(i) : "";
        if(!StringLen(key)) key = "[" + (string)i + "]";
        else key = "[" + key + "]";
        
        flatten(element[i], buffer, compact, prefix + key);
     }
   }
   
   static JsValue *toUniformCase(JsValue *source, const bool upper = false)
   {
      if(source.t == JS_PRIMITIVE)
      {
         if(source.a == JS_STRING)
         {
            string s = source.s;
            if(upper) StringToUpper(s);
            else StringToLower(s);
            return new JsValue(s);
         }
         return new JsValue(source);
      }
      else
      {
         JsValue *result = new JsValue(source.t);
         if(source.t == JS_OBJECT)
         {
            string keys[];
            source.getProperties(keys);
            for(int i = 0; i < source.size(); i++)
            {
               result.put(keys[i], toUniformCase(source[i], upper));
            }
         }
         else
         {
            for(int i = 0; i < source.length(); i++)
            {
               result.put(toUniformCase(source[i], upper));
            }
         }
         return result;
      }
   }
   
};

/* Can't do this due to MQL5 limitation (pointers vs values mixture)
class JsObject: public JsValue
{
public:
   JsObject() : JsValue(JS_OBJECT) { }
};

class JsArray: public JsValue
{
public:
   JsArray() : JsValue(JS_ARRAY) { }
};
*/

//+------------------------------------------------------------------+
//| Helper classes for stack overflow control                        |
//+------------------------------------------------------------------+

class JsCallController
{
public:
   int counter;
   JsCallController(): counter(0) { };
};

class JsCallCounter
{
   JsCallController *owner;
public:
   JsCallCounter(JsCallController *controller): owner(controller)
   {
      owner.counter++;
   }
   ~JsCallCounter()
   {
      owner.counter--;
   }
};

//+------------------------------------------------------------------+
//| Lightweight pseudo-string proxies on top of entire input text    |
//+------------------------------------------------------------------+
struct JsToken
{
   int offset; // points to data, control delimiter is at -1 (if not left trimmed)
   int length;
   ushort c;
};

//+------------------------------------------------------------------+
//| JSON parser class                                                |
//+------------------------------------------------------------------+
class JsParser
{
public:
   int cursor;
   JsToken token2[];
   int offsets[][2]; // [offset][line No]
   bool error;
   int error_cursor;
   JsCallController stack;
   string copy; // input document as is
   
   bool isWhitespace(const ushort c)
   {
      return c == ' ' || c == '\r' || c == '\n' || c == '\t';
   }
   
   void tokenTrimLeft(const int i)
   {
      while(isWhitespace(copy[token2[i].offset]) && token2[i].offset < (i < ArraySize(token2) - 1 ? token2[i + 1].offset : StringLen(copy)))
      {
         token2[i].offset++;
         token2[i].length--;
      }
   }
   
   void tokenTrimRight(const int i)
   {
      while(isWhitespace(copy[token2[i].offset + token2[i].length - 1]) && token2[i].length > 0)
         token2[i].length--;
   }
   
   string token(const int i) const // show token with leading delimiter
   {
      return ((token2[i].c != 1 && token2[i].c != JS_EOF) || token2[i].length ? ShortToString(token2[i].c) + StringSubstr(copy, token2[i].offset, token2[i].length) : "");
   }
   
   void tokenize()
   {
      //copy = context;

      // lookup table for syntax chars       
      static const bool tbl[256] = {0,0,0,0,0,0,0,0,0,0,/*1*/0,0,0,/*1*/0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
      // static const ushort ctrl[] = {'{', '}', '[', ']', ',', ':', '\r', '\n'};
      
      bool quotes = false;
      
      JsToken _t = {0, 0, (ushort)1}; // start with optional whitespace
      PUSH(token2, _t);

      int m = EXPAND(offsets);
      offsets[m][0] = 0;
      
      for(int i = 0; i < StringLen(copy); i++)
      {
         if(copy[i] == '"')
         {
            quotes = !quotes;
            
            m = EXPAND(offsets);
            offsets[m][0] = i;
            JsToken t = {i + 1, 0, '"'};
            PUSH(token2, t);
            token2[m - 1].length = i - token2[m - 1].offset;
         }
         else
         {
            if(quotes) // inside quotes
            {
               if(copy[i] == '\\' && copy[i + 1] == '"')
               {
                  i++; // skip next escaped quote
               }
            }
            else
            {
               if(copy[i] < 256 && tbl[copy[i]])
               {
                  m = EXPAND(offsets);
                  offsets[m][0] = i;
                  JsToken t = {i + 1, 0, copy[i]};
                  PUSH(token2, t);
                  token2[m - 1].length = i - token2[m - 1].offset;
               }
            }
         }
      }
      
      if(ArraySize(token2))
      {
         token2[ArraySize(token2) - 1].length = StringLen(copy) - token2[ArraySize(token2) - 1].offset;
      }
      
      for(int i = 0; i < ArraySize(token2); i++)
      {
         if(token2[i].c != '"') tokenTrimLeft(i);
         if(token2[i].c != '"') tokenTrimRight(i);
      }

      int lineno = 1;
      for(int i = 0; i < ArrayRange(offsets, 0); ++i)
      {
         int position = offsets[i][0];
         offsets[i][1] = lineno;
         // CRLF \r\n - Windows
         // LF \n - Linux/Unix
         // CR \r - Mac
         if(copy[position] == '\r') lineno++;
         else if(copy[position] == '\n' && position && copy[position - 1] != '\r') lineno++;
      }
      // end of file
      JsToken t = {StringLen(copy), 0, (ushort)(JS_EOF)};
      PUSH(token2, t);
      m = EXPAND(offsets);
      offsets[m][0] = StringLen(copy);
      offsets[m][1] = lineno;
   }
   
   int next() // pre-increment safeguard
   {
      if(cursor < ArraySize(token2) - 1) ++cursor;
      return cursor;
   }

   int post() // post-increment safeguard
   {
      const int prev = cursor;
      next();
      return prev;
   }
   
   string parse_key()
   {
      if(token2[cursor].c == '"')
      {
         const JsToken t = token2[post()];
         const string result = StringSubstr(copy, t.offset, t.length);
         if(token2[cursor].c != '"')
         {
            if(!error) {PrintFormat("Closing '\"' expected, got: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
            error = true;
            return NULL;
         }
         next();
         return result;
      }
      else
      {
         if(!error) {PrintFormat("Opening '\"' expected, got: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
         error = true;
         return NULL;
      }
   }
   
   bool stack_guard()
   {
      if(stack.counter > JS_STACK_LIMIT)
      {
         if(!error) { Print("Too many nested structures, the limit exceeded: ", JS_STACK_LIMIT); error_cursor = cursor; }
         error = true;
         return false;
      }
      return true;
   }
   
   JsValue *parse_value(const bool skip = false)
   {
      JsCallCounter cnt(&stack);
      if(!stack_guard()) return NULL;
      
      if(token2[cursor].c == '"')
      {
         const JsToken t = token2[post()];
         string v = StringSubstr(copy, t.offset, t.length);
         while((token2[cursor].c != '"'
            || (copy[ token2[cursor - 1].offset + token2[cursor - 1].length - 1 ] == '\\'))
            && token2[cursor].c != JS_EOF)
         {
            const JsToken w = token2[post()];
            v += StringSubstr(copy, w.offset, w.length);
         }
         StringReplace(v, "\\\"", "\"");
         // TODO: unescape more chars? \u0000
         // static const ushort specs[] = {'"', '\\', '\/', '\r', '\n', '\t', '\b', '\f'};

         if(token2[cursor].c != '"')
         {
            if(!error) { PrintFormat("Unclosed string: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
            error = true;
         }
         else if(token2[cursor].length > 0)
         {
            tokenTrimRight(cursor);
            if(token2[cursor].length > 0)
            {
               if(!error) { PrintFormat("Garbage after closing quote: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
               error = true;
            }
         }
         next();
         return new JsValue(v);
      }
      else if(token2[cursor].c == '{')
      {
         return parse_object();
      }
      else if(token2[cursor].c == '[' && !skip)
      {
         return parse_array();
      }
      else // primitive, should be ":123.456", ":true", ",123", "\"text\"", "[null"
      {
         JsValue *result = token2[cursor].length ? new JsValue(StringSubstr(copy, token2[cursor].offset, token2[cursor].length)) : new JsValue(NULL);
         if(result.a == JS_NONE)
         {
            if(!error) { PrintFormat("Value expected, got: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
            error = true;
         }
         else if(result.a == JS_STRING && token2[cursor].c != '"')
         {
            if(!error) { PrintFormat("Unexpected string, no quotes: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
            error = true;
         }
         next();
         return result;
      }
   }
   
   JsValue *parse_array()
   {
      JsCallCounter cnt(&stack);
      if(!stack_guard()) return NULL;

      JsValue *current = NULL;
      if(token2[cursor].c == '[')
      {
         current = new JsValue(JS_ARRAY);
         const int i = cursor; // prevent reentrancy from parse_value
         do
         {
            if((token2[cursor].c == '[' || token2[cursor].c == ',') && !token2[cursor].length) // skip leading '[' or iterative ','
            {
               next();
               if(token2[cursor].c == ',')
               {
                  if(!error) { PrintFormat("Extra comma: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
                  error = true;
                  break;
               }
            }
            if(token2[cursor].c == ']')
            {
               if(token2[cursor].length == 0) break; // valid array close-up, including empty one
               if(!error) { PrintFormat("Delimiter after array expected, got some data: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
               error = true;
               break;
               
            }
            current.put(parse_value(i == cursor)); // parse_value increments cursor internally
            
            if(!(token2[cursor].c == ']' && !token2[cursor].length) && token2[cursor].c != ',')
            {
               if(!error) { PrintFormat("'],' expected, got: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
               error = true;
               return current;
            }
         }
         while(token2[cursor].c != ']' && token2[cursor].c != JS_EOF);
         next();
      }
      else
      {
         if(!error) { PrintFormat("'[' expected, got: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
         error = true;
         return NULL;
      }
      return current;
   }
   
   JsValue *parse_object()
   {
      JsCallCounter cnt(&stack);
      if(!stack_guard()) return NULL;

      JsValue *current = NULL;
      if(token2[cursor].c == '{')
      {
         current = new JsValue(JS_OBJECT);
         const int i = cursor;
         do
         {
            if((token2[cursor].c == '{' || token2[cursor].c == ',') && !token2[cursor].length) // equivalent mod of toyjson2 ?
            {
               next();
            }
            if(token2[cursor].c == '}' && !token2[cursor].length && i == cursor - 1)
            {
               break; // empty object
            }
            string key = parse_key();        // parse_key increments cursor internally
            if(token2[cursor].c != ':')
            {
               if(!error) { PrintFormat("':' expected, got: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
               error = true;
               return current;
            }
            if(token2[cursor].length == 0) next(); // can be ":<whitespace>" (if a string or object is next) or ":<whitespace>value"
            current.put(key, parse_value()); // parse_value increments cursor internally

            if(!(token2[cursor].c == '}' && !token2[cursor].length) && token2[cursor].c != ',')
            {
               if(!error) { PrintFormat("'},' expected, got: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
               error = true;
               return current;
            }
         }
         while(token2[cursor].c != '}' && token2[cursor].c != JS_EOF);
         next();
      }
      else
      {
         if(!error) { PrintFormat("'{' expected, got: '%s' @ %d", token(cursor), cursor); error_cursor = cursor; }
         error = true;
         return NULL;
      }
      return current;
   }
   
public:
   JsParser(): cursor(0), error_cursor(0) { }
   JsValue *parse(const string &text)
   {
      tokenize();
      // printTokens();
      
      cursor = 0;
      if(token2[cursor].c == (ushort)(1) && token2[cursor].length == 0) next(); // skip single start token (0x1) and whitespace, if present
      error = false;
      
      JsValue *result = parse_value();
      if(!error)
      {
         if(cursor != ArraySize(token2) - 1)
         {
            Print("Trailing garbage detected at the end: @", cursor);
            error_cursor = cursor;
            error = true;
         }
      }
      return result;
   }
   
   void printTokens(const bool context = false) const
   {
      if(context)
      {
         PrintFormat("Line No: %d, Offset: 0x%X/%d bytes", offsets[error_cursor][1], offsets[error_cursor][0], offsets[error_cursor][0]);
         string line = "";
         for(int i = error_cursor - 10; i <= error_cursor + 10; ++i)
         {
            if(i >= 0 && i < ArraySize(token2))
            {
               line += "[" + (string)i + "]:`" + token(i) + "` ";
            }
         }
         Print(line);
      }
      else
      {
         ArrayPrint(token2);
      }
   }
   
   static JsValue *jsonify(const string text)
   {
      JsParser parser;
      JsValue *result = parser.parse(text);
      if(parser.error)
      {
         parser.printTokens(true);
         JsValue *error = new JsValue(JS_ERROR);
         error.put("Bad JSON", result);
         return error;
      }
      return result;
   }
   
   bool isValid() const
   {
      return !error;
   }
};

const static JsValue JsValue::null(JS_NULL);
//+------------------------------------------------------------------+