#pragma once

#include "modules/meta/base.hpp"

POLYBAR_NS

namespace modules {
  using interval_t = chrono::duration<double>;

  template <class Impl>
  class timer_module : public module<Impl> {
   public:
    using module<Impl>::module;

    void start() {
      this->m_mainthread = thread(&timer_module::runner, this);
    }

   protected:
    void runner() {
      this->m_log.trace("%s: Thread id = %i", this->name(), concurrency_util::thread_id(this_thread::get_id()));

      const auto check = [&]() -> bool {
        std::unique_lock<std::mutex> guard(this->m_updatelock);
        return CAST_MOD(Impl)->update();
      };

      try {
        // warm up module output before entering the loop
        check();
        CAST_MOD(Impl)->broadcast();

        while (this->running()) {
          if (check()) {
            CAST_MOD(Impl)->broadcast();
          }
          // wait until next full interval to avoid drifting clocks
          using clock = chrono::system_clock;
          using sys_duration_t = clock::time_point::duration;

          auto sys_interval = chrono::duration_cast<sys_duration_t>(m_interval);
          clock::time_point now = clock::now();
          sys_duration_t adjusted = sys_interval - (now.time_since_epoch() % sys_interval);

          // The seemingly arbitrary addition of 500ms is due
          // to the fact that if we wait the exact time our
          // thread will be woken just a tiny bit prematurely
          // and therefore the wrong time will be displayed.
          // It is currently unknown why exactly the thread gets
          // woken prematurely.
          CAST_MOD(Impl)->sleep_until(now + adjusted + 500ms);
        }
      } catch (const exception& err) {
        CAST_MOD(Impl)->halt(err.what());
      }
    }

   protected:
    interval_t m_interval{1.0};
  };
}  // namespace modules

POLYBAR_NS_END