jsonfile.h

// jsonfile.h - the muwerk json file class
 
#pragma once
 
#include "ustd_platform.h"
#include "ustd_array.h"
#include "ustd_map.h"
#include "muwerk.h"
#include "filesystem.h"
 
#include <Arduino_JSON.h>  // Platformio lib no. 6249
 
#ifndef MAX_FRICKEL_DEPTH
#define MAX_FRICKEL_DEPTH 9
#endif
 
namespace ustd {
 
class jsonfile {
  private:
    bool loaded = false;
    bool forcenew = false;
    bool autocommit = true;
    String path = "/";
    String filename = "";
    JSONVar obj;
 
  public:
    jsonfile(bool auto_commit = true, bool force_new = false, String path = "/")
        : forcenew(force_new), autocommit(auto_commit), path(path) {
        obj = JSON.parse("{}");
    }
 
    void clear(bool auto_commit = true, bool force_new = false) {
        filename = "";
        obj = JSON.parse("{}");
        autocommit = auto_commit;
        forcenew = force_new;
        loaded = false;
    }
 
    bool init(String basename, JSONVar &value, bool auto_commit = true) {
        filename = basename;
        obj = value;
        autocommit = auto_commit;
        forcenew = true;
        loaded = false;
        return autocommit ? commit() : true;
    }
 
    bool init(String basename, String value, bool auto_commit = true) {
        JSONVar jv = JSON.parse(value);
        return init(basename, jv, auto_commit);
    }
 
    bool initFromFile(String basename, String fn, bool auto_commit = true) {
        bool result = loadFile(basename, fn);
        if (result) {
            autocommit = auto_commit;
            forcenew = true;
            return autocommit ? commit() : true;
        }
        return false;
    }
 
    String toString() const {
        return JSON.stringify(obj);
    }
 
    bool commit() {
        if (filename == "") {
            DBG("Cannot commit uninitialized object");
            return false;
        }
        String jsonString = JSON.stringify(obj);
 
        DBG2("Writing file: " + path + filename + ".json, content: " + jsonString);
 
        fs::File f = fsOpen(path + filename + ".json", "w");
        if (!f) {
            DBG("File " + path + filename + ".json can't be opened for write, failure.");
            return false;
        } else {
            f.print(jsonString.c_str());
            f.close();
            forcenew = false;
            return true;
        }
    }
 
    bool exists(String key) {
        ustd::array<String> keyparts;
        JSONVar subobj;
        if (prepareRead(key, keyparts, subobj)) {
            DBG2("From " + key + ", element found.");
            return true;
        };
        return false;
    }
 
    static bool atomicExists(String key) {
        jsonfile jf;
        return jf.exists(key);
    }
 
    bool remove(String key) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = undefined;
        return autocommit ? commit() : true;
    }
 
    static bool atomicRemove(String key) {
        jsonfile jf;
        return jf.remove(key);
    }
 
    bool readJsonVar(String key, JSONVar &value) {
        ustd::array<String> keyparts;
        if (!prepareRead(key, keyparts, value)) {
            return false;
        }
        return true;
    }
 
    static bool atomicReadJsonVar(String key, JSONVar &value) {
        jsonfile jf;
        return jf.readJsonVar(key, value);
    }
 
    bool readJsonVarArray(String key, ustd::array<JSONVar> &values) {
        ustd::array<String> keyparts;
        JSONVar subobj;
        if (!prepareRead(key, keyparts, subobj)) {
            return false;
        }
        if (JSON.typeof(subobj) != "array") {
            DBG("From " + key + ", element has wrong type '" + JSON.typeof(subobj) +
                "' - expected 'array'");
            return false;
        }
        values.resize(subobj.length());
        for (int i = 0; i < subobj.length(); i++) {
            JSONVar element(subobj[i]);
            values[i] = element;
        }
        return true;
    }
 
    static bool atomicReadJsonVarArray(String key, ustd::array<JSONVar> &values) {
        jsonfile jf;
        return jf.readJsonVarArray(key, values);
    }
 
    bool readStringArray(String key, ustd::array<String> &values, bool strict = false) {
        ustd::array<String> keyparts;
        JSONVar subobj;
        if (!prepareRead(key, keyparts, subobj)) {
            return false;
        }
        if (JSON.typeof(subobj) != "array") {
            DBG("From " + key + ", element has wrong type '" + JSON.typeof(subobj) +
                "' - expected 'array'");
            return false;
        }
        if (strict) {
            // check that all elements are strings
            for (int i = 0; i < subobj.length(); i++) {
                if (JSON.typeof(subobj[i]) != "string") {
                    DBG("From " + key + ", array element " + String(i) + " has wrong type '" +
                        JSON.typeof(subobj[i]) + "' - expected 'string'");
                    return false;
                }
            }
        }
        values.resize(subobj.length());
        for (int i = 0; i < subobj.length(); i++) {
            values[i] = String((const char *)subobj[i]);
        }
        return true;
    }
 
