#include <systemc>
#include <cci_configuration>
#include <iostream>
#include <string>
 
class UARTController : public sc_core::sc_module {
public:
    cci::cci_param<int> baud_rate;
    cci::cci_param<bool> enable_parity;
 
    SC_HAS_PROCESS(UARTController);
    UARTController(sc_core::sc_module_name name)
        : sc_core::sc_module(name)
        , baud_rate("baud_rate", 9600, "Baud rate of the UART")
        , enable_parity("enable_parity", false, "Enable parity checking")
    {
        // Attach Metadata to assist external tools
        baud_rate.add_metadata("unit", cci::cci_value("bps"));
        baud_rate.add_metadata("min", cci::cci_value(1200));
        baud_rate.add_metadata("max", cci::cci_value(115200));
        baud_rate.add_metadata("ui_category", cci::cci_value("Timing"));
    }
 
    void print_status() {
        std::cout << "[UART] Initialized with Baud: " << baud_rate.get_value() 
                  << ", Parity: " << (enable_parity.get_value() ? "ON" : "OFF") << "\n";
    }
};
 
// Mock function simulating an external JSON Configuration Tool
void run_json_configurator(cci::cci_broker_handle broker) {
    std::cout << "--- JSON Tool Loading Presets ---\n";
    
    // A mock JSON string read from a config file
    std::string config_json = R"({
        "baud": 115200,
        "parity": true
    })";
 
    // 1. Parse JSON into a cci_value map
    cci::cci_value parsed = cci::cci_value::from_json(config_json);
    
    if (parsed.is_map()) {
        cci::cci_value::const_map_reference vmap = parsed.get_map();
        
        // 2. Set presets dynamically based on the JSON keys
        if (vmap.has_entry("baud")) {
            broker.set_preset_cci_value("top.uart.baud_rate", vmap.at("baud"));
            std::cout << "Set preset for baud_rate from JSON.\n";
        }
        if (vmap.has_entry("parity")) {
            broker.set_preset_cci_value("top.uart.enable_parity", vmap.at("parity"));
            std::cout << "Set preset for enable_parity from JSON.\n";
        }
    }
}
 
// Mock function simulating a GUI extracting Metadata to draw a slider
void run_gui_metadata_extractor(cci::cci_broker_handle broker) {
    std::cout << "\n--- GUI Tool Extracting Metadata ---\n";
    
    cci::cci_param_untyped_handle h_baud = broker.get_param_handle("top.uart.baud_rate");
    
    if (h_baud.is_valid()) {
        // Extract the metadata map
        cci::cci_value meta_val = h_baud.get_metadata();
        
        if (meta_val.is_map()) {
            cci::cci_value::const_map_reference meta = meta_val.get_map();
            
            std::cout << "Rendering UI for '" << h_baud.name() << "':\n";
            std::cout << "  Description: " << h_baud.get_description() << "\n";
            
            if (meta.has_entry("min") && meta.has_entry("max")) {
                std::cout << "  -> Drawing Slider from " 
                          << meta.at("min").get_int() << " to " 
                          << meta.at("max").get_int();
                
                if (meta.has_entry("unit")) {
                    std::cout << " " << meta.at("unit").get_string();
                }
                std::cout << "\n";
            }
        }
    }
}
 
int sc_main(int argc, char* argv[]) {
    cci::cci_register_broker(new cci_utils::consuming_broker("Global_Broker"));
    cci::cci_broker_handle broker = cci::cci_get_broker();
 
    // 1. External tool runs BEFORE module instantiation to set presets
    run_json_configurator(broker);
 
    // 2. Hierarchy is elaborated. Modules consume presets.
    struct Top : public sc_core::sc_module {
        UARTController uart;
        Top(sc_core::sc_module_name n) : sc_core::sc_module(n), uart("uart") {}
    };
    Top top("top");
 
    // 3. Print the internal state to verify JSON was applied
    std::cout << "\n--- Internal State ---\n";
    top.uart.print_status();
 
    // 4. GUI tool runs to extract metadata
    run_gui_metadata_extractor(broker);
 
    return 0;
}