#include <why.h>
#include <why-sensor.h>
#include <why-irq.h>
#include <why-messagequeue.h>
#include <why-time.h>
#include <why-watchdog.h>
#include <why-thread.h>
#include <why-file.h>
#include <why-mqtt.h>
#include <why-mutex.h>
#include <why-eventloop.h>

#include <string>
#include <format>


struct sensor_data
{
    Why::TimeSpec timestamp;
    std::string_view sensorname;
    uint64_t value;
};

int main()
{
    Why::init();

    Why::RandomSensor s1(0, 100);
    Why::RandomSensor s2(100, 200);

    Why::MessageQueue<sensor_data> sensor_data_queue(7);
    Why::MessageQueue<Why::TimeSpec/*timestamp*/> snapshot_queue(5);

    auto csv_file = Why::File::open("data.csv", Why::File::WriteOnly|Why::File::Append|Why::File::Create);
    assert(csv_file);
    auto mqtt = Why::MQTTPublisher::create("why-topic", "127.0.0.1");
    assert(mqtt);

    Why::Thread poller(
        [&sensor_data_queue, &snapshot_queue, &csv_file, &mqtt](){
            Why::Eventloop loop;

            // incoming data
            loop.watch(
                sensor_data_queue,
                [&sensor_data_queue, &csv_file, &mqtt](){
                    auto [timestamp, sensorname, value] = sensor_data_queue.get();    // <-- does not block
                           
                    // write to CSV
                    std::string line = std::format("{};{};{}\n", timestamp.to_seconds(), sensorname, value);
                    auto written = csv_file->write((const uint8_t*)line.c_str(), line.size());
                    assert(written);

                    // publish MQTT
                    std::string json = std::format("{{\"timestamp\": {}, \"sensorname\": {}, \"value\": {} }}", 
                                                   timestamp.to_seconds(), sensorname, value);
                    auto ok = mqtt->publish(json);
                    assert(ok);
                });

            // snapshot button
            loop.watch(
                snapshot_queue,
                [&snapshot_queue, &csv_file](){
                    auto timestamp = snapshot_queue.get(); // <-- does not block
                    std::string snapshot_filename = std::format("snapshot-{}.csv", timestamp.to_seconds());

                    Why::File::rename("data.csv", snapshot_filename);
                    csv_file = Why::File::open("data.csv", Why::File::WriteOnly|Why::File::Append|Why::File::Create);
                });

            loop();                                    // <-- here we block
        });

    // activate snapshot button
    Why::IRQ::connect(666, [&snapshot_queue](int /*irqnum*/){
        if (! snapshot_queue.put_noblock(Why::now_monotonic()))
            std::println(stderr, "OIDA! ZAH AUN!!");
    });

    // activate sensor interrupts
    {
        auto isr = [&sensor_data_queue, &s1, &s2](int irqnum){
            sensor_data data;
            if (irqnum == 7)
                data = {.timestamp=Why::now_monotonic(), .sensorname="s1", .value=s1.get_value()};
            else if (irqnum == 42)
                data = {.timestamp=Why::now_monotonic(), .sensorname="s2", .value=s2.get_value()};
            else
                assert(!"unexpected irq");
        
            if (! sensor_data_queue.put_noblock(data))
                std::println(stderr, "OIDA! ZAH AUN!!");
        };
        Why::IRQ::connect(7, isr);
        Why::IRQ::connect(42, isr);
    }

    // activate and feed watchdog
    const Why::TimeSpec watchdog_timeout(2, 0);
    Why::Watchdog::activate(watchdog_timeout);
    while (true) {
        Why::Watchdog::feed();
        Why::sleep(watchdog_timeout - Why::TimeSpec(0, 500'000'000));
    }

    return 0;
}
