JSON_helper.h

#pragma once
#include <iostream>
#include <fstream>
#include <ctime>
#include <chrono>
#include "rapidjson/rapidjson.h"
#include "rapidjson/reader.h"
#include "rapidjson/filereadstream.h"
#include "rapidjson/schema.h"
#include "rapidjson/error/en.h"
#include "JSONScenarioSchemaHelper.h"
#include <Emulator_helpers.h>
 
 
struct JSONSettings {
    bool auto_pause = false;
    std::chrono::seconds simulation_limit;
    std::vector<NodeConnections> node_connections;
    std::vector<NodeSettings> node_settings;
 
    void reset();
 
    void validateAndSort();
};
 
 
class JSONScenarioReader
{
public:
    inline std::string getVersion() {
        return version;
    }
 
    inline JSONSettings getSettings() {
        return settings;
    }
 
    bool parse(std::string path);
 
    inline rapidjson::ParseResult getLastParseResult() {
        return lastParseResult;
    }
 
    inline rapidjson::ParseResult getLastSchemaParseResult() {
        return lastSchemaParseResult;
    }
 
    static bool pathExists(const char* path);
 
    void clear() {
        settings.reset();
    }
 
protected:
    std::string version = "0.0.1";
 
    bool verified = false;
 
    JSONSettings settings;
 
    rapidjson::ParseResult lastParseResult;
    rapidjson::ParseResult lastSchemaParseResult;
 
    bool ParseJSON(std::string filePath);
 
    struct JSONReaderHandler : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, JSONReaderHandler> {
        void init(JSONScenarioReader* reader_) {
            reader = reader_;
            reader->version = "";
            reader->verified = false;
            reader->settings.reset();
        }
        
        bool Null() { 
            return true;
        }
        bool Bool(bool b) {
            if (lastKeys.size() == 2 && lastKeys[1] == "settings") {
                if (currentKey == "auto_pause") {
                    reader->settings.auto_pause = b;
                }
            }
            else if (lastKeys.size() == 4 && lastKeys[1] == "settings" && lastKeys[2] == "node_settings" && currentKey == "is_gateway") {
                currentNodeSettings.isGateway = b;
            }
            return true;
        }
 
        bool Int(int i) {
            return AnyNumber(i, i, false);
        }
        bool Uint(unsigned u) { 
            return AnyNumber(u, u, true);
        }
        bool Int64(int64_t i) {
            return AnyNumber(i, i, false);
        }
        bool Uint64(uint64_t u) {
            return AnyNumber(u, u, true);
        }
 
        bool Double(double d) {
            if (lastKeys.size() == 4 && lastKeys[1] == "settings" && lastKeys[2] == "node_connections") {
                if (currentKey == "RSSI") {
                    if (d >= -120.00f && d <= 0.00f) {
                        currentNodeConnection.RSSI = d;
                    }
                }
                else if (currentKey == "RSSI_tolerance") {
                    if (d >= 0.00f && d <= 120.00f) {
                        currentNodeConnection.RSSI_tolerance = d;
                    }
                }
                else if (currentKey == "quality") {
                    if (d >= 0.00f && d <= 1.00f) {
                        currentNodeConnection.Quality = d;
                    }
                }
            }
            return true; 
        }
 
        bool String(const char* str, rapidjson::SizeType length, bool copy) {
            std::string value = std::string(str, length);
            if (lastKeys.size() == 1) {
                if (currentKey == "type") {
                    if (value == "Simulation scenario") {
                        reader->verified = true;
                    }
                    else return false;
                }
                else if (currentKey == "version") {
                    reader->version = value;
                }
            }
            else if (lastKeys.size() == 4 && lastKeys[1] == "settings" && lastKeys[2] == "node_settings" && currentKey == "SSID") {
                currentNodeSettings.SSID = std::string(str, length);
            }
            //TODO decode scenario
            return true;
        }
 
        bool StartObject() {
            lastKeys.push_back(currentKey);
            if (lastKeys.size() == 4) {
                currentNodeConnection = NodeConnections(); //Clearing
                currentNodeSettings.clear();
            }
            return true; 
        }
        bool Key(const char* str, rapidjson::SizeType length, bool copy) {
            currentKey = std::string(str, length);
            return true;
        }
        bool EndObject(rapidjson::SizeType memberCount) {
            lastKeys.pop_back();
            if (lastKeys.size() == 3 && lastKeys[1] == "settings" && lastKeys[2] == "node_connections") {
                reader->settings.node_connections.push_back(currentNodeConnection);
            }
            else if (lastKeys.size() == 3 && lastKeys[1] == "settings" && lastKeys[2] == "node_settings" && currentNodeSettings.MACAddress != 0) {
                reader->settings.node_settings.push_back(currentNodeSettings);
            }
            return true;
        }
 
        bool StartArray(){
            lastKeys.push_back(currentKey);
            currentKey = "";
            return true;
        }
        bool EndArray(rapidjson::SizeType elementCount) {
            lastKeys.pop_back();
            return true;
        }
 
