#include <why.h>
#include <why-sensor.h>
#include <why-irq.h>
#include <why-messagequeue.h>
#include <why-pollsignal.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 <why-timer.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);
    Why::PollSignal watchdog_pollsignal;

    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);

    // 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 watchdog, and start feed timer
    const Why::TimeSpec watchdog_timeout(2, 0);
    Why::Watchdog::activate(watchdog_timeout);
    Why::Timer watchdog_timer([&watchdog_pollsignal](){watchdog_pollsignal.raise(42);});
    watchdog_timer.start(
        Why::TimeSpec(1,0),                              // initial expiration in a second
        watchdog_timeout - Why::TimeSpec(0, 500'000'000) // period
    );

    // start main work: watch out for events
    Why::Eventloop loop;

    // incoming data
    loop.watch(
        sensor_data_queue,
        [&sensor_data_queue, &csv_file, &mqtt](){
            auto [timestamp, sensorname, value] = sensor_data_queue.get();
                           
            // 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();
            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);
        });

    // watchdog feeding
    loop.watch(
        watchdog_pollsignal,
        [&watchdog_pollsignal](){
            watchdog_pollsignal.reset();
            Why::Watchdog::feed();
        });

    loop();                                            // <-- innocent-looking but cool

    return 0;
}
