#ifndef TIME_KEEPER_H
#define TIME_KEEPER_H

#include <esp_log.h>
#include <esp_timer.h>

#include "i2c.h"

/**
 * Stores arguments and ESP timer handle for a Timer.
 * In general Timers should be used via the TimeKeeper interface only.
 *
 * Timers cannot be copied, and are only created by a TimeKeeper instance.
 * The public way to access a Timer is by obtaining a TimerHandle (Timer *).
 * The TimeKeeper can delete existing Timers, calling it's destructor.
 * The ESP timer will be deleted when this class desctructor is called.
 */
struct Timer {
  explicit Timer(esp_timer_create_args_t args) :
      args_(args), esp_timer_(nullptr)
  {
    ESP_LOGI(TAG, "Creating esp_timer with name: %s", args_.name);
    ESP_ERROR_CHECK(esp_timer_create(&args, &esp_timer_));
  }

  ~Timer()
  {
    ESP_LOGI(TAG, "Destroying esp_timer with name: %s", args_.name);
    ESP_ERROR_CHECK(esp_timer_delete(esp_timer_));
  }

  Timer(const Timer &) = delete;

  Timer(Timer &) = delete;

  Timer &operator=(Timer &) = delete;

  /// Arguments passed to ESP API during timer creation.
  esp_timer_create_args_t args_;

  /// ESP timer handle.
  esp_timer_handle_t esp_timer_;

private:
  /// Tag used for ESP logging.
  const char * TAG = "Timer";
};

/**
 * ESP timer mananger class.
 *
 * Timers should only be accessed using the get_handle method.
 * If the Timer destructor is called the underlying ESP timer will be deleted.
 */
struct TimeKeeper {
  /// Timer handle type used for referring to Timers.
  using TimerHandle = Timer *;

  TimerHandle get_handle(const char *name)
  {
    return &managed_timers_.at(name);
  }

  TimerHandle operator[](const char *name) { return get_handle(name); }

  /**
   * Create a new managed Timer with the provided ESP arguments.
   * The timer can be retrieved later using the args.name field value.
   *
   * @param args ESP timer creation arguments.
   * @return TimerHandle Handle to a Timer managed by this TimeKeeper.
   * @sa get_handle
   * @sa operator[](const char*)
   */
  TimerHandle create_timer(esp_timer_create_args_t args)
  {
    auto rt = managed_timers_.emplace(args.name, args);
    if (!rt.second) {
      ESP_LOGE(TAG, "Display::Timer already exists with name %s", args.name);
      return nullptr;
    }
    return &rt.first->second;
  }

  /// Stop a Timer with the given name.
  [[maybe_unused]] void stop_timer(const char *name)
  {
    ESP_ERROR_CHECK(esp_timer_stop(get_handle(name)->esp_timer_));
  }

  /// Delete a Timer with the given name.
  [[maybe_unused]] void delete_timer(const char *name)
  {
    managed_timers_.erase(name);
  }

  /// Create a Timer with the ESP args and call esp_timer_start_periodic.
  [[maybe_unused]] void
  start_new_timer_periodic(esp_timer_create_args_t args,
                           uint64_t period)
  {
    start_timer_periodic(create_timer(args)->args_.name, period);
  }

  /// Calls esp_timer_start_periodic on the Timer with the given name.
  [[maybe_unused]] void start_timer_periodic(const char *name,
                                             uint64_t period)
  {
    ESP_ERROR_CHECK(
        esp_timer_start_periodic(get_handle(name)->esp_timer_, period));
  }

  /// Create a Timer with the ESP args and call esp_timer_start_once.
  [[maybe_unused]] void
  start_new_timer_once(esp_timer_create_args_t args,
                       uint64_t timeout_us)
  {
    start_timer_once(create_timer(args)->args_.name, timeout_us);
  }

  /// Calls esp_timer_start_once on the Timer with the given name.
  [[maybe_unused]] void start_timer_once(const char *name,
                                         uint64_t timeout_us)
  {
    ESP_ERROR_CHECK(
        esp_timer_start_once(get_handle(name)->esp_timer_, timeout_us));
  }

private:
  /// Existing ESP timers created for this TimeKeeper instance.
  std::unordered_map<const char *, Timer> managed_timers_;

  /// Tag used for ESP logging.
  const char * TAG = "TimeKeeper";
};

#endif // TIME_KEEPER_H