        bool AnyNumber(uint64_t valu, int64_t val, bool isUnsinged) {
            if (lastKeys.size() == 2 && lastKeys[1] == "settings") {
                if (currentKey == "simulation_limit") {
                    reader->settings.simulation_limit = std::chrono::seconds(valu);
                }
            }
            else if (lastKeys.size() == 4 && lastKeys[1] == "settings" && lastKeys[2] == "node_connections") {
                if (currentKey == "node1") {
                    if (valu > 0 && valu <= UINT32_MAX) {
                        currentNodeConnection.Node1 = valu;
                    }
                }
                else if (currentKey == "node2") {
                    if (valu > 0 && valu <= UINT32_MAX) {
                        currentNodeConnection.Node2 = valu;
                    }
                }
            }
            else if (lastKeys.size() == 4 && lastKeys[1] == "settings" && lastKeys[2] == "node_settings") {
                if (currentKey == "node") {
                    currentNodeSettings.MACAddress = (uint32_t)valu;
                }
                else if (currentKey == "MCU_frequency") {
                    currentNodeSettings.MCUFrequency = (uint32_t)valu;
                }
                else if (currentKey == "pre_send_cycles_delay") {
                    currentNodeSettings.preSendCyclesDelay = (uint32_t)valu;
                }
                else if (currentKey == "pre_send_delay") {
                    currentNodeSettings.preSendDelay = std::chrono::nanoseconds(valu);
                }
                else if (currentKey == "sending_speed") {
                    currentNodeSettings.sendingSpeed = (uint32_t)valu;
                }
                else if (currentKey == "extra_bits_sent_count") {
                    currentNodeSettings.extraBitsSentCount = (uint32_t)valu;
                }
                else if (currentKey == "post_send_cycles_delay") {
                    currentNodeSettings.postSendCyclesDelay = (uint32_t)valu;
                }
                else if (currentKey == "post_send_delay") {
                    currentNodeSettings.postSendDelay = std::chrono::nanoseconds(valu);
                }
                else if (currentKey == "pre_receive_cycles_delay") {
                    currentNodeSettings.preReceiveCyclesDelay = (uint32_t)valu;
                }
                else if (currentKey == "pre_receive_delay") {
                    currentNodeSettings.preReceiveDelay = std::chrono::nanoseconds(valu);
                }
                else if (currentKey == "post_receive_cycles_delay") {
                    currentNodeSettings.postReceiveCyclesDelay = (uint32_t)valu;
                }
                else if (currentKey == "post_receive_delay") {
                    currentNodeSettings.postReceiveDelay = std::chrono::nanoseconds(valu);
                }
                else if (currentKey == "available_cycles_delay") {
                    currentNodeSettings.availableCyclesDelay = (uint32_t)valu;
                }
                else if (currentKey == "available_delay") {
                    currentNodeSettings.availableDelay = std::chrono::nanoseconds(valu);
                }
                else if (currentKey == "interference_check_cycles_delay") {
                    currentNodeSettings.interferenceCheckCyclesDelay = (uint32_t)valu;
                }
                else if (currentKey == "interference_check_delay") {
                    currentNodeSettings.interferenceCheckDelay = std::chrono::nanoseconds(valu);
                }
                else if (currentKey == "max_frame_size") {
                    if (valu > 255) valu = 255; //overflow protection
                    currentNodeSettings.maxFrameSize = (uint8_t)valu;
                }
                else if (currentKey == "input_fifo_size") {
                    currentNodeSettings.InputFiFoSize = (int)valu;
                }
                else if (currentKey == "start_delay") {
                    currentNodeSettings.simulationOffset = std::chrono::nanoseconds(valu);
                }
            }
            return true;
        }
 
    private:
        std::string currentKey;
        std::vector<std::string> lastKeys;
        NodeConnections currentNodeConnection;
        NodeSettings currentNodeSettings;
        JSONScenarioReader* reader;
    };
 
};
 
class JSONLogsWriter
{
public:
 
    ~JSONLogsWriter() {
        terminate();
    }
 
    std::string version = "0.0.1";
 
    bool begin(const JSONSettings& settings, std::string path);
 
    void terminate();
 
    void end(int errorCode, std::string errorText);
 
    void exceptionEnd(int errorCode, std::string errorText);
 
    void end();
 
    void logMessageTransmit(RawMessage &message);
 
    void logMessageReceive(MeshMAC node, std::chrono::nanoseconds receiveTime, RawMessage& message, float RSSI);
 
    void logReceiveInterference(MeshMAC node, std::chrono::nanoseconds simulationTime, MeshMAC sender_node1, uint64_t sender_node1_UID, float rssi1, MeshMAC sender_node2, uint64_t sender_node2_UID, float rssi2);
 
    void logTransmitInterference(MeshMAC node, uint64_t node_UID, std::chrono::nanoseconds simulationTime, MeshMAC sender_node, uint64_t sender_node_UID, float RSSI);
 
    void logMessageLost(MeshMAC sender, MeshMAC receiver, uint64_t node_UID, std::chrono::nanoseconds simulationTime, float RSSI);
 
    void logAPLReceived(MeshMAC node, MeshMAC sender_node, std::chrono::nanoseconds simulationTime, char* messageData, size_t length);
 
    void logTableChange(MeshMAC node, std::string& descriptor, TableChangeType changeType, std::chrono::nanoseconds simulationTime, const char* data, size_t length);
 
    static std::string EncodeSpecialCharacters(const char* text, size_t inLength);
 
    static std::string EncodeSpecialCharacters(std::string& text) {
        return EncodeSpecialCharacters(text.c_str(), text.length());
    }
 
    static std::string GetCurrentTimeISO8601();
 
protected:
 
    bool beginCalled = false;
    std::chrono::steady_clock::time_point simulationStartTime;
    std::ofstream outFile;
    bool anyLogWritten = false;
};