#pragma once

#include "types.hpp"
#include <chrono>
#include <ratio>

namespace util {
using std::chrono::system_clock;
using namespace std::chrono_literals;

template <typename F>
auto time_of(F &&fn) -> std::chrono::duration<f64, std::milli> {
  const auto start = std::chrono::system_clock::now();
  fn();
  const auto end = std::chrono::system_clock::now();

  return {end - start};
}

class Delta {
  system_clock::time_point last;

public:
  Delta() : last(system_clock::now()) {}

  template <typename Rep, typename Ratio>
  inline auto has_elapsed(const std::chrono::duration<Rep, Ratio> &duration)
      -> bool {
    const auto now = system_clock::now();

    if (duration < (now - last)) {
      last = now;
      return true;
    } else {
      return false;
    }
  }

  template <typename Rep = usize, typename Ratio = std::milli>
  inline auto elapsed() -> std::chrono::duration<Rep, Ratio> {
    const auto now = system_clock::now();
    const auto duration =
        std::chrono::duration_cast<std::chrono::duration<Rep, Ratio>>(now -
                                                                      last);
    last = now;

    return duration;
  }

  inline auto has_elapsed_s(f64 seconds) -> bool {
    return has_elapsed(std::chrono::duration<f64>(seconds));
  }

  inline auto has_elapsed_ms(i64 milliseconds) -> bool {
    return has_elapsed(std::chrono::duration<i64, std::milli>(milliseconds));
  }

  inline auto elapsed_ms() -> std::chrono::duration<isize, std::milli> {
    const auto now = system_clock::now();
    const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
        system_clock::now() - last);
    last = now;
    return duration;
  }

  inline auto elapsed_s() -> std::chrono::duration<f64> {
    const auto now = system_clock::now();
    const auto duration =
        std::chrono::duration<f64>(system_clock::now() - last);
    last = now;
    return duration;
  }
};
} // namespace util