    static bool atomicReadStringArray(String key, ustd::array<String> &values,
                                      bool strict = false) {
        jsonfile jf;
        return jf.readStringArray(key, values, strict);
    }
 
    bool readBoolArray(String key, ustd::array<bool> &values, bool strict = false) {
        ustd::array<String> keyparts;
        JSONVar subobj;
        if (!prepareRead(key, keyparts, subobj)) {
            return false;
        }
        if (JSON.typeof(subobj) != "array") {
            DBG("From " + key + ", element has wrong type '" + JSON.typeof(subobj) +
                "' - expected 'array'");
            return false;
        }
        if (strict) {
            // check that all elements are bools
            for (int i = 0; i < subobj.length(); i++) {
                if (JSON.typeof(subobj[i]) != "boolean") {
                    DBG("From " + key + ", array element " + String(i) + " has wrong type '" +
                        JSON.typeof(subobj[i]) + "' - expected 'boolean'");
                    return false;
                }
            }
        }
        values.resize(subobj.length());
        for (int i = 0; i < subobj.length(); i++) {
            values[i] = (bool)subobj[i];
        }
        return true;
    }
 
    static bool atomicReadBoolArray(String key, ustd::array<bool> &values, bool strict = false) {
        jsonfile jf;
        return jf.readBoolArray(key, values, strict);
    }
 
    bool readDoubleArray(String key, ustd::array<double> &values, bool strict = false) {
        ustd::array<String> keyparts;
        JSONVar subobj;
        if (!prepareRead(key, keyparts, subobj)) {
            return false;
        }
        if (JSON.typeof(subobj) != "array") {
            DBG("From " + key + ", element has wrong type '" + JSON.typeof(subobj) +
                "' - expected 'array'");
            return false;
        }
        if (strict) {
            // check that all elements are bools
            for (int i = 0; i < subobj.length(); i++) {
                if (JSON.typeof(subobj[i]) != "number") {
                    DBG("From " + key + ", array element " + String(i) + " has wrong type '" +
                        JSON.typeof(subobj[i]) + "' - expected 'number'");
                    return false;
                }
            }
        }
        values.resize(subobj.length());
        for (int i = 0; i < subobj.length(); i++) {
            values[i] = (double)subobj[i];
        }
        return true;
    }
 
    static bool atomicReadDoubleArray(String key, ustd::array<double> &values,
                                      bool strict = false) {
        jsonfile jf;
        return jf.readDoubleArray(key, values, strict);
    }
 
    bool readLongArray(String key, ustd::array<long> &values, bool strict = false) {
        ustd::array<String> keyparts;
        JSONVar subobj;
        if (!prepareRead(key, keyparts, subobj)) {
            return false;
        }
        if (JSON.typeof(subobj) != "array") {
            DBG("From " + key + ", element has wrong type '" + JSON.typeof(subobj) +
                "' - expected 'array'");
            return false;
        }
        if (strict) {
            // check that all elements are bools
            for (int i = 0; i < subobj.length(); i++) {
                if (JSON.typeof(subobj[i]) != "number") {
                    DBG("From " + key + ", array element " + String(i) + " has wrong type '" +
                        JSON.typeof(subobj[i]) + "' - expected 'number'");
                    return false;
                }
            }
        }
        values.resize(subobj.length());
        for (int i = 0; i < subobj.length(); i++) {
            values[i] = (long)subobj[i];
        }
        return true;
    }
 
    static bool atomicReadLongArray(String key, ustd::array<long> &values, bool strict = false) {
        jsonfile jf;
        return jf.readLongArray(key, values, strict);
    }
 
    bool readBool(String key, bool defaultVal) {
        ustd::array<String> keyparts;
        JSONVar subobj;
        if (!prepareRead(key, keyparts, subobj)) {
            return defaultVal;
        }
        if (JSON.typeof(subobj) != "boolean") {
            DBG("From " + key + ", element has wrong type '" + JSON.typeof(subobj) +
                "' - expected 'boolean'");
            return defaultVal;
        }
        bool result = (bool)subobj;
        DBG2("From " + key + ", value: " + (result ? "true" : "false"));
        return result;
    }
 
    static bool atomicReadBool(String key, bool defaultVal) {
        jsonfile jf;
        return jf.readBool(key, defaultVal);
    }
 
    String readString(String key, String defaultVal = "") {
        ustd::array<String> keyparts;
        JSONVar subobj;
        if (!prepareRead(key, keyparts, subobj)) {
            return defaultVal;
        }
        if (JSON.typeof(subobj) != "string") {
            DBG("From " + key + ", element has wrong type '" + JSON.typeof(subobj) +
                "' - expected 'string'");
            return defaultVal;
        }
        String result = (const char *)subobj;
        DBG2("From " + key + ", value: " + result);
        return result;
    }
 
