#include <cstdlib>
#include <iostream>
#include <thread>
#include <csignal>

#include "device.hpp"

volatile std::sig_atomic_t gSignum;

void signal_callback_handler(int signum) {
  gSignum = signum;
}

namespace djm::device {

Device::Device(std::unique_ptr<AnalyticsSource> analyticsSource_,
               std::unique_ptr<TemperatureSource> temperatureSource_)
    : analyticsSource(std::move(analyticsSource_)),
      temperatureSource(std::move(temperatureSource_)) {}

int Device::run(telemetry::Sink::Writer&& writer)
{
  using std::literals::chrono_literals::operator""ms;

  static bool signal_callback_handler_installed = false;
  if (!signal_callback_handler_installed) {
    std::signal(SIGTERM, signal_callback_handler); // systemd shutdown request
    std::signal(SIGINT, signal_callback_handler);  // ctrl-c
  }

  while (!gSignum) {
    auto start = std::chrono::system_clock::now();

    auto tempReading = temperatureSource->read(100ms);
    if (tempReading) {
      std::cout << "read temperatures: " << tempReading->fmtDebug()
                << std::endl;
      writer.capture(tempReading.value());
    } else {
      std::cout << "failed to read temperature sensors" << std::endl;
    }

    auto analyticsEvent = analyticsSource->await(250ms);
    if (analyticsEvent) {
      std::cout << "got analytics event: " << analyticsEvent->fmtDebug()
                << std::endl;
      writer.capture(analyticsEvent.value());
    } else {
      std::cout << "no analytics event available" << std::endl;
    }

    auto delta = std::chrono::system_clock::now() - start;
    std::this_thread::sleep_for(1000ms - delta);
  }

  std::string shutdown_reason("gracefull shutdown");
  std::cout <<std::endl <<"[device] shutdown_reason: " <<shutdown_reason <<std::endl;

  writer.capture(shutdown_reason);
  return EXIT_SUCCESS;
}

}  // namespace djm::device