    static String atomicReadString(String key, String defaultVal = "") {
        jsonfile jf;
        return jf.readString(key, defaultVal);
    }
 
    String readString(String key, unsigned int minLength, String defaultVal = "") {
        String val = readString(key, defaultVal);
        return val.length() < minLength ? defaultVal : val;
    }
 
    static String atomicReadString(String key, unsigned int minLength, String defaultVal = "") {
        jsonfile jf;
        return jf.readString(key, minLength, defaultVal);
    }
 
    double readDouble(String key, double defaultVal) {
        ustd::array<String> keyparts;
        JSONVar subobj;
        if (!prepareRead(key, keyparts, subobj)) {
            return defaultVal;
        }
        if (JSON.typeof(subobj) != "number") {
            DBG("From " + key + ", element has wrong type '" + JSON.typeof(subobj) +
                "' - expected 'number'");
            return defaultVal;
        }
        double result = (double)subobj;
        DBG2("From " + key + ", value: " + String(result));
        return result;
    }
 
    static double atomicReadDouble(String key, double defaultVal) {
        jsonfile jf;
        return jf.readDouble(key, defaultVal);
    }
 
    double readDouble(String key, double minVal, double maxVal, double defaultVal) {
        long val = readDouble(key, defaultVal);
        return (val < minVal || val > maxVal) ? defaultVal : val;
    }
 
    static double atomicReadDouble(String key, double minVal, double maxVal, double defaultVal) {
        jsonfile jf;
        return jf.readDouble(key, minVal, maxVal, defaultVal);
    }
 
    long readLong(String key, long defaultVal) {
        return (long)readDouble(key, (double)defaultVal);
    }
 
    static long atomicReadLong(String key, long defaultVal) {
        jsonfile jf;
        return jf.readLong(key, defaultVal);
    }
 
    long readLong(String key, long minVal, long maxVal, long defaultVal) {
        long val = readLong(key, defaultVal);
        return (val < minVal || val > maxVal) ? defaultVal : val;
    }
 
    static long atomicReadLong(String key, long minVal, long maxVal, long defaultVal) {
        jsonfile jf;
        return jf.readLong(key, minVal, maxVal, defaultVal);
    }
 
    bool writeJsonVar(String key, JSONVar &value) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = value;
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteJsonVar(String key, JSONVar &value) {
        jsonfile jf;
        return jf.writeJsonVar(key, value);
    }
 
    bool writeJsonVar(String key, String value) {
        JSONVar jv = JSON.parse(value);
        if (JSON.typeof(jv) == "undefined") {
            DBG("Invalid JSON-value " + value);
            return false;
        }
 
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = jv;
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteJsonVar(String key, String value) {
        jsonfile jf;
        return jf.writeJsonVar(key, value);
    }
 
    bool writeString(String key, String value) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = (const char *)value.c_str();
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteString(String key, String value) {
        jsonfile jf;
        return jf.writeString(key, value);
    }
 
    bool writeStringArray(String key, ustd::array<String> &values) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = JSON.parse("[]");
        for (unsigned int i; i < values.length(); i++) {
            target[i] = (const char *)values[i].c_str();
        }
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteStringArray(String key, ustd::array<String> &values) {
        jsonfile jf;
        return jf.writeStringArray(key, values);
    }
 
    bool writeBool(String key, bool value) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = value;
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteBool(String key, bool value) {
        jsonfile jf;
        return jf.writeBool(key, value);
    }
 
    bool writeBoolArray(String key, ustd::array<bool> &values) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = JSON.parse("[]");
        for (unsigned int i; i < values.length(); i++) {
            target[i] = values[i];
        }
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteBoolArray(String key, ustd::array<bool> &values) {
        jsonfile jf;
        return jf.writeBoolArray(key, values);
    }
 
    bool writeDouble(String key, double value) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = value;
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteDouble(String key, double value) {
        jsonfile jf;
        return jf.writeDouble(key, value);
    }
 
    bool writeDoubleArray(String key, ustd::array<double> &values) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = JSON.parse("[]");
        for (unsigned int i; i < values.length(); i++) {
            target[i] = values[i];
        }
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteDoubleArray(String key, ustd::array<double> &values) {
        jsonfile jf;
        return jf.writeDoubleArray(key, values);
    }
 
    bool writeLong(String key, long value) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = value;
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteLong(String key, long value) {
        jsonfile jf;
        return jf.writeLong(key, value);
    }
 
    bool writeLongArray(String key, ustd::array<long> &values) {
        JSONVar target;
        if (!prepareWrite(key, target)) {
            return false;
        }
        target = JSON.parse("[]");
        for (unsigned int i; i < values.length(); i++) {
            target[i] = values[i];
        }
        return autocommit ? commit() : true;
    }
 
    static bool atomicWriteLongArray(String key, ustd::array<long> &values) {
        jsonfile jf;
        return jf.writeLongArray(key, values);
    }
 
  private:
    bool loadFile(String basename, String fn) {
        filename = basename;
        fs::File f = fsOpen(fn, "r");
        if (!f) {
            return false;
        }
        String jsonstr = "";
        if (!f.available()) {
            DBG2("Opened " + fn + ", but no data in file!");
            return false;
        }
        while (f.available()) {
            // Lets read line by line from the file
            String line = f.readStringUntil('\n');
            jsonstr += line;
        }
        f.close();
        JSONVar content = JSON.parse(jsonstr);
        if (JSON.typeof(content) == "undefined") {
            DBG("Parsing input file " + fn + "failed, invalid JSON!");
            DBG2("Content: " + jsonstr);
            return false;
        }
        DBG2("Input file " + fn + " successfully parsed");
        DBG3("Content: " + jsonstr);
        obj = content;
        loaded = true;
        return true;
    }
 
    bool checkLoad(String basename) {
        if (basename != filename) {
            filename = basename;
            loaded = false;
        }
        if (loaded || forcenew) {
            return true;
        }
        return loadFile(basename, path + basename + ".json");
    }
 
    bool prepareRead(String key, ustd::array<String> &keyparts, JSONVar &subobj,
                     bool objmode = false) {
        normalize(key);
        ustd::split(key, '/', keyparts);
        if (keyparts.length() < (objmode ? 1 : 2)) {
            DBG("Key-path too short, minimum needed is filename/topic, got: " + key);
            return false;
        }
        if (!checkLoad(keyparts[0])) {
            return false;
        }
        JSONVar iterator(obj);
        for (unsigned int i = 1; i < keyparts.length() - 1; i++) {
            JSONVar tmpCopy(iterator[keyparts[i]]);
            iterator = tmpCopy;
            if (JSON.typeof(iterator) == "undefined") {
                DBG2("From " + key + ", element " + keyparts[i] + " not found.");
                return false;
            }
        }
        String lastKey = keyparts[keyparts.length() - 1];
        if (!iterator.hasOwnProperty(lastKey)) {
            DBG2("From " + key + ", element " + lastKey + " not found.");
            return false;
        } else {
            JSONVar tmpCopy(iterator[lastKey]);
            subobj = tmpCopy;
        }
        return true;
    }
 
    bool prepareWrite(String key, JSONVar &target, bool objmode = false) {
        ustd::array<String> keyparts;
 
        normalize(key);
        ustd::split(key, '/', keyparts);
        if (keyparts.length() < (objmode ? 1 : 2)) {
            DBG("Key-path too short, minimum needed is filename/topic, got: " + key);
            return false;
        }
        if (keyparts.length() > MAX_FRICKEL_DEPTH) {
            DBG("Key-path too long, maxdepth is " + String(MAX_FRICKEL_DEPTH) + ", got: " + key);
            return false;
        }
        if (!checkLoad(keyparts[0]) && forcenew) {
            DBG("Creating new file /" + keyparts[0] + ".json");
        }
 
        // frickel
        switch (keyparts.length()) {
        case 1:
            // possible only in object mode
            target = obj;
            return true;
        case 2:
            target = obj[keyparts[1]];
            return true;
        case 3:
            target = obj[keyparts[1]][keyparts[2]];
            return true;
        case 4:
            target = obj[keyparts[1]][keyparts[2]][keyparts[3]];
            return true;
        case 5:
            target = obj[keyparts[1]][keyparts[2]][keyparts[3]][keyparts[4]];
            return true;
        case 6:
            target = obj[keyparts[1]][keyparts[2]][keyparts[3]][keyparts[4]][keyparts[5]];
            return true;
        case 7:
            target =
                obj[keyparts[1]][keyparts[2]][keyparts[3]][keyparts[4]][keyparts[5]][keyparts[6]];
            return true;
        case 8:
            target = obj[keyparts[1]][keyparts[2]][keyparts[3]][keyparts[4]][keyparts[5]]
                        [keyparts[6]][keyparts[7]];
            return true;
        case 9:
            target = obj[keyparts[1]][keyparts[2]][keyparts[3]][keyparts[4]][keyparts[5]]
                        [keyparts[6]][keyparts[7]][keyparts[8]];
            return true;
        default:
            DBG("SERIOUS PROGRAMMING ERROR - MAX_FRICKEL_DEV higher than implemented support "
                "in " __FILE__ " line number " +
                String(__LINE__));
            return false;
        }
    }
 
    static void normalize(String &src) {
        if (src.c_str()[0] == '/') {
            src = src.substring(1);
        }
    }
};
 
}  // namespace